Entrada

Uma string que contém no máximo um de cada uma das cartas A, Be C. Eles podem estar em qualquer ordem. A cadeia vazia é uma entrada válida.

^{Nota: Uma versão anterior deste desafio usava as letras em LEJvez de ABCe elas ainda podem ser usadas, se desejado.}

Saída

Uma corda dos A, B, Cletras que não estavam presentes na entrada. Eles podem estar em qualquer ordem.

Se a saída for a sequência vazia, simplesmente não fornecer saída é válida, se isso fizer sentido para sua implementação. (por exemplo, você não precisa realmente chamar printuma string vazia.)

Exemplos

• Se a entrada for B, a saída deve ser CAou ACdesde Ae Cnão está presente na entrada.
• Se a entrada for a sequência vazia, a saída deverá ser ABCou qualquer permutação, pois nenhuma das três letras está presente na entrada.
• Se a entrada for CAB, a saída deve ser a sequência vazia, porque todas as três letras estão presentes na entrada.

Casos de teste

Existem tão poucos casos de entrada que podemos enumerar todos eles:

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

Todas as saídas válidas para cada entrada são fornecidas, separadas por |'s. ""representa a cadeia vazia

Pontuação

O código mais curto em bytes vence. Mas lembre-se de que você pode obter mais reconhecimento por resolver o desafio de uma maneira única , e não de uma maneira curta;)

Python 3, 29 27 22 bytes

lambda x:{*"ABC"}-{*x}

-2 bytes graças a Jonathan Allan

-5 bytes graças a Rod

Gelatina , 4 bytes

Obrigado a @DuctrTape pelo prod sobre a mudança e a presença de "ABC" no dicionário de Jelly.

“ḃ»ḟ

Experimente online!

“ḃ»procura a entrada "ABC" no dicionário de Jelly, ḟé o díodo de descarte do arquivador que descarta os caracteres encontrados na entrada dessa lista de caracteres. O resultado é impresso implicitamente.

Para uma versão em minúscula, a entrada do dicionário a ser usada pode ser "abac" ( “c») ou "abaca" ( “i»).

Quando o desafio era "LEJ", apenas 6 bytes podiam ser alcançados na variante maiúscula, pois não existem entradas de dicionário com esse conjunto de caracteres, deixando-nos criar a lista de caracteres “LEJ”(ou uma permutação dos mesmos).

A variante minúscula apresentou melhor desempenho em 5 bytes devido à presença da palavra "gelatina" ( “ẎṄ»).

Bash + coreutils, 15 bytes

tr -d x$1<<<LEJ

Experimente online!

Gostaria de omitir o x, mas tr -destaria faltando um argumento quando a string de entrada estivesse vazia. (Ele xnão causa nenhum dano, pois não há x no LEJ da string aqui.) Normalmente tr -d "$1", eu escreveria , mas fazê-lo da maneira que fiz é um byte menor que isso.

Retina , 14 bytes

A contagem de bytes assume a codificação ISO 8859-1.

$
¶ABC
D`.
A1`

Experimente online!

Explicação

$
¶ABC

Acrescente uma segunda linha contendo ABC.

D`.

Desduplicar os caracteres. Isso exclui todos os caracteres da segunda linha que já aparece na primeira linha.

A1`

Descarte a primeira linha.

05AB1E , 6 4 bytes

2 bytes salvos usando o novo žRcomando, conforme sugerido por Kevin Cruijssen

žRsм

Experimente online! ou como testes

Explicação

   м  # remove the character of
  s   # the input
žR    # from the string "ABC"

Java 7, 73 58 bytes

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

15 bytes salvos graças a @KritixiLithos .

Código do teste:

Experimente aqui.

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(""));
  }
}

Saída:

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

Na verdade , 7 bytes

"LEJ"-Σ

Experimente online!

"LEJ"-Σ
"LEJ"    the letters
     -   exclude letters present in input
      Σ  concatenate

Pitão, 5 bytes

-"ABC

Teste aqui

Expande para

-"ABC"Q
-       # Filter on absence
 "ABC"  # Literal string 
      Q # Input

MATL, 10 8 bytes

Economizou dois bytes graças a Suever. setdiffé mais curto que ismember.

'ABC'iX-

Experimente aqui!

Explicação

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

Sim, isso pode ter sido uma tarefa trivial, mas estou bastante satisfeito por conseguir resolvê-lo sozinho com o MATL. _{Eu nunca disse que era a solução mais curta ... Obrigado Suever!}

JavaScript ES6, 41 39 38 bytes

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

Economizou 2 bytes graças a Arnauld. Economizou 1 bytes graças ao LarsW.

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

