Tan fácil como el ABC

28

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;)

Pasatiempos de Calvin
fuente
1
La tarea es establecer la diferencia entre una constante y una entrada. Requerir que todo se haga en cadenas es engorroso con respecto a la dificultad de la tarea real.
Mego
2
Recuerdo vagamente una coincidencia de duplicados más exacta donde tenías que restar la entrada de un conjunto constante.
xnor
1
¿Pueden las entradas contener letras fuera de "ABC"? La especificación: "Una cadena que contiene como máximo una de cada una de las letras A, B y C" no excluye tales entradas.
theonlygusti
1
@theonlygusti La entrada solo debe contener ABC
Calvin's Hobbies

Respuestas:

20

Python 3, 29 27 22 bytes

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

-2 bytes gracias a Jonathan Allan

-5 bytes gracias a Rod

Trelzevir
fuente
print(*{*"LEJ"}-{*input()})ahorra 2. (probado en 3.5 y 3.6).
Jonathan Allan
14
Me encanta python ❤️
theonlygusti
@theonlygusti ¿Qué pasó con <3 y ♥?
wizzwizz4
@theonlygusti: Me encantaría Python si puedo reemplazar lamda con 𝛌
Fahim Parkar
10

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" ( “ẎṄ»).

Jonathan Allan
fuente
1
Me gusta cómo la mayoría del código solo genera la cadena "ABC", y el programa en sí mismo es un carácter. Gelatina clásica.
sagiksp
6

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.

Mitchell Spector
fuente
También tuve los mismos pensamientos, incluso con las citas, de inmediato.
rexkogitans
6

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.

