像ABC一样容易

28

输入值

包含每个字母的最多一个字符串A，B和C。它们可以按任何顺序排列。空字符串是有效输入。

注意：此挑战的先前版本使用字母LEJ代替，ABC如果需要，它们仍可以使用。

输出量

的字符串A，B，C字母不存在输入。它们可以按任何顺序排列。

如果输出为空字符串，则简单地不给出任何输出是有效的，如果这对您的实现有意义。（例如，您不需要实际调用print一个空字符串。）

例子

  • 如果输入是B，则输出应该要么是CA或者AC因为A与C不存在于输入端。
  • 如果输入为空字符串，则输出应为ABC或任何排列，因为输入中的三个字母均不存在。
  • 如果输入为，CAB则输出应为空字符串，因为所有三个字母均出现在输入中。

测试用例

输入案例很少，我们可以列举所有这些案例：

in -> out1 | out2 | out3 | ...
ABC -> ""
ACB -> ""
BCA -> ""
BAC -> ""
CAB -> ""
CBA -> ""
AB -> C
AC -> B
BC -> A
BA -> C
CA -> B
CB -> A
A -> BC | CB
B -> CA | AC
C -> AB | BA
"" -> ABC | ACB | BCA | BAC | CAB | CBA

给出了每个输入的所有有效输出，以|s 分隔。""代表空字符串

计分

以字节为单位的最短代码获胜。但请记住，以独特的方式而非短暂的方式解决挑战可能会获得更多认可；）

code-golf  string  set-theory 
— 卡尔文的爱好
source
1
— Mego
1
任务是设置常量和输入之间的差。考虑到实际任务的难度，要求一切都以字符串形式完成很麻烦。
— Mego
2
我隐约记得一个更精确的重复匹配，您必须从常数集中减去输入。
— xnor
1
输入是否可以包含“ ABC”之外的字母？规范：“字符串中最多包含字母A，B和C中的每个字母”不排除此类输入。
— theonlygusti
1
@theonlygusti输入的内容仅应包含ABC
— 卡尔文的爱好

Answers:

10

果冻，4字节

感谢@DuctrTape提供有关Jelly词典中的更改和“ ABC”的出现的信息。

“ḃ»ḟ

在线尝试！

“ḃ»在Jelly字典中查找条目“ ABC”，ḟ是过滤器丢弃二元组，它从该字符列表中丢弃在输入中找到的字符。结果被隐式打印。

对于小写版本，要使用的词典条目可以是“ abac”（“c»）或“ abaca ”（“i»）。

当挑战是“ LEJ”时，在大写字母变体中只能获得6个字节，因为没有字典条目与那组字符一起存在，这使我们可以创建字符列表“LEJ”（或其排列）。

由于存在单词“ jell”（），小写变体在5个字节处表现更好“ẎṄ»。

— 乔纳森·艾伦
source
1
我喜欢大多数代码只是生成字符串“ ABC”的方式，而实际程序本身就是一个字符。经典果冻。
— sagiksp
6

Bash + coreutils，15个字节

tr -d x$1<<<LEJ

在线尝试！

我想省略x，但是tr -d当输入字符串为空时会丢失参数。（这x没有任何害处，因为在这里的字符串LEJ中没有任何x。）我通常会写tr -d "$1"，但是按照我的方式做的比这短一个字节。

— 米切尔·史派克
source
我也有同样的想法-即使有引号-也是如此。
— rexkogitans
6

视网膜，14字节

字节数假定为ISO 8859-1编码。

$
¶ABC
D`.
A1`

在线尝试！

说明

$
¶ABC

追加包含的第二行ABC。

D`.

对字符进行重复数据删除。这将从第二行中已经出现在第一行中的每个字符删除。

A1`

丢弃第一行。

