En tant que grand fan de la série télévisée Lost , j'ai toujours été intrigué par la séquence de chiffres qui apparaît de manière répétitive dans les épisodes. Ces chiffres sont:

$4, 8, 15, 16, 23, 42$ (A104101)

À l'aide de n'importe quel langage de programmation, écrivez un code qui génère ces nombres.

Notation:

• La réponse la plus courte l'emporte

• La sortie ne doit pas contenir d'autres chiffres ou lettres. Vous pouvez utiliser n'importe quel autre caractère comme séparateur, ou même aucun séparateur du tout.

• Vous ne pouvez pas séparer les chiffres du même numéro. $48\_15162342$ est une réponse valide, mais $481\_5162342$ ne l'est pas.

• Vous devez respecter la commande.

• Si votre code ne contient aucun des chiffres de la séquence, réduisez votre score de 30%. Cette règle vous permet de saisir les chiffres séparément. Par exemple:

  abcde1fg5h
  

  Est un candidat valide car la réponse ne contient pas le nombre $15$ , seulement ses chiffres. Cependant, tout $4$ ou $8$ invalidera le bonus.

• Si le code ne contient aucun chiffre, réduisez votre score de 50%. D'autres personnages comme $¹$ , $²$ ou $³$ sont toujours valables pour ce bonus.

Perdu , 29 27/2 = 13,5 octets

%?\>>>>>>>>>>
>>\"*"@"

Essayez-le en ligne! ou vérifier qu'il est déterministe

Semblait comme la bonne langue à utiliser.

Explication:

Lost est un langage 2D où le pointeur commence n'importe où , va dans n'importe quelle direction. Cela conduit généralement à de nombreuses vérifications que le pointeur n'est pas entré dans une section plus tôt.

...>>>>>>>>>>  These arrows filter all pointers that appear on the top line
.............  Or going vertically


%............  This flips the flag so that the program can end
.............  This stops premature termination

.?\..........  Clear the stack by skipping if a value popped from the stack is positive
.............  When the stack is empty, the \ directs the pointer down

.............  The \ directs the pointer right
..\"*"..  The string literal pushes all the Lost values to the stack

..\..........  The @ terminates the program if the % flag is switched
>>\........@.  Otherwise it clears the stack and repeats

.............  The quote here is to prevent the pointer getting stuck
............"  This happens when the pointer starts between the other quotes

Gelée , 7/2 = 3,5 octets

“ƲÞIȥ’Ḥ

Imprime les nombres sans séparateur, c'est-à-dire l'entier $4815162342$ .

Essayez-le en ligne!

Comment ça fonctionne

“ƲÞIȥ’est un littéral entier bijectif base-250.
Ʋ, Þ, I, Et ȥont (1-based) indices $154$ , $21$ , $74$ et $171$ dans la page de code de gelée, de sorte qu'ils codent le nombre entier $250^3\cdot154+250^2\cdot21+250\cdot74+171=2407581171$ .

Enfin, Ḥ(unhalve) double l'entier, donnant $2\cdot2407581171=4815162342$ .

Le doublement est nécessaire, car le codage de la sortie mène directement à “¡9)Ƙ[’, qui contient un chiffre.

Neim , 6 5 octets, 3 2,5 points

Jσς§A

Explication:

J     Push 48
 σ    Push 15
  ς   Push 16
   §  Push 23
    A Push 42
      Implicitly join the contents 
      of the stack together and print

Essayez-le en ligne!

05AB1E , score: 10 9 7 octets / 2 = 3,5

•‘o]Ê•·

Essayez-le en ligne.

Ou alternative de 7 octets :

•’µ[%•R

Essayez-le en ligne.

Les deux sorties de l'entier 4815162342.

Explication:

•‘o]Ê•     # Compressed integer 2407581171
      ·    # Doubled

