As Easy As A-B-C

Question

Input

A string that contains at most one of each of the letters A, B, and C. They may be in any order. The empty string is valid input.

^{Note: A previous version of this challenge used the letters LEJ instead of ABC and they may still be used if desired.}

Output

A string of the A, B, C letters that were not present in the input. They may be in any order.

If the output would be the empty string then simply giving no output is valid, if that makes sense for your implementation. (e.g. you don't need to actually call print on an empty string.)

Examples

• If the input is B then the output should either be CA or AC since A and C are not present in the input.
• If the input is the empty string then the output should be ABC or any permutation since none of the three letters are present in the input.
• If the input is CAB then the output should be the empty string because all three letters are present in the input.

Test Cases

There are so few input cases that we can enumerate all of them:

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

All valid outputs for each input are given, separated by |'s. "" represents the empty string

Scoring

The shortest code in bytes wins. But keep in mind that you may get more recognition for solving the challenge in a unique way rather than in a short way ;)

Answer 1

Python 3, 29 27 22 bytes

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

-2 bytes thanks to Jonathan Allan

-5 bytes thanks to Rod

Answer 2

Jelly, 4 bytes

Thanks to @DuctrTape for the prod about the change and the presence of "ABC" in Jelly's dictionary.

“ḃ»ḟ

Try it online!

“ḃ» looks up the entry "ABC" in Jelly's dictionary, ḟ is the filer discard dyad which discards the characters found in the input from that list of characters. The result is implicitly printed.

---

For a lower case version the dictionary entry to use can be either of "abac" (“c») or "abaca" (“i»).

---

When the challenge was "LEJ" only 6 bytes could be achieved in the upper case variant, since no dictionary entries exist with that set of characters, leaving us to create the list of characters “LEJ” (or a permutation thereof).

The lowercase variant faired better at 5 bytes due to the presence of the word "jell" (“ẎṄ»).

Answer 3

05AB1E, 6 4 bytes

Saved 2 bytes using the new žR command as suggested by Kevin Cruijssen

žRsм

Try it online! or as a Test Suite

Explanation

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

Answer 4

Bash + coreutils, 15 bytes

tr -d x$1<<<LEJ

Try it online!

I'd like to omit the x, but then tr -d would be missing an argument when the input string was empty. (The x doesn't do any harm, since there aren't any x's in the here-string LEJ.) I'd normally write tr -d "$1", but doing it the way I did is one byte shorter than that.

Answer 5

Retina, 14 bytes

Byte count assumes ISO 8859-1 encoding.

$
¶ABC
D`.
A1`

Try it online!

Explanation

$
¶ABC

Append a second line containing ABC.

D`.

Deduplicate the characters. This deletes every character from the second line which already appears in the first line.

A1`

Discard the first line.

Answer 6

Java 7, 73 58 bytes

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

15 bytes saved thanks to @KritixiLithos.

Test code:

Try it here.

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

Output:

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

Answer 7

Actually, 7 bytes

"LEJ"-Σ

Try it online!

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

Answer 8

Pyth, 5 bytes

-"ABC

Test it here

Expands to

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

Answer 9

JavaScript ES6, 41 39 38 Bytes

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

Saved 2 bytes thanks to Arnauld. Saved 1 bytes thanks to LarsW.

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

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

Answer 10

MATL, 10 8 bytes

Saved two bytes thanks to Suever. setdiff is shorter than ismember.

'ABC'iX-

Try it here!

Explanation

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

Yes, this might have been a trivial task, but I'm quite satisfied I managed to solve it with MATL all by myself. _{I never said it was the shortest solution... Thanks Suever!}

Answer 11

V, 10 bytes

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

Try it online!

Hexdump:

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

Explanation

Input is on the first line of the buffer. So something like:

EL

and the cursor is on the first character. So we delete the input (which stores it in register ") and enter insert mode simultaneously using C.

Once in insert mode, the characters LEJ are inserted, after which I return to normal mode using <ESC>.

Now we have to remove all the characters that are present in the input.

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

And once this happens, we are left with the remaining letters in the buffer.

Answer 12

Ruby, 27 19 18 bytes

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

-1 byte thanks to Martin Ender

Answer 13

Haskell, 27 26 bytes

import Data.List
("ABC"\\)

Try it online! Usage: ("ABC"\\) "CB" yields "A".

\\ is the set difference operator, the parenthesis form a so called section which is a short form for the lamda (\x -> "ABC" \\ x).

---

Without import: (same byte count thanks to @nimi)

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

Try it online! Usage: f "CB" yields "A".

---

Other approaches:

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

Answer 14

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...

Answer 15

GNU sed, 34 29 bytes

Includes +1 for -r

-5 thanks to Digital Trauma

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

Try it online!

For some reason TIO doesn't work with extended regex (-r), so I had to wrap it in 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

Answer 16

Mathematica, 37 bytes

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

Answer 17

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

Answer 18

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

Answer 19

CJam, 7 bytes

"ABC"l-

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

Answer 20

MATLAB / Octave, 20 bytes

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

Online Demo

Answer 21

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

Answer 22

Japt, 13 12 bytes

"ABC"r"[{U}]

Saved a byte thanks to ETHproductions.

Try it online!

Answer 23

APL, 7 bytes

'ABC'∘~

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

Answer 24

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.

Answer 25

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)

