вход

Строка , которая содержит не более одного из каждых из букв A, Bи C. Они могут быть в любом порядке. Пустая строка является допустимым вводом.

^{Примечание. В предыдущей версии этого задания LEJвместо букв использовались буквы, ABCи они могут при желании использоваться.}

Выход

Строка из A, B, Cбукв , которые не присутствовали на входе. Они могут быть в любом порядке.

Если выводом будет пустая строка, то просто отсутствие вывода допустимо, если это имеет смысл для вашей реализации. (например, вам не нужно фактически вызывать printпустую строку.)

Примеры

• Если на входе , Bто выход должен быть либо CAили ACтак Aи Cнет на входе.
• Если на входе есть пустая строка, то на выходе должна быть ABCили любая перестановка, так как ни одна из трех букв не присутствует на входе.
• Если на входе CABвывод, то на выходе должна быть пустая строка, потому что на входе присутствуют все три буквы.

Тестовые случаи

Есть так мало входных случаев, что мы можем перечислить все из них:

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

Все действительные выходы для каждого входа даны, разделенные символом |'s. ""представляет пустую строку

счет

Самый короткий код в байтах побеждает. Но имейте в виду, что вы можете получить больше признания за решение задачи уникальным способом, а не коротким путем;)

Python 3, 29 27 22 байта

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

-2 байта благодаря Джонатану Аллану

-5 байт благодаря штанге

Желе , 4 байта

Спасибо @DuctrTape за побуждение об изменении и наличии "ABC" в словаре Jelly.

“ḃ»ḟ

Попробуйте онлайн!

“ḃ»ищет запись "ABC" в словаре Jelly, ḟявляется фильтром, отбрасывающим диаду, которая отбрасывает символы, найденные во входных данных из этого списка символов. Результат неявно печатается.

Для строчной версии словарной записи можно использовать «abac» ( “c») или «abaca» ( “i»).

Когда задание было «LEJ», в верхнем регистре можно было получить только 6 байтов, поскольку в этом наборе символов нет словарных записей, что позволяет нам создать список символов “LEJ”(или его перестановку).

Вариант в нижнем регистре сработал лучше на 5 байтов из-за присутствия слова «желе» ( “ẎṄ»)

Bash + coreutils, 15 байт

tr -d x$1<<<LEJ

Попробуйте онлайн!

Я хотел бы опустить x, но тогда tr -dбудет отсутствовать аргумент, когда входная строка была пустой. (Это xне приносит никакого вреда, так как в строке LEJ здесь нет символов x). Я обычно пишу tr -d "$1", но делаю так, как делал, на один байт короче этого.

Сетчатка , 14 байт

Количество байтов предполагает кодировку ISO 8859-1.

$
¶ABC
D`.
A1`

Попробуйте онлайн!

объяснение

$
¶ABC

Добавить вторую строку, содержащую ABC.

D`.

Дублируйте персонажей. При этом удаляются все символы из второй строки, которые уже появляются в первой строке.

A1`

Откажитесь от первой строки.

05AB1E , 6 4 байта

Сохранено 2 байта с использованием новой žRкоманды, предложенной Кевином Круйссеном

žRsм

Попробуйте онлайн! или как тестовый набор

объяснение

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

Java 7, 73 58 байт

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

15 байтов сохранено благодаря @KritixiLithos .

Тестовый код:

Попробуй это здесь.

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

Выход:

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

На самом деле , 7 байтов

"LEJ"-Σ

Попробуйте онлайн!

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

Pyth, 5 байт

-"ABC

Проверьте это здесь

Расширяется до

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

MATL, 10 8 байт

Сохранено два байта благодаря Suever. setdiffкороче чем ismember.

'ABC'iX-

Попробуй это здесь!

объяснение

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

Да, это могло быть тривиальной задачей, но я вполне доволен, что мне удалось решить ее с помощью MATL самостоятельно. _{Я никогда не говорил, что это было самое короткое решение ... Спасибо, Суэвер!}

JavaScript ES6, 41 39 38 байт

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

Сохранено 2 байта благодаря Арно. Сохранено 1 байт благодаря LarsW.

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

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

