Aussi simple qu'ABC

28

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

Loisirs de Calvin
la source
1
La tâche est définie différence entre une constante et une entrée. Exiger que tout soit fait en chaînes est lourd en ce qui concerne la difficulté de la tâche réelle.
Mego
2
Je me souviens vaguement d'une correspondance de dupe plus exacte où vous deviez soustraire l'entrée d'un ensemble constant.
xnor
1
Les entrées peuvent-elles contenir des lettres en dehors de "ABC"? La spécification: "Une chaîne qui contient au plus une de chacune des lettres A, B et C" n'exclut pas ces entrées.
theonlygusti
1
@theonlygusti L'entrée ne doit contenir que ABC
Calvin's Hobbies

Réponses:

20

Python 3, 29 27 22 octets

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

-2 octets grâce à Jonathan Allan

-5 octets grâce à Rod

Trelzevir
la source
print(*{*"LEJ"}-{*input()})enregistre 2. (testé sur 3.5 et 3.6).
Jonathan Allan
14
J'adore le python ❤️
theonlygusti
@theonlygusti Qu'est-il arrivé à <3 et ♥?
wizzwizz4
@theonlygusti: J'adorerais le python si je pouvais remplacer lamda par 𝛌
Fahim Parkar
10

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" ( “ẎṄ»).

Jonathan Allan
la source
1
J'aime la façon dont la plupart du code génère simplement la chaîne "ABC", et le programme lui-même est un caractère. Gelée classique.
sagiksp
6

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.

Mitchell Spector
la source
J'ai eu les mêmes pensées - même avec les citations - immédiatement aussi.
rexkogitans
6

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.

