Tâche:

Votre défi est, étant donné les soumissions précédentes et lui-même en tant qu'entrée, de sortir la langue dans laquelle ils sont écrits, dans le format suivant:

Supposons que le premier programme est en Ruby. Il doit sortir 1, parce que Ruby est la première 1langue utilisée dans ce défi. Un exemple de programme est:

a=gets
puts 1

Lorsqu'elle est donnée en entrée, elle retourne 1.

Le prochain programme pourrait être en Python. Il doit sortir 2, car Python est le dernier 2langage utilisé dans le challenge. Un exemple de programme est:

print(1 if input()[0]=="a"else 2)

Compte tenu de la première soumission, il produit 1et se produit lui-même 2.

Vous êtes autorisé à répéter des langues, mais vous n'êtes pas autorisé à soumettre une réponse dans la langue de la réponse précédente.

Par exemple, si le troisième programme est en Ruby, il doit générer 1le premier programme et lui-même (étant donné que Ruby est la première 1langue utilisée), il doit également générer le deuxième programme 2.

Règles:

• Si nle défi contient des réponses, il doit y avoir au moins floor(n / 3)des langues différentes. Toute soumission qui enfreint cette règle est disqualifiée.
• Deux "réponses voisines" (par exemple, réponse net réponse n+1) ne peuvent pas utiliser le même langage.
• Les différentes versions d'une langue ne comptent pas comme des langues différentes (donc Python 2 == Python 3).
• Les réponses doivent prendre en compte les soumissions précédentes.
• La première soumission doit prendre en compte.
• Vous n'êtes pas autorisé à soumettre plusieurs réponses à la suite.
• Les "réponses répétées" (les réponses qui ont exactement le même code qu'une soumission précédente) ne sont pas autorisées.
• Les réponses ne sont pas autorisées à dépasser le nombre d'octets alloué de cette réponse - voir "Nombre d'octets alloué" pour plus de détails.

Nombre d'octets alloué:

Pour chaque numéro de réponse n, le nombre d' octets alloué pour cette réponse est 45 + 5n.

Format de réponse:

Formatez votre réponse comme suit:

# {answer no.}, {language}
{program}
This prints:
- `1` in answer(s) {all answers using 1st language, with links}
- `2` in answer(s) {all answers using 2nd language, with links}
...
{optional explanation}

Pour les listes de réponses, procédez comme suit:

- `1` in answers [1]({link to answer}), [3]({link to answer})...

Notation:

La première réponse pour survivre après 7 jours sans aucune soumission valide est déclarée gagnante.

26. > <> (langue 12), 164 octets

Mon tout premier programme en> <>! C'est 156 caractères, mais 164 octets en UTF-8.

^$|(?![⊂⍴])[⊂-⍴]|\B=|{}
{:}&1+&=?v
      .&0/
v+!?='>'i41i
v+?='y'i47
v+?=' 'i12
v+?=' 'i24
v4
v6
v7
v8
v9
va
  v?(0:i
v1
n;\b1laa*)?+
/"^mwfPes{'tc"i2&01.;

Cela imprime:

• 1avec les réponses 1 , 5 , 7 , 9 et 14 (rétine).

• 2avec la réponse 2 (Brain-Flak).

• 3avec la réponse 3 (APL).

• 4avec les réponses 4 , 12 et 15 (Javascript).

• 5avec les réponses 6 et 8 (R).

• 6avec les réponses 10 , 17 , 20 , 22 et 25 (Bash).

• 7avec les réponses 11 et 19 (Mathematica).

• 8avec la réponse 13 (Python).

• 9avec la réponse 16 (Perl).

• 10avec les réponses 18 , 21 et 23 (C / C ++).

• 11avec la réponse 24 (Zsh).

• 12 avec cette réponse (> <>).

Essayez-le en ligne!

Explication:

La première ligne est simplement la réponse n ° 5. Il ne fait rien mais envoie le pointeur d'instruction à la ligne du bas. /tourne le poisson à droite, et les personnages ^mwfPes{'tcsont mis sur la pile. Un seul caractère d'entrée est read ( i). (Appelons ce caractère Cpour exposition.) 2 est mis dans le registre ( 2&). Ensuite, nous sautons au début de la deuxième ligne (ligne 1) ( 01.).

Cette ligne se compare Cà chaque caractère de la pile. Une copie de Cest conservée au bas de la pile. {fait pivoter la pile pour qu’elle Csoit sur le dessus; :le duplique; }fait pivoter la copie vers le bas. Nous incrémentons le registre ( &1+&) jusqu'à ce qu'une correspondance soit trouvée. (Donc si Cest "c", le registre en contient 3 lorsque la correspondance est trouvée; si Cest "t", le registre en tient 4, etc.). Nous passons ensuite au premier caractère du numéro de ligne dans le registre ( 0&.) .

Les lignes 3 à 13 traitent de ce qu'il faut faire quand Cc, t, ', {, etc., respectivement. Le pointeur d'instruction recule lorsque nous sautons; il atterrit sur le premier caractère de la ligne donnée, mais après un saut, il coche avant d'exécuter, il commence donc à s'exécuter à partir de la fin de la ligne en revenant en arrière. Chaque ligne indique le numéro de langue approprié sur la pile, puis envoie le poisson à l' ninstruction, qui l'imprime.

^est le cas le plus compliqué, en raison de ma propre ignoble avec la première ligne de cette réponse. La ligne 13 lit l'entrée jusqu'à EOF. Ensuite, il passe à la ligne 15, qui compare la longueur de la pile ( l) à 100 ( aa*). Si c'est plus long ( )?), on ajoute + bet 1pour avoir 12, ce langage; sinon, 1 reste en haut de la pile.

1. Retina , 0 octet

Essayez-le en ligne!

Le programme vide s'imprime 1lorsqu'il reçoit une entrée vide (c'est-à-dire lui-même), car il compte combien de fois la regex vide correspond à l'entrée (qui est toujours 1+length(input)).

2. Brain-Flak , 22 octets

{<>(())(<>)}{}(<>{}())

Essayez-le en ligne!

Ceci vérifie le haut de la pile et en place un sur la pile opposée s'il est différent de zéro. Il incrémente et retourne ensuite la pile opposée. Cela fait qu'il retourne 1 pour le programme vide et 2 pour toute autre chose.

Puisque les piles dans Brain-Flak sont égales à zéro, un programme vide aura un zéro en haut de la pile tandis que tout autre programme (à l'exception des programmes qui se terminent par des caractères nuls) aura une valeur de vérité. Cela signifie que nous pouvons exécuter un programme très simple si sur la pile d’entrée.

{      (<>)}{}              #If not zero
 <>(())                     #Push one to the other stack
              (<>{}())      #Switch to other stack and increment by one

3. APL, 7 octets

' {'⍳⊃⍞

Explication:

      ⍞  read from the keyboard
     ⊃   first item of list, or space if empty
' {'⍳    index into the string ' {', giving N+1 (=3) if not found

10. Bash (+ coreutils) [langue 6], 44, 74 octets

Version fixe (renvoie l'identifiant de langue)

expr substr "1234151516" $(expr index "365f8dc0eb" `md5sum|cut -c12`) 1 #G

Note: ceci attend le retour à la ligne suivant, après le texte du programme en entrée

9. Rétine (langue 1), 20 octets

$|}\{|[:'][^]']|,\b1

Essayez-le en ligne!

Comme plannapus, j’ai décidé de réécrire pour changer un peu les choses, ce qui a également permis de raccourcir considérablement le code (une modification de ma dernière réponse pour tenir compte du dernier plannapus aurait abouti à environ 32 octets, je pense).

Explication

Comme mes autres réponses, cela ne fait que compter le nombre de correspondances de regex, mais le fait beaucoup plus efficacement:

• $correspond à la fin de la chaîne. Cela fonctionne toujours, même s'il y a une correspondance allant jusqu'à la fin de la chaîne, ce qui nous donne une ligne de base 1pour toutes les entrées.
• }\{trouve une seule correspondance dans le deuxième programme (Brain-Flak), ce qui porte le nombre à ce niveau 2. La barre oblique inverse n'est pas nécessaire pour échapper mais elle empêche cette partie de l'expression régulière de se correspondre.
• [:'][^]']est assez chic en fait. Le seul but est de compter les deux 'dans le programme APL (langue 3) et les trois :dans le programme JavaScript (langue 4), mais nous devons éviter que cette partie ne se corresponde. Ainsi , nous nous assurons également que le caractère suivant est ni ', ni ](parce que ceux -ci ne semble pas après ceux que nous ne voulons égaler, mais ils apparaissent dans ce programme ici).
• La 'partie précédente provoque déjà une correspondance dans les programmes R, nous avons donc besoin de trois autres. La sous-chaîne ,1apparaît dans les deux à trois reprises, et dans aucun autre programme. Nous l'assortissons en ajoutant une limite de mot tautologique entre les deux ,\b1pour l'empêcher de se reproduire à nouveau.

18. C (langue 10), 121 octets

C'est la norme C89 ou C90. Cela fonctionne avec Clang ou GCC sur Try It Online.

main(n){char*v=" ^{ s ePfwm",b[999],*c;gets(b);c=strchr(v,*b);n=strlen(b);printf("%d",n?c?c-v:n>99?4:n>60?5:n>15?1:3:1);}

Cela imprime:

• 1avec les réponses 1 , 5 , 7 , 9 et 14 (rétine).

• 2avec la réponse 2 (Brain-Flak).

• 3avec la réponse 3 (APL).

• 4avec les réponses 4 , 12 et 15 (Javascript).

• 5avec les réponses 6 et 8 (R).

• 6avec les réponses 10 et 17 (Bash).

• 7avec la réponse 11 (Mathematica).

• 8avec la réponse 13 (Python).

• 9avec la réponse 16 (Perl).

• 10 avec cette réponse (C).

Voici un pilote bash qui l'exécute avec toutes les 18 réponses sur Essayez-le en ligne!

Équivalent non golfé (646 octets):

#include <string.h>
#include <stdio.h>
int main(){
    char *v=" ^{ s ePfwm", b[999];
    gets(b); /* buffer overrun if more than 998 characters in the input.
                could be a problem if we get to 191 answers */
    char *c = strchr(v, b[0]); /* Find first character of input in v, or null */
    int n = strlen(b);
    if (!n) {
        printf("1");
    } else if (c) {
        printf("%d", c-v); /* Index of first character of input in v */
    } else if (n > 99) {
        printf("4");
    } else if (n > 60) {
        printf("5");
    } else if (n > 15) {
        printf("1");
    } else {
        printf("3");
    }
    return 0;
}

5. Retina (langue 1), 23 octets

^$|(?![⊂⍴])[⊂-⍴]|\B=|{}

Essayez-le en ligne! (Teste toutes les entrées possibles.)

Compte les correspondances de différentes choses dans l'entrée:

• ^$ correspond à la chaîne d'entrée, à savoir la première réponse une fois.
• {} correspond à lui-même, dont il existe deux dans le deuxième programme, et un dans celui-ci.
• (?![⊂⍴])[⊂-⍴]correspond aux caractères avec les points de code 8834 à 9076, exclusifs , qui trouvent trois correspondances dans le troisième programme. Nous utilisons la prévision négative pour éviter que les extrémités de la plage ne soient mises en correspondance dans ce programme.
• \B=correspond à un mot =qui n'est pas précédé d'un mot. Cela correspond à quatre du =quatrième programme et ne correspond pas =à celui de ce programme.

7. Retina (langue 1), 27 octets

^$|(?![⊂⍴])[⊂-⍴]|\B=|{}|\b5

Essayez-le en ligne! (Teste toutes les entrées possibles.)

Une modification mineure de la cinquième réponse . \B=trouve déjà 4 correspondances dans la sixième réponse et en \b5trouve une autre sans faire correspondre les autres réponses.

4, JavaScript (ES6), 32 octets

s=>s?s[0]==`{`?2:s[0]==`s`?4:3:1

Sorties 1 pour une entrée vide, 2 si l'entrée commence par a {, 4 si elle commence par an set 3 sinon ..

11. Mathematica [langue 7], 53 octets

Position[Characters@"^{'sceP",#&@@#][[1,1]]/._@__->1&

Fonction sans nom prenant une liste de caractères comme argument et produisant un entier positif. Il suffit simplement de ramifier sur la première lettre de l’entrée, en utilisant sa position dans la chaîne "^{'sceP"pour décider de la sortie. Cela donne la bonne réponse pour toutes les soumissions précédentes, à l' exception du programme initial Retina vide et de la réponse la plus récente de Retina ; Ces deux erreurs de /._@__->1frappe , mais la sortie est réparée par la règle qui transforme toute fonction non évaluée en 1.

16. Perl (langue 9), 94 octets

while(<>){print substr("1234151516748149",index("0F=POmS6D4e_XWVH",chr(47+length($_)%70)),1);}

Essayez-le en ligne! (vérifie toutes les réponses). Sorties "1234151516748149"

Cela imprime:

• 1 avec les réponses 1, 5, 7, 9 et 14 (rétine).
• 2 avec la réponse 2 (Brain-Flak).
• 3 avec la réponse 3 (APL).
• 4 avec les réponses 4, 12 et 15 (Javascript).
• 5 avec les réponses 6 et 8 (R).
• 6 avec la réponse 10 (Bash).
• 7 avec la réponse 11 (Mathematica).
• 8 avec la réponse 13 (Python).
• 9 avec cette réponse (Perl).

Le programme vérifie la longueur des entrées et les mappe à la distribution linguistique actuelle.

6. R (langue 5), 61 octets

cat(switch(substr(readline(),1,1),"{"=2,"'"=3,"s"=4,"c"=5,1))

Vérifie quel est le premier caractère de l'entrée et choisit la sortie en conséquence.

Ceci imprime donc:

• 1avec les réponses 1 et 5 (rétine).

• 2avec la réponse 2 (Brain-Flak).

• 3avec la réponse 3 (APL).

• 4avec la réponse 4 (Javascript).

• et 5avec cette réponse.

Usage:

> cat(switch(substr(readline(),1,1),"{"=2,"'"=3,"s"=4,"c"=5,1))

1
> cat(switch(substr(readline(),1,1),"{"=2,"'"=3,"s"=4,"c"=5,1))
{<>(())(<>)}{}(<>{}())
2
> cat(switch(substr(readline(),1,1),"{"=2,"'"=3,"s"=4,"c"=5,1))
' {'⍳⊃⍞
3
> cat(switch(substr(readline(),1,1),"{"=2,"'"=3,"s"=4,"c"=5,1))
s=>s?s[0]==`{`?2:s[0]==`s`?4:3:1
4
> cat(switch(substr(readline(),1,1),"{"=2,"'"=3,"s"=4,"c"=5,1))
^$|(?![⊂⍴])[⊂-⍴]|\B=|{}
1
> cat(switch(substr(readline(),1,1),"{"=2,"'"=3,"s"=4,"c"=5,1))
cat(switch(substr(readline(),1,1),"{"=2,"'"=3,"s"=4,"c"=5,1))
5

8. R (langue 5), 76 octets

c=which(c("","{","'","s","c")==substr(readline(),1,1));ifelse(length(c),c,1)

Vérifie la première lettre de l'entrée, et la compare avec un vecteur contenant (dans cet ordre) une chaîne vide, {, ', set c. Il génère ensuite l'index de la correspondance (l'indexation R est basée sur 1) ou 1 s'il n'y a pas de correspondance.

Même concept que la réponse n ° 6 mais empêche que la réponse n ° 7 ne corresponde.

Cela imprime:

• 1avec les réponses 1 , 5 et 7 (rétine).

• 2avec la réponse 2 (Brain-Flak).

• 3avec la réponse 3 (APL).

• 4avec la réponse 4 (Javascript).

• et 5avec la réponse 6 et cette réponse (R).

Si je ne me trompe pas, l'allocation de comptage d'octets pour cette réponse était de 94 octets.

12. Javascript (langue 4), 117 octets

Note: J'ai changé un personnage pour corriger une erreur dans celle-ci.

c=>c?c[0]=='e'?6:c[0]=='$'||c[0]=='^'?1:c[0]=='c'&&c.length>80?4:c[0]=='P'?7:c[0]=='c'?5:c[0]=='{'?2:c[0]=='s'?4:3:1;

Vérifie la première lettre de l'entrée, si c'est c, vérifie la longueur de l'entrée.

Les sorties:

• 1 pour les réponses 1, 5, 7, 9
• 2 pour la réponse 2
• 3 pour la réponse 3
• 4 pour la réponse 4 et cette réponse
• 5 pour les réponses 6, 8
• 6 pour la réponse 10
• 7 pour la réponse 11

13. Python (langue 8), 110 octets

Remarque: cette réponse a été modifiée 6 heures après la publication, sur recommandation du PO.

from hashlib import*;print("1234151516748"["a5e1f936cd78b".index(sha256(input().encode()).hexdigest()[34])])#N

C'est la même idée que la réponse 10 (en bash), mais en Python 3. (Cette approche peut fonctionner pour au plus 3 entrées supplémentaires avant que nous n'ayons plus de chiffres hexadécimaux.)

Cela imprime:

• 1avec les réponses 1 , 5 , 7 et 9 (rétine).

• 2avec la réponse 2 (Brain-Flak).

• 3avec la réponse 3 (APL).

• 4avec les réponses 4 et 12 (Javascript).

• 5avec les réponses 6 et 8 (R).

• 6avec la réponse 10 (Bash).

• 7avec la réponse 11 (Mathematica).

• 8 pour cette réponse (Python).

Essayez-le en ligne! pour: réponse 1 , réponse 2 , réponse 3 , réponse 4 , réponse 5 , réponse 6 , réponse 7 , réponse 8 , réponse 9 , réponse 10 , réponse 11 , réponse 12 , ou cette réponse .

24. Zsh (langue 11), 142 octets

Ma réponse précédente n ° 18 en C fonctionne toujours sans modification pour toutes les entrées suivantes ( démo ). Alors mélangeons un peu.

typeset -A p
p=("[\$^]*|'\[*" 1 '{*' 2 "' *" 3 '?=>*' 4 'c?[wt]*' 5 'e*' 6 'P*' 7 'f*' 8 'w*' 9 'm*' 10 'ty*' 11)
echo ${p[(k)$1]:-1} #@<`w&X{

Le commentaire à la fin a pour but de faire correspondre la longueur des réponses 21 et 23 et de s'assurer qu'aucun caractère des hachages sha256 ou sha384 n'est unique pour chaque réponse jusqu'à présent, en utilisant les caractères vérifiés par les réponses de Lyth en C ++. ;-)

Cela imprime:

• 1avec les réponses 1 , 5 , 7 , 9 et 14 (rétine).

• 2avec la réponse 2 (Brain-Flak).

• 3avec la réponse 3 (APL).

• 4avec les réponses 4 , 12 et 15 (Javascript).

• 5avec les réponses 6 et 8 (R).

• 6avec les réponses 10 , 17 , 20 et 22 (Bash).

• 7avec les réponses 11 et 19 (Mathematica).

• 8avec la réponse 13 (Python).

• 9avec la réponse 16 (Perl).

• 10avec les réponses 18 , 21 et 23 (C / C ++).

• 11 avec cette réponse (Zsh).

Essayez-le en ligne!

14. Retina (langue 1), 39 octets

'[ ⍳]|}\{|[o@:][^]'c@:]|^c|,\b1|1\d|$

Essayez-le en ligne! (Teste toutes les entrées valides.)

15. Javascript (langue 4), 108 octets

Golfé

t=>({24:2,86:3,5:4,73:5,68:5,74:7,4:6,79:4,1:8,67:4})[[...t].reduce((r,c,i)=>r*i^c.charCodeAt(0),0)&0x5F]||1

17. Bash (+ coreutils + openssl) (langue 6), 103 octets

Golfé

expr substr 69418476151514321 $(expr index 2PtgBOlrvfDVC8ZHL `openssl md5 -binary|base64|cut -c2`) 1 #x

Utilise la même technique que ma réponse n ° 10 , mais avec un dictionnaire codé en Base64 , au lieu de Hex .

J'ai mis en place le fichier de données suivant pour le test:

6 17 expr substr 69418476151514321 $(expr index 2PtgBOlrvfDVC8ZHL `openssl md5 -binary|base64|cut -c2`) 1 #x
9 16 while(<>){print substr("1234151516748149",index("0F=POmS6D4e_XWVH",chr(47+length($_)%70)),1);}
4 15 t=>({24:2,86:3,5:4,73:5,68:5,74:7,4:6,79:4,1:8,67:4})[[...t].reduce((r,c,i)=>r*i^c.charCodeAt(0),0)&0x5F]||1
1 14 '[ ⍳]|}\{|[o@:][^]'c@:]|^c|,\b1|1\d|$
8 13 from hashlib import*;print("1234151516748"["a5e1f936cd78b".index(sha256(input().encode()).hexdigest()[34])])#N
4 12 c=>c?c[0]=='e'?6:c[0]=='$'||c[0]=='^'?1:c[0]=='c'&&c.length>80?4:c[0]=='P'?7:c[0]=='c'?5:c[0]=='{'?2:c[0]=='s'?4:3:1;
7 11 Position[Characters@"^{'sceP",#&@@#][[1,1]]/._@__->1&
6 10 expr substr "1234151516" $(expr index "365f8dc0eb" `md5sum|cut -c12`) 1 #G
1 09 $|}\{|[:'][^]']|,\b1
5 08 c=which(c("","{","'","s","c")==substr(readline(),1,1));ifelse(length(c),c,1)
1 07 ^$|(?![⊂⍴])[⊂-⍴]|\B=|{}|\b5
5 06 cat(switch(substr(readline(),1,1),"{"=2,"'"=3,"s"=4,"c"=5,1))
1 05 ^$|(?![⊂⍴])[⊂-⍴]|\B=|{}
4 04 s=>s?s[0]==`{`?2:s[0]==`s`?4:3:1
3 03 ' {'⍳⊃⍞
2 02 {<>(())(<>)}{}(<>{}())
1 01

Tester

for i in `seq 17`
do
  echo -n `cat lchain|sed -n $i'{p;q}'|cut -c1`=\>
  cat lchain|sed -n $i'{p;q}'|cut -c6-|\
  expr substr 69418476151514321 $(expr index 2PtgBOlrvfDVC8ZHL `openssl md5 -binary|base64|cut -c2`) 1 #x
done

6=>6
9=>9
4=>4
1=>1
8=>8
4=>4
7=>7
6=>6
1=>1
5=>5
1=>1
5=>5
1=>1
4=>4
3=>3
2=>2
1=>1

19. Mathematica (langue 7), 96 octets

Position[ToCharacterCode@StringSplit@";NRU$ Q B [1: =L J, 5% 3 # >",Mod[Length@#,59,33]][[1,1]]&

Fonction sans nom prenant une liste de caractères en entrée et renvoyant un entier:

• 1avec les réponses 1 , 5 , 7 , 9 et 14 (rétine).

• 2avec la réponse 2 (Brain-Flak).

• 3avec la réponse 3 (APL).

• 4avec les réponses 4 , 12 et 15 (Javascript).

• 5avec les réponses 6 et 8 (R).

• 6avec les réponses 10 et 17 (Bash).

• 7avec la réponse 11 et cette réponse (Mathematica).

• 8avec la réponse 13 (Python).

• 9avec la réponse 16 (Perl).

• 10avec la réponse 18 (C).

Jusqu'à présent, toutes les longueurs de réponses sont distinctes, et même distinctes modulo 59 - on peut donc détecter par quel entier compris dans la plage 33, 34, ..., 91 elles sont congruentes (mod 59). Ce sont tous des caractères ASCII imprimables, codés par la chaîne ";NRU$ Q B [1: =L J, 5% 3 # >"; using ToCharacterCode@StringSplit@transforme cette chaîne en une liste de dix listes d'entiers dans cette plage et Position[...,Mod[Length@#,59,33]][[1,1]]recherche laquelle des dix sous-listes correspond à la longueur modifiée de l'entrée.

20. Bash (+ coreutils + openssl) (langue 6), 121 octets

Golfé

expr substr 67A69418476151514321 $(expr index 7042PtgBOlrvfDVC8ZHL `openssl md5 -binary|base64|cut -c2`) 1| dc -e16i?p #u

La même méthode que ma réponse n ° 17 (qui est basée sur ma réponse initiale n ° 10 ).

Comme nous avons maintenant 10 langues distinctes, je suis passé au codage de position hexadécimal.

Les données

6 20 expr substr 67A69418476151514321 $(expr index 7042PtgBOlrvfDVC8ZHL `openssl md5 -binary|base64|cut -c2`) 1| dc -e16i?p #u
7 19 Position[ToCharacterCode@StringSplit@";NRU$ Q B [1: =L J, 5% 3 # >",Mod[Length@#,59,33]][[1,1]]&
A 18 main(n){char*v=" ^{ s ePfwm",b[999],*c;gets(b);c=strchr(v,*b);n=strlen(b);printf("%d",n?c?c-v:n>99?4:n>60?5:n>15?1:3:1);}
6 17 expr substr 69418476151514321 $(expr index 2PtgBOlrvfDVC8ZHL `openssl md5 -binary|base64|cut -c2`) 1 #x
9 16 while(<>){print substr("1234151516748149",index("0F=POmS6D4e_XWVH",chr(47+length($_)%70)),1);}
4 15 t=>({24:2,86:3,5:4,73:5,68:5,74:7,4:6,79:4,1:8,67:4})[[...t].reduce((r,c,i)=>r*i^c.charCodeAt(0),0)&0x5F]||1
1 14 '[ ⍳]|}\{|[o@:][^]'c@:]|^c|,\b1|1\d|$
8 13 from hashlib import*;print("1234151516748"["a5e1f936cd78b".index(sha256(input().encode()).hexdigest()[34])])#N
4 12 c=>c?c[0]=='e'?6:c[0]=='$'||c[0]=='^'?1:c[0]=='c'&&c.length>80?4:c[0]=='P'?7:c[0]=='c'?5:c[0]=='{'?2:c[0]=='s'?4:3:1;
7 11 Position[Characters@"^{'sceP",#&@@#][[1,1]]/._@__->1&
6 10 expr substr "1234151516" $(expr index "365f8dc0eb" `md5sum|cut -c12`) 1 #G
1 09 $|}\{|[:'][^]']|,\b1
5 08 c=which(c("","{","'","s","c")==substr(readline(),1,1));ifelse(length(c),c,1)
1 07 ^$|(?![⊂⍴])[⊂-⍴]|\B=|{}|\b5
5 06 cat(switch(substr(readline(),1,1),"{"=2,"'"=3,"s"=4,"c"=5,1))
1 05 ^$|(?![⊂⍴])[⊂-⍴]|\B=|{}
4 04 s=>s?s[0]==`{`?2:s[0]==`s`?4:3:1
3 03 ' {'⍳⊃⍞
2 02 {<>(())(<>)}{}(<>{}())
1 01

Test (sortie)

./test
6=>6
7=>7
A=>10
6=>6
9=>9
4=>4
1=>1
8=>8
4=>4
7=>7
6=>6
1=>1
5=>5
1=>1
5=>5
1=>1
4=>4
3=>3
2=>2

23. C (gcc) (langue 10), 142 octets

main(c){int d[256]={0};while((c=getchar())!=EOF)d[c]++;printf("%d",d[88]?9:d[119]?5*d[123]:d[35]?d[38]?7:8-d[96]:d[48]?4:d[60]?2:1+d[158]*2);}

Essayez-le en ligne!

• 1avec les réponses 1 , 5 , 7 , 9 et 14 (rétine).

• 2avec la réponse 2 (Brain-Flak).

• 3avec la réponse 3 (APL).

• 4avec les réponses 4 , 12 et 15 (Javascript).

• 5avec les réponses 6 et 8 (R).

• 6avec les réponses 10 , 17 , 20 et 22 (Bash).

• 7avec les réponses 11 et 19 (Mathematica).

• 8avec la réponse 13 (Python).

• 9avec la réponse 16 (Perl).

• 10avec les réponses 18 , 21 et cette réponse (C).

Ce programme compte le nombre de caractères différents (en ASCII, afin que les caractères UTF-8 multi-octets soient divisés en plusieurs entrées), puis suit un arbre de décision conçu avec soin, en fonction du nombre d'occurrences de tel ou tel caractère.

L'arbre de décision est inchangé par rapport à # 21 (yay!). Je ne suis pas autorisé à publier exactement le même code, nous sommes donc revenus au C pur avec des modifications mineures.

21. C ++ (gcc) (langage 10 en tant que variante de C), 142 octets

main(){int K,d[256]{0};while((K=getchar())!=EOF)d[K]++;printf("%d",d[88]?9:d[119]?5*d[123]:d[35]?d[38]?7:8-d[96]:d[48]?4:d[60]?2:1+d[158]*2);}

Essayez-le en ligne!

• 1avec les réponses 1 , 5 , 7 , 9 et 14 (rétine).

• 2avec la réponse 2 (Brain-Flak).

• 3avec la réponse 3 (APL).

• 4avec les réponses 4 , 12 et 15 (Javascript).

• 5avec les réponses 6 et 8 (R).

• 6avec les réponses 10 , 17 et 20 (Bash).

• 7avec les réponses 11 et 19 (Mathematica).

• 8avec la réponse 13 (Python).

• 9avec la réponse 16 (Perl).

• 10avec la réponse 18 et cette réponse (C).

Ce programme compte le nombre de caractères différents (en ASCII, afin que les caractères UTF-8 multi-octets soient divisés en plusieurs entrées), puis suit un arbre de décision conçu avec soin, en fonction du nombre d'occurrences de tel ou tel caractère.

Anecdote : la lettre K n'a pas été utilisée jusqu'à cette entrée. Les lettres I, E, Y, j, k, q et z restent inutilisées.

22. Bash (+ coreutils) [langue 6], 123, 131 octets

EDIT: Publié une version incorrecte au début, devrait être corrigé maintenant.

Golfé

expr substr 6A67A69418476151514321 $(expr index i3xFepQsAalyIvtqPY7ZN+ \\`openssl sha256 -binary|base64|cut -c10`) 1| dc -e16i?p #L

Même technique que mes réponses n ° 20, n ° 17 et n ° 10 .

Les données

6 22 expr substr 6A67A69418476151514321 $(expr index i3xFepQsAalyIvtqPY7ZN+ \\`openssl sha256 -binary|base64|cut -c10`) 1| dc -e16i?p #L
A 21 main(){int K,d[256]{0};while((K=getchar())!=EOF)d[K]++;printf("%d",d[88]?9:d[119]?5*d[123]:d[35]?d[38]?7:8-d[96]:d[48]?4:d[60]?2:1+d[158]*2);}
6 20 expr substr 67A69418476151514321 $(expr index 7042PtgBOlrvfDVC8ZHL `openssl md5 -binary|base64|cut -c2`) 1| dc -e16i?p #u
7 19 Position[ToCharacterCode@StringSplit@";NRU$ Q B [1: =L J, 5% 3 # >",Mod[Length@#,59,33]][[1,1]]&
A 18 main(n){char*v=" ^{ s ePfwm",b[999],*c;gets(b);c=strchr(v,*b);n=strlen(b);printf("%d",n?c?c-v:n>99?4:n>60?5:n>15?1:3:1);}
6 17 expr substr 69418476151514321 $(expr index 2PtgBOlrvfDVC8ZHL `openssl md5 -binary|base64|cut -c2`) 1 #x
9 16 while(<>){print substr("1234151516748149",index("0F=POmS6D4e_XWVH",chr(47+length($_)%70)),1);}
4 15 t=>({24:2,86:3,5:4,73:5,68:5,74:7,4:6,79:4,1:8,67:4})[[...t].reduce((r,c,i)=>r*i^c.charCodeAt(0),0)&0x5F]||1
1 14 '[ ⍳]|}\{|[o@:][^]'c@:]|^c|,\b1|1\d|$
8 13 from hashlib import*;print("1234151516748"["a5e1f936cd78b".index(sha256(input().encode()).hexdigest()[34])])#N
4 12 c=>c?c[0]=='e'?6:c[0]=='$'||c[0]=='^'?1:c[0]=='c'&&c.length>80?4:c[0]=='P'?7:c[0]=='c'?5:c[0]=='{'?2:c[0]=='s'?4:3:1;
7 11 Position[Characters@"^{'sceP",#&@@#][[1,1]]/._@__->1&
6 10 expr substr "1234151516" $(expr index "365f8dc0eb" `md5sum|cut -c12`) 1 #G
1 09 $|}\{|[:'][^]']|,\b1
5 08 c=which(c("","{","'","s","c")==substr(readline(),1,1));ifelse(length(c),c,1)
1 07 ^$|(?![⊂⍴])[⊂-⍴]|\B=|{}|\b5
5 06 cat(switch(substr(readline(),1,1),"{"=2,"'"=3,"s"=4,"c"=5,1))
1 05 ^$|(?![⊂⍴])[⊂-⍴]|\B=|{}
4 04 s=>s?s[0]==`{`?2:s[0]==`s`?4:3:1
3 03 ' {'⍳⊃⍞
2 02 {<>(())(<>)}{}(<>{}())
1 01

Essai

./test
6=>6
A=>10
6=>6
7=>7
A=>10
6=>6
9=>9
4=>4
1=>1
8=>8
4=>4
7=>7
6=>6
1=>1
5=>5
1=>1
5=>5
1=>1
4=>4
3=>3
2=>2
1=>1

25. Bash (langue 6), 169 octets

Même technique que mes réponses n ° 22, n ° 20, n ° 17 et n ° 10 .

Désolé @ Qwerp-Derp! ;) Je promets que c'est le dernier :)

Golfé

{ echo -n 'addsomesalt?';cat; }|expr substr 6BA6A67A69418476151514321 $(expr index 1W0TC4YrKwRGAJupDqn7Xlcog \\`openssl sha256 -binary|base64|cut -c40`) 1| dc -e16i?p #8

Les données

Notez que les nouvelles lignes sont codées comme \ n pour la réponse n ° 24

6 25 { echo -n 'addsomesalt?';cat; }|expr substr 6BA6A67A69418476151514321 $(expr index 1W0TC4YrKwRGAJupDqn7Xlcog \\`openssl sha256 -binary|base64|cut -c40`) 1| dc -e16i?p #8
B 24 typeset -A p\np=("[\$^]*|'\[*" 1 '{*' 2 "' *" 3 '?=>*' 4 'c?[wt]*' 5 'e*' 6 'P*' 7 'f*' 8 'w*' 9 'm*' 10 'ty*' 11)\necho ${p[(k)$1]:-1} #@<`w&X{
A 23 main(c){int d[256]={0};while((c=getchar())!=EOF)d[c]++;printf("%d",d[88]?9:d[119]?5*d[123]:d[35]?d[38]?7:8-d[96]:d[48]?4:d[60]?2:1+d[158]*2);}
6 22 expr substr 6A67A69418476151514321 $(expr index i3xFepQsAalyIvtqPY7ZN+ \\`openssl sha256 -binary|base64|cut -c10`) 1| dc -e16i?p #L
A 21 main(){int K,d[256]{0};while((K=getchar())!=EOF)d[K]++;printf("%d",d[88]?9:d[119]?5*d[123]:d[35]?d[38]?7:8-d[96]:d[48]?4:d[60]?2:1+d[158]*2);}
6 20 expr substr 67A69418476151514321 $(expr index 7042PtgBOlrvfDVC8ZHL `openssl md5 -binary|base64|cut -c2`) 1| dc -e16i?p #u
7 19 Position[ToCharacterCode@StringSplit@";NRU$ Q B [1: =L J, 5% 3 # >",Mod[Length@#,59,33]][[1,1]]&
A 18 main(n){char*v=" ^{ s ePfwm",b[999],*c;gets(b);c=strchr(v,*b);n=strlen(b);printf("%d",n?c?c-v:n>99?4:n>60?5:n>15?1:3:1);}
6 17 expr substr 69418476151514321 $(expr index 2PtgBOlrvfDVC8ZHL `openssl md5 -binary|base64|cut -c2`) 1 #x
9 16 while(<>){print substr("1234151516748149",index("0F=POmS6D4e_XWVH",chr(47+length($_)%70)),1);}
4 15 t=>({24:2,86:3,5:4,73:5,68:5,74:7,4:6,79:4,1:8,67:4})[[...t].reduce((r,c,i)=>r*i^c.charCodeAt(0),0)&0x5F]||1
1 14 '[ ⍳]|}\{|[o@:][^]'c@:]|^c|,\b1|1\d|$
8 13 from hashlib import*;print("1234151516748"["a5e1f936cd78b".index(sha256(input().encode()).hexdigest()[34])])#N
4 12 c=>c?c[0]=='e'?6:c[0]=='$'||c[0]=='^'?1:c[0]=='c'&&c.length>80?4:c[0]=='P'?7:c[0]=='c'?5:c[0]=='{'?2:c[0]=='s'?4:3:1;
7 11 Position[Characters@"^{'sceP",#&@@#][[1,1]]/._@__->1&
6 10 expr substr "1234151516" $(expr index "365f8dc0eb" `md5sum|cut -c12`) 1 #G
1 09 $|}\{|[:'][^]']|,\b1
5 08 c=which(c("","{","'","s","c")==substr(readline(),1,1));ifelse(length(c),c,1)
1 07 ^$|(?![⊂⍴])[⊂-⍴]|\B=|{}|\b5
5 06 cat(switch(substr(readline(),1,1),"{"=2,"'"=3,"s"=4,"c"=5,1))
1 05 ^$|(?![⊂⍴])[⊂-⍴]|\B=|{}
4 04 s=>s?s[0]==`{`?2:s[0]==`s`?4:3:1
3 03 ' {'⍳⊃⍞
2 02 {<>(())(<>)}{}(<>{}())
1 01

Test de sortie

6=>6
B=>11
A=>10
6=>6
A=>10
6=>6
7=>7
A=>10
6=>6
9=>9
4=>4
1=>1
8=>8
4=>4
7=>7
6=>6
1=>1
5=>5
1=>1
5=>5
1=>1
4=>4
3=>3
2=>2
1=>1