Entrada

Una cadena que contiene a lo sumo uno de cada una de las letras A, By C. Pueden estar en cualquier orden. La cadena vacía es una entrada válida.

^{Nota: Una versión anterior de este desafío usaba las letras en LEJlugar de ABCy aún se pueden usar si se desea.}

Salida

Una cadena de los A, B, Cletras que no estaban presentes en la entrada. Pueden estar en cualquier orden.

Si el resultado sería la cadena vacía, entonces simplemente no dar ningún resultado es válido, si eso tiene sentido para su implementación. (por ejemplo, no es necesario llamar printa una cadena vacía).

Ejemplos

• Si la entrada es, Bentonces la salida debería ser CAo ACdesde Ay Cno estar presente en la entrada.
• Si la entrada es la cadena vacía, la salida debería ser ABCo cualquier permutación ya que ninguna de las tres letras está presente en la entrada.
• Si la entrada es CABentonces, la salida debería ser la cadena vacía porque las tres letras están presentes en la entrada.

Casos de prueba

Hay tan pocos casos de entrada que podemos enumerarlos todos:

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

Se proporcionan todas las salidas válidas para cada entrada, separadas por |'s. ""representa la cadena vacía

Tanteo

El código más corto en bytes gana. Pero tenga en cuenta que puede obtener más reconocimiento por resolver el desafío de una manera única en lugar de hacerlo de manera breve;)

Python 3, 29 27 22 bytes

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

-2 bytes gracias a Jonathan Allan

-5 bytes gracias a Rod

Jalea , 4 bytes

Gracias a @DuctrTape por el comentario sobre el cambio y la presencia de "ABC" en el diccionario de Jelly.

“ḃ»ḟ

Pruébalo en línea!

“ḃ»busca la entrada "ABC" en el diccionario de Jelly, ḟes la diada de descarte del archivador que descarta los caracteres encontrados en la entrada de esa lista de caracteres. El resultado se imprime implícitamente.

Para una versión en minúscula, la entrada del diccionario a utilizar puede ser "abac" ( “c») o "abaca" ( “i»).

Cuando el desafío era "LEJ", solo se podían lograr 6 bytes en la variante mayúscula, ya que no existen entradas de diccionario con ese conjunto de caracteres, lo que nos permite crear la lista de caracteres “LEJ”(o una permutación de los mismos).

La variante en minúscula mejoró a 5 bytes debido a la presencia de la palabra "gelatina" ( “ẎṄ»).

Bash + coreutils, 15 bytes

tr -d x$1<<<LEJ

Pruébalo en línea!

Me gustaría omitir el x, pero luego me tr -dfaltaría un argumento cuando la cadena de entrada estaba vacía. (El xno hace ningún daño, ya que no hay ninguna x en el LEJ de cadena aquí.) Normalmente escribiría tr -d "$1", pero hacerlo de la manera que lo hice es un byte más corto que eso.

Retina , 14 bytes

El recuento de bytes asume la codificación ISO 8859-1.

$
¶ABC
D`.
A1`

Pruébalo en línea!

Explicación

$
¶ABC

Agregue una segunda línea que contenga ABC.

D`.

Deduplicar los personajes. Esto elimina todos los caracteres de la segunda línea que ya aparece en la primera línea.

A1`

Descarta la primera línea.

05AB1E , 6 4 bytes

Se guardaron 2 bytes con el nuevo žRcomando sugerido por Kevin Cruijssen

žRsм

Pruébalo en línea! o como un conjunto de pruebas

Explicación

   м  # 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 guardados gracias a @KritixiLithos .

Código de prueba:

Pruébalo aquí

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

Salida:

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

En realidad , 7 bytes

"LEJ"-Σ

Pruébalo en línea!

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

Pyth, 5 bytes

-"ABC

Pruébalo aquí

Se expande a

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

MATL, 10 8 bytes

Guardado dos bytes gracias a Suever. setdiffes más corto que ismember.

'ABC'iX-

Pruébalo aquí!

Explicación

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

Sí, esta podría haber sido una tarea trivial, pero estoy bastante satisfecho de que logré resolverlo con MATL solo. _{Nunca dije que era la solución más corta ... ¡Gracias, Suever!}

JavaScript ES6, 41 39 38 Bytes

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

