Ingresso

Una stringa che contiene al massimo una di ciascuna delle lettere A, Be C. Possono essere in qualsiasi ordine. La stringa vuota è un input valido.

^{Nota: una versione precedente di questa sfida utilizzava le lettere LEJanziché ABCe, se lo si desidera, possono comunque essere utilizzate.}

Produzione

Una stringa di A, B, Clettere che non erano presenti nell'input. Possono essere in qualsiasi ordine.

Se l'output sarebbe la stringa vuota, allora semplicemente dare nessun output è valido, se questo ha senso per la tua implementazione. (ad es. non è necessario chiamare effettivamente printuna stringa vuota.)

Esempi

• Se l'input è Ballora l'output dovrebbe essere CAo ACpoiché Ae Cnon è presente nell'input.
• Se l'input è la stringa vuota, allora dovrebbe essere l'output ABCo qualsiasi permutazione poiché nessuna delle tre lettere è presente nell'input.
• Se l'input è CABallora l'output dovrebbe essere la stringa vuota perché tutte e tre le lettere sono presenti nell'input.

Casi test

Ci sono così pochi casi di input che possiamo elencarli tutti:

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

Vengono forniti tutti gli output validi per ciascun input, separati da |'s. ""rappresenta la stringa vuota

punteggio

Vince il codice più breve in byte. Ma tieni presente che potresti ottenere più riconoscimenti per risolvere la sfida in un modo unico piuttosto che in un modo breve;)

Python 3, 29 27 22 byte

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

-2 byte grazie a Jonathan Allan

-5 byte grazie a Rod

Gelatina , 4 byte

Grazie a @DuctrTape per l'informazione sul cambiamento e la presenza di "ABC" nel dizionario di Jelly.

“ḃ»ḟ

Provalo online!

“ḃ»cerca la voce "ABC" nel dizionario di Jelly, ḟè il filer scartare la diade che scarta i caratteri trovati nell'input da quell'elenco di caratteri. Il risultato viene stampato implicitamente.

Per una versione in minuscolo la voce del dizionario da utilizzare può essere "abac" ( “c») o "abaca" ( “i»).

Quando la sfida era "LEJ", nella variante maiuscola potevano essere raggiunti solo 6 byte, poiché non esiste alcuna voce del dizionario con quel set di caratteri, lasciandoci a creare la lista di caratteri “LEJ”(o una sua permutazione).

La variante minuscola è migliorata a 5 byte a causa della presenza della parola "gelatina" ( “ẎṄ»).

Bash + coreutils, 15 byte

tr -d x$1<<<LEJ

Provalo online!

Vorrei omettere il x, ma poi mi tr -dmancherebbe un argomento quando la stringa di input era vuota. ( xNon fa alcun danno, dal momento che non ci sono x nella LEJ qui-stringa.) Normalmente scrivo tr -d "$1", ma farlo nel modo che ho fatto è un byte più corto di quello.

Retina , 14 byte

Il conteggio dei byte presuppone la codifica ISO 8859-1.

$
¶ABC
D`.
A1`

Provalo online!

Spiegazione

$
¶ABC

Aggiungi una seconda riga contenente ABC.

D`.

Deduplica i personaggi. Questo elimina tutti i caratteri dalla seconda riga che appare già nella prima riga.

A1`

Elimina la prima riga.

05AB1E , 6 4 byte

Salvato 2 byte usando il nuovo žRcomando come suggerito da Kevin Cruijssen

žRsм

Provalo online! o come una suite di test

Spiegazione

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

Java 7, 73 58 byte

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

15 byte salvati grazie a @KritixiLithos .

Codice di prova:

Provalo qui.

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

Produzione:

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

In realtà , 7 byte

"LEJ"-Σ

Provalo online!

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

Pyth, 5 byte

-"ABC

Provalo qui

Si espande a

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

MATL, 10 8 byte

Due byte salvati grazie a Suever. setdiffè più corto di ismember.

'ABC'iX-

Provalo qui!

Spiegazione

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

Sì, questo potrebbe essere stato un compito banale, ma sono abbastanza soddisfatto di essere riuscito a risolverlo con MATL da solo. _{Non ho mai detto che fosse la soluzione più breve ... Grazie Suever!}

JavaScript ES6, 41 39 38 byte

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

