introduction

Le calcul est un langage de plaisanterie ésotérique .

De l' entrée esolangs:

Le calcul n'a pas de syntaxe requise et a le pouvoir de résoudre tous les problèmes. Il est assez intelligent pour interpréter n'importe quel langage humain (anglais, espagnol, latin, etc.), tout langage de programmation (C ++, Java, brainfuck, etc.), ou tout type de données auquel vous pouvez penser. Le seul inconvénient est qu'il n'y a absolument pas d'E / S.

Quelques exemples de programmes

Hello World

Un programme de base Hello World

What is love?

Détermine que l'amour est (bébé ne me fait pas de mal).

When will we ever graduate?

Détermine la date exacte de sortie de cette version bêta de ce site.

Le défi

Votre tâche consiste à écrire un interpréteur de calcul complet. Cela semble assez difficile, mais gardez à l'esprit que Compute n'a absolument pas d'E / S. Ainsi, votre interprète dormira juste une seconde pour chaque ligne du programme d'entrée et sortira \n\nDone.après cela (c'est la seule exception à la chose sans E / S).

Vous pouvez trouver l'interprète officiel au bas de ce site .
Notez que l'interpréteur officiel fait une pause d'une seconde pour chaque caractère du code source donné. Pour éviter de longues périodes d'attente tout en testant votre interprète avec des questions significatives, nous restons avec des lignes dans ce défi.

Règles

• L'entrée peut contenir plusieurs lignes séparées par un \n. Il y aura toujours au moins une ligne.
• Contrairement à l'implémentation officielle, vous n'avez pas besoin de prendre un fichier en entrée. Vous pouvez utiliser le programme Compute dans n'importe quelle forme d'entrée que vous souhaitez.
• La seule sortie autorisée est \n\nDone.. Une nouvelle ligne de fin est autorisée.
• Fonction ou programme complet autorisé.
• Règles par défaut pour les entrées / sorties.
• Des échappatoires standard s'appliquent.
• C'est le golf de code , donc le nombre d'octets le plus bas l'emporte. Tiebreaker est une soumission antérieure.

05AB1E , 16 15 14 13 octets

Code:

[Ig>#w’

D€µ.

Explication:

[        # Starts an infinite loop
 I       # Input string
  g>     # Length + 1
    #    # If equal to 1, break out of the loop
     w   # Wait 1 second

Cette partie équivaut à "\n\nDone.":

      ’  # Push "\n\nDone." on top of the stack

D€µ.     # The compressed string is ended implicitly
         # Implicit, print top of the stack

Essayez-le en ligne!

Utilise l' encodage CP-1252 .

Oration , 117 octets

I need time!
To iterate, input().
Inhale.
Now sleep(1).
Backtracking.
Boring,
boring.
Listen!
Capture Done.
Carry on!

Expliquons cela. Tout d'abord, cela se transforme en:

import time
while input():
    time.sleep(1)
print("\n")
print("\n")
print("Done")

Encore confus? Disons-le comme ceci:

I need time!

Importe le module time.

To iterate, input().

Il s'agit d'une boucle while dont la condition est input().

Inhale.

Notre programme doit respirer maintenant et inhale, bien que moins sain, il est plus golfeur.

Now sleep(1).

Nowprenez le module le plus récent importé et ajoutez- .sleep(1)le.

Backtracking.

Sortons de la boucle while.

Boring,
boring.

Imprime deux nouvelles lignes.

Listen!

Commence à capturer une chaîne.

Capture Done.

Ajoute Done.à la chaîne capturée.

Carry on!

Termine la capture de la chaîne.

JavaScript Shell REPL, 38 octets

En tant que fonction qui accepte le programme comme argument de chaîne et renvoie le résultat:

s=>sleep(s.split`
`.length)||`

Done.`

29 octets si la fonction peut accepter son entrée sous la forme d'un tableau de lignes, ou si elle doit dormir 1 seconde par caractère:

s=>sleep(s.length)||`

Done.`

34 octets s'il devrait également ressembler davantage à un programme et afficher explicitement Terminé:

s=>sleep(s.length)||print`

Done.`

Cela fonctionne pour moi dans l'interpréteur Spidermonkey autonome.

Javascript ES6, 46 45 octets

a=>setTimeout(x=>alert`

Done.`,a.length*1e3)

Merci à ӍѲꝆΛҐӍΛПҒЦꝆ pour avoir sauvé un octet

Suppose un tableau en entrée.

Comme ӍѲꝆΛҐӍΛПҒЦꝆ et edc65 l' ont souligné, vous pouvez écrire ce qui suit, mais cela n'économisera aucun octet:

a=>setTimeout("alert`\n\nDone`",a.length*1e3)

Bash + coreutils, 28

sleep `wc -l`
echo "

Done."

Dort 1 seconde pour chaque ligne. Utilisez-le à la wc -cplace pour chaque octet ou à la wc -mplace pour chaque caractère.

Pyth, 15 14 octets

.dcl.z1b"Done.

^{(Vous pouvez l' essayer en ligne , mais cela ne sert à rien.)}

Perl, 21 + 1 = 22 octets

sleep 1}{$_="\n\nDone."

Nécessite le -pdrapeau:

$ perl -pe'sleep 1}{$_="\n\nDone."' <<< $'a\nb\nc'


Done.              

Python 3, 58 octets

import time
while input():time.sleep(1)
print("\n\nDone.")

MATL , 17 octets

10c'Done.'`jt?1Y.

Une ligne vide de fin (suivie d'une nouvelle ligne) est utilisée pour marquer la fin de l'entrée. Cela est nécessaire dans MATL car l'entrée est interactive et chaque entrée se termine par une nouvelle ligne.

Essayez-le en ligne!

10c           % push newline character
'Done.'       % push string
`             % do...while
  j           % input string
  t           % duplicate
  ?           % if non-empty
    1Y.       % pause for 1 second
              % loop condition is the current string. If non-empty: next iteration
              % If empty: exit loop and print stack contents. There are two strings
              % and a newline is printed after each, so the desired output is obtained

QBasic, 54 octets

LINE INPUT x$
IF x$=""GOTO 1
SLEEP 1
RUN
1?
?
?"Done."

Prend le programme ligne par ligne à partir de l'entrée utilisateur, terminé par une ligne vierge. Respecte la lettre de la loi, mais peut-être pas l'esprit, en s'arrêtant 1 seconde après avoir lu chaque ligne. (La spécification ne dit pas techniquement que les pauses doivent toutes venir après la fin de l'entrée.) Si cela est considéré comme trop louche, voici une version de 64 octets qui s'arrête après que tout le programme a été entré:

DO
LINE INPUT x$
IF x$=""GOTO 1
t=t+1
LOOP
1SLEEP t
?
?
?"Done."

Version bonus avec fichier E / S (87 octets):

INPUT f$
OPEN f$FOR INPUT AS 1
1LINE INPUT #1,x$
SLEEP 1
IF 0=EOF(1)GOTO 1
?
?
?"Done."

Rubis, 32 octets

$<.map{sleep 1}
puts"\n\nDone."

Lit à partir de stdin.

OCaml, 61 octets

fun a->List.iter(fun _->Unix.sleep 1)a;print_string"\n\nDone"

Suppose que l'entrée est une liste.

Gelée , 12 octets (non concurrent)

ỴLœS@⁷⁷“ẋḲp»

Essayez-le en ligne!

Remarque: veuillez ne pas suggérer de mettre le ⁷⁷dans la chaîne compressée, cela le rendra plus long ( “¡OÑL[Ṁ»).

Explication:

ỴLœS@⁷⁷“ẋḲp» Main link. Arguments: z.
ỴL           The number of lines in z. (x)
     ⁷       Newline ("\n") (y)
  œS@        After sleeping for x seconds, return y.
      ⁷      Newline ("\n")
       “ẋḲp» Compressed string ("Done.")

awk, 34 octets

END{print"\nDone."|"cat;sleep "NR}

Comme il n'y a pas d'E / S et que le résultat final est inévitable, la Done.pièce est sortie dès le début.

$ awk 'END{print"\nDone."|"cat;sleep "NR}' file

La seule façon de dormir dans awk est d'utiliser le système sleep. Le moyen le plus court de l'invoquer est de le faire print|"sleep "NRet nous pourrions aussi bien en abuser print.