Wkład

Ciąg znaków, który zawiera co najwyżej jeden z każdego z pism A, Boraz C. Mogą być w dowolnej kolejności. Pusty ciąg jest prawidłowym wejściem.

^{Uwaga: poprzednia wersja tego wyzwania używała liter LEJzamiast ABCi mogą być nadal używane w razie potrzeby.}

Wydajność

Łańcuch z A, B, Cliter, które nie były obecne na wejściu. Mogą być w dowolnej kolejności.

Jeśli dane wyjściowe byłyby pustym łańcuchem, po prostu nie dawanie żadnego wyniku jest poprawne, jeśli ma to sens dla twojej implementacji. (np. nie musisz wywoływać printpustego ciągu).

Przykłady

• Jeśli wejście jest, Bwówczas wyjście powinno być CAalbo ACodtąd Ai Cnie jest obecne na wejściu.
• Jeśli wejście jest pustym ciągiem, wyjście powinno być ABClub jakąkolwiek permutacją, ponieważ żadna z trzech liter nie jest obecna na wejściu.
• Jeśli wejście jest, CABto wyjście powinno być pustym ciągiem, ponieważ wszystkie trzy litery są obecne na wejściu.

Przypadki testowe

Jest tak mało przypadków wprowadzania danych, że możemy wyliczyć je wszystkie:

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

Podane są wszystkie prawidłowe dane wyjściowe dla każdego wejścia, oddzielone przez |'s. ""reprezentuje pusty ciąg

Punktacja

Najkrótszy kod w bajtach wygrywa. Pamiętaj jednak, że możesz zyskać więcej uznania za rozwiązanie wyzwania w sposób wyjątkowy, a nie na krótki;)

Python 3, 29 27 22 bajtów

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

-2 bajty dzięki Jonathanowi Allanowi

-5 bajtów dzięki Rod

Galaretka , 4 bajty

Dzięki @DuctrTape dla producenta o zmianie i obecności „ABC” w słowniku Jelly.

“ḃ»ḟ

Wypróbuj online!

“ḃ»wyszukuje wpis „ABC” w słowniku Jelly, ḟjest to dyada odrzutu plików, która odrzuca znaki znalezione na wejściu z tej listy znaków. Wynik zostanie domyślnie wydrukowany.

W przypadku wersji z małymi literami wpis w słowniku może być „abac” ( “c») lub „abaca” ( “i»).

Gdy wyzwaniem było „LEJ”, w wariancie wielkimi literami można było osiągnąć tylko 6 bajtów, ponieważ dla tego zestawu znaków nie istnieją wpisy słownika, co pozwala nam utworzyć listę znaków “LEJ”(lub ich permutację).

Wariant z małymi literami lepiej zadziałał przy 5 bajtach ze względu na obecność słowa „jell” ( “ẎṄ»).

Bash + coreutils, 15 bajtów

tr -d x$1<<<LEJ

Wypróbuj online!

Chciałbym pominąć x, ale tr -dnie byłoby argumentu, gdy łańcuch wejściowy był pusty. ( xNie wyrządza to żadnej szkody, ponieważ nie ma żadnych znaków x w tym łańcuchu LEJ.) Normalnie bym napisał tr -d "$1", ale robienie tego tak, jak zrobiłem, jest o jeden bajt krótsze.

Siatkówka , 14 bajtów

Liczba bajtów zakłada kodowanie ISO 8859-1.

$
¶ABC
D`.
A1`

Wypróbuj online!

Wyjaśnienie

$
¶ABC

Dodaj drugi wiersz zawierający ABC.

D`.

Deduplikuj postacie. Spowoduje to usunięcie każdego znaku z drugiego wiersza, który już pojawia się w pierwszym wierszu.

A1`

Odrzuć pierwszą linię.

05AB1E , 6 4 bajtów

Zaoszczędzono 2 bajty, używając nowego žRpolecenia, zgodnie z sugestią Kevina Cruijssena

žRsм

Wypróbuj online! lub jako pakiet testowy

Wyjaśnienie

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

Java 7, 73 58 bajtów

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

15 bajtów zapisanych dzięki @KritixiLithos .

Kod testowy:

Wypróbuj tutaj.

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

Wydajność:

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

Właściwie 7 bajtów

"LEJ"-Σ

Wypróbuj online!

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

Pyth, 5 bajtów

-"ABC

Sprawdź to tutaj

Rozwija się do

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

MATL, 10 8 bajtów

Zaoszczędził dwa bajty dzięki Suever. setdiffjest krótszy niż ismember.

'ABC'iX-

Wypróbuj tutaj!

Wyjaśnienie

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

Tak, to mogło być trywialne zadanie, ale jestem całkiem zadowolony, że udało mi się to rozwiązać samodzielnie za pomocą MATL-a. _{Nigdy nie powiedziałem, że to najkrótsze rozwiązanie ... Dzięki, Suever!}