•’µ[%•     # Compressed integer 2432615184
      R    # Reversed

Voir cette astuce de mes 05AB1E (section Comment compresser les grands entiers? ) Pour comprendre pourquoi •‘o]Ê•est 2407581171et •’µ[%•est 2432615184.

Ancienne réponse de 9 octets produisant la liste [4,8,15,16,23,42]:

•ΓƒÇ²•т;в

-1 octet (et donc -0,5 score) grâce à @Emigna .

Plus long que l'autre réponse 05AB1E , mais cela génère la liste [4,8,15,16,23,42]au lieu de l'entier 4815162342.

Essayez-le en ligne.

Explication:

•ΓƒÇ²•       # Compressed integer 1301916192
      т;     # Integer 50 (100 halved)
        в    # Convert the first integer to Base-50 (arbitrary): [4,8,15,16,23,42]

Voir cette astuce 05AB1E (sections Comment compresser de grands entiers? Et Comment compresser des listes d'entiers? ) Pour comprendre pourquoi •ΓƒÇ²•est 1301916192et •ΓƒÇ²•50вest [4,8,15,16,23,42].

JavaScript (ES7), 34/2 = 17 octets

_=>eval(atob`NjUwNTgxMDErNDEqKjY`)

Essayez-le en ligne!

Cela décode et évalue l'expression "65058101+41**6", qui ne contient aucun chiffre une fois codé en base-64.

JavaScript (ES6), 13 octets

Solution évidente ennuyeuse.

_=>4815162342

Essayez-le en ligne!

Python 3 , 25 octets, 12,5 points

print(*map(ord,'ዏٗ*'))

Essayez-le en ligne!

𩦦 （髒, ⿰ 馬 葬）, 𧨦 （謚, ⿰ 言 ⿱⿵ 八一 皿） coûtent 4 octets, mais U + 0657 ne coûte que 2 octets ...

Python 3 , 29 octets, 14,5 points

print(ord('𩦦')*ord('湡'))

Essayez-le en ligne!

𩦦 （⿰ 馬 葬） est le caractère variant de 髒 qui signifie "sale". 湡 est le nom d'une rivière. Et ils n'ont rien à voir avec cette question que je connaissais.

Brain-Flak , 52/2 == 26 octets

(((((((((()()()())){})){}[()])())[]()()())){}[[]]())

Essayez-le en ligne!

Java 8, score: 12 11,9 (70% de 17 octets)

v->767*6277917L+3

-0,1 score grâce à @RickHitchcock .

Essayez-le en ligne.

Explication:

v->               // Method with empty unused parameter and long return-type
  767             //  767
     *6277917L    //  multiplied by 6277917 (as long)
              +3  //  And then 3 is added

Ancienne réponse avec un score de: 12 (50% de 24 octets):

v->(long)''*'Ⓥ'*'䧶'

Contient un caractère non imprimable 0x1B.

Essayez-le en ligne.

Explication:

v->                   // Method with empty unused parameter and long return-type
  (long)              //  Cast the character (and therefore the result) to a long
        ''            //  27
           *'Ⓥ'       //  Multiplied by 9419
                *'䧶'  //  Multiplied by 18934

En Java, les caractères peuvent être placés automatiquement dans des entiers contenant leur valeur unicode. Malheureusement, le maximum pris en charge Unicode pour les caractères est 65,535, donc je ne peux pas utiliser seulement deux caractères pour multiplier (puisque les deux plus grands nombres qui divisent l'attendu 4,815,162,342sont 56,802et 84,771, où 84,771malheureusement dépasse le maximum 65,535.
En outre, puisque la taille maximale d'un intest 32 ² -1 ( 2,147,483,647) et le résultat 4,815,162,342est plus grand que cela, une conversion explicite en long, qui peut contenir jusqu'à 64 ² -1 ( 9,223,372,036,854,775,807), est requise.

Une réponse ennuyeuse aurait été de 14 octets sans aucun bonus:

v->4815162341L

Essayez-le en ligne.

R, 18x0,7 = score de 12,6

cat(9*2*267509019)

Assez explicite, fait juste un peu d'arithmétique en évitant les nombres en question.

7 , 10 octets, 27 caractères

115160723426754314105574033

Essayez-le en ligne!

La représentation compacte de ce programme sur disque est ( xxdformat):

00000000: 269c 3a71 6f63 308b 7c0d                 &.:qoc0.|.

Explication

Nous avons déjà vu cette séquence de nombres dans Automate Saving the World , qui consistait à imprimer les nombres à intervalles réguliers, ce qui la rend intéressante en nécessitant l'utilisation d'une langue très ancienne. Beaucoup de langues plus récentes peuvent avoir leurs propres rebondissements qui rendent ce défi intéressant, cependant. _{(Oui, ce paragraphe, et en fait la raison pour laquelle j'ai commencé à écrire cette réponse, n'est en fait qu'un moyen de rassembler tous les défis associés dans la barre latérale; normalement, les gens le font en utilisant des commentaires, mais je n'ai pas assez de représentants .)}

La première chose à noter est que 7 est entièrement composé de chiffres, donc il est peu probable que les bonus ici fonctionnent (bien que si vous voyez le programme comme une séquence d'octets, aucun d'entre eux ne correspond aux représentations ASCII de l'un des nombres originaux , vous pouvez donc réclamer le bonus dans ce sens). La prochaine chose à noter est que 7 a des commandes pour recréer la séquence de commandes susceptible d'avoir produit une donnée spécifique; alors pourrions-nous éventuellement interpréter les numéros perdus 4815162342comme une section d'un programme 7 lui-même?

La réponse est "pas tout à fait". La partie la plus problématique est ce deuxième numéro 8,. 7 programmes sont écrits en octal; il n'y a pas de nombre comme 8. Ainsi, le tout début de la chaîne devra être imprimé différemment.

La base du programme est donc basée sur le 7 programme "Hello world":

5431410557403
543141055          string literal
         7         separate data from code
          4        rearrange stack: {program's source}, empty element, {literal}
           0       escape {the literal}, appending it to {the empty element}
            3      output {the escaped literal}, pop {the program's source}

avec le littéral échappé étant dans un langage spécifique au domaine qui est interprété comme suit:

5                  output format: US-TTY using pairs of digits in the string
 43                select character set: digits and common symbols
   14              "4"
     10            "8"
       55          forget the set output format

Après cela vient un extra 3, qui génère l'élément de pile restant (et se termine en raison d'une pile restante insuffisante). Cet élément est spécifié au début du programme, et pour éviter l'inégal 6(qui fonctionne un peu comme une parenthèse fermante), nous le générons en utilisant du code, plutôt que de l'écrire directement en tant que données. (Notez qu'il y a deux 7caractères implicites au début du programme, ce qui est pertinent ici):

{77}115160723426
 7                 empty stack element
  7 11516          append "1151"
         0         append "6"
          723246   append "2324"

Cela produit le littéral suivant:

115162324
1                  set output format: literally as octal
 15162324          "15162324"

qui est imprimé.

05AB1E , 6 * 0,7 = 4,2 octets

•1Z&ð“

Essayez-le en ligne!

Imprime le nombre non compressé de la base-255

MASM 8088 Source d'assemblage, (93 octets - 50%) = 46,5 octets

Ne pas utiliser de nombres ou la séquence dans la source:

MOV AH,'P'-'G'
LEA DX,L
INT '!'
RET
T EQU '-'-'+'
L DW 'ph'/T,'jb'/T,'lb'/T,'fd'/T,'dh'/T,'$'

Production:

A>LOST.COM
4815162342

Fusain , 13 octets / 2 = 6,5

ＩＥTPIHA.⁻⁸⁸℅ι

Essayez-le en ligne! Le lien est vers la version détaillée du code. Fonctionne en soustrayant les codes ASCII de la chaîne TPIHA.de 88 et en les convertissant en chaîne.

Aheui (ésotope) , 45 octets (15 caractères) * 0,5 = 22,5 points

반밤밪박밭빠따받발따밣뱣히망어

Essayez-le en ligne!

Explication:

Voir aussi ceci; Aheui Reference ( anglais )

Aheui program starts with default stack '아'(or none)

반: push 2, move cursor right by 1(→).
밤: push 4, →
밪: push 3, →
박: push 2, →
밭: push 4, →
빠: dup, →
따: pop 2, push mul result(16).
받: push 3, →
발: push 5, →
따: pop 2, push mul result(15).
밣: push 8, →
뱣: push 4, move cursor right by 2(→→).
히: end.
망: pop 1, print, → (if stack is empty, move cursor left by 1.)
어: move cursor left by 1(←).

Notez que ㅁ (instruction d'impression) déplace le curseur en sens inverse si la pile (ou la file d'attente) est vide.

Perl 5 , 16 octets - 30% = 11,2

say 0x5FAB2EA2*3

Essayez-le en ligne!

PowerShell , 12 octets * 0,7 = 8,4

0x5FAB2EA2*3

Essayez-le en ligne!

"Port" de la réponse de Xcali pour avoir une meilleure réponse Powershell.

naz , 46 octets, score 32,2

2a2a1o2m1o7s1o5m1o2s2s1o6m1o2s2s1o1a1o1a1o2s1o

Produit simplement chaque chiffre 4815162342un par un.

JavaScript, 143 octets (je ne sais pas comment marquer)

(g=`${2*2}`)=>g.repeat(6).replace(/(.)/g,(m,p,i,k='')=>
  (k=m*[g-3,g-2,g,g,+g+2,g*3-1][i]
  ,RegExp(`${g-2}|${g}`).test(i)?k-1:i==+g+1?k-(g/2):k))

Essayez-le en ligne!

Commencez par six 4, multipliez, ajoutez, soustrayez par, à, de 4pour dériver la sortie.

PHP, 35/2 = 17,5

<?=zzzzzzzzzzzzzzz^NVBVKOVKLVHIVNH;

une approche numérique: 40 * .7 = 28

<?=2+2,_,5+3,_,17-2,_,17-1,_,17+6,_,7*6;

pas de chiffres, pas de chaînes: 68/2 = 34

<?=$p++,!$p++,$p+=$p,_,$p+=$p,_,~-$q=$p+$p,_,$q,_,--$p+$q,_,$p*~-$p;

Essayez-les en ligne .

JavaScript (SpiderMonkey), 67 octets / 2 = 33,5 60 octets / 2 = 30 58 octets / 2 = 29 48 octets / 2 = 24

-7 octets / 3,5 , -2 octets / 1 avec l'aimable autorisation de @JoKing, -10 octets / 5 avec l'aimable autorisation de @tsh

print(a=-~-~-~-~[],a+=a,b=a+~-a,a+a,a+b,--b+b+b)

Essayez-le en ligne!

APL (Dyalog Unicode), 18/2 = 9 octets

×/⎕UCS'𩦦湡'

Juste ennuyeux vieille multiplication de caractères.

Essayez-le en ligne!

JavaScript (ES6), 16 * 0,7 = 11,2 octets

_=>767*6277917+3

Génère les chiffres sans délimiteurs.

Essayez-le en ligne!

Espace , score: 49 41 octets / 2 = 20,5

[S S S T    S S S T T   T   T   T   S S S S S S S T T   S S S T S T T   T   T   T   S S T   T   S N
_Push_4815162342][T N
S T _Print_number]

Lettres S(espace), T(tabulation) et N(nouvelle ligne) ajoutées uniquement en surbrillance.
[..._some_action]ajouté à titre d'explication uniquement.

Essayez-le en ligne (avec des espaces bruts, des tabulations et des nouvelles lignes uniquement).

Pseudo-code:

Integer i = 4815162342
Print i as number to STDOUT

Explication:

Dans les espaces, un nombre est poussé comme suit:

• S: Activer la manipulation de la pile
• S: Numéro push
• S/ T: Positif / négatif respectivement
• Certains T/ Ssuivis d'un simple N: Décimal en binaire, où Test 1 et Sest 0

Après cela, il est simplement imprimé avec TNST:

• TN: Activer les E / S
• S: Afficher le haut de la pile
• T: Comme nombre

F #, 45 octets = 22,5 points

Juste une forboucle courante qui imprime les chiffres:

for c in"DHOPWj"do printf"%d"(int c-int '@')

Ce qui précède est un programme complet qui peut être compilé en un exécutable.

Dans une boucle REPL (lecture-évaluation-impression), par exemple FSI (F # Interactive), la version courte suivante fonctionnera, car la REPL affichera une représentation de l'expression évaluée; il a 35 octets = 17,5 points:

[for c in"DHOPWj"->int c-int '@'];;

Pyke , 3 points

77 91 f8 86 98 06

Essayez-le ici!

Le premier octet signale la lecture dans la base 128 jusqu'à ce qu'un octet sans le bit haut soit défini.

Enfin, 32 est soustrait du résultat (pour des raisons historiques).

Cela permet la génération de grands nombres dans de très petites quantités d'espace

MathGolf , 7 octets * 0,5 = 3,5

ÿ≤┼ÇÅ$∞

Essayez-le en ligne!

Explication

Notez que ce code ne fonctionne pas encore sur TIO. J'ai récemment apporté quelques modifications à MathGolf, y compris l'ajout de l' $opérateur. Une fois qu'il est tiré sur TIO, vous pouvez l'exécuter là-bas, je ferai alors une mise à jour de cette réponse. Il fonctionne parfaitement dans le terminal

ÿ≤┼ÇÅ     Push "≤┼ÇÅ"
     $    pop(a), push ord(a) (pushes 2407581171)
      ∞   pop a, push 2*a

J'utilise le fait que MathGolf possède des littéraux d'un octet pour créer des chaînes d'une longueur maximale de 4. Si je voulais convertir le nombre entier à partir d'une chaîne de base 256, j'aurais dû en utiliser deux "et la chaîne aurait été 5 personnages. De cette façon, j'économise 2 octets, mais je perds un octet en ayant à la fin l'opérateur de doublage.

Python 3 34 points

b=len("  ");c=b*b;d=c*b;e=d*b;g=e+d-b//b;print(c,d,e-b//b,e,g,g*b-c)

Python 3 , 44 38 19 18,5 octets

-6 octets grâce à @Jo King
-50% octets grâce à @ouflak pour avoir souligné le bonus de 50%
-1 octet grâce à @Dennis

for i in'밗ɯ*':print(ord(i),end='')

Essayez-le en ligne!

Japt, 10 9 octets / 2 = 4,5

"0¢*"mc

Essaye-le

Befunge-98 (FBBI) , 15 octets / 2 = 7,5 points

"*H/!k-"*.*+..@

Essayez-le en ligne!

Explication:

Poussez d'abord les valeurs ASCII des caractères * + H /! K- (42, 72, 47, 33, 107, 45) dans cet ordre vers la pile. Puis calculez$4815 = 45 \cdot 107$ et $1623 = 33\cdot 47+72$et sortie.