Guardado 2 bytes gracias a Arnauld. Guardado 1 bytes gracias a LarsW.

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

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

V , 10 bytes

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

Pruébalo en línea!

Hexdump:

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

Explicación

La entrada está en la primera línea del búfer. Entonces algo como:

EL

y el cursor está en el primer carácter. Entonces, eliminamos la entrada (que la almacena en el registro ") y entramos en modo de inserción simultáneamente usando C.

Una vez en el modo de inserción, LEJse insertan los caracteres , después de lo cual vuelvo al modo normal usando <ESC>.

Ahora tenemos que eliminar todos los caracteres que están presentes en la entrada.

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

Y una vez que esto sucede, nos quedan las letras restantes en el búfer.

Ruby, 27 19 18 bytes

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

-1 byte gracias a Martin Ender

Haskell , 27 26 bytes

import Data.List
("ABC"\\)

Pruébalo en línea! Uso: ("ABC"\\) "CB"rendimientos "A".

\\es el operador de diferencia de conjunto, el paréntesis forma una sección llamada que es una forma abreviada de lamda (\x -> "ABC" \\ x).

Sin importación: (mismo número de bytes gracias a @nimi)

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

Pruébalo en línea! Uso: f "CB"rendimientos "A".

Otros enfoques:

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

GNU sed , 34 29 bytes

Incluye +1 para -r

-5 gracias a Digital Trauma

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

Pruébalo en línea!

Por alguna razón, TIO no funciona con regex extendido ( -r), así que tuve que envolverlo en 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

Brain-Flak , 120 + 3 = 123 bytes

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

Se ejecuta con la -cbandera, agregando 3 bytes

Pruébalo en línea!

Explicación

En general, este programa hace el conjunto de la pila derecha menos la pila izquierda con la pila derecha inicializada CBAy la pila izquierda inicializada en la entrada.

Código anotado

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

Más explicaciones por venir ...

Mathematica, 37 bytes

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

Zanahoria , 15 bytes, no competitiva

no compite debido a un error que encontré al devolver coincidencias y cadenas vacías. Así que lo arreglé

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

Pruébalo en línea! (copiar pegar)

Explicación

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-

Pruébalo en línea! (Como un conjunto de pruebas separado por salto de línea).

MATLAB / Octave, 20 bytes

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

Demo en línea

Octava, 29 27 bytes

Ahorré dos bytes gracias a Suever, al crear la cadena 'ABC', dentro de la ismemberllamada.

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

Usamos ~ismember()como índices lógicos a la variable x. Lo peculiar es que creamos x='ABC' adentro ismember , no enfrente. El orden que Octave ve esto:

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

donde iesta la entrada:

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

Aplicación completa probada en 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));
}

Resultados de la prueba

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'∘~

~se establece resta, ∘se compone, por lo que esta es una función que devuelve ABCmenos los caracteres en su entrada.

Medusa , 9 bytes

PNI
 "ABC

Pruébalo en línea!

En notación más convencional, este programa se traduce en:

P(N("ABC", I))

Ies la entrada, Nes la diferencia de la lista y Pes la salida.

Perl 5.9.9 79 38 37 35 bytes

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

(no estoy seguro de las reglas de conteo aquí: han incluido interruptores pero no el comando perl).

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

(recuentos ajustados después del comentario de adjudicación a continuación)

Lisp común, 71 bytes

La entrada más grande en este momento, pero al menos es legible ;-)

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

Japt , 13 12 bytes

"ABC"r"[{U}]

Guardado un byte gracias a ETHproductions.

Pruébalo en línea!

Pyth, 4 bytes

-<G3

Pruébalo aquí!

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

Tenga en cuenta que esto usa minúsculas, lo que podría no ser aceptable

C, 53 bytes

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

Si no se permiten declaraciones implícitas de string.h, 72 bytes , para agregar#include<string.h>

Pruébalo en línea!

o algo un poco más divertido a 75 bytes

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

Pruébalo en línea!

Lote, 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

Toma entrada en STDIN, lo que significa que %1está vacío cuando el código cae en la subrutina auxiliar y no se imprime nada.

R , 47 40 bytes

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

Pruébalo en línea!

Reemplaza cualquier letra en la cadena de entrada con la cadena vacía.