Giriş

En fazla harflerin her biri içeren bir dize A, Bve C. Herhangi bir sırayla olabilirler. Boş dize geçerli girdidir.

^{Not: Bu zorluğun önceki bir sürümü LEJyerine harfleri kullandı ABCve istenirse yine de kullanılabilirler.}

Çıktı

Bir dize A, B, Cgiriş mevcut değildi harflerle. Herhangi bir sırayla olabilirler.

Eğer çıktı boş dizge ise, uygulamanız için bir anlam ifade ediyorsa, sadece geçerli bir çıktı vermek geçerli değildir. (örn. aslında printboş bir dize çağırmanıza gerek yoktur .)

Örnekler

• Giriş ise Bdaha sonra çıkış ya olmalı CAya da ACyana Ave Cgiriş mevcut değildir.
• Girdi boş dizge ise, girişte ABCüç harften hiçbiri bulunmadığından çıktı veya herhangi bir permütasyon olmalıdır .
• Girdi ise CAB, çıktıda boş harf olması gerekir, çünkü girişte her üç harf de bulunur.

Test Kılıfları

Hepsini sıralayabileceğimiz çok az girdi vakası var:

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

Her giriş için tüm geçerli çıkışlar |'s ile ayrılarak verilir . ""boş dizgeyi temsil eder

puanlama

Bayt cinsinden en kısa kod kazanır. Ancak, zorluğu kısa sürede değil , benzersiz bir şekilde çözmek için daha fazla tanınma alabileceğinizi unutmayın ;)

Python 3, 29 27 22 bayt

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

Jonathan Allan sayesinde -2 bayt

Rod sayesinde -5 bayt

Jöle , 4 bayt

Jelly sözlüğündeki değişiklik ve "ABC" nin varlığı ile ilgili eşya için @DuctrTape'e teşekkürler.

“ḃ»ḟ

Çevrimiçi deneyin!

“ḃ»ḟJelly'in sözlüğündeki "ABC" girişine bakar, girişte bulunan karakterleri bu karakter listesinden atan, disk dolgusu atma dyad'ıdır. Sonuç örtük olarak yazdırılır.

Küçük harf sürümü için kullanılacak sözlük girişi "abac" ( “c») veya "abaca" () olabilir.“i» ) olabilir.

Meydan okuma yalnızca "LEJ" iken 6 hiçbir sözlüğe girdi karakterlerinin bu set ile mevcut beri bayt karakter listesi oluşturmak için bize bırakarak, büyük harf varyantı elde edilebilir “LEJ”(veya bir permütasyon bunun).

Küçük harf çeşidi , "jell" ( ) kelimesinin bulunması nedeniyle 5 baytta daha iyi sonuç verdi “ẎṄ».

Bash + coreutils, 15 bayt

tr -d x$1<<<LEJ

Çevrimiçi deneyin!

Bunu atlamak isterdim x, ancak tr -dgiriş dizesi boşken bir argüman eksik. (Buradaki xLEJ dizisinde hiç x olmadığı için hiçbir zararı yoktur.) Normalde yazardım tr -d "$1", ama yaptığım gibi yapmak bundan bir bayt daha kısa.

Retina , 14 bayt

Bayt sayısı, ISO 8859-1 kodlamasını varsayar.

$
¶ABC
D`.
A1`

Çevrimiçi deneyin!

açıklama

$
¶ABC

İçeren ikinci bir satır ekleyin ABC.

D`.

Karakterleri tekilleştirin. Bu, zaten ilk satırda görünen ikinci satırdaki her karakteri siler.

A1`

İlk satırı atın.

05AB1E , 6 4 bayt

Kevin CruijssenžR tarafından önerilen yeni komutu kullanarak 2 bayt kaydedildi

žRsм

Çevrimiçi deneyin! veya Test Paketi olarak

açıklama

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

Java 7, 73 58 bayt

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

@KritixiLithos sayesinde 15 bayt kaydedildi .

Test kodu:

Burada dene.

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

Çıktı:

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

Aslında , 7 bayt

"LEJ"-Σ

Çevrimiçi deneyin!

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

Pyth, 5 bayt

-"ABC

Burada test et

İçin genişler

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

Matl, 10 8 bayt