— 马丁·恩德
source
1`antigrep阶段的一部分如何工作？
— Kritixi Lithos '02
@KritixiLithos配置字符串中的数字为限制。1通常表示“仅X一次”。限制的确切工作方式（即X是多少）取决于您使用的阶段类型。对于antigrep阶段，Retina首先检查哪些行与正则表达式匹配（此处为每行，因为正则表达式为空），但是该限制表示“仅丢弃第一条匹配的行”。同样，如果这是grep阶段，则意味着“仅保留第一条匹配行”。Wiki上列出了所有限制的语义。
— Martin Ender
6

05AB1E，6 4字节

žR按照Kevin Cruijssen的建议，使用新命令保存了2个字节

žRsм

在线尝试！ 或作为测试套件

说明

   м  # remove the character of
  s   # the input
žR    # from the string "ABC"
— 艾米尼亚
source
输入不应该只J返回EL, LE吗？
— 魔术
2
真好！与FYI一样，输入也可以表示为"""{input}"""，它也适用于空字符串:)。
— 阿德南
@carusocomputing：它可以返回任何一个（在这种情况下，它返回LE）。
— Emigna
1
— Kevin Cruijssen
1
@Emigna Tbh号 我认为可能是因为这一挑战而添加了它，但是我个人以前从未使用过它。
— 凯文·克鲁伊森
5

Java 7，73 58字节

String c(String s){return"EJL".replaceAll("[ "+s+"]","");}

@KritixiLithos节省了15个字节。

测试代码：

在这里尝试。

class M{
  static String c(String s){return"EJL".replaceAll("[ "+s+"]","");}

  public static void main(final String[] a) {
    System.out.print("LEJ=" + c("LEJ") + "; ");
    System.out.print("LJE=" + c("LJE") + "; ");
    System.out.print("EJL=" + c("EJL") + "; ");
    System.out.print("ELJ=" + c("ELJ") + "; ");
    System.out.print("JLE=" + c("JLE") + "; ");
    System.out.print("JEL=" + c("JEL") + "; ");
    System.out.print("LE=" + c("LE") + "; ");
    System.out.print("LJ=" + c("LJ") + "; ");
    System.out.print("EJ=" + c("EJ") + "; ");
    System.out.print("EL=" + c("EL") + "; ");
    System.out.print("JL=" + c("JL") + "; ");
    System.out.print("JE=" + c("JE") + "; ");
    System.out.print("L=" + c("L") + "; ");
    System.out.print("E=" + c("E") + "; ");
    System.out.print("J=" + c("J") + "; ");
    System.out.print("\"\"=" + c(""));
  }
}

输出：

LEJ=; LJE=; EJL=; ELJ=; JLE=; JEL=; LE=J; LJ=E; EJ=L; EL=J; JL=E; JE=L; L=EJ; E=JL; J=EL; ""=EJL
— 凯文·克鲁伊森
source
1
你能"["+s+"]"代替s.replaceAll("(.)","$1|")吗？
— Kritixi Lithos
@KritixiLithos聪明。对于空字符串，它会失败，但是通过添加一个空格（或其他任何不是的字符EJL），它又可以工作了，但仍然要短得多。:)
— Kevin Cruijssen
4

MATL，10 8个字节

感谢Suever，节省了两个字节。setdiff比短ismember。

'ABC'iX-

在这里尝试！

说明

'ABC'      % Create a string literal
     i     % User input
      X-   % Set difference, between two elements of the stack

是的，这可能是一件微不足道的任务，但是我很满意自己独自使用MATL来解决它。我从未说过这是最短的解决方案...谢谢Suever！

— 斯蒂夫·格里芬
source
4

JavaScript ES6，41 39 38字节

s=>eval(`'ABC'.replace(/[${s}]/g,'')`)

感谢Arnauld，节省了2个字节。感谢LarsW，节省了1个字节。

f=s=>eval(`'ABC'.replace(/[${s}]/g,'')`)

console.log(f("AB"));
展开摘要

— 汤姆
source
我在移动设备上，因此无法测试我的代码，但是我认为这应该可以工作：s=>eval`'ABC'.replace(/[${s}]/g,'')`
— LarsW
干得好！.join``在我提出的解决方案中，能够说出的字为您节省了两个字符：f=s=>"ABC".replace(RegExp(`[${s}]`,'g'),"")。
— nnnnnn
1
@LarsW确切的代码似乎不起作用，但是在模板字符串周围添加了括号并节省了一个字节。谢谢！
— 汤姆（Tom），
3

V，10字节

CLEJ<ESC>Ó[<C-r>"]

在线尝试！

十六进制转储：

00000000: 434c 454a 1bd3 5b12 225d                 CLEJ..[."]

说明

输入在缓冲区的第一行。所以像这样：

EL

并且光标位于第一个字符上。因此，我们删除输入（将其存储在寄存器中"）并使用进入同时模式C。

进入插入模式后，将LEJ插入字符，然后使用进入正常模式<ESC>。

现在，我们必须删除输入中存在的所有字符。

Ó                       " remove every
 [<C-r>"]               "  character that appears in the input
                        " synonym of Vim's :s/[<C-r>"]//g

一旦发生这种情况，我们将剩下的字母留在缓冲区中。

— 克里蒂希·石印
source
3

Ruby，27 19 18字节

->s{"ABC".tr s,""}

-1字节感谢Martin Ender

— 国标
source
3

Haskell，27 26字节

import Data.List
("ABC"\\)

在线尝试！用法：("ABC"\\) "CB"产量"A"。

\\是集合差运算符，括号内的部分称为lamda的缩写(\x -> "ABC" \\ x)。

不导入：（由于@nimi而使字节数相同）

f x=[c|c<-"ABC",all(/=c)x]

在线尝试！用法：f "CB"产量"A"。

其他方法：

f x=filter(`notElem`x)"ABC"
(`filter`"ABC").flip notElem
f x=[c|c<-"ABC",notElem c x]
— 莱科尼
source
1
希望(\\)不久后会搬到序曲。
— theonlygusti
@theonlygusti我希望不会；对于列表，这实际上不是明智的操作（至少除非您明确声明要按列表设置，否则至少不是这样）。该任务的默认操作应为Data.Set.difference。
— 停止了逆时针转动
@ceasedtoturncounterclockwis为什么不明智？此外，我希望它移动的唯一原因是它经常有用。
— theonlygusti
1
@theonlygusti在某种意义上是不明智的，如果您发现自己正在使用它，则表明您可能使用了错误的数据结构。列表可以具有重复的元素，一个顺序，并且它们可以是惰性构造的（甚至是无限的）。(\\)不尊重这一切。旨在用于此行为的数据类型的结构通常使它们更加高效，安全（因为可能的稳定性等假说可能会被打破），并且暴露出更舒适的接口。
— 停止了逆时针转动
@ceasedtoturncounterclockwis是的，是的。“ ...的第一个实例”，但nvm
— theonlygusti
3

GNU sed，34 29字节

包括+1的 -r

-5感谢数字创伤

s/^/ABC/
:
s/(.)(.*)\1/\2/
t

在线尝试！

由于某种原因，TIO无法与扩展的正则表达式（-r）一起使用，因此我不得不将其包装在BASH中。

s/^/ABC/        # put ABC at the beginning of the string
:               # nameless label
s/(.)(.*)\1/\2/ # remove a duplicate letter
t               # branch to the nameless label if something changed
— 赖利
source
换行符，-n并且P是不必要的。您也可以将其包装在bash中，以使其在TIO中工作。不知道为什么-r不起作用。tio.run/nexus/bash#DcmxDYAwDATA/qdIR4JELCjp7F8jooIFCPubb@/...
— 数字创伤
@DigitalTrauma谢谢！我在写这篇文章的时候以为除了A，B和C之外还会有其他字符。
— 莱利
3

脑筋急转弯，120 + 3 = 123字节

<>((((((((()()){}){}){}){}){}())())())<>{({}(<()>)){(([({})]<>({}))){(<({}<>{})<>([{}]{}<>)>)}{}}{}{}<>{}{({}<>)<>}{}}<>

它与-c标志一起运行，添加3个字节

在线尝试！

说明

总的来说，该程序几乎将右堆栈集减去左堆栈，并将右堆栈初始化为CBA，并将左堆栈初始化为输入。

带注释的代码

<>((((((((()()){}){}){}){}){}())())())<> # Switch to right stack, push CBA, switch back
{({}(<()>)){(([({})]<>({}))){(<({}<>{})<>([{}]{}<>)>)}{}}{}{}<>{}{({}<>)<>}{}}<>

将会有更多的解释...

— 0'
source
2

Carrot，15字节，无竞争

由于发现错误返回匹配和空字符串而导致无法竞争。所以我就解决了

ABC^//[^#]/gS""

在线尝试！（复制粘贴）

说明

ABC^                   //sets stack (just a string, not an array) to "ABC"
    /                  //return match(es) of:
     /[^#]/g           // `#` is the placeholder for the input
                       // so effectively, this returns the matches of any character not present in the input
                       // applied on the stack
                       //this returns an array of all the matches of the regex
            S""        //join all the elements of the array using "", the empty string