Answer 26

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))

Answer 27

Pyth, 4 bytes

-<G3

Try it here!

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

Note this uses lower case which might not be acceptable

Answer 28

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!

Answer 29

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.

Answer 30

R, 47 40 bytes

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

Try it online!

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

Answer 31

Lua, 41 bytes

print((('LEJ'):gsub('['..(...)..']',''))

Answer 32

Befunge, 40 39 bytes

~2p~2vv:<_>"C"-#v_@
8p2~p<>,0^g2::+1<*8

Try it online!

Answer 33

PHP, 43 40 bytes

<?=preg_replace("([Z$argv[1]])","",ABC);

Z added to character class to work around missing terminating ] warning for empty input.

no regex, 43 bytes:

<?=str_replace(str_split($argv[1]),"",ABC);

• str_split splits input to array of single characters
• str_replace replaces all occurences of each array element in ABC with the empty string

Answer 34

VB.Net, 65 bytes

Sub F(s)
Console.Write(String.Join("","ABC".Except(s)))
End Sub

A subroutine (function) that takes the input string, and removes each character present in the input from the string "ABC". Then it joins the resulting characters back into a string, before printing them to the console.

Answer 35

Pure bash, 59 bytes

If the newline isn't necessary, removing the final "echo" takes it down to 54 bytes.

for i in A B C
{
[ X${1//$i/} = X$1 ] && echo -n $i
}
echo

Answer 36

Clojure, 39 bytes

#(apply str((group-by(set %)"ABC")nil))

Transforms input string into set of characters, and then uses it as a function by which it groups string "ABC". For example, if the input string is "B" then the result is {nil [\A \C], \B [\B]} and all we have to do is take value by key nil and convert it to string. Beats Common Lisp!

See it online

Answer 37

Go, 158 153 151 146 bytes

condensed:

package main;import(."os";."fmt");func main(){b:=[3]int{65,66,67};for _,e:=range Args[1]{b[e-65]=1};Print(string(b[0])+string(b[1])+string(b[2]))}

uncondensed:

package main

import (
    ."os"
    ."fmt"
)

func main() {
    //A,B,C are represented as 65,66,67 in int
    b := [3]int{65, 66, 67}
    //Loop through the ABC argument.
    for _,e := range Args[1]{
        //Find the letter that exists. If it's A then b[65-65] -> b[0] -> A
        //We replace the integer, with 1 which is equal to an empty string if converted.
        b[e-65] = 1
    }
    //Covert each int to string.
    Print(string(b[0])+string(b[1])+string(b[2]))
}

Answer 38

Scala, 23 bytes

(s:String)=>"ABC"diff s

Answer 39

Mathematica 38 Bytes

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

splits out the characters of the input string and the string "ABC" and performs their complement and a shorthand StringJoin.

Answer 40

PHP, 61 bytes

<?=implode("",array_diff(["A","B","C"],str_split($argv[1])));

Answer 41

perl 5.18, 35 bytes

print"ABC"=~s/[@{[shift||" "]}]//gr

Examples:

perl -le'print"ABC"=~s/[@{[shift||" "]}]//gr' A        # BC
perl -le'print"ABC"=~s/[@{[shift||" "]}]//gr' BC       # A
perl -le'print"ABC"=~s/[@{[shift||" "]}]//gr'          # ABC

Answer 42

Perl 6, 38 bytes

say join "","ABC".split(get.split(""))

Example found in close to every "remove substring" answer. EDIT: Fixed the mistake when AC it returns ABC

Answer 43

CJam, 7 bytes

"abc"l-

Explanation:

"abc"l-
"abc"   e#Push ['a','b','c']
     l  e#Push input
      - e#Remove input from ['a','b','c']
        e#Implict output

Answer 44

Gema, 44 characters

\A=@set{r;ABC}
?=@set{r;@subst{?=;$r}}
\Z=$r

Sample run:

bash-4.3$ printf CB | gema '\A=@set{r;ABC};?=@set{r;@subst{?=;$r}};\Z=$r'
A

Answer 45

Bash, 22 bytes

x=ABC
echo ${x//[$1]/}

Try it online!

Zsh, 20 bytes

x=ABC
<<<${x//[$1]/}

Try it online!

Nothing crazy, just remove matches from the string "ABC"

Answer 46

Japt, 7 bytes

"ABC"kU

Run it online | Run the testcases

---

As Embodiment of Ignorance pointed out:

6 bytes if lowercase input/output is acceptable:

`¯b`kU

Run it online

Answer 47

Japt, 7 bytes

Input & output as strings.

;3îB kU

Try it

Input & output as arrays of characters.

3õdI kU

Try it