Memasukkan

Sebuah string yang berisi paling banyak satu dari masing-masing huruf A, Bdan C. Mereka mungkin dalam urutan apa pun. String kosong adalah input yang valid.

^{Catatan: Versi sebelumnya dari tantangan ini menggunakan huruf dan LEJbukan ABCdan mereka masih dapat digunakan jika diinginkan.}

Keluaran

Sebuah string dari A, B, Churuf yang tidak hadir dalam input. Mereka mungkin dalam urutan apa pun.

Jika output akan menjadi string kosong maka tidak memberikan output valid, jika itu masuk akal untuk implementasi Anda. (mis. Anda tidak perlu benar-benar memanggil printstring kosong.)

Contohnya

• Jika inputnya Bmaka output harus CAatau ACkarena Adan Ctidak ada dalam input.
• Jika input adalah string kosong maka output harus ABCatau permutasi karena tidak ada dari ketiga huruf yang ada dalam input.
• Jika inputnya CABmaka output harus berupa string kosong karena ketiga huruf ada dalam input.

Uji Kasus

Ada begitu sedikit kasus masukan yang dapat kami sebutkan semuanya:

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

Semua output yang valid untuk setiap input diberikan, dipisahkan oleh |'s. ""mewakili string kosong

Mencetak gol

Kode terpendek dalam byte menang. Namun perlu diingat bahwa Anda mungkin mendapatkan lebih banyak pengakuan untuk menyelesaikan tantangan dengan cara yang unik daripada dengan cara yang singkat;)

Python 3, 29 27 22 byte

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

-2 byte terima kasih kepada Jonathan Allan

-5 byte terima kasih kepada Rod

Jelly , 4 byte

Terima kasih kepada @DuctrTape untuk dorongan tentang perubahan dan kehadiran "ABC" dalam kamus Jelly.

“ḃ»ḟ

Cobalah online!

“ḃ»mencari entri "ABC" dalam kamus Jelly, ḟadalah angka dua membuang filer yang membuang karakter yang ditemukan dalam input dari daftar karakter. Hasilnya dicetak secara implisit.

Untuk versi huruf kecil, entri kamus yang digunakan dapat berupa "abac" ( “c») atau "abaca" ( “i»).

Ketika tantangannya adalah "LEJ" hanya 6 byte yang dapat dicapai dalam varian huruf besar, karena tidak ada entri kamus dengan set karakter tersebut, meninggalkan kami untuk membuat daftar karakter “LEJ”(atau permutasi daripadanya).

Varian huruf kecil lebih baik pada 5 byte karena kehadiran kata "jell" ( “ẎṄ»).

Bash + coreutils, 15 byte

tr -d x$1<<<LEJ

Cobalah online!

Saya ingin menghilangkan x, tetapi kemudian tr -dakan kehilangan argumen ketika string input kosong. (Tidak xada salahnya, karena tidak ada x di sini-string LEJ.) Saya biasanya menulis tr -d "$1", tetapi melakukannya dengan cara yang saya lakukan adalah satu byte lebih pendek dari itu.

Retina , 14 byte

Hitungan byte mengasumsikan penyandian ISO 8859-1.

$
¶ABC
D`.
A1`

Cobalah online!

Penjelasan

$
¶ABC

Tambahkan baris kedua yang berisi ABC.

D`.

Gandakan karakter. Ini menghapus setiap karakter dari baris kedua yang sudah muncul di baris pertama.

A1`

Buang baris pertama.

05AB1E , 6 4 byte

Disimpan 2 byte menggunakan žRperintah baru seperti yang disarankan oleh Kevin Cruijssen

žRsм

Cobalah online! atau sebagai Test Suite

Penjelasan

   м  # 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 disimpan berkat @KritixiLithos .

Kode uji:

Coba di sini.

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

Keluaran:

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

Sebenarnya , 7 byte

"LEJ"-Σ

Cobalah online!

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

Pyth, 5 byte

-"ABC

Uji di sini

Perluas ke

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

MATL, 10 8 byte

Disimpan dua byte berkat Suever. setdifflebih pendek dari ismember.