Martin Ender
fuente
¿Cómo funciona exactamente la 1`parte de la etapa antigrep?
Kritixi Lithos
@KritixiLithos Los números en la cadena de configuración son límites. 1generalmente significa "solo hacer X una vez". La forma exacta en que el trabajo limita (es decir, qué es X) depende del tipo de etapa que esté utilizando. Para las etapas antigiro, Retina primero verifica qué líneas coinciden con la expresión regular (aquí, cada línea, ya que la expresión regular está vacía), pero luego el límite significa "solo descartar la primera línea coincidente". Del mismo modo, si se tratara de una etapa grep, significaría "solo mantener la primera línea coincidente". La semántica de todos los límites se enumera en la wiki .
Martin Ender
6

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"
Emigna
fuente
¿No debería una entrada de solo Jretorno EL, LE?
Urna mágica de pulpo
2
¡Agradable! Al igual que para su información, las entradas también se pueden representar como """{input}""", lo que también funciona para cadenas vacías :).
Adnan
@carusocomputing: puede regresar (en este caso, regresa LE).
Emigna
1
Puede ser de 4 bytes ahora
Kevin Cruijssen
1
@Emigna Tbh no. Creo que quizás se agregó debido a este desafío, pero personalmente no lo he usado antes.
Kevin Cruijssen
5

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
Kevin Cruijssen
fuente
1
¿Se puede hacer en "["+s+"]"lugar de s.replaceAll("(.)","$1|")?
Kritixi Lithos
@KritixiLithos Smart. Falla para la cadena vacía, pero al agregar un espacio (o cualquier otro carácter que no lo sea EJL) funciona nuevamente, que aún es mucho más corto. :)
Kevin Cruijssen
5

Pyth, 5 bytes

-"ABC

Pruébalo aquí

Se expande a

-"ABC"Q
-       # Filter on absence
 "ABC"  # Literal string 
      Q # Input
Barra
fuente
abc se puede escribir como<G3
Maltysen
@Maltysen, sí, el pez lodo lo usó, pero de todos modos es minúscula = \
Rod
4

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!

Stewie Griffin
fuente
4

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

Tom
fuente
Estoy en el móvil, así que no puedo probar mi código, pero creo que debería funcionar:s=>eval`'ABC'.replace(/[${s}]/g,'')`
LarsW
¡Buen trabajo! Ser capaz de decir .join``le ahorra dos personajes más de la solución que había llegado con: f=s=>"ABC".replace(RegExp(`[${s}]`,'g'),"").
nnnnnn
1
@LarsW Ese código exacto no parecía funcionar, pero agregar corchetes alrededor de la cadena de la plantilla sí lo hizo y guardó un byte. ¡Gracias!
Tom
3

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.

Kritixi Lithos
fuente
3

Ruby, 27 19 18 bytes

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

-1 byte gracias a Martin Ender

GB
fuente
3

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]
Laikoni
fuente
1
Espero (\\)ser trasladado a Preludio pronto.
theonlygusti
@theonlygusti Espero que no lo haga; Esto no es realmente una operación sensata para las listas (al menos no a menos que declares explícitamente que quieres lista como conjunto). La operación predeterminada para esa tarea debería ser Data.Set.difference.
dejó de girar en sentido contrario a las agujas del reloj
@ceasedtoturncounterclockwis ¿por qué no es sensato? Además, la única razón por la que deseo que se mueva es porque es útil, con frecuencia.
theonlygusti
1
@theonlygusti no es sensato en el sentido de que si te encuentras usándolo, es una señal de que probablemente estés usando la estructura de datos incorrecta. Las listas pueden tener elementos duplicados, un orden, y pueden construirse perezosamente (incluso infinitas). (\\)no respeta nada de esto Los tipos de datos destinados a este comportamiento tienen una estructura que los hace generalmente bastante más eficientes, más seguros (porque no se pueden romper los supuestos de estabilidad, etc.) y exponen una interfaz más cómoda.
dejó de girar en sentido contrario a las agujas del reloj
@ceasedtoturncounterclockwis qué, sí lo hace. "La primera instancia de ..." pero nvm
theonlygusti
3

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
Riley
fuente
La nueva línea, -ny Pson innecesarios. También puede concluir esto en bash para que funcione en TIO. No tengo idea de por qué -rno funciona. tio.run/nexus/bash#DcmxDYAwDATA/qdIR4JELCjp7F8jooIFCPubb@/…
Trauma digital
@DigitalTrauma ¡Gracias! Estaba pensando que habría caracteres además de A, B y C cuando escribí esto.
Riley
3

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 ...

0 '
fuente
2

Mathematica, 37 bytes

Complement@@Characters@{"ABC",#}<>""&
Martin Ender
fuente
¿Hay alguna razón por la que usaste cadenas aquí en lugar de listas de caracteres?
Greg Martin
Hábito @GregMartin, supongo
Martin Ender
solo que creo que sale más corto si puedes evitarloCharacters
Greg Martin
2

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
Kritixi Lithos
fuente
2

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
Stewie Griffin
fuente
2

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

Michael Coxon
fuente
1
Esa no es una respuesta válida, tiene que ser una función o un programa, no un fragmento de código.
theonlygusti
Ah Mi error. Primer temporizador aquí. ¿Entonces necesito la parte impresa?
Michael Coxon
@MichaelCoxon: debe ingresar la entrada en un programa completo, que compila (no recomendado en C #, tiene muchas repeticiones), o en una función que se puede llamar varias veces; por el momento es solo una declaración. En C #, casi siempre es más fácil convertirlo en una función creando una lambda, que toma la entrada a través de sus argumentos y regresa a través de su valor de retorno.
string.Join("",...)-> string.Concat(...)Ahorra 1 byte
Encarnación de la ignorancia
1

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.

marinus
fuente
1

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.

Martin Ender
fuente
1

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)

Tom Tanner
fuente
¿Funcionará para una entrada vacía?
Titus
Ahora arreglé el error de transcripción (tenía "..", escribí {,,} aquí ...)
Tom Tanner
Su código tiene 35 bytes de longitud. (34 +1 para la -lbandera). :)
Paul Picard
Gracias. El -l es para la prettificación (como en una nueva línea al final de la salida). no estaba seguro si eso era necesario según las reglas del concurso.
Tom Tanner
Con 5.14+ , puede hacerlo perl -pe'$_=eval"ABC=~y/$_//dr"'por solo 23 bytes (22 + 1 para -p).
ThisSuitIsBlackNot
1

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))
volcado de memoria
fuente
1

Japt , 13 12 bytes

"ABC"r"[{U}]

Guardado un byte gracias a ETHproductions.

Pruébalo en línea!

Tom
fuente
Bien, gracias por usar Japt! Puede eliminar la cita final para guardar un byte.
ETHproductions
1

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

Azul
fuente
1

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!

Ahemone
fuente
52 bytes
techo
1

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.

Neil
fuente
1

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.

BLT
fuente