Connaissez-vous cette langue?


34

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.


1
Un utilisateur peut-il publier deux soumissions consécutives consécutives?
Kritixi Lithos le

Donc, en l'état, je pourrais répéter tel quel, sans aucun changement, ma réponse n ° 6 en tant que réponse n ° 8, après quoi Martin pourrait répéter son numéro n ° 7 (sauf erreur de ma part), etc. jusqu'à la réponse n ° 15 avant d'atteindre le seuil imposé (c'est-à-dire les floor(n / 3)langues). Je suppose que ce n'est pas le comportement voulu.
Plannapus

@plannapus j'ai remarqué cela aussi. Bien sûr, votre objectif est d’avoir la dernière réponse, alors sachant que j’aurais un suivi trivial, vous voudrez peut-être compliquer les choses (ce à quoi je n’avais pas pensé avant de poster ma propre réponse).
Martin Ender

3
Le nombre d'octets alloués augmente avec la progression géométrique, et probablement que le défi ne se terminera pas tant que nous n'aurons plus de langues, pas parce que le code deviendra trop long.
Wolfram

2
À l’OMI, une limite fixe raisonnable (par exemple, 384 ou 256 octets) aurait mieux fonctionné et aurait déclenché une concurrence serrée à la fin.
Zeppelin le

Réponses:


4

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.


23

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


12

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

Pourriez-vous éditer cette réponse? J'ai accidentellement voté :)
Conor O'Brien

9

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

8

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


7

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.

Hm, je viens de me rendre compte que cela n’empêche pas les réponses R, car 1c’est tout simplement leur sortie par défaut. Je devrai faire quelque chose à ce sujet lors de la prochaine réponse.
Martin Ender

7

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

6

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.

5

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

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


Vous pouvez remplacer le s[0]=='{'pars[0]>'z'

1
@Masterzagh Je pensais aussi à la façon dont cela peut être
joué au

@KritixiLithos Eh bien oui, mais il a déjà joué au golf alors j'ai pensé qu'il voudrait aller plus loin.

@Masterzagh Les gens devraient éviter de modifier des réponses valables dans des défis comme celui-ci, car ils peuvent invalider a) les réponses ultérieures, b) les réponses en cours d'élaboration.
Martin Ender

@MartinEnder, vous avez raison. En tant que tel, je ne l'éditerai pas. Je sais que ça a l'air de jouer au golf (à cause des opérateurs ternaires), mais je ne l'ai pas écrit exprès comme ça ... Merci quand même pour tous les commentaires!
Luc

4

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.


Je pense qu'il est vraiment temps de gâcher cette stratégie de premier personnage :)
Martin Ender

1
J'allais le faire, mais je me suis alors rappelé que je devais aussi écrire correctement dans ma propre langue: D
Greg Martin

4

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.


3

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

Pour exécuter ceci en dehors d'un REPL, voir le commentaire sous la réponse 8.
planifié le

3

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.


Les interprètes en ligne de FYI R (rfiddle, ideone et tryitonline) semblent avoir du mal à gérer stdin (au moins avec readline ()) et ne se comportent donc pas correctement. Si vous voulez essayer ceci (et la réponse précédente), vous devrez essayer localement sur une version installée de R, j'en ai peur.
Plannapus

^ Ok, en dehors d'un REPL readlinedevrait être remplacé par readLines(file("stdin")). Ce qui signifie 16 caractères supplémentaires: la réponse 6 devrait donc être de 77 octets (sur 79 autorisés) et cette réponse de 92 octets (sur 94 autorisés). Avec ce changement, cela fonctionne aussi sur les interprètes en ligne.
Plannapus

3

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

3

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 .


Quelle est la limite d'octets actuelle?
Vi.

@Vi .: Eh bien, il était de 149 pour la réponse 13 et 163 pour la réponse 14; mais l'OP vient de changer les règles de comptage d'octets en 45 + 5n, de sorte qu'il serait de 110 octets pour la réponse 13 et de 115 octets pour la réponse 14.
Nick Matteo

Vous devriez probablement mettre la solution de 110 octets en place.
Clismique

@ Qwerp-Derp: D'accord. Espérons que cela ne gênera le travail de quiconque.
Nick Matteo

OK, attendez environ 60 réponses jusqu'à ce que la limite d'octets soit atteinte.
Vi.

3

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!


Je pense que ceci est la première réponse à avoir plusieurs lignes ... +1 de moi.
clismique

2

14. Retina (langue 1), 39 octets

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

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


1
Allez Martin, postez dans une autre langue ... aussi, pourriez-vous faire le formatage des réponses?
Clismique

3
@ Qwerp-Derp Ceci est en train de devenir une variante intéressante du golf regex standard. Au lieu d’avoir un ensemble d’entrées et d’avoir à faire correspondre certaines d’entre elles et d’échouer certaines autres, vous devez ici obtenir un nombre spécifique de correspondances sur chacune des entrées. Je me demande si cette expression rationnelle explose de manière exponentielle à un moment donné.
Martin Ender

Est-ce vraiment 39 octets? TIO rapporte 37 octets.
Arnauld

1
@Arnauld TIO est codé en dur pour compter uniquement les caractères pour Retina car vous utilisez souvent des codages sur un octet. Cette réponse nécessite cependant UTF-8.
Martin Ender

2

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

2

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

2

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.


1

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

1

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.


0

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.


Il y a une option pour considérer le langage C ++ 11, il ne reste que quelques octets pour l'adapter.
Lyth

0

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

C'est quoi 44?
Clismique

22 * 2? 󠀠󠀠󠀠󠀠󠀠
Vi.

@ Qwerp-Derp, juste une faute de frappe
zeppelin le

Allez, tes réponses deviennent ennuyeuses maintenant - si ta prochaine réponse est la suivante, j'envisage de voter à la baisse (ce n'est pas intéressant, tu sais?)
clismique le

1
Quelque chose cloche ici. Il n'y a que 20 entrées dans vos lettres hachées (3PgT, etc.). Pour une entrée vide, j'obtiens une erreur et pour la réponse n ° 2, le résultat est "4" (les deux ont fonctionné correctement avec la réponse 20.)
Nick Matteo

0

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
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.