'ABC'iX-

Coba di sini!

Penjelasan

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

Ya, ini mungkin tugas yang sepele, tapi saya cukup puas saya berhasil menyelesaikannya dengan MATL sendirian. _{Saya tidak pernah mengatakan itu adalah solusi terpendek ... Terima kasih Suever!}

JavaScript ES6, 41 39 38 Bytes

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

Disimpan 2 byte berkat Arnauld. Disimpan 1 byte berkat LarsW.

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

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

V , 10 byte

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

Cobalah online!

Hexdump:

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

Penjelasan

Input ada di baris pertama buffer. Jadi sesuatu seperti:

EL

dan kursor berada pada karakter pertama. Jadi kami menghapus input (yang menyimpannya dalam register ") dan masuk ke mode insert secara bersamaanC .

Setelah dalam mode penyisipan, karakter LEJ dimasukkan, setelah itu saya kembali ke mode normal menggunakan <ESC>.

Sekarang kita harus menghapus semua karakter yang ada di input.

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

Dan begitu ini terjadi, kita akan tinggal dengan huruf-huruf yang tersisa di buffer.

Ruby, 27 19 18 byte

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

-1 byte terima kasih kepada Martin Ender

Haskell , 27 26 byte

import Data.List
("ABC"\\)

Cobalah online! Penggunaan: ("ABC"\\) "CB"hasil "A".

\\adalah operator perbedaan set, tanda kurung membentuk bagian yang disebut yang merupakan bentuk pendek untuk lamda (\x -> "ABC" \\ x).

Tanpa impor: (jumlah byte yang sama berkat @nimi)

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

Cobalah online! Penggunaan: f "CB"hasil "A".

Pendekatan lain:

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

GNU sed , 34 29 byte

Termasuk +1 untuk -r

Terima kasih untuk Trauma Digital

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

Cobalah online!

Untuk beberapa alasan TIO tidak bekerja dengan regex diperpanjang ( -r), jadi saya harus membungkusnya dalam 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

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

It is run with the -c flag, adding 3 bytes

Try it online!

Explanation

Overall this program pretty much does the right stack set minus the left stack with the right stack initialized to CBA and the left stack initialized to the input.

Annotated Code

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

More explanation to come...

Mathematica, 37 bytes

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

Carrot, 15 bytes, non-competing

non-competing because of a bug I found with returning matches and empty strings. So I just fixed it

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

Try it online! (copy & paste)

Explanation

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-

Try it online! (As a linefeed-separated test suite.)

MATLAB / Octave, 20 bytes

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

Online Demo

Octave, 29 27 bytes

Saved two bytes thanks to Suever, by creating the string 'ABC', inside the ismember call.

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

We use ~ismember() as logical indices to the variable x. The peculiar thing is, we create x='ABC' inside ismember, not in front of it. The order Octave sees this:

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

where i is the input:

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

Full app tested 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));
}

Test results

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

~ is set subtraction, ∘ is compose, so this is a function that returns ABC minus the characters in its input.

Jellyfish, 9 bytes

PNI
 "ABC

Try it online!

In more conventional notation, this program translates to:

P(N("ABC", I))

I is the input, N is list difference, and P is output.

Perl 5.9.9 79 38 37 35 bytes

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

(not sure of the counting rules here - have included switches but not the perl command).

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

(adjusted counts after adjudication comment below)

Common Lisp, 71 bytes

The largest entry at the moment, but at least it is readable ;-)

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

Japt, 13 12 bytes

"ABC"r"[{U}]

Saved a byte thanks to ETHproductions.

Try it online!

Pyth, 4 bytes

-<G3

Try it here!

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

Note this uses lower case which might not be acceptable

C, 53 bytes

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

If implicit declarations of string.h are not allowed, 72 bytes, to add #include<string.h>

Try it online!

or something a bit more fun at 75 bytes

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

Try it 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

Takes input on STDIN, which means that %1 is empty when the code falls through into the helper subroutine and nothing gets printed.

R, 47 40 bytes

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

Try it online!

Replaces any letters in the input string with the empty string.