Il y a environ un an, le 31 décembre 2015, j'avais l'idée que:

Nous devrions faire une chaîne de capsule temporelle. Tout le monde peut ajouter un personnage et les années à venir verront qui peut créer le meilleur programme parmi tous les personnages avec les esolangs existants.

Doorknob a gracieusement rassemblé des personnages de la communauté PPCG et les a gardés en sécurité pendant un an.

Une somme exorbitante 74 personnes ont participé nous avons donc une spiffing 74 imprimable ASCII personnages pour jouer avec!

Voici les 74 caractères de la chaîne de la capsule témoin 2016 dans l'ordre dans lequel ils ont été soumis:

H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``#|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

Voici les 74 caractères de la chaîne de la capsule temporelle 2016 dans l'ordre ASCII (notez l'espace espace):

 !!!!!#$$%&())))*+...1449:=@@@AHILOQQQTTZ\\^`````````eefmpxy{||||~~~~~~~~~

Ce n’est pas beaucoup de choses à travailler, mais ici, nous aimons les défis.

Le défi

Pour déterminer quelle langue est la "meilleure" avec la chaîne de la capsule temporelle, nous aurons 6 (pour 201 6 ) défis de plus en plus difficiles, dans lesquels vous devrez utiliser un sous-ensemble des 74 caractères de la capsule temporelle.

Avoir 6 défis distincts permet de s'assurer que plus de langues peuvent rivaliser, mais seules les meilleures langues pourront y répondre et obtenir un score élevé.

Notation:

• Chaque défi sera noté de 0 à 74 en fonction du nombre de caractères utilisés.
• Des scores plus élevés sont meilleurs.
• Si votre langue ne peut pas terminer un défi, votre score pour ce défi est 0.
• Tout sous-ensemble non vide de défis peut être complété.
• Votre score final est la somme des scores des 6 défis.
• Le meilleur score final possible est 6 × 74 ou 444 .

Les défis

1. Run

Si le code d'une langue ne peut pas fonctionner en premier lieu, il ne pourra rien faire du tout.

Écrivez le programme complet le plus long possible (en utilisant uniquement les 74 caractères de la capsule temporelle, rappelez-vous) qui s'exécute / s'exécute sans erreur de compilation ni d'erreur d'exécution.