V , 10 байт

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

Попробуйте онлайн!

HexDump:

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

объяснение

Вход находится в первой строке буфера. Так что-то вроде:

EL

и курсор находится на первом символе. Таким образом, мы удаляем вход (который сохраняет его в регистре ") и вводим режим вставки одновременно, используя C.

В режиме вставки вставляются символы LEJ, после чего я возвращаюсь в обычный режим с помощью <ESC>.

Теперь мы должны удалить все символы, которые присутствуют на входе.

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

И как только это произойдет, мы останемся с оставшимися буквами в буфере.

Рубин, 27 19 18 байт

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

-1 байт благодаря Мартину Эндеру

Haskell , 27 26 байтов

import Data.List
("ABC"\\)

Попробуйте онлайн! Использование: ("ABC"\\) "CB"урожайность "A".

\\является оператором разности множеств, скобки образуют так называемый раздел, который является краткой формой для лямды (\x -> "ABC" \\ x).

Без импорта: (одинаковое количество байтов благодаря @nimi)

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

Попробуйте онлайн! Использование: f "CB"урожайность "A".

Другие подходы:

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

GNU sed , 34 29 байт

Включает +1 для -r

-5 благодаря цифровой травме

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

Попробуйте онлайн!

По какой-то причине TIO не работает с расширенным regex ( -r), поэтому мне пришлось обернуть его в 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 байта

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

Запускается с -cфлагом, добавляя 3 байта

Попробуйте онлайн!

объяснение

В целом, эта программа в значительной степени выполняет установку правого стека за вычетом левого стека с правым стеком, инициализированным для, CBAи левым стеком, инициализированным для ввода.

Аннотированный код

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

Больше объяснений, чтобы прийти ...

Mathematica, 37 байт

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

Морковь , 15 байтов, неконкурирующая

неконкурентный из-за ошибки, которую я обнаружил при возвращении совпадений и пустых строк. Так что я просто исправил

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

Попробуйте онлайн! (копировать вставить)

объяснение

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 байтов

"ABC"l-

Попробуйте онлайн! (Как набор тестов с разделением строк).

MATLAB / Octave, 20 байтов

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

Демо онлайн

Октава, 29 27 байт

Благодаря Suever удалось сохранить два байта, создав строку 'ABC'внутри ismemberвызова.

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

Мы используем в ~ismember()качестве логических индексов для переменной x. Особенность в том, что мы создаем x='ABC' внутри ismember , а не перед ним. Орден видит это следующим образом:

@(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 байтов 32 байта 47 байтов 35 байтов

где iвход:

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

Полное приложение протестировано в 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));
}

Результаты теста

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 байт

'ABC'∘~

~установлено вычитание, ∘составить, так что это функция, которая возвращает ABCминус символы на входе.

Медуза , 9 байт

PNI
 "ABC

Попробуйте онлайн!

В более привычных обозначениях эта программа переводится как:

P(N("ABC", I))

Iявляется вводом, Nявляется разницей в списке и Pявляется выводом.

Perl 5.9.9 79 38 37 35 байт

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

(не уверен в правилах подсчета здесь - включены ключи, но не команда perl).

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

(скорректированное количество после комментария решения ниже)

Common Lisp, 71 байт

Самая большая запись на данный момент, но, по крайней мере, она читаема ;-)

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

Japt , 13 12 байт

"ABC"r"[{U}]

Сохраненный байт благодаря ETHproductions.

Попробуйте онлайн!

Pyth, 4 байта

-<G3

Попробуй это здесь!

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

Обратите внимание, что здесь используется нижний регистр, который может быть неприемлемым

C, 53 байта

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

Если неявные объявления string.h не разрешены, 72 байта , для добавления#include<string.h>

Попробуйте онлайн!

или что-то более веселое в 75 байтов

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

Попробуйте онлайн!

Пакет, 101 байт

@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

Принимает ввод в STDIN, что означает, что %1он пуст, когда код падает в подпрограмму помощника и ничего не печатается.

R , 47 40 байт

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

Попробуйте онлайн!

Заменяет любые буквы во входной строке пустой строкой.