Contribution

Une chaîne qui contient au plus un de chacune des lettres A, Bet C. Ils peuvent être dans n'importe quel ordre. La chaîne vide est une entrée valide.

^{Remarque: Une version précédente de ce défi utilisait les lettres LEJau lieu de ABCet elles peuvent toujours être utilisées si vous le souhaitez.}

Sortie

Une chaîne des A, B, des Clettres qui ne sont pas présents dans l'entrée. Ils peuvent être dans n'importe quel ordre.

Si la sortie est la chaîne vide, donner simplement aucune sortie est valide, si cela a du sens pour votre implémentation. (par exemple, vous n'avez pas besoin d'appeler réellement printune chaîne vide.)

Exemples

• Si l'entrée est Balors la sortie doit être CAou ACdepuis Aet Cn'est pas présente dans l'entrée.
• Si l'entrée est la chaîne vide, la sortie doit être ABCou toute permutation, car aucune des trois lettres n'est présente dans l'entrée.
• Si l'entrée est CABalors la sortie doit être la chaîne vide car les trois lettres sont présentes dans l'entrée.

Cas de test

Il y a si peu de cas d'entrée que nous pouvons tous les énumérer:

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

Toutes les sorties valides pour chaque entrée sont données, séparées par |des. ""représente la chaîne vide

Notation

Le code le plus court en octets gagne. Mais gardez à l'esprit que vous pouvez obtenir plus de reconnaissance pour résoudre le défi d'une manière unique plutôt que d'une manière courte;)

Python 3, 29 27 22 octets

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

-2 octets grâce à Jonathan Allan

-5 octets grâce à Rod

Gelée , 4 octets

Merci à @DuctrTape pour l'info sur le changement et la présence de "ABC" dans le dictionnaire de Jelly.

“ḃ»ḟ

Essayez-le en ligne!

“ḃ»recherche l'entrée "ABC" dans le dictionnaire de Jelly, ḟest la dyade de rejet de filer qui supprime les caractères trouvés dans l'entrée de cette liste de caractères. Le résultat est implicitement imprimé.

Pour une version minuscule, l'entrée de dictionnaire à utiliser peut être "abac" ( “c») ou "abaca" ( “i»).

Lorsque le défi était "LEJ", seuls 6 octets pouvaient être atteints dans la variante majuscule, car aucune entrée de dictionnaire n'existe avec cet ensemble de caractères, nous laissant créer la liste des caractères “LEJ”(ou une permutation de ceux-ci).

La variante minuscule résiste mieux à 5 octets en raison de la présence du mot "jell" ( “ẎṄ»).

Bash + coreutils, 15 octets

tr -d x$1<<<LEJ

Essayez-le en ligne!

Je voudrais omettre le x, mais il tr -dmanquerait alors un argument lorsque la chaîne d'entrée était vide. (Le xne fait aucun mal, car il n'y a pas de x dans le LEJ ici.) J'écrirais normalement tr -d "$1", mais le faire comme je l'ai fait est un octet plus court que cela.

Rétine , 14 octets

Le nombre d'octets suppose un codage ISO 8859-1.

$
¶ABC
D`.
A1`

Essayez-le en ligne!

Explication

$
¶ABC

Ajoutez une deuxième ligne contenant ABC.

D`.

Dédupliquez les caractères. Cela supprime chaque caractère de la deuxième ligne qui apparaît déjà dans la première ligne.

A1`

Jetez la première ligne.

05AB1E , 6 4 octets

Enregistré 2 octets en utilisant la nouvelle žRcommande comme suggéré par Kevin Cruijssen

žRsм

Essayez-le en ligne! ou comme suite de tests

Explication

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

Java 7, 73 58 octets

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

15 octets enregistrés grâce à @KritixiLithos .

Code de test:

Essayez-le ici.

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

Sortie:

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

En fait , 7 octets

"LEJ"-Σ

Essayez-le en ligne!

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

Pyth, 5 octets

-"ABC

Testez-le ici

S'étend à

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

MATL, 10 8 octets

Enregistré deux octets grâce à Suever. setdiffest plus court que ismember.

'ABC'iX-

Essayez-le ici!

Explication

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

Oui, cela aurait pu être une tâche triviale, mais je suis assez satisfait d'avoir réussi à le résoudre avec MATL tout seul. _{Je n'ai jamais dit que c'était la solution la plus courte ... Merci Suever!}

JavaScript ES6, 41 39 38 octets

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