Peu importe ce que le programme fait, peu importe qu’il ait une entrée / sortie ou qu’il entre dans une boucle infinie, il importe seulement qu’il soit exécuté sans erreur. (Les avertissements sont acceptables, de même que les erreurs causées par une mauvaise saisie de l'utilisateur.)

Les commentaires sont autorisés, cela pourrait donc être aussi simple que

#H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

en Python pour un score de 74.

(N'ayez pas peur de répondre si c'est le seul défi que votre langue puisse réussir, mais ne vous attendez pas à beaucoup de votes non plus.)

Score = durée du programme (plus le programme est long, mieux c'est)

2. I / O

Un langage qui n'a ni forme d'entrée ni de sortie est presque aussi inutile qu'un langage qui ne peut pas fonctionner.

Avec un caractère ASCII imprimable! compris entre (0x33) et }(0x7D), indiquez le caractère ASCII imprimable avant et après.

La sortie peut être une chaîne ou une liste de longueur deux ou des caractères séparés par un espace ou une nouvelle ligne.

Par exemple, si l'entrée est }la sortie peut être |~ou ["|", "~"]ou | ~ou |\n~.

De même, "est la sortie pour !et ACest la sortie pour B.

Score = 74 - durée du programme (un programme plus court est préférable)

3. Facilité de vie

Les conditions sont souvent nécessaires à l' exhaustivité de Turing , ce qui est souvent nécessaire pour qu'une langue soit utile.

Étant donné un entier positif, s'il se termine par les chiffres décimaux, 16remplacez-le 6par a 7et indiquez le résultat. sinon, indiquez l'entrée non modifiée. Vous pouvez utiliser des chaînes pour les entrées / sorties si vous le préférez.

Exemples:

2016 -> 2017
16 -> 17
116 -> 117
1616 -> 1617
6 -> 6
15 -> 15
17 -> 17
106 -> 106
2106 -> 2106

Score = 74 - durée du programme (un programme plus court est préférable)

4. Capacité de bouclage

Un langage qui ne peut pas faire de boucles engendrera du code répétitif si fastidieux que vous aurez besoin de faire une pause de programmation pendant un certain temps.

Avec un entier positif, indiquez un carré ASCII de cette longueur remplie d'un motif de petits carrés concentriques alternant entre deux caractères ASCII imprimables distincts . Ils ne doivent pas obligatoirement être les mêmes deux caractères pour des entrées différentes.

Par exemple:

1    <- input
X    <- output

2
XX
XX

3
XXX
X-X
XXX

4
XXXX
X--X
X--X
XXXX

5
YYYYY
Y...Y
Y.Y.Y
Y...Y
YYYYY

6
XXXXXX
X----X
X-XX-X
X-XX-X
X----X
XXXXXX

7
ZZZZZZZ
Z-----Z
Z-ZZZ-Z
Z-Z-Z-Z
Z-ZZZ-Z
Z-----Z
ZZZZZZZ

Score = 74 - durée du programme (un programme plus court est préférable)

5. Math

Une langue qui n'est pas bonne avec les chiffres et les mathématiques pourrait tout aussi bien être pour les spécialistes des sciences humaines.

Ne prenez aucune entrée, mais indiquez les 72 diviseurs entiers de 2016 , positifs et négatifs, dans n'importe quel ordre. La sortie peut être formatée sous forme de chaîne ou de liste de manière raisonnable.

Exemple:

-1, -2, -3, -4, -6, -7, -8, -9, -12, -14, -16, -18, -21, -24, -28, -32, -36, -42, -48, -56, -63, -72, -84, -96, -112, -126, -144, -168, -224, -252, -288, -336, -504, -672, -1008, -2016, 1, 2, 3, 4, 6, 7, 8, 9, 12, 14, 16, 18, 21, 24, 28, 32, 36, 42, 48, 56, 63, 72, 84, 96, 112, 126, 144, 168, 224, 252, 288, 336, 504, 672, 1008, 2016

Score = 74 - durée du programme (un programme plus court est préférable)

6. Esotérisme

(Non, pas ça .) Chez PPCG, nous aimons notre substance ésotérique et les quines en sont un bon exemple.

Écrivez le plus long quine possible, selon les règles habituelles de quine . Un quine est un programme qui ne prend aucune entrée et se produit lui-même.

Score = durée du programme (plus le programme est long, mieux c'est)

Règles spécifiques

• Dans chacun des 6 défis, votre programme doit être un sous-ensemble des 74 personnages de la capsule témoin réorganisés à votre guise. Il peut s'agir d'un sous-ensemble vide ou d'un sous - ensemble impropre . Ainsi, chacun de vos programmes peut comporter entre 0 et 74 caractères.
• Une nouvelle ligne de fin à la fin de l'entrée / de la sortie / du code est acceptable n'importe où, car certaines langues l'exigent ou ne peuvent pas être facilement évitées.
• Sauf indication contraire, chaque défi peut être complété sous forme de fonction ou de programme complet en fonction de nos valeurs par défaut .
• Tous les défis doivent être complétés dans la même langue.
• Vous devez utiliser une langue (ou une version d'une langue) créée avant 2017, où que vous soyez sur Terre .
• N'importe qui est invité à répondre, que vous ajoutiez un personnage à la capsule temporelle ou non.

_{N'hésitez pas à utiliser les caractères de la capsule temporelle 2016 dans vos propres défis.}

Glypho , 74 + (74 - 36) = 112

1. Run (74 octets)

!!#%QTQT@=A@$!!$)()*!&))+...1449:@HILOQZ\\^`````````eefmpx|||{~~~~~~y~|~ ~

2. IO (36 octets)

!!!#!$!$4419TAHT\ee\OQQQ))*+)..)|~~~

Explication

Glypho semblait être un assez bon choix pour ce défi, car il se moquait des personnages réellement utilisés. Au lieu de cela, il examine des groupes de quatre caractères et choisit la commande en fonction du motif de répétition de ces quatre caractères. Comme il y a beaucoup de doublons dans la chaîne de la capsule temporelle, nous sommes assez flexibles dans les programmes que nous pouvons écrire, sauf que nous sommes limités aux programmes de 18 commandes (ce qui n'est pas beaucoup dans Glypho). Bien que cela me permette de résoudre les deux premiers problèmes assez facilement, je doute que Glypho puisse gérer les autres avec si peu de caractères.

J'ai testé ceux-ci en utilisant l'interpréteur Java récupéré du 2006-06-23 sur la machine de retour , qui utilise une correspondance légèrement différente des commandes:

0000 n
0001 i
0010 >
0011 \
0012 1
0100 <
0101 d
0102 [
0110 +
0111 o
0112 *
0120 -
0121 ]
0122 !
0123 e

Le programme Run se traduit par:

1d-+[...]

Où ...est une ordure que je n'ai pas pris la peine de traduire.

1      Push 1.
d      Duplicate.
-      Turn into -1.
+      Add. Gives 0.
[...]  Skip the rest because the top of the stack is zero.

Le programme IO se traduit par:

id1-+o1+o

Voici ce que cela fait:

i   Read a character.
d   Duplicate.
1   Push 1.
-   Turn into -1.
+   Add to character, i.e. decrement it.
o   Output it.
1   Push another 1.
+   Add to character, i.e. increment it.
o   Output it.

CJam, 74 + (74 - 14) + (74 - 26) = 182 points

1. Run (74 octets)

e# !!!!!$$%&())))*+...1449:=@@@AHILOQQQTTZ\\^`````````efmpxy{||||~~~~~~~~~

Passer e#à l'avant commente toute la ligne.

2. I / O (14 octets)

9`)ZH*+~):Q(Q)

Dennis a sauvegardé 8 octets.

Explication:

9`                   Push "9".
  )                  Extract character '9'.
   ZH*               Push 3 * 17 = 51.
      +              Add to get character 'l'.
       ~             Eval as CJam code. Command l reads a line.
        )            Extract the only character from the input line
         :Q(         Assign to Q and decrement
            Q)       Push Q and increment

3. Facilité de navigation (26 octets)

4`)4Z|`I!`|~^~~T$AT$*%H(=+

Explication:

4`)                            Push character '4'
   4Z|`                        Push 4 | 3 = 7, stringify
       I!`                     Push !18 = 0, stringify
          |~                   Setwise or and eval to get 70
            ^                  XOR to get 'r'
             ~                 Eval to read input
              ~                Eval the input as CJam code to turn
                               it into an integer
               T$              Duplicate it
                 A             Push 10
                  T$*          Duplicate that and multiply → 100
                     %         Mod the copy by 100
                      H(=      Compare to 17 - 1 = 16
                         +     Add the result (1 or 0) to the original

Je regarderai les autres plus tard. ( EDIT : Je doute qu’ils soient possibles, sans littéraux de bloc ou de chaîne… peut-être en mathématique?)

J, score 71 + (74 - 19) = 126

Tâche 1, longueur 71

AHILO=:( |T`T`Z`e`e`f`m`p`x`y|.~~%~@{|~^|Q@Q@Q+.*.449!~!~!~!!#$$&1\\~~)

Cela définit un verbe AHILOcomme étant l'intérieur. Inutilisé:

)))

Je ne pense pas qu'il y ait un moyen d'obtenir plus longtemps que cela.

Tâche 3, longueur 19

+($#~$~4)=1e4|&%:*~

La manière de faire cette tâche sans restrictions est la +16=100|]suivante:

        ]  Input
    100|   mod 100
 16=       equals 16? (Evaluates to 1 or 0)
+          Add to input.

Nous avons +, =et plusieurs copies ou |à notre disposition, et il est facile de se déplacer ], mais les chiffres sont plus problématiques. Voici la première partie qui calcule l'entrée modulo 100:

1e4|&%:*~
       *~  Input squared (multiplied with itself).
1e4        The number 10000.
   |       Perform modulo
    &      on
     %:    their square roots.

Après cela, produisons le nombre 16. Le moyen le plus simple est d'utiliser *~4(multiplié par 4 avec lui-même), mais nous l'avons déjà utilisé *, c'est donc interdit. Au lieu de cela, nous allons faire une manipulation de tableau.

($#~$~4)
    $~4   Reshape 4 to shape 4, resulting in the array 4 4 4 4.
  #~      Replicate wrt itself: replace each 4 by four 4s.
 $        Take length.

Travail

2

C'est absolument impossible. Les seuls moyens de manipuler les valeurs des caractères sont a.et u:, et nous n’avons accès à aucun d’eux.

Maintenant, si nous pouvions utiliser à la aplace de, disons A, alors ce serait une solution:

Q{~(*^.4%9 1)+I.~&Q=:a.

Le plus difficile pour que cela fonctionne est de produire le nombre -1.

Q{~(*^.4%9 1)+I.~&Q=:a.
                     a.  The array of all bytes.
                  Q=:    Bind it to Q
              I.~&       and find the input's index in it.
   (        )+           Add the following array:
    *                    Signum of
     ^.                  logarithm of
       4%                4 divided by
         9 1             the array 9 1.
                         This evaluates to -1 1.
Q{~                      Index back into Q.

4

(*.1:"|~@+.)

Cela génère la forme de l'enveloppe, mais je n'arrive pas à trouver un moyen de générer des personnages. Hélas.

5

Certes, cela semble être la tâche la plus facile à faire dans J. Cependant, sans i.cela, ce sera assez difficile.

6

Ceci est probablement impossible sans une fake-out similaire, 449ou quelque chose du genre, car la chaîne de la capsule ne contient pas de guillemets ni aucune autre manière de produire des chaînes J.

PowerShell - Note totale: 74

1. Run - Score: 74

#~= `TeQ.)`~H|$QL4yA)\*`!^O$1)!Z`!`~|\`&T@!x+e(f|Q`.|!4%.{~`:~~)m@~`@p~I9~

Dans la mesure où cela est extrêmement difficile dans PowerShell (toutes les méthodes possibles pour obtenir une entrée sont impossibles avec les caractères donnés, pour autant que je sache), j'ai au moins décidé de randomiser le premier défi afin que nous ne copions pas tous l'exemple directement. de la poste.

Voici donc un générateur de réponse aléatoire 1 (pour les langues où se #trouve un commentaire):

'#'+$(-join([char[]]' !!!!!$$%&())))*+...1449:=@@@AHILOQQQTTZ\\^`````````eefmpxy{||||~~~~~~~~~'|Get-Random -Count 73))

Essayez-le en ligne!

Mèmes , score de ( 62 65 + 70) 135

1: courir

J'ai enlevé tous les backticks ( `) et opérateurs mathématiques. Ils étaient en conflit parce qu'il n'y avait pas assez de nombres pour satisfaire tous les opérateurs unaires et binaires. J'en ai laissé quelques-uns, ce qui donne 3 octets . Programme résultant:

 !!!!!#$$%&())))...+1^4*49:=@@@AHILOQQQTTZ\\eefmpxy{||||~~~~~~~~~

Je ne sais pas pourquoi ni comment cela a fonctionné. Au moins, il ne lève aucune exception d'exécution C # et ne plante donc pas.

6: Quine

Vous savez, s'il y avait eu une -ou une minuscule qquelque part dans ces 74 caractères, cela serait trop facile. Je suis content pour l' Iopérateur, au moins.

1/4I

Ce code n'est pas vraiment évident. Voici une explication:

1    Set object to 1 (1)
/4   Divide by 4     (0.25)
I    Set object to a fraction string. (1/4)

Les chaînes de fractions (par exemple 1/4) sont affichées avec un I à la fin, pour indiquer exactement cela. L' Iopérateur est généralement inutile, je l'ai ajouté pour d'autres moyens, mais bon, ça marche comme ça!

Le code ci-dessus est invalide. Stupid me n'a pas vu que les 74 caractères ne contiennent pas un seul opérateur de division, forwardslash ( /). Je suis venu avec quelque chose d'autre cependant:

True

Explication:

T    Set object to "true" (bool value)
rue  None of these are valid tokens, so they don't get interpreted.

Sorties True(en raison de la façon dont C # traite les Boolean.ToString()majuscules et non les minuscules). Je ne suis pas sûr que ce soit une bonne question, en attendant, je continue à me casser la tête pour en faire une valide, vraiment correcte et intuitive.

Pourrait peut-être aussi résoudre le défi I / O et Math, mais il me manque des jetons (caractères) spécifiques qui ne sont pas inclus dans les 74 caractères.

Brainfuck, 74 octets

H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``#|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

Je devais juste le faire.

Explication:

Tout personnage qui n'est pas un personnage Brainfuck valide est traité comme un commentaire. Le seul code qui est réellement exécuté est le suivant:

.+..

Cela ne produit aucune sortie imprimable, puisque ni 0 ni 1 ne sont des caractères imprimables en ASCII. Cependant, cela ne cause pas d'erreur, nous avons donc réussi le premier défi.

Mathematica, score de 62

Je serais surpris que quelqu'un puisse faire fonctionner les défis 2-6 dans Mathematica. Voici le meilleur de ce que j'ai fait avec le défi 1:

A:=1.`!#&@(4`+4.`*9.`^$$H~I~L~O~Q~Q~Q~T~T||Z||e@@efmpxy%)!!!!

Définit une fonction assez stupide Aavec une valeur constante. Les 12 caractères non utilisés sont:

)))\\`````{~

Octave, score 74

1. Run

x =@(AHILOQQQTTZeefmpy)+.1||!!!!!~~~~~~~~~4.^.4||9%#$$)))*@@\`````````{\&:

50 de ces caractères font partie de la fonction, les 24 autres ne le sont pas.

Ce qu'il fait:

x =@(AHILOQQQTTZeefmpy)crée une fonction xpouvant prendre une variable AHILOQQQTTZeefmpyen entrée.

Pour comprendre le reste:

a||bappelle la fonction all()sur aet b. Si l'un ou les deux retournent vrai, l' ||opérateur retournera vrai.

!aet ~asignifie la même chose ici, ils sont les deux not(a).

a.^b est un pouvoir élément-sage (a(1)^b(1), a(2)^b(2) ...)

Explication continue

Je raccourcirai chacune des étapes au fur et à mesure:

4.^.4||9  % This is 4 raised to the power of .4||9
          % .4||9 is true, since both .4 and 9 are true
          % true is evaluated to 1 when used in an expression
...       % 4 raised to the power of 1 is simply 4.
4         % The above expression simplified

Et:

!!!!!~~~~~~~~~4  % ! and ~ are the not() operator, so this is equivalent to:
not(not(not(not(not(not(not(not(not(not(not(not(not(not(4))))))))))))))

Il y a un nombre pair de not, donc c'est équivalent à not(not(4))qui est trueou 1.

+.1||1      % This is equivalent to all(+.1) | all(1), which returns true

Le reste est commenté.

*> <> , note totale = 74

1. Courir, marquer 74

f:4%*e+e14=p!Q H@~^)$.`~A|Q)~`\ZI~O.~@``#|9@)T\T`(!``|`~!y!`)Q~$x.|m~~&!L{

Essayez-le ici!

C'était extrêmement difficile à faire sans le ;personnage. En fait, je pensais que ce serait impossible pendant quelques instants, jusqu'à ce que je voie la %, j'avais fondamentalement abandonné.

Ceci est également un programme valide> <>.

Expliqué (parties non pertinentes omises)

f:4%*e+e14=p!Q 

f:               copy 15
  4%             pop 15, push 15%4 (3)
    *            pop 15 and 3, push 15*3 (45)
     e+          pop 45, push 45+14 (59, ascii ";")
       e         push 14
        14=      push 0
           p     replace coord (14, 0) with ";"
            !Q   skip Q (this is just filler)
              ;  end execution

Défis relevés

Je pourrais essayer les autres défis ... ils seraient extrêmement durs et impliqueraient peut-être de contourner les règles de manière étrange, mais une utilisation libérale des |rétroviseurs et des !trampolines devrait permettre au moins un défi supplémentaire.

Ces défis sont particulièrement difficiles, car nous ne sommes autorisés à utiliser des sorties avec *> <> ( oet n), ni même des appels de fonctions ( C), des retours de fonction ( R) et des terminateurs de programme ( ;). Même si nous manquons également id'entrée, nous pouvons toujours avoir des entrées placées sur la pile, ce qui est un plus. Un autre avantage est que nous obtenons une seule pinstruction, ce qui nous permet de remplacer une instruction dans la boîte à code. Cela pourrait peut-être être utilisé plusieurs fois (nous n’avons pas encore trouvé de solution pratique), ce qui ferait en sorte que les autres programmes semblent plus possibles (car nous serions en mesure de générer deux ou plusieurs instructions).

Haskell, score de 63

1. Run:

(!!!!!#$$%&*+...:@@@\\^||||~~~~~~~~~)fmpxyAHILOQQQTTZ e=14`e`49

Non utilisés sont )))```````{. Les commentaires en Haskell sont --ou {- ... -}, il n’ya donc pas de version facile à tous les commentaires.

Ce code définit un opérateur infixe !!!!!#$$%&*+...:@@@\^||||~~~~~~~~~qui prend deux arguments:

1. fmpxyAHILOQQQTTZ qui est ignoré et peut donc être d'un type arbitraire
2. e, qui doit être une fonction prenant deux nombres

Dans le corps de la fonction eest ensuite appliqué à 14 et 49, en utilisant la `notation -infix.

