Eingang

Ein String, der höchstens eine von jedem des Buchstaben enthält A, Bund C. Sie können in beliebiger Reihenfolge sein. Die leere Zeichenfolge ist eine gültige Eingabe.

^{Hinweis: In einer früheren Version dieser Herausforderung wurden die Buchstaben LEJanstelle von verwendet, ABCund sie können weiterhin verwendet werden, wenn dies gewünscht wird.}

Ausgabe

Eine Reihe von den A, B, CBuchstaben , die nicht in der Eingabe waren. Sie können in beliebiger Reihenfolge sein.

Wenn es sich bei der Ausgabe um eine leere Zeichenfolge handelt, ist es nur gültig, keine Ausgabe anzugeben, wenn dies für Ihre Implementierung sinnvoll ist. (Sie müssen beispielsweise keine printleere Zeichenfolge aufrufen .)

Beispiele

• Wenn es sich bei der Eingabe um eine Eingabe handelt, sollte Bdie Ausgabe entweder "da" CAoder " ACda" sein Aund Cnicht in der Eingabe vorhanden sein.
• Wenn die Eingabe eine leere Zeichenfolge ist, sollte die Ausgabe eine ABCbeliebige Permutation sein, da keiner der drei Buchstaben in der Eingabe vorhanden ist.
• Wenn die Eingabe ist, sollte CABdie Ausgabe die leere Zeichenfolge sein, da alle drei Buchstaben in der Eingabe vorhanden sind.

Testfälle

Es gibt so wenige Eingabefälle, dass wir sie alle aufzählen können:

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

Alle gültigen Ausgaben für jede Eingabe werden durch |'s getrennt angegeben. ""steht für die leere Zeichenfolge

Wertung

Der kürzeste Code in Bytes gewinnt. Bedenken Sie jedoch, dass Sie möglicherweise mehr Anerkennung dafür erhalten, dass Sie die Herausforderung eher auf einzigartige als auf kurze Weise gelöst haben ;)

Python 3, 29 27 22 Bytes

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

-2 Bytes dank Jonathan Allan

-5 Bytes dank Rod

Gelee , 4 Bytes

Vielen Dank an @DuctrTape für den Artikel über die Änderung und das Vorhandensein von "ABC" in Jellys Wörterbuch.

“ḃ»ḟ

Probieren Sie es online!

“ḃ»schlägt den Eintrag "ABC" in Jellys Wörterbuch nach, ḟist die Filer-Discard-Dyade, die die in der Eingabe gefundenen Zeichen aus dieser Zeichenliste verwirft. Das Ergebnis wird implizit gedruckt.

Für eine Kleinbuchstabenversion kann der zu verwendende Wörterbucheintrag entweder "abac" ( “c») oder "abaca" ( “i») sein.

Wenn die Herausforderung "LEJ" war, konnten in der Großbuchstabenvariante nur 6 Bytes erreicht werden, da mit diesem Zeichensatz keine Wörterbucheinträge vorhanden sind, so dass wir die Liste der Zeichen “LEJ”(oder eine Permutation davon) erstellen müssen .

Die Kleinbuchstabenvariante lag aufgrund des Wortes "jell" ( ) besser bei 5 Bytes “ẎṄ».

Bash + Coreutils, 15 Bytes

tr -d x$1<<<LEJ

Probieren Sie es online!

Ich möchte das weglassen x, aber dann tr -dwürde ein Argument fehlen, wenn die Eingabezeichenfolge leer war. (Das xschadet nicht, da im LEJ der Here-Zeichenfolge keine X enthalten sind.) Normalerweise würde ich schreiben tr -d "$1", aber so wie ich es getan habe, ist es ein Byte kürzer.

Retina , 14 Bytes

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.

$
¶ABC
D`.
A1`

Probieren Sie es online!

Erläuterung

$
¶ABC

Fügen Sie eine zweite Zeile hinzu, die Folgendes enthält ABC.

D`.

Deduplizieren Sie die Zeichen. Dies löscht jedes Zeichen aus der zweiten Zeile, die bereits in der ersten Zeile erscheint.

A1`

Verwerfen Sie die erste Zeile.

05AB1E , 6 4 Bytes

2 Bytes mit dem neuen žRBefehl gespeichert, wie von Kevin Cruijssen vorgeschlagen

žRsм

Probieren Sie es online! oder als Test Suite

Erläuterung

   м  # 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+"]","");}

Dank @KritixiLithos werden 15 Bytes eingespart .

Testcode:

Probieren Sie es hier aus.

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

Ausgabe:

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

Eigentlich 7 Bytes

"LEJ"-Σ

Probieren Sie es online!

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

Pyth, 5 Bytes

-"ABC

Teste es hier

Erweitert sich zu

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

MATL, 10 8 Bytes

Zwei Bytes gespart dank Suever. setdiffist kürzer als ismember.

'ABC'iX-

Probieren Sie es hier aus!

Erläuterung

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

Ja, dies mag eine triviale Aufgabe gewesen sein, aber ich bin sehr zufrieden, dass ich es geschafft habe, sie mit MATL ganz alleine zu lösen. _{Ich habe nie gesagt, dass es die kürzeste Lösung ist ... Danke, Suever!}