Enregistré 2 octets grâce à Arnauld. 1 octets enregistrés grâce à LarsW.

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

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

V , 10 octets

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

Essayez-le en ligne!

Hexdump:

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

Explication

L'entrée se trouve sur la première ligne du tampon. Donc quelque chose comme:

EL

et le curseur se trouve sur le premier caractère. Nous supprimons donc l'entrée (qui la stocke dans le registre ") et passons simultanément en mode insertion C.

Une fois en mode insertion, les caractères LEJsont insérés, après quoi je reviens en mode normal en utilisant <ESC>.

Nous devons maintenant supprimer tous les caractères présents dans l'entrée.

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

Et une fois que cela se produit, nous nous retrouvons avec les lettres restantes dans le tampon.

Rubis, 27 19 18 octets

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

-1 octet grâce à Martin Ender

Haskell , 27 26 octets

import Data.List
("ABC"\\)

Essayez-le en ligne! Utilisation: ("ABC"\\) "CB"rendements "A".

\\est l'opérateur de différence d'ensemble, les parenthèses forment une soi-disant section qui est une forme courte pour le lamda (\x -> "ABC" \\ x).

Sans importation: (même nombre d'octets grâce à @nimi)

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

Essayez-le en ligne! Utilisation: f "CB"rendements "A".

Autres approches:

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

GNU sed , 34 29 octets

Comprend +1 pour -r

-5 grâce à Digital Trauma

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

Essayez-le en ligne!

Pour une raison quelconque, TIO ne fonctionne pas avec regex ( -r) étendu , j'ai donc dû l'encapsuler dans 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 octets

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

Il est exécuté avec l' -cindicateur, en ajoutant 3 octets

Essayez-le en ligne!

Explication

Dans l'ensemble, ce programme fait à peu près l'ensemble de pile de droite moins la pile de gauche avec la pile de droite initialisée à CBAet la pile de gauche initialisée à l'entrée.

Code annoté

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

Plus d'explications à venir ...

Mathematica, 37 octets

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

Carotte , 15 octets, non concurrente

non compétitif à cause d'un bug que j'ai trouvé avec le retour des matchs et des chaînes vides. Donc je l'ai juste réparé

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

Essayez-le en ligne! (copier coller)

Explication

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 octets

"ABC"l-

Essayez-le en ligne! (En tant que suite de tests séparés par des sauts de ligne.)

MATLAB / Octave, 20 octets

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

Démo en ligne

Octave, 29 27 octets

Enregistré deux octets grâce à Suever, en créant la chaîne 'ABC', à l'intérieur de l' ismemberappel.

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

Nous utilisons ~ismember()comme indices logiques la variable x. Ce qui est particulier, c'est que nous créons à l' x='ABC' intérieur ismember , pas devant. L'ordre d'Octave voit ceci:

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

où iest l'entrée:

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

Application complète testée dans 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));
}

Résultats de test

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 octets

'ABC'∘~

~est défini soustraction, ∘est composé, c'est donc une fonction qui renvoie ABCmoins les caractères dans son entrée.

Méduse , 9 octets

PNI
 "ABC

Essayez-le en ligne!

En notation plus conventionnelle, ce programme se traduit par:

P(N("ABC", I))

Iest l'entrée, la Ndifférence de liste et la Psortie.

Perl 5.9.9 79 38 37 35 octets

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

(pas sûr des règles de comptage ici - ont inclus des commutateurs mais pas la commande perl).

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

(comptes ajustés après le commentaire d'arbitrage ci-dessous)

Lisp commun, 71 octets

La plus grande entrée pour le moment, mais au moins elle est lisible ;-)

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

Japt , 13 12 octets

"ABC"r"[{U}]

Un octet enregistré grâce à ETHproductions.

Essayez-le en ligne!

Pyth, 4 octets

-<G3

Essayez-le ici!

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

Notez que cela utilise des minuscules qui pourraient ne pas être acceptables

C, 53 octets

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

Si les déclarations implicites de string.h ne sont pas autorisées, 72 octets , à ajouter#include<string.h>

Essayez-le en ligne!

ou quelque chose d'un peu plus amusant à 75 octets

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

Essayez-le en ligne!

Lot, 101 octets

@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

Prend l'entrée sur STDIN, ce qui signifie qu'il %1est vide lorsque le code tombe dans le sous-programme d'assistance et que rien n'est imprimé.

R , 47 40 octets

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

Essayez-le en ligne!

Remplace toutes les lettres de la chaîne d'entrée par la chaîne vide.