Exemple d'utilisation:

Prelude> () !!!!!#$$%&*+...:@@@\\^||||~~~~~~~~~ (*)
686

L'opérateur est appliqué au ()tuple vide et (*)l'opérateur de multiplication 14*49 = 686est calculé.

Essayez-le en ligne!

Autres défis

Je doute que tous les autres défis soient possibles, notamment en raison de l'absence de noms de variables possibles pouvant apparaître deux fois, ce qui est seulement e(ou quelque chose comme eQT), car les noms de variables ne peuvent pas commencer par une lettre majuscule. Bien sûr, n'en avoir qu'un ne =sert à rien non plus.

Pyth, 131 pour l'instant (2 défis complets)

1. Run, 74

# `````````!!!)!)!)*$AOeIefLmpxQ|Q|y|Q|~~~~~~~~~()${+%&\=@@@^\:.1.4.49TTZH

Ce programme ne prend aucune entrée et ne crée aucune sortie.

Ce programme utilise $$, ce qui permet l'exécution de code arbitraire, et est donc interdit en ligne, donc ce programme en ligne s'exécute en mode hors connexion. Voici sa sortie de compilation, pour que vous puissiez voir ce qui est réellement exécuté:

while True:
 try:
  (repr(repr(repr(repr(repr(repr(repr(repr(repr(Pnot(Pnot(Pnot()))))))))))))
  imp_print(Pnot())
  imp_print(Pnot())
  imp_print(times(AOeIefLmpxQ|Q|y|Q|~~~~~~~~~(),uniquify(plus(mod(("=" and lookup(lookup(lookup(Ppow(":",.1),.4),.49),T)),T),Z))))
  imp_print(H)
 except Exception:
  break