JavaScript ES6, 41 39 38 Bytes

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

2 Bytes dank Arnauld gespeichert. Dank LarsW 1 Byte gespeichert.

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

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

V , 10 Bytes

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

Probieren Sie es online!

Hexdump:

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

Erläuterung

Die Eingabe erfolgt in der ersten Zeile des Puffers. Also so etwas wie:

EL

und der Cursor befindet sich auf dem ersten Zeichen. Also löschen wir den Eingang (der ihn im Register speichert ") und gehen gleichzeitig mit in den Einfügemodus C.

Sobald LEJich mich im Einfügemodus befinde, werden die Zeichen eingefügt. Danach kehre ich mit in den normalen Modus zurück <ESC>.

Jetzt müssen wir alle Zeichen entfernen, die in der Eingabe vorhanden sind.

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

Und sobald dies passiert ist, verbleiben die restlichen Buchstaben im Puffer.

Ruby, 27 19 18 Bytes

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

-1 Byte dank Martin Ender

Haskell , 27 26 Bytes

import Data.List
("ABC"\\)

Probieren Sie es online! Verbrauch: ("ABC"\\) "CB"Erträge "A".

\\ist der gesetzte Differenzoperator, die Klammern bilden einen sogenannten Abschnitt, der eine Kurzform für das Lamda ist(\x -> "ABC" \\ x) .

Ohne Import: (gleiche Byteanzahl dank @nimi)

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

Probieren Sie es online! Verbrauch: f "CB"Erträge"A" .

Andere Ansätze:

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

GNU sed , 34 29 Bytes

Beinhaltet +1 für -r

-5 dank Digital Trauma

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

Probieren Sie es online!

Aus irgendeinem Grund funktioniert TIO nicht mit Extended Regex ( -r), daher musste ich es in BASH packen.

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

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

Es wird mit dem -cFlag ausgeführt und fügt 3 Bytes hinzu

Probieren Sie es online!

Erläuterung

Insgesamt setzt dieses Programm so ziemlich den rechten Stapel minus den linken Stapel, auf den der rechte Stapel initialisiert ist CBA und der linke Stapel auf die Eingabe initialisiert wird.

Kommentierter Code

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

Weitere Erklärung zu kommen ...

Mathematica, 37 Bytes

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

Karotte , 15 Bytes, nicht konkurrierend

Nicht konkurrierend wegen eines Fehlers, den ich bei der Rückgabe von Übereinstimmungen und leeren Zeichenfolgen gefunden habe. Also habe ich es einfach behoben

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

Probieren Sie es online! (Kopieren Einfügen)

Erläuterung

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-

Probieren Sie es online! (Als durch Zeilenvorschub getrennte Testsuite.)

MATLAB / Octave, 20 Bytes

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

Online Demo

Oktave, 29 27 Bytes

Dank Suever konnten zwei Bytes gespart werden, indem die Zeichenfolge 'ABC'innerhalb des ismemberAufrufs erstellt wurde.

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

Wir verwenden ~ismember()als logische Indizes für die Variable x. Die eigentümliche Sache ist, wir erschaffen im x='ABC' Inneren ismember , nicht davor. Die Reihenfolge Octave sieht so aus:

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

Wo iist die Eingabe:

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

Vollständige App in LINQPad getestet

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

Testergebnisse

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

~Ist die Subtraktion gesetzt, ∘wird komponiert. Dies ist eine Funktion, die ABCminus der Zeichen in ihrer Eingabe zurückgibt .

Qualle , 9 Bytes

PNI
 "ABC

Probieren Sie es online!

In konventioneller Notation übersetzt dieses Programm:

P(N("ABC", I))

Iist die Eingabe, Nist Listendifferenz und Pwird ausgegeben.

Perl 5.9.9 79 38 37 35 Bytes

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

(Ich bin mir der Zählregeln hier nicht sicher - habe Schalter enthalten, aber nicht den Perl-Befehl).

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

(Angepasste Zählungen nach dem Kommentar unten)

Common Lisp, 71 Bytes

Der derzeit größte Eintrag, aber zumindest lesbar ;-)

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

Japt , 13 12 Bytes

"ABC"r"[{U}]

Dank ETHproductions ein Byte gespart.

Probieren Sie es online!

Pyth, 4 Bytes

-<G3

Probieren Sie es hier aus!

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

Beachten Sie, dass Kleinbuchstaben verwendet werden, die möglicherweise nicht akzeptiert werden

C 53 Bytes

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

Wenn implizite Deklarationen von string.h nicht zulässig sind, 72 Byte hinzugefügt werden#include<string.h>

Probieren Sie es online!

oder etwas mehr Spaß bei 75 Bytes

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

Probieren Sie es 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

Übernimmt die Eingabe in STDIN, was bedeutet, dass sie %1leer ist, wenn der Code in die Hilfsunterroutine gelangt und nichts gedruckt wird.

R , 47 40 Bytes

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

Probieren Sie es online!

Ersetzt alle Buchstaben in der Eingabezeichenfolge durch die leere Zeichenfolge.