console.log(f("AB"));

V , 10 bytes

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

Experimente online!

Hexdump:

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

Explicação

A entrada está na primeira linha do buffer. Então, algo como:

EL

e o cursor está no primeiro caractere. Portanto, excluímos a entrada (que a armazena no registro ") e entramos no modo de inserção simultaneamente usando C.

Uma vez no modo de inserção, os caracteres LEJsão inseridos, após o que eu volto ao modo normal usando <ESC>.

Agora temos que remover todos os caracteres presentes na entrada.

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

E uma vez que isso acontece, ficamos com as letras restantes no buffer.

Ruby, 27 19 18 bytes

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

-1 byte graças a Martin Ender

Haskell , 27 26 bytes

import Data.List
("ABC"\\)

Experimente online! Uso: ("ABC"\\) "CB"rendimentos "A".

\\é o operador de diferença definida, os parênteses formam uma seção chamada que é uma forma abreviada para a lamda (\x -> "ABC" \\ x).

Sem importação: (mesma contagem de bytes graças a @nimi)

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

Experimente online! Uso: f "CB"rendimentos "A".

Outras abordagens:

f x=filter(`notElem`x)"ABC"
(`filter`"ABC").flip notElem
f x=[c|c<-"ABC",notElem c x]

GNU sed , 34 29 bytes

Inclui +1 para -r

-5 graças ao Digital Trauma

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

Experimente online!

Por alguma razão, o TIO não funciona com o regex estendido ( -r), então tive que envolvê-lo no 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

Flak cerebral , 120 + 3 = 123 bytes

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

É executado com o -csinalizador, adicionando 3 bytes

Experimente online!

Explicação

No geral, esse programa praticamente faz o conjunto da pilha direita menos a pilha esquerda, com a pilha direita inicializada CBAe a pilha esquerda inicializada na entrada.

Código anotado

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

Mais explicações por vir ...

Mathematica, 37 bytes

Complement@@Characters@{"ABC",#}<>""&

Cenoura , 15 bytes, não concorrente

não concorrente por causa de um erro que encontrei ao retornar correspondências e seqüências de caracteres vazias. Então eu apenas consertei

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

Experimente online! (copiar colar)

Explicação

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

CJam , 7 bytes

"ABC"l-

Experimente online! (Como um conjunto de testes separado por avanço de linha.)

MATLAB / oitava, 20 bytes

@(x)setdiff('ABC',x)

Demo Online

Oitava, 29 27 bytes

Economizou dois bytes graças ao Suever, criando a string 'ABC'dentro da ismemberchamada.

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

Usamos ~ismember()como índices lógicos para a variável x. O que é peculiar é que criamos x='ABC' dentro ismember , não na frente dele. A ordem em que o Octave vê isso:

@(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

C #, 50 bytes 32 bytes 47 bytes 35 bytes

Onde iestá a entrada:

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

Aplicativo completo testado no 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));
}

Resultado dos testes

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

APL, 7 bytes

'ABC'∘~

~é definida como subtração, ∘é composta, portanto, esta é uma função que retorna ABCmenos os caracteres em sua entrada.

Água-viva , 9 bytes

PNI
 "ABC

Experimente online!

Em notação mais convencional, este programa se traduz em:

P(N("ABC", I))

Ié a entrada, Né a diferença da lista e Pé emitida.

Perl 5.9.9 79 38 37 35 bytes

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

(não tenho certeza das regras de contagem aqui - incluímos opções, mas não o comando perl).

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

(contagem ajustada após comentário de adjudicação abaixo)

Common Lisp, 71 bytes

The largest entry at the moment, but at least it is readable ;-)

(lambda(s)(coerce(set-difference'(#\A #\B #\C)(coerce s'list))'string))

Japt, 13 12 bytes

"ABC"r"[{U}]

Saved a byte thanks to ETHproductions.

Try it online!

Pyth, 4 bytes

-<G3

Try it here!

 <G3 -  alphabet[:3]
-    - input-^

Note this uses lower case which might not be acceptable

C, 53 bytes

b=64;c(char*a){while(b<67)putchar(++b*!strchr(a,b));}

If implicit declarations of string.h are not allowed, 72 bytes, to add #include<string.h>

Try it online!

or something a bit more fun at 75 bytes

a[128]={};b=64;c(char*d){while(*d)++a[*d++];while(b<67)putchar(b*!a[++b]);}

Try it online!

Batch, 101 bytes

@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

Takes input on STDIN, which means that %1 is empty when the code falls through into the helper subroutine and nothing gets printed.

R, 47 40 bytes

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

Try it online!

Replaces any letters in the input string with the empty string.