Il y a environ un an, le 31 décembre 2015, j'avais l'idée que:
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 AC
est 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, 16
remplacez-le 6
par a 7
et 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.
la source
6×74 or 444
n’est pas possible, car cela signifierait des programmes vides, qui se comportent différemment. par conséquent, 442 est le minimum réel, car cela signifie que deux des 3 programmes de prise d'entrée ont un caractèreRéponses:
Glypho , 74 + (74 - 36) = 112
1. Run (74 octets)
2. IO (36 octets)
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:
Le programme Run se traduit par:
Où
...
est une ordure que je n'ai pas pris la peine de traduire.Le programme IO se traduit par:
Voici ce que cela fait:
la source
CJam, 74 + (74 - 14) + (74 - 26) = 182 points
1. Run (74 octets)
Passer
e#
à l'avant commente toute la ligne.2. I / O (14 octets)
Dennis a sauvegardé 8 octets.
Explication:
3. Facilité de navigation (26 octets)
Explication:
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?)
la source
9`)ZH*+~):Q(Q)
.J, score 71 + (74 - 19) = 126
Tâche 1, longueur 71
Cela définit un verbe
AHILO
comme é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
La manière de faire cette tâche sans restrictions est la
+16=100|]
suivante: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: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.Travail
2
C'est absolument impossible. Les seuls moyens de manipuler les valeurs des caractères sont
a.
etu:
, et nous n’avons accès à aucun d’eux.Maintenant, si nous pouvions utiliser à la
a
place de, disonsA
, alors ce serait une solution:Le plus difficile pour que cela fonctionne est de produire le nombre -1.
4
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,
449
ou 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.la source
Q{~1+I.~&Q=:a.
donne le caractère suivant: lie l’alphabeta.
àQ
, trouve l’index de l’entrée avecI.
, ajoute un, et indexe dansQ
. L'essayer Le seul problème qui reste est de produire-1
...+16=100&|
. Vous avez juste besoin de produire 16 et 100 en quelque sorte.+($@#~@$~4)=1e4|&%:*~
C'était extrêmement énervant car nous n’avons qu’un(&=:+*
et deux4
s chacun .Q{~(*^.4%9 1)+I.~&Q=:a.
j'ai compris que le logarithme^.
donnait des nombres négatifs pour les entrées strictement comprises entre 0 et 1, et nous avons%
pour produire des fractions et*
pour porter les résultats à -1 et 1.PowerShell - Note totale: 74
1. Run - Score: 74
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):Essayez-le en ligne!
la source
$^
"premier symbole de la ligne précédente de la session", ce qui serait extrêmement limité et très probablement, une flexion sévère des règles d'E / S standard.$^
est vide dans une nouvelle session de toute façon.Mèmes , score de (
6265 + 70) 1351: 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: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 minusculeq
quelque part dans ces 74 caractères, cela serait trop facile. Je suis content pour l'I
opérateur, au moins.Ce code n'est pas vraiment évident. Voici une explication:
Les chaînes de fractions (par exemple1/4
) sont affichées avec un I à la fin, pour indiquer exactement cela. L'I
opé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:Explication:
Sorties
True
(en raison de la façon dont C # traite lesBoolean.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.
la source
Brainfuck, 74 octets
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.
la source
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:
Définit une fonction assez stupide
A
avec une valeur constante. Les 12 caractères non utilisés sont:la source
Octave, score 74
1. Run
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 fonctionx
pouvant prendre une variableAHILOQQQTTZeefmpy
en entrée.Pour comprendre le reste:
a||b
appelle la fonctionall()
sura
etb
. Si l'un ou les deux retournent vrai, l'||
opérateur retournera vrai.!a
et~a
signifie la même chose ici, ils sont les deuxnot(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:
Et:
Il y a un nombre pair de
not
, donc c'est équivalent ànot(not(4))
qui esttrue
ou1
.Le reste est commenté.
la source
*> <> , note totale = 74
1. Courir, marquer 74
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)
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 *> <> (
o
etn
), ni même des appels de fonctions (C
), des retours de fonction (R
) et des terminateurs de programme (;
). Même si nous manquons égalementi
d'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 seulep
instruction, 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).la source
Haskell, score de 63
1. Run:
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:fmpxyAHILOQQQTTZ
qui est ignoré et peut donc être d'un type arbitrairee
, qui doit être une fonction prenant deux nombresDans le corps de la fonction
e
est ensuite appliqué à 14 et 49, en utilisant la`
notation -infix.Exemple d'utilisation:
L'opérateur est appliqué au
()
tuple vide et(*)
l'opérateur de multiplication14*49 = 686
est 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 commeeQT
), 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.la source
Pyth, 131 pour l'instant (2 défis complets)
1. Run, 74
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é: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~
,I
etL
qui 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 lesQ
s 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
.f
de la création de caractères arbitraires.3. Facilité de vie: 74 - 17 = 57
Essayez-le en ligne
Un programme Pyth équivalent serait:
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é|&
,or
alorsand
, 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
100
directement, je le génère avec*TT
, carT
est initialisé à10
.Au lieu d'écrire
16
directement, je le génère avecye|LZ9
.|LZ
fonctionne essentiellement comme la fonction de plage,|LZ9
donne donc[0, 1, 2, 3, 4, 5, 6, 7, 8]
.e
prend le dernier élément d'une liste, donnant8
.y
le double, donnant16
comme souhaité. Avec un extra+
ou un extra*
je pourrais sauver un personnage, mais ils sont tous deux plus utiles ailleurs.Plus à venir!
la source
Ruby - Score: 74
1. Run
Saisi du défi.
la source
JavaScript (ES6), score = 74
1. Run, 74 octets
6. Esotérisme (invalide)
Pour mémoire, ma quine suggérée était:
qui s'est avéré invalide, comme indiqué dans les commentaires ci-dessous.
la source
Rétine, score 74
1. Courir, marquer 74
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 oud
de classe de caractères numériques.la source
Pip, score 74 + (74 - 19) = 129
Tant de backticks avec nary une citation à être vu, simple ou double!
Tâche 1, note 74
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'-w
indicateur ajouté pour prouver qu'aucun avertissement n'est généré.Tâche 3, score 55 (longueur 19)
Utiliser une méthode de saisie plutôt étrange - le cinquième argument de ligne de commande - est possible. Essayez-le en ligne!
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écessiteC
, ou éventuellement une indexation dans laPA
variable. Construire et évaluer du code ne peut se faire sansV
. 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 niRL
(liste répétée) et n'avoir qu'une seule chance d'utiliserAL
(ajouter la liste) - peu probable) ou éventuellement quelque chose avecCG
(grille de coordonnées) ouMC
( coordonnées de carte), les deux interdites .La tâche 5 est à la limite de la possibilité. Les boucles seraient difficiles, car
F
ou etM
ap ne sont pas possibles, et les gammes ne peuvent pas être construites avec,
. Il y a peut-être quelque chose à faire avec leT
mal. L'incrément pourrait être de lax:x+1
variété (évidemment avec une variable autre quex
, 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 égalementR
(remplacer),RP
(repr) ouV
(eval), dont aucun n'est disponible.la source
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@~*^)$.
( Essayez-le en ligne! )~+1A|Q)p~
\Z!IQ~e:O.~@#|9@)Tf\eT`=(!
|~!y!
) Q~$x.4|m4~~&!L{%Il produira un désordre de choses, cependant (mais aussi sa source une fois: 3).
Je travaillerai sur d'autres défis, cependant.
la source
Q
du tout (puisqu'il s'agit de la fonction intégrée de Quining), et il n'y a pas de guillemets doubles, vous ne pouvez donc pas formater de chaîne. J'ai travaillé quelque temps sur ce sujet hier et je suis à peu près sûr que les autres programmes ne sont pas possibles uniquement avec les 74 caractères.05AB1E - Score total: 74
1. Run, 74 octets
Tout ce qui cause une erreur est ignoré par 05AB1E. Toute cette ligne de code est un NOP.
Essayez-le en ligne!
la source
(abusé) PHP, 74 + 74 = 148
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: Pla source
output this char
s'il rencontrait un<
. Je ne dis pas qu'il est capable de gérer la charge utile ou ça, je dis simplement que ce n'est pas différent d'une langue ayant un caractèreoutput the source
. S'il ne s'agit pas d'une réponse valide pour la partie 1, toute langue qui accepte une entrée sans erreur n'est pas une réponse valide également. Je ne pense pas que cela soit plus abusif que la plupart des réponses ici.Mathematica, score 68
Remarquez le retour à la ligne suivant. Je ne pense pas que Mathematica puisse relever tous les autres défis.
la source
Labyrinthe, score 74
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
2016
chiffre à la fois. (En résumé: placez les 22
sur la pile, sautez / imprimez l’un, déplacez l’autre vers la pile auxiliaire, imprimez 0, enfoncez le 21
sur la pile, sautez / imprimez 1, incrémentez, bitwise not, negate (last1
est un3
à ce point), somme avec le2
de 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.la source
SmileBASIC, 48 points
défi 1:
explication:
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.
la source
MATL , score total 74
1. Courir, marquer 74
Tout jusqu'à
%
est le code réel.%
est un symbole de commentaire, donc les caractères à sa droite sont ignorés.Le programme sort
1
sans erreur.Essayez-le en ligne!
la source
bash, score 74
1: courir. Nous pouvons courir tous les 74
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.
la source
Perl 6 , note totale 74
1. Courir, marquer 74
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:
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 utiliserQ`f`.IO.e
pour vérifier s'il existe ouQ`f`.IO.x
pour 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.la source
Lua, score 31
1. Course (31 sur 74 points)
la source
variable =stuff
est 1 octet plus long.Gelée , score 74
1. Run , 74
Je ne sais pas comment faire l'un des autres.
la source
/// , 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.
la source