Il est assez difficile d'écrire un programme avec des caractères arbitraires qui ne génèrent pas d'erreur en Pyth. Je me suis lancé le défi supplémentaire d'exiger que le programme s'exécute sans intervention de l'utilisateur.

La première étape consiste à utiliser #pour manger toutes les erreurs. Ensuite, nous devons éviter les erreurs causées par ~, Iet Lqui ont chacune leurs propres détails. Ceci est réalisé en les plaçant dans la $$, ce qui les incorpore dans la compilation de sortie et les soumet donc aux règles de compilation de Python, pas à celles de Pyth. Enfin, pour éviter toute saisie de la part de l'utilisateur, les différents jetons d'arité 0 (Variables et similaires) sont placés à la fin et les Qs sont déplacés à l'intérieur du $$bloc.

2. IO

Ce sera incroyablement difficile, si possible. Aucune des fonctions Pyth qui créent des chaînes ou des caractères arbitraires n’est présente, à l’exception .fde la création de caractères arbitraires.

3. Facilité de vie: 74 - 17 = 57

|&x%Q*TTye|LZ9Q+1

Essayez-le en ligne

Un programme Pyth équivalent serait:

?n%Q100 16Q+1

Ce code prend le mod d’entrée 100, le compare à 16 et utilise ensuite un ternaire pour choisir entre l’entrée et l’entrée plus un. En raison de restrictions de caractères, j'ai effectué quelques substitutions:

• Au lieu de ?, ternaire, j'utilisé |&, oralors and, qui a la même fonctionnalité, sauf qu'il se casse si l'entrée est égale à zéro, mais puisque nous sommes garantis d' entrée entier positif, il est très bien. (Cela aurait pu être corrigé pour aucun caractère supplémentaire, mais c'est plus simple de cette façon.)

• Au lieu de comparer directement les deux nombres, je prends leur XOR avec x, qui est zéro si et seulement si ils sont égaux, comme souhaité.

• Au lieu d'écrire 100directement, je le génère avec *TT, car Test initialisé à 10.

• Au lieu d'écrire 16directement, je le génère avec ye|LZ9. |LZfonctionne essentiellement comme la fonction de plage, |LZ9donne donc [0, 1, 2, 3, 4, 5, 6, 7, 8]. eprend le dernier élément d'une liste, donnant 8. yle double, donnant 16comme souhaité. Avec un extra +ou un extra *je pourrais sauver un personnage, mais ils sont tous deux plus utiles ailleurs.

Plus à venir!

Ruby - Score: 74

1. Run

#H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

Saisi du défi.

JavaScript (ES6), score = 74

1. Run, 74 octets

Z=` !!!!!#$$%())))...1449:@@@\AHILOQQQTT^\`eefmpxy{||||~~~~~~~~~`*``+``&``

6. Esotérisme (invalide)

Pour mémoire, ma quine suggérée était:

1.4e+49

qui s'est avéré invalide, comme indiqué dans les commentaires ci-dessous.

Rétine, score 74

1. Courir, marquer 74

)))` !!!!!#$$%&()*.+..1449:=@@@AHILOQQQTTZ\\^````````eefmpxy{||||~~~~~~~~~

J'ai déplacé les parens supplémentaires à la config afin qu'ils s'équilibrent dans la regex. J'ai également déplacé le `droit après ceux-ci, et changé +.en .+.

