Đầu vào

Một chuỗi có chứa ít nhất một trong mỗi của các chữ cái A, Bvà C. Họ có thể theo thứ tự bất kỳ. Chuỗi rỗng là đầu vào hợp lệ.

^{Lưu ý: Phiên bản trước của thử thách này đã sử dụng các chữ cái LEJthay vì ABCvà chúng vẫn có thể được sử dụng nếu muốn.}

Đầu ra

Một chuỗi của A, B, Cchữ cái không có mặt ở đầu vào. Họ có thể theo thứ tự bất kỳ.

Nếu đầu ra sẽ là chuỗi rỗng thì đơn giản là không có đầu ra nào hợp lệ, nếu điều đó có ý nghĩa đối với việc triển khai của bạn. (ví dụ: bạn không cần phải thực sự gọi printvào một chuỗi trống.)

Ví dụ

• Nếu đầu vào là Bsau đó đầu ra hoặc là nên CAhay ACtừ Avà Ckhông có mặt trong các đầu vào.
• Nếu đầu vào là chuỗi rỗng thì đầu ra phải ABChoặc bất kỳ hoán vị nào vì không có ba chữ cái nào xuất hiện trong đầu vào.
• Nếu đầu vào là CABđầu ra phải là chuỗi trống vì cả ba chữ cái đều có trong đầu vào.

Các trường hợp thử nghiệm

Có rất ít trường hợp đầu vào mà chúng ta có thể liệt kê tất cả chúng:

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

Tất cả các đầu ra hợp lệ cho mỗi đầu vào được đưa ra, cách nhau bởi |. ""đại diện cho chuỗi trống

Chấm điểm

Mã ngắn nhất tính bằng byte thắng. Nhưng hãy nhớ rằng bạn có thể được công nhận nhiều hơn để giải quyết thử thách theo cách độc đáo hơn là theo cách ngắn;)

Python 3, 29 27 22 byte

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

-2 byte nhờ Jonathan Allan

-5 byte nhờ Rod

Thạch , 4 byte

Cảm ơn @DuctrTape cho prod về sự thay đổi và sự hiện diện của "ABC" trong từ điển của Jelly.

“ḃ»ḟ

Hãy thử trực tuyến!

“ḃ»tra cứu mục "ABC" trong từ điển của Jelly, ḟlà trình quay phim loại bỏ dyad loại bỏ các ký tự được tìm thấy trong đầu vào từ danh sách các ký tự đó. Kết quả được in ngầm.

Đối với phiên bản chữ thường, mục từ điển cần sử dụng có thể là "abac" ( “c») hoặc "abaca" ( “i»).

Khi thử thách là "LEJ" chỉ có thể đạt được 6 byte trong biến thể chữ hoa, vì không có mục từ điển nào tồn tại với bộ ký tự đó, khiến chúng ta tạo danh sách các ký tự “LEJ”(hoặc hoán vị của chúng).

Biến thể chữ thường công bằng tốt hơn ở mức 5 byte do sự hiện diện của từ "jell" ( “ẎṄ»).

Bash + coreutils, 15 byte

tr -d x$1<<<LEJ

Hãy thử trực tuyến!

Tôi muốn bỏ qua x, nhưng sau đó tr -dsẽ thiếu một đối số khi chuỗi đầu vào trống. (Điều xnày không gây hại gì cả, vì không có bất kỳ x nào trong chuỗi LEJ ở đây.) Tôi thường viết tr -d "$1", nhưng thực hiện theo cách tôi đã làm ngắn hơn một byte.

Võng mạc , 14 byte

Số lượng byte giả định mã hóa ISO 8859-1.

$
¶ABC
D`.
A1`

Hãy thử trực tuyến!

Giải trình

$
¶ABC

Nối một dòng thứ hai chứa ABC.

D`.

Nhân đôi các nhân vật. Thao tác này sẽ xóa mọi ký tự khỏi dòng thứ hai đã xuất hiện trong dòng đầu tiên.

A1`

Hủy dòng đầu tiên.

05AB1E , 6 4 byte

Đã lưu 2 byte bằng žRlệnh mới theo đề xuất của Kevin Cruijssen

žRsм

Hãy thử trực tuyến! hoặc như một bộ thử nghiệm

Giải trình

   м  # 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 được lưu nhờ @KritixiLithos .

Mã kiểm tra:

Hãy thử nó ở đây.

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

Đầu ra:

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

Trên thực tế , 7 byte

"LEJ"-Σ

Hãy thử trực tuyến!

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

Bình thường, 5 byte

-"ABC

Kiểm tra nó ở đây

Mở rộng để

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

MATL, 10 8 byte

Đã lưu hai byte nhờ Suever. setdiffngắn hơn ismember.

'ABC'iX-

Hãy thử nó ở đây!

Giải trình

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

Vâng, đây có thể là một nhiệm vụ tầm thường, nhưng tôi khá hài lòng, tôi đã tự mình giải quyết nó bằng MATL. _{Tôi chưa bao giờ nói đó là giải pháp ngắn nhất ... Cảm ơn Suever!}

JavaScript ES6, 41 39 38 byte

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