JavaScript ES6, 41 39 38 bajtów

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

Zaoszczędź 2 bajty dzięki Arnauldowi. Zaoszczędzono 1 bajt dzięki LarsW.

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

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

V , 10 bajtów

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

Wypróbuj online!

Hexdump:

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

Wyjaśnienie

Dane wejściowe znajdują się w pierwszym wierszu bufora. Więc coś takiego:

EL

a kursor znajduje się na pierwszym znaku. Usuwamy więc dane wejściowe (które przechowują je w rejestrze ") i jednocześnie wchodzimy w tryb wstawiania C.

W trybie wstawiania znaki LEJsą wstawiane, po czym wracam do trybu normalnego za pomocą <ESC>.

Teraz musimy usunąć wszystkie znaki, które są obecne na wejściu.

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

A gdy to się stanie, pozostaniemy z pozostałymi literami w buforze.

Ruby, 27 19 18 bajtów

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

-1 bajt dzięki Martin Ender

Haskell , 27 26 bajtów

import Data.List
("ABC"\\)

Wypróbuj online! Zastosowanie: ("ABC"\\) "CB"plony"A" .

\\jest operatorem ustawionej różnicy, nawias tworzy tak zwaną sekcję, która jest krótką formą dla lamdy (\x -> "ABC" \\ x).

Bez importu: (ta sama liczba bajtów dzięki @nimi)

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

Wypróbuj online! Zastosowanie: f "CB"plony "A".

Inne podejścia:

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

GNU sed , 34 29 bajtów

Obejmuje +1 dla -r

-5 dzięki Digital Trauma

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

Wypróbuj online!

Z jakiegoś powodu TIO nie działa z rozszerzonym wyrażeniem regularnym (-r ), więc musiałem zawinąć go w 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 bajty

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

Jest uruchamiany z -cflagą, dodając 3 bajty

Wypróbuj online!

Wyjaśnienie

Ogólnie rzecz biorąc, ten program właściwie ustawia prawy stos minus lewy stos, a prawy stos jest inicjowany, CBAa lewy stos inicjowany do wejścia.

Kod z adnotacjami

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

Więcej wyjaśnień w przyszłości ...

Mathematica, 37 bajtów

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

Marchewka , 15 bajtów, niekonkurująca

niekonkuruje z powodu błędu, który znalazłem przy zwracaniu dopasowań i pustych ciągów. Właśnie to naprawiłem

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

Wypróbuj online!(kopiuj wklej)

Wyjaśnienie

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 bajtów

"ABC"l-

Wypróbuj online! (Jako zestaw testów oddzielony od linii).

MATLAB / Octave, 20 bajtów

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

Demo online

Oktawa, 29 27 bajtów

Zaoszczędził dwa bajty dzięki Suever, tworząc ciąg 'ABC'w ismemberwywołaniu.

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

Używamy ~ismember()jako logicznych wskaźników dla zmiennej x. Osobliwe jest to, że tworzymy x='ABC' wewnątrz ismember , a nie przed nim. Kolejność Octave widzi to:

@(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 bajtów 32 bajty 47 bajtów 35 bajtów

gdzie ijest wejście:

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

Pełna aplikacja przetestowana w 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));
}

Wyniki testów

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 bajtów

'ABC'∘~

~jest ustawione odejmowanie, ∘jest komponowane, więc jest to funkcja zwracająca ABCminus znaki na wejściu.

Meduza , 9 bajtów

PNI
 "ABC

Wypróbuj online!

W bardziej konwencjonalnej notacji program ten przekłada się na:

P(N("ABC", I))

Ijest wejściem, Nróżnicą listy i Pwyjściem.

Perl 5,9,9 79 38 37 35 bajtów

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

(nie jestem pewien zasad liczenia tutaj - uwzględniły przełączniki, ale nie polecenie perl).

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

(skorygowane zliczenia po komentarzu o orzeczeniu poniżej)

Common Lisp, 71 bajtów

Największy w tej chwili wpis, ale przynajmniej jest czytelny ;-)

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

Japt , 13 12 bajtów

"ABC"r"[{U}]

Oszczędność bajtu dzięki produktom ETH.

Wypróbuj online!

Pyth, 4 bajty

-<G3

Wypróbuj tutaj!

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

Zauważ, że używa małych liter, które mogą być nie do przyjęcia

C, 53 bajty

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

Jeśli niejawne deklaracje string.h nie są dozwolone, 72 bajty , aby dodać#include<string.h>

Wypróbuj online!

lub coś bardziej zabawnego przy 75 bajtach

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

Wypróbuj online!

Partia, 101 bajtów

@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

Pobiera dane wejściowe STDIN, co oznacza, że %1jest pusty, gdy kod wpada do podprogramu pomocnika i nic nie jest drukowane.

R , 47 40 bajtów

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

Wypróbuj online!

Zastępuje wszelkie litery w ciągu wejściowym pustym ciągiem.