Essayez-le en ligne

Les autres sont probablement impossibles, car il n'y a pas de nouvelles lignes. Il n'y a pas non plus -de translittération ou dde classe de caractères numériques.

Pip, score 74 + (74 - 19) = 129

Tant de backticks avec nary une citation à être vu, simple ou double!

Tâche 1, note 74

`` `\``!!!!!`#$$%&())))*+...1449:=@@@ILOQQQTTZ\^efmpx{|||~~~~~~~~~`|`yeAH`

Fondamentalement, juste une série de littéraux de motif (regex) dans des backticks, dont le dernier est imprimé. Comme il y a un nombre impair de backticks, nous devons échapper à l'un d'entre eux ( `\``). Essayez-le en ligne , avec l' -windicateur ajouté pour prouver qu'aucun avertissement n'est généré.

Tâche 3, score 55 (longueur 19)

e+!!e%(1.#x.!9)=4*4

Utiliser une méthode de saisie plutôt étrange - le cinquième argument de ligne de commande - est possible. Essayez-le en ligne!

                     e is 5th cmdline arg; x is empty string
       1.#x.!9       Concatenate 1, 0 (length of x), and 0 (not 9)
    e%(       )      e mod 100...
               =4*4  ... equals 16?
  !!                 Logically negate twice
e+                   Add to e (+1 if number mod 100 is 16, +0 otherwise)
                     Expression is autoprinted

Autres tâches

Il est possible d'obtenir des entrées pour la tâche 2 , selon la même méthode que la tâche 3 ci-dessus. Le problème est de convertir en code ASCII et de revenir à un caractère. Le premier peut être fait avec A, mais le dernier nécessite C, ou éventuellement une indexation dans la PAvariable. Construire et évaluer du code ne peut se faire sans V. Je ne pense pas que la tâche est possible.

La tâche 4 est difficile même sans un jeu de caractères restreint. A priori, il faudrait des listes (sans utiliser les []délimiteurs ni RL(liste répétée) et n'avoir qu'une seule chance d'utiliser AL(ajouter la liste) - peu probable) ou éventuellement quelque chose avec CG(grille de coordonnées) ou MC( coordonnées de carte), les deux interdites .

La tâche 5 est à la limite de la possibilité. Les boucles seraient difficiles, car Fou et Map ne sont pas possibles, et les gammes ne peuvent pas être construites avec ,. Il y a peut-être quelque chose à faire avec le Tmal. L'incrément pourrait être de la x:x+1variété (évidemment avec une variable autre que x, cependant). Les contrôles de divisibilité peuvent utiliser %. Néanmoins, je ne pense pas qu'il y ait suffisamment de caractères - surtout des lettres répétées - pour faire tout ce qui doit se passer.

La tâche 6 semble complètement impossible. Tous les Pip quines connus ont "en eux. Ils utilisent également R(remplacer), RP(repr) ou V(eval), dont aucun n'est disponible.

En fait, score (74 + 0 + 0 + 0 + 0 + 0 + 0 ) = 74

Oui, la chaîne de capsule fonctionnera avec En fait comme pour Run, car elle ignore toutes les erreurs et chaque erreur devient un NOP.

H@~*^)$.~+1A|Q)p~\Z!IQ~e:O.~@#|9@)Tf\eT`=(!|~!y!) Q~$x.4|m4~~&!L{%( Essayez-le en ligne! )