— 克里蒂希·石印
source
2

八度，29 27字节

由于Suever通过'ABC'在ismember调用内部创建字符串，节省了两个字节。

@(s)x(~ismember(x='ABC',s))

我们使用~ismember()变量的逻辑索引x。奇特的是，我们x='ABC' 在内部 ismember而不是在内部创建。八度命令看到以下内容：

@(s)                        % Anonymous function that takes a string s as input
                x='ABC'     % Create a variable x with the characters 'ABC'
       ismember(x='ABC',s)  % True for elements that are in both x and s. False otherwise.
      ~ismember(x='ABC',s)  % Negate this, so that we keep the characters that aren't in s
@(s)x(~ismember(x='ABC',s)) % Use the logical vector as indices to x and return the result
— 斯蒂夫·格里芬
source
2

C＃，50个字节 32个字节 47个字节 35个字节

i输入在哪里：

i=>string.Join("","ABC".Except(i));

完整的应用在LINQPad中经过测试

void Main()
{
    var testcases = new Dictionary<string,string[]>
    {
        ["ABC"] = new[]{""},
        ["ACB"] = new[]{""},
        ["BCA"]  = new[]{""},
        ["BAC"]  = new[]{""},
        ["CAB"]  = new[]{""},
        ["CBA"]  = new[]{""},
        ["AB"] = new[]{"C"},
        ["AC"] = new[]{"B"},
        ["BC"] = new[]{"A"},
        ["BA"] = new[]{"C"},
        ["CA"] = new[]{"B"},
        ["CB"] = new[]{"A"},
        ["A"] = new[]{"BC","CB"},
        ["B"] = new[]{"CA","AC"},
        ["C"] = new[]{"AB","BA"},
        [""] = new[]{"ABC","ACB","BCA","BAC","CAB","CBA"},
    };

    var output = "";

    foreach(var input in testcases.Keys)
    {
        var expect = testcases[input];
        var actual = GetResult(input);
        if(!expect.Contains(actual)) throw new ApplicationException($"{input}:{string.Join(",",expect)}:{actual}");
        output+=$"{input} -> {actual}\n";
    }
    output.Dump();
}