Suever sayesinde iki bayt kurtarıldı. setdiffdaha kısa ismember.

'ABC'iX-

Burada dene!

açıklama

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

Evet, bu önemsiz bir görev olabilirdi, ama bunu MATL ile tek başıma çözmeyi başardığım için çok memnunum. _{Asla en kısa çözüm olduğunu söylemedim ... Teşekkürler Suever!}

JavaScript ES6, 41 39 38 Bayt

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

Arnauld sayesinde 2 bayt kaydedildi. LarsW sayesinde 1 bayt kaydedildi.

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

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

V , 10 bayt

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

Çevrimiçi deneyin!

HexDump:

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

açıklama

Giriş tamponun ilk satırında. Yani şöyle bir şey:

EL

ve imleç ilk karakterin üzerindedir. Böylece girişi siliyoruz (kayıt defterine kaydeder ") ve aynı anda kullanarak insert moduna giriyoruz.C .

Ekleme moduna girdikten sonra, karakterler LEJeklenir, ardından normal moda geri dönerim.<ESC> .

Şimdi girişteki tüm karakterleri silmemiz gerekiyor.

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

Ve bu olduğunda, arabellekte kalan harflerle birlikte kalırız.

Ruby, 27 19 18 bayt

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

Martin Ender sayesinde -1 bayt

Haskell , 27 26 bayt

import Data.List
("ABC"\\)

Çevrimiçi deneyin! Kullanımı: ("ABC"\\) "CB"verim "A".

\\küme fark operatörü, parantez lamda için kısa bir form olan sözde bir bölüm oluşturur (\x -> "ABC" \\ x).

İçe aktarma olmadan: (@nimi sayesinde aynı bayt sayısı)

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

Çevrimiçi deneyin! Kullanımı: f "CB"verim "A".

Diğer yaklaşımlar:

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

GNU sed , 34 29 bayt

İçin +1 içerir -r

-5 Dijital Travma sayesinde

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

Çevrimiçi deneyin!

Nedense TIO genişletilmiş regex ( -r) ile çalışmıyor , bu yüzden BASH içine sarmak zorunda kaldı.

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

Beyin Flak , 120 + 3 = 123 bayt

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

İle çalıştırılır -cBayrakla , 3 bayt eklenir

Çevrimiçi deneyin!

açıklama

Genel olarak, bu program hemen hemen sağ küme eksi ve sol kümeye başlangıçtaki başlangıç ​​kümesine ve sol kümeye başlangıçtaki kümeye CBAbaşlangıç ​​değeri veriyor.

Açıklamalı Kod

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

Gelecek daha fazla açıklama ...

Mathematica, 37 bayt

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

Havuç , 15 bayt, rakipsiz

dönen bir hata nedeniyle eşleşmeyen ve boş dizelerle buldum. Ben de düzelttim

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

Çevrimiçi deneyin! (kopyala yapıştır)

açıklama

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 bayt

"ABC"l-

Çevrimiçi deneyin! (Satır ayrılmış bir test takımı olarak.)

MATLAB / Octave, 20 bayt

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

Çevrimiçi Demo

Octave, 29 27 bayt

Arama 'ABC'içinde, dize oluşturarak Suever sayesinde iki bayt kaydedildi ismember.

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

~ismember()Değişkene mantıksal göstergeler olarak kullanıyoruz x. Kendine özgü şey, onun önünde değil, x='ABC' içinde yaratıyoruz ismember. Octave emri bunu görür:

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

igiriş nerede :

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

Tam uygulama LINQPad'de test edildi

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 sonuçları

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 bayt

'ABC'∘~

~set çıkarma, ∘kompozisyon oluşturma, bu yüzden ABCgirişindeki karakterleri eksi döndüren bir fonksiyondur .

Denizanası , 9 bayt

PNI
 "ABC

Çevrimiçi deneyin!

Daha geleneksel gösterimde, bu program aşağıdakilere çevirir:

P(N("ABC", I))

Igirdi, Nliste farkı ve Pçıktı.

Perl 5,9,9 79 38 37 35 bayt

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

(Buradaki sayma kurallarından emin değilim - anahtarları dahil ettik ancak perl komutunu kullanmadınız).

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

(aşağıdaki değerlendirme yorumundan sonra düzeltilmiş sayımlar)

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.