Martin Ender
la source
Comment fonctionne exactement la 1`partie de l'étape antigène?
Kritixi Lithos
@KritixiLithos Les nombres dans la chaîne de configuration sont des limites. 1signifie généralement "ne faire X qu'une seule fois". La façon dont les limites fonctionnent exactement (c'est-à-dire ce qu'est X) dépend du type de scène que vous utilisez. Pour les étapes antigéniques, Retina vérifie d'abord quelles lignes correspondent à l'expression régulière (ici, chaque ligne, car l'expression régulière est vide), mais ensuite la limite signifie «ne supprimer que la première ligne correspondante». De même, s'il s'agissait d'une étape grep, cela signifierait "ne conserver que la première ligne correspondante". La sémantique de toutes les limites est répertoriée sur le wiki .
Martin Ender
6

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"
Emigna
la source
Une entrée ne devrait-elle pas seulement Jrevenir EL, LE?
Urne de poulpe magique
2
Agréable! Tout comme un FYI, les entrées peuvent également être représentées comme """{input}""", ce qui fonctionne également pour les chaînes vides :).
Adnan
@carusocomputing: Il peut renvoyer l'un ou l'autre (dans ce cas, il revient LE).
Emigna
1
Peut être 4 octets maintenant
Kevin Cruijssen
1
@Emigna Tbh no. Je pense qu'il a peut-être été ajouté à cause de ce défi, mais je ne l'ai jamais utilisé auparavant.
Kevin Cruijssen
5

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
Kevin Cruijssen
la source
1
Pouvez-vous faire à la "["+s+"]"place de s.replaceAll("(.)","$1|")?
Kritixi Lithos
@KritixiLithos Smart. Il échoue pour la chaîne vide, mais en ajoutant un espace (ou tout autre caractère qui ne l'est pas EJL), cela fonctionne à nouveau, ce qui est encore beaucoup plus court. :)
Kevin Cruijssen
5

Pyth, 5 octets

-"ABC

Testez-le ici

S'étend à

-"ABC"Q
-       # Filter on absence
 "ABC"  # Literal string 
      Q # Input
Barre
la source
abc peut s'écrire<G3
Maltysen
@Maltysen ouais muddyfish a utilisé ça, mais c'est quand même en minuscules = \
Rod
4

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!

Stewie Griffin
la source
4

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

À M
la source
Je suis sur mobile, donc je ne peux pas tester mon code, mais cela devrait fonctionner je pense:s=>eval`'ABC'.replace(/[${s}]/g,'')`
LarsW
Bon travail! Être capable de dire .join``vous permet d' économiser deux personnages sur la solution que j'étais venu avec: f=s=>"ABC".replace(RegExp(`[${s}]`,'g'),"").
nnnnnn
1
@LarsW Ce code exact ne semblait pas fonctionner, mais l'ajout de crochets autour de la chaîne de modèle l'a fait et a enregistré un octet. Merci!
Tom
3

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.

Kritixi Lithos
la source
3

Rubis, 27 19 18 octets

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

-1 octet grâce à Martin Ender

GB
la source
3

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]
Laikoni
la source
1
J'espère que je (\\)serai bientôt transféré à Prelude.
theonlygusti
@theonlygusti J'espère que non; ce n'est pas vraiment une opération sensée pour les listes (du moins pas sauf si vous déclarez explicitement que vous voulez que la liste soit définie). L'opération par défaut pour cette tâche devrait être Data.Set.difference.
cessé de tourner dans le sens inverse des aiguilles d'une montre le
@ceasedtoturncounterclockwis pourquoi n'est-ce pas raisonnable? D'ailleurs, la seule raison pour laquelle je souhaite qu'il soit déplacé, c'est parce qu'il est utile, fréquemment.
theonlygusti
1
@theonlygusti ce n'est pas raisonnable dans le sens où si vous vous retrouvez à l'utiliser, c'est un signe que vous utilisez probablement la mauvaise structure de données. Les listes peuvent avoir des éléments en double, un ordre et elles peuvent être paresseusement construites (même infinies). (\\)ne respecte rien de tout cela. Les types de données qui sont destinés à ce comportement ont une structure qui les rend généralement un peu plus efficaces, plus sûrs (car aucune hypothèse possible de stabilité, etc. ne peut être rompue) et exposant une interface plus confortable.
cessé de tourner dans le sens inverse des aiguilles d'une montre le
@ceasedtoturncounterclockwis quoi, oui c'est le cas. "La première instance de ..." mais nvm
theonlygusti
3

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
Riley
la source
La nouvelle ligne, -net Psont inutiles. Vous pouvez également terminer cela en bash pour le faire fonctionner dans TIO. Aucune idée pourquoi -rça ne marche pas. tio.run/nexus/bash#DcmxDYAwDATA/qdIR4JELCjp7F8jooIFCPubb@/…
Digital Trauma
@DigitalTrauma Merci! Je pensais qu'il y aurait des personnages en plus de A, B et C quand j'ai écrit cela.
Riley
3

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

0 '
la source
2

Mathematica, 37 octets

Complement@@Characters@{"ABC",#}<>""&
Martin Ender
la source
Y a-t-il une raison pour laquelle vous avez utilisé des chaînes ici plutôt que des listes de caractères?
Greg Martin
@GregMartin habitude, je suppose
Martin Ender
juste que je pense que ça sort plus court si vous pouvez éviterCharacters
Greg Martin
2

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
Kritixi Lithos
la source
2

CJam , 7 octets

"ABC"l-

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

Martin Ender
la source
2

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
Stewie Griffin
la source
2

C #, 50 octets 32 octets 47 octets 35 octets

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

Michael Coxon
la source
1
Ce n'est pas une réponse valable, ce doit être une fonction ou un programme, pas un extrait de code.
theonlygusti
Ah. Ma faute. Première minuterie ici. J'ai donc besoin de la partie imprimée?
Michael Coxon
@MichaelCoxon: Vous devez soit faire l'entrée dans un programme entier, qui compile (non recommandé en C #, il a beaucoup de passe-partout), ou dans une fonction qui peut être appelée plusieurs fois; pour le moment, ce n'est qu'une déclaration. En C #, il est presque toujours plus facile d'en faire une fonction en créant un lambda, qui prend l'entrée via ses arguments et retourne via sa valeur de retour.
string.Join("",...)-> string.Concat(...)Enregistre 1 octet
Incarnation de l'ignorance
1

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.

marinus
la source
1

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.

Martin Ender
la source
1

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)

Tom Tanner
la source
Est-ce que cela fonctionnera pour une entrée vide?
Titus
Maintenant, j'ai corrigé l'erreur de transcription (avait "..", tapé {,,} ici ...)
Tom Tanner
Votre code fait 35 octets de long. (34 +1 pour le -ldrapeau). :)
Paul Picard
Merci. Le -l est pour la prettification (comme dans une nouvelle ligne à la fin de la sortie.). Je ne savais pas si cela était nécessaire dans le règlement du concours.
Tom Tanner
Avec 5.14+ , vous ne pouvez le faire que perl -pe'$_=eval"ABC=~y/$_//dr"'pour 23 octets (22 + 1 pour -p).
ThisSuitIsBlackNot
1

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))
coredump
la source
1

Japt , 13 12 octets

"ABC"r"[{U}]

Un octet enregistré grâce à ETHproductions.

Essayez-le en ligne!

À M
la source
Bien, merci d'utiliser Japt! Vous pouvez supprimer le guillemet de fin pour enregistrer un octet.
ETHproductions
1

Pyth, 4 octets

-<G3

Essayez-le ici!

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

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

Bleu
la source
1

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!

Ahemone
la source
52 octets
plafondcat
1

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

Neil
la source
1

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.

BLT
la source