Il produira un désordre de choses, cependant (mais aussi sa source une fois: 3).

Je travaillerai sur d'autres défis, cependant.

05AB1E - Score total: 74

1. Run, 74 octets

H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``#|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

Tout ce qui cause une erreur est ignoré par 05AB1E. Toute cette ligne de code est un NOP.

Essayez-le en ligne!

(abusé) PHP, 74 + 74 = 148

H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``#|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

L'interpréteur PHP vide simplement le code source jusqu'à ce qu'il trouve un, <?car il nous manque <toutes les permutations de ces caractères. Je suppose que ce n’est pas pire que d’utiliser une commande Quine intégrée: P

Mathematica, score 68

`A: = .1% *. 44y # +. 9 ^` H @ `$ I @` L @ (`$ O ~` Q ~ `Q ~` Q ~ `T ~ T ~ Z ~ e ~ e | e f | m | p | x) !!!!! & \

Remarquez le retour à la ligne suivant. Je ne pense pas que Mathematica puisse relever tous les autres défis.

Labyrinthe, score 74

AH)
IL)
OQ:
`=!)~`{+4.@ !!!$$%&(*..149@@TTZ\\^```eefmpxy||||~~~~~~~~
`Q#
`Q)
``!

Je suis à peu près sûr que n'importe quel assortiment de ces personnages produit un programme Labyrinth valide, mais pour le rendre un peu plus intéressant, il affiche un 2016chiffre à la fois. (En résumé: placez les 2 2sur la pile, sautez / imprimez l’un, déplacez l’autre vers la pile auxiliaire, imprimez 0, enfoncez le 2 1sur la pile, sautez / imprimez 1, incrémentez, bitwise not, negate (last 1est un 3à ce point), somme avec le 2de la pile aux, 5 * 10 + 4 = 54, affiche comme valeur ascii, termine)

La plus grande partie de la longue ligne est simplement ignorée car elle @termine le programme.

Les défis 2, 3 et 4 sont impossibles, car aucune des commandes d'entrée de Labyrinth n'est disponible ( ,ou ?), et je n'ai rien proposé pour 5 ou 6.

SmileBASIC, 48 points

défi 1:

@LOQQQTTZ A$=H$+@efmy+@9414*!exp(!!.||!!.#||I%):

explication:

@LOQQTTZ 'label
A$= 'set value of A$ (string)
H$ 'string
+@efmy 'adds label, interpreted as string literal
+@9414 'adds label, interpreted as string literal
*!exp( 'multiplies by logical not e^x (= 0)
!!. 'not not 0.0 (= 0)
||!!.# 'or not not 0.0 converted to a float (= 0)
||I% 'or I% (integer variable)
: 'equivalent to a line break, does nothing here

autres:

Aucune commande d'entrée / sortie n'étant disponible, le reste n'est pas possible.

Pourtant, pas mal pour une vraie langue sans utiliser de commentaires.

MATL , score total 74

1. Courir, marquer 74

`4.e4 1.$!!!!!T+Zyf9.)AH^ILx@Q@Q@Qm||||~~~~~~~~~:=Tp*O%#$&()))\\````````e{

Tout jusqu'à %est le code réel. %est un symbole de commentaire, donc les caractères à sa droite sont ignorés.

Le programme sort 1sans erreur.

Essayez-le en ligne!

bash, score 74

1: courir. Nous pouvons courir tous les 74

#H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

6: Esotérisme:

Le programme vide est un quine in bash.

Sans aucun caractère d'espacement, rien d'autre sur la liste ne peut être accompli. Ergo, j'ai l'entrée gagnante bash.

Perl 6 , note totale 74

1. Courir, marquer 74

my @TOTAL=$!||(e*4...9^e)Z+1~4||!!Q`{fp)))\#\&`~Q!```HI````!~Q:x~~~$~@~@~%

Sans commentaires.
(Il suffit de mettre le texte #à l'avant pour que tout soit commenté, mais c'est plus amusant.)

Travail

C'est le sous-ensemble du langage Perl 6 qui utilise uniquement les caractères autorisés:

Constantes: e

Noms de type: IO

Fonctions: exp

Les méthodes:
    sur le type IO: .e .f .x
    (... probablement plus.)

Opérateurs: | infixe: | préfixe:
    ----------- + ----------------------- + ---------
    numérique: | + * + ^ + | + &% | + + ^
    chaîne: | ~ x ~ ^ ~ | ~ & | ~
    booléen: | || ~~ | !
    jonctions: | | & ^ |  
    misc: | =: = Z .. ... |  

syntaxe:
    littéraux numériques: 1 4 9
    littéraux de chaîne: Q` `Q! ! etc.
    Commandes shell: Q: x` `Q: x! ! etc.
    Quelle que soit l'étoile: *
    variables: mon \ $ @ &
    groupement: ()
    commentaires: # # `()
    désespacer: \

L’obstacle immédiat empêchant les défis 2-6, c’est qu’il ne semble pas y avoir de moyen de faire des E / S:

• Si nous supposons qu'il existe un fichier appelé f, nous pourrions utiliser Q`f`.IO.epour vérifier s'il existe ou Q`f`.IO.xpour vérifier s'il est exécutable. Mais nous ne pouvons ni le lire ni en écrire.

• Nous pourrions utiliser Q:x` `une commande shell (en supposant que nous trouvions les caractères pour un). Mais nous ne pouvons rien interpoler, alors ce ne serait que bon pour la lecture, pas pour l'écriture.

• Comme il n'y a pas d'accolade fermante, nous ne pouvons pas créer de bloc lambda (par exemple {1 + $_}) qui retourne automatiquement la valeur de sa dernière instruction.

• Nous pourrions utiliser l'astérisque pour créer une expression lambda (par exemple 1+*), mais dans ce cas, nous ne pouvons prendre qu'un seul argument, ne faire référence à cet argument qu'une seule fois et sommes encore plus limités dans la syntaxe / les opérateurs que nous pouvons utiliser.

Lua, score 31

1. Course (31 sur 74 points)

AHILOQQQTTZeefmpxy=1.%4+(4.*9.)

Gelée , score 74

1. Run , 74

 ||||!!!!!$$~~~~~~~~^@=@~%449:`e@`e`QAHILOQQTTZ{\\f`m`p`x`y`&`*.#1+.()))).

Je ne sais pas comment faire l'un des autres.

/// , score: 146

1. Run, Score: 74

!!!!!#$$%&())))*+...1449:=@@@AHILOQQQTTZ\\^`````````eefmpxy{||||~~~~~~~~~

6. Quine, Score: 72

!!!!!#$$%&())))*+...1449:=@@@AHILOQQQTTZ^`````````eefmpxy{||||~~~~~~~~~

Oui, quand il n'y a pas de barre oblique ni de barre oblique dans le code, il s'imprime tout seul.