Đã lưu 2 byte nhờ Arnauld. Đã lưu 1 byte nhờ LarsW.

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

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

V , 10 byte

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

Hãy thử trực tuyến!

Hexdump:

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

Giải trình

Đầu vào là trên dòng đầu tiên của bộ đệm. Vì vậy, một cái gì đó như:

EL

và con trỏ ở ký tự đầu tiên. Vì vậy, chúng tôi xóa đầu vào (lưu trữ nó trong đăng ký ") và nhập chế độ chèn đồng thời bằng cách sử dụng C.

Khi ở chế độ chèn, các ký tự LEJđược chèn, sau đó tôi trở lại chế độ bình thường bằng cách sử dụng <ESC>.

Bây giờ chúng ta phải loại bỏ tất cả các ký tự có trong đầu vào.

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

Và một khi điều này xảy ra, chúng ta còn lại các chữ cái còn lại trong bộ đệm.

Ruby, 27 19 18 byte

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

-1 byte nhờ Martin Ender

Haskell , 27 26 byte

import Data.List
("ABC"\\)

Hãy thử trực tuyến! Công dụng: ("ABC"\\) "CB"sản lượng "A".

\\là toán tử khác biệt được thiết lập, dấu ngoặc đơn tạo thành một phần được gọi là phần ngắn của lamda (\x -> "ABC" \\ x).

Không nhập: (cùng số byte nhờ @nimi)

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

Hãy thử trực tuyến! Công dụng: f "CB"sản lượng "A".

Các cách tiếp cận khác:

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

GNU sed , 34 29 byte

Bao gồm +1 cho -r

-5 nhờ Chấn thương kỹ thuật số

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

Hãy thử trực tuyến!

Vì một số lý do, TIO không hoạt động với regex ( -r) mở rộng , vì vậy tôi phải gói nó trong 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

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

Nó được chạy với -ccờ, thêm 3 byte

Hãy thử trực tuyến!

Giải trình

Nhìn chung, chương trình này thực hiện khá nhiều ngăn xếp bên phải trừ đi ngăn xếp bên trái với ngăn xếp bên phải được khởi tạo CBAvà ngăn xếp bên trái được khởi tạo cho đầu vào.

Mã chú thích

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

Thêm lời giải thích sắp tới ...

Toán học, 37 byte

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

Cà rốt , 15 byte, không cạnh tranh

không cạnh tranh vì một lỗi tôi tìm thấy với các kết quả trùng khớp và chuỗi trống. Vì vậy, tôi chỉ sửa nó

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

Hãy thử trực tuyến!(sao chép dán)

Giải trình

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-

Hãy thử trực tuyến! (Là một bộ thử nghiệm được phân tách bằng nguồn cấp.)

MATLAB / Octave, 20 byte

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

Demo trực tuyến

Tháng mười, 29 27 byte

Đã lưu hai byte nhờ Suever, bằng cách tạo chuỗi 'ABC', bên trong ismembercuộc gọi.

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

Chúng tôi sử dụng ~ismember()như các chỉ số logic cho biến x. Điều đặc biệt là, chúng tôi tạo ra x='ABC' bên trong ismember , không phải ở phía trước của nó. Đơn hàng Octave thấy điều này:

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

nơi ilà đầu vào:

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

Ứng dụng đầy đủ được thử nghiệm trong 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));
}

Kết quả kiểm tra

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

~được đặt trừ, ∘được soạn thảo, vì vậy đây là hàm trả về ABCtrừ các ký tự trong đầu vào của nó.

Sứa , 9 byte

PNI
 "ABC

Hãy thử trực tuyến!

Trong ký hiệu thông thường hơn, chương trình này dịch là:

P(N("ABC", I))

Ilà đầu vào, Nlà sự khác biệt danh sách, và Plà đầu ra.

Perl 5.9.9 79 38 37 35 byte

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

(không chắc chắn về các quy tắc đếm ở đây - đã bao gồm các công tắc nhưng không bao gồm lệnh perl).

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

(số lượng điều chỉnh sau khi bình luận xét xử dưới đây)

Lisp thông thường, 71 byte

Mục lớn nhất tại thời điểm này, nhưng ít nhất nó có thể đọc được ;-)

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

Japt , 13 12 byte

"ABC"r"[{U}]

Đã lưu một byte nhờ vào ETHproductions.

Hãy thử trực tuyến!

Bình thường, 4 byte

-<G3

Hãy thử nó ở đây!

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

Lưu ý điều này sử dụng chữ thường có thể không được chấp nhận

C, 53 byte

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

Nếu khai báo ngầm định của string.h không được phép, 72 byte , để thêm#include<string.h>

Hãy thử trực tuyến!

hoặc một cái gì đó thú vị hơn một chút ở 75 byte

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

Hãy thử trực tuyến!

Mẻ, 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

Đưa đầu vào vào STDIN, có nghĩa %1là trống khi mã rơi vào chương trình con của trình trợ giúp và không có gì được in.

R , 47 40 byte

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

Hãy thử trực tuyến!

Thay thế bất kỳ chữ cái nào trong chuỗi đầu vào bằng chuỗi trống.