Salvato 2 byte grazie ad Arnauld. Salvato 1 byte grazie a LarsW.

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

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

V , 10 byte

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

Provalo online!

hexdump:

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

Spiegazione

L'input è sulla prima riga del buffer. Quindi qualcosa del tipo:

EL

e il cursore si trova sul primo carattere. Quindi eliminiamo l'input (che lo memorizza nel registro ") e accediamo contemporaneamente alla modalità insert C.

Una volta in modalità inserimento, i caratteri LEJvengono inseriti, dopodiché torno alla modalità normale usando <ESC>.

Ora dobbiamo rimuovere tutti i caratteri presenti nell'input.

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

E una volta che ciò accade, ci rimangono le lettere rimanenti nel buffer.

Rubino, 27 19 18 byte

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

-1 byte grazie a Martin Ender

Haskell , 27 26 byte

import Data.List
("ABC"\\)

Provalo online! Utilizzo: ("ABC"\\) "CB"rese "A".

\\è l'operatore differenza impostata, la parentesi forma una cosiddetta sezione che è una forma abbreviata per il lamda (\x -> "ABC" \\ x).

Senza importazione: (stesso conteggio dei byte grazie a @nimi)

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

Provalo online! Utilizzo: f "CB"rese "A".

Altri approcci:

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

GNU sed , 34 29 byte

Include +1 per -r

-5 grazie a Digital Trauma

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

Provalo online!

Per qualche motivo TIO non funziona con regex esteso ( -r), quindi ho dovuto inserirlo in 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 byte

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

Viene eseguito con il -cflag, aggiungendo 3 byte

Provalo online!

Spiegazione

Nel complesso questo programma fa praticamente lo stack di destra meno lo stack di sinistra con lo stack di destra inizializzato su CBAe lo stack di sinistra inizializzato sull'input.

Codice annotato

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

Altre spiegazioni a venire ...

Mathematica, 37 byte

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

Carota , 15 byte, non competitiva

non competitiva a causa di un bug che ho trovato con le partite di ritorno e le stringhe vuote. Quindi l'ho appena risolto

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

Provalo online! (copia incolla)

Spiegazione

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 byte

"ABC"l-

Provalo online! (Come una suite di test separata da avanzamento riga.)

MATLAB / Ottava, 20 byte

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

Demo online

Ottava, 29 27 byte

Salvato due byte grazie a Suever, creando la stringa 'ABC', all'interno della ismemberchiamata.

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

Usiamo ~ismember()come indici logici per la variabile x. La cosa peculiare è che creiamo x='ABC' dentro ismember , non di fronte. L'ordine Octave vede questo:

@(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 byte 32 byte 47 byte 35 byte

dov'è il'input:

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

App completa testata in 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));
}

Risultati del test

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 byte

'ABC'∘~

~viene impostata la sottrazione, ∘è composta, quindi questa è una funzione che restituisce ABCmeno i caratteri nel suo input.

Medusa , 9 byte

PNI
 "ABC

Provalo online!

In notazione più convenzionale, questo programma si traduce in:

P(N("ABC", I))

Iè l'input, Nè la differenza dell'elenco e Pviene emesso.

Perl 5,9,9 79 38 37 35 byte

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

(non sono sicuro delle regole di conteggio qui - hanno incluso gli switch ma non il comando perl).

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

(conteggi corretti dopo il commento di aggiudicazione di seguito)

Lisp comune, 71 byte

La voce più grande al momento, ma almeno è leggibile ;-)

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

Japt , 13 12 byte

"ABC"r"[{U}]

Salvataggio di un byte grazie a ETHproductions.

Provalo online!

Pyth, 4 byte

-<G3

Provalo qui!

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

Nota che utilizza lettere minuscole che potrebbero non essere accettabili

C, 53 byte

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

Se non sono consentite dichiarazioni implicite di string.h, 72 byte , da aggiungere#include<string.h>

Provalo online!

o qualcosa di un po 'più divertente a 75 byte

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

Provalo online!

Lotto, 101 byte

@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

Accetta input su STDIN, il che significa che %1è vuoto quando il codice rientra nella subroutine helper e non viene stampato nulla.

R , 47 40 byte

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

Provalo online!

Sostituisce qualsiasi lettera nella stringa di input con la stringa vuota.