// Define other methods and classes here
private string GetResult(string input){
    return string.Join("","ABC".Except(i));
}

检测结果

ABC->
ACB->
BCA->
BAC->
CAB->
CBA->
AB-> C
AC-> B
BC-> A
BA-> C
CA-> B
CB-> A
A-> BC
B-> AC
C-> AB-
> ABC

— 迈克尔·考克森
source
1
那不是一个有效的答案，它必须是函数或程序，而不是代码片段。
— theonlygusti
啊。我的错。第一次来这里。所以我需要打印部分吗？
— Michael Coxon
@MichaelCoxon：您需要将其输入到整个程序中，该程序可以进行编译（在C＃中不建议使用，因为它有很多样板），或者需要输入可以多次调用的函数；目前，这只是一个声明。在C＃中，通过创建一个lambda使其成为一个函数几乎总是最容易的，该lambda通过其参数接受输入，并通过其返回值返回。
string.Join("",...)-> string.Concat(...)保存1个字节
— 无知的体现
1

APL，7个字节

'ABC'∘~

~设置为减，∘为撰写，因此这是一个返回ABC减去输入中的字符的函数。

— 马里纳斯
source
1

Perl 5.9.9 79 38 37 35字节

perl -le '$_="ABC";eval"y/$ARGV[0]//d";print'

（不确定此处的计数规则-包括开关，但不包括perl命令）。

> perl -le '$_="ABC";eval"y/$ARGV[0]//d";print' AB
C
> perl -le '$_="ABC";eval"y/$ARGV[0]//d";print'
ABC

（下面的裁决后的调整数）

— 汤姆·坦纳
source
这对空输入有用吗？
— 泰特斯
现在，我修复了抄写错误（“ ..”，在此处键入{,,} ...）
— Tom Tanner
您的代码长35个字节。（-l标记为34 +1 ）。:)
— Paul Picard
谢谢。-l用于美化（如输出末尾的换行符）。不确定比赛规则是否必要。
— 汤姆·坦纳
使用5.14+时，您只能执行perl -pe'$_=eval"ABC=~y/$_//dr"'23个字节的操作（对于则为22 +1 -p）。
— ThisSuitIsBlackNot '17
1

Common Lisp，71个字节

目前最大的条目，但至少它是可读的;-)

(lambda(s)(coerce(set-difference'(#\A #\B #\C)(coerce s'list))'string))
— 核心转储
source
1

批处理，101字节

@set/ps=
@for %%c in (L E J)do @call set d=%%s:%%c=%%&call:c %%c
:c
@if "%d%"=="%s%" set/pd=%1<nul

在STDIN上接受输入，这意味着%1当代码落入helper子例程且没有任何输出时，该字段为空。

— 尼尔
source
1

R，47 40字节

gsub(paste0("[",scan(,""),"]"),"","ABC")

在线尝试！

用空字符串替换输入字符串中的任何字母。

— BLT
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.