3… 2… 1… Crash off!

47

Votre tâche consiste à écrire un programme complet qui continuera à décompter à partir de 10 à chaque exécution.

  • La première fois que vous exécutez le programme, il devrait être imprimé 10.
  • La prochaine fois, il devrait sortir 9.
  • La prochaine fois, il devrait sortir 8, et ainsi de suite.
  • Au lieu d’imprimer 0, le programme devrait planter. Vous ne devez plus gérer le programme en cours d'exécution par la suite.
  • Toute installation utilisée pour le stockage peut être considérée comme vide avant la première exécution du programme.

Voici un exemple d'implémentation dans Python 3:

try:f=open("a","r+");v=int(f.read())
except:f=open("a","w");v=10
1/v
print(v)
f.seek(0)
f.write(str(v-1))

C'est du , donc la réponse la plus courte (mesurée en octets) est gagnante.

Fruit d'esolanging
la source
12
Qu'est-ce que le crash implique?
Conor O'Brien
2
@ ConorO'Brien Hmm ... cela n'a pas été discuté en méta?
Esolanging Fruit
2
@ Challenger5 Pas que je sache. Lancer une erreur serait-il suffisant?
Conor O'Brien
1
@ ConorO'Brien Oui.
Fruit Esolanging
Connexes .
FryAmTheEggman

Réponses:

18

6502 langage machine + Apple] [+ ROM, 12 (11? 10? 9?) Octets

CE 06 80 F0 01 A2 0B A9 00 4C 24 ED

Devrait commencer à $8000. Se bloque sur le moniteur système lorsque le nombre atteint 0.


C6 B6 F0 01 A2 0B A9 00 4C 24 ED

Devrait commencer à $B1. Cela enregistre un octet, car je peux utiliser la version (deux octets) de zéro page DEC, mais écrase la routine critique Applesoft CHRGET; vous devez le charger et l'appeler à partir du moniteur, puis utilisez CTRL+ BReturnpour réinitialiser BASIC une fois que vous avez terminé. Pas sûr si cela invalide ou pas.


CE 06 80 F0 01 A2 0B 4C 26 ED

Devrait commencer à $8000. Cela n'initialise pas $9E, économisant deux octets. Cependant, cela signifie que vous ne devez pas l'appeler avec une adresse négative (ou, si vous l'appelez depuis le moniteur, vous devez appeler le moniteur avec une adresse positive). Si vous le faites, de Applesoft CALLla routine va stocker FFdans $9E, l' amenant à ajouter 65280 au numéro lors de l' impression. Encore une fois, je ne sais pas si cela invalide la solution ou non.


C6 B6 F0 01 A2 0B 4C 26 ED

Devrait commencer à $B1. Ceci est une combinaison des deux programmes ci-dessus, économisant un total de trois octets; vous devrez appeler le moniteur avec une adresse positive, le charger et l'exécuter à partir de là, et utiliser Ctrl+ BReturnpour réinitialiser BASIC une fois que vous aurez terminé.


Notez que ces programmes ne modifient que le programme en mémoire; recharger le programme à partir du disque réinitialisera le compte à rebours. Cela fonctionne parce que les Apple] [(et] [+, // e et // c) n’ont aucun système de protection de la mémoire; le programme (et ses auto-modifications) restera en mémoire même après sa fermeture. Vous pourrez donc continuer à l'exécuter de mémoire jusqu'à ce que vous remplaciez cette mémoire par quelque chose d'autre.


Échantillon échantillon

]BLOAD COUNT THEN BRK
]CALL 32768
10
]CALL 32768
9
]CALL 32768
8
]CALL 32768
7
]CALL 32768
6
]CALL 32768
5
]CALL 32768
4
]CALL 32768
3
]CALL 32768
2
]CALL 32768
1
]CALL 32768

8008-    A=80 X=9D Y=00 P=36 S=EE
*

Explication

     DEC NUM+1  ; Decrement the LDX instruction's operand
     BEQ NUM+1  ; If it is now zero, branch to it; 00 is the opcode for the BRK instruction, which causes the program to crash to the monitor
NUM  LDX #$0B   ; Load the X register with 0x0A; the operand has already been decremented once
     LDA #$00   ; Load the accumulator with 0
     JMP $ED24  ; Jump to $ED24, an Applesoft ROM routine which prints A (high byte),X (low byte) in decimal

Explication de la version 10 octets

     DEC NUM+1  ; Decrement the LDX instruction's operand
     BEQ NUM+1  ; If it is now zero, branch to it; 00 is the opcode for the BRK instruction, which causes the program to crash to the monitor
NUM  LDX #$0B   ; Load the X register with 0x0A; the operand has already been decremented once
     JMP $ED26  ; Jump to $ED26, which is two bytes into the Applesoft routine at $ED24. The two skipped bytes would store the accumulator in $9E

Des variantes

Imprime ERRet émet un bip lorsque le nombre atteint 0

Normal - 15 octets

CE 06 80 F0 07 A2 0B A9 00 4C 24 ED 4C 2D FF

Écrasement CHRGET- 14 octets

C6 B6 F0 07 A2 0B A9 00 4C 24 ED 4C 2D FF

N'initialise pas $9E- 13 octets

CE 06 80 F0 05 A2 0B 4C 26 ED 4C 2D FF

Écrase CHRGETet n'initialise pas $9E- 12 octets

C6 B6 F0 05 A2 0B 4C 26 ED 4C 2D FF

Gèle lorsque le nombre atteint 0

Normal - 12 octets

CE 06 80 F0 FE A2 0B A9 00 4C 24 ED

Écrasement CHRGET- 11 octets

C6 B6 F0 FE A2 0B A9 00 4C 24 ED

N'initialise pas $9E- 10 octets

CE 06 80 F0 FE A2 0B 4C 26 ED

Écrase CHRGETet n'initialise pas $9E- 9 octets

C6 B6 F0 FE A2 0B 4C 26 ED
nom_insertion_ici
la source
Je ne suis pas sûr de comprendre cela. Ne serait-ce pas la même chose que d'avoir une fonction en Python qui décrémente une variable globale et ne fonctionne que si elle est exécutée dans le shell? Est-ce permis? Ce que je veux dire, c'est qu'on ne s'attend normalement pas à ce qu'un programme quitte la mémoire à un moment donné, pour être rechargé à nouveau plus tard.
Redstarcoder
3
@redstarcoder No - Apple II n’a littéralement aucun système d’allocation de mémoire; vous pouvez tout stocker n'importe où dans la RAM et il restera accessible à tout programme jusqu'à ce qu'il soit écrasé par une autre valeur.
insert_name_here
@inset_name_here, je ne suis pas sûr de savoir comment il est accessible partout dans la RAM change quoi que ce soit. Pourriez-vous exécuter d'autres programmes de manière fiable et exécuter encore ce programme plus tard? Peut-être que je ne connais pas suffisamment les règles ici pour bien comprendre, alors je vais simplement laisser tomber. Je m'attends simplement à ce qu'un programme complet persiste lors des redémarrages et puisse fonctionner normalement si d'autres programmes sont exécutés entre ses exécutions, mais je ne sais pas ce que la communauté décide d'un programme complet.
Redstarcoder
1
@redstarcoder le consensus général est que le programme est exécuté sur un ordinateur de développement avec rien d'autre que le logiciel requis et ne fait rien d'autre dans l'intervalle.
Tom Carpenter
1
8 octets si vous courez à partir de 6E $ à la place: C6 75 F0 03 4C 22 ED 0B
peter ferrie
35

Perl sous Linux, 17 octets

J'ai pensé qu'il pourrait être intéressant de créer un programme qui ne maintienne aucun état et ne modifie pas son propre code source; autrement dit, il vérifie à quelle fréquence il est exécuté en interrogeant le système d'exploitation. La question dit "On peut supposer que toutes les installations utilisées pour le stockage sont vides avant la première exécution du programme" et nous voudrions donc partir d'un système d'exploitation complètement vide. En tant que tel, je ferais mieux de vous expliquer comment vous y prenez, sinon il est difficile de tester le programme.

Il existe en fait deux façons de configurer le programme. Quoi qu’il en soit, le système d’exploitation minimal utilisé n’exécutera rien d’autre qu’un shell (pour nous permettre d’exécuter Perl à son tour), et le shell le plus simple possible (pour qu’il ne fasse rien d’extrême qui rend le système Vide). /bin/dashest un bon choix ici, car il était conçu comme un shell minimal pour la récupération du système. Ensuite, nous devons démarrer Linux de telle sorte que rien ne soit exécuté dash. Nous pouvons le faire soit en redémarrant l'ordinateur avec init=/bin/dashla ligne de commande Linux pour qu'il démarre rien d' autre que dash, ou (bien plus pratique) la création d' un conteneur Linux en utilisant unshare -Urfp /bin/dashdans un terminal ( unsharene pas réellement créer un système d' exploitation en blanc, mais il Simulerun; notamment, l’intérieur du conteneur pense que c’est sa racine, dashpense qu’il est init, etc., comme cela arriverait avec un système d’exploitation vierge). Avertissement: Je n'ai pas encore testé cela sur du métal nu, mais uniquement à l'intérieur unshare, mais cela devrait fonctionner dans les deux sens en théorie.

Enfin, une fois que nous avons cette configuration, nous devons simplement examiner le PID; comme nous sommes sur un système vierge, le système init (ici, le shell) aura le PID 1, de sorte que les exécutions de Perl auront des PID de 2 à 12 inclus. Donc, notre programme ressemble à ceci:

say 12-$$||die

Voici un exemple de parcours:

$ unshare -Urfp /bin/dash
# perl -E 'say 12-$$||die'
10
# perl -E 'say 12-$$||die'
9
# perl -E 'say 12-$$||die'
8
# perl -E 'say 12-$$||die'
7
# perl -E 'say 12-$$||die'
6
# perl -E 'say 12-$$||die'
5
# perl -E 'say 12-$$||die'
4
# perl -E 'say 12-$$||die'
3
# perl -E 'say 12-$$||die'
2
# perl -E 'say 12-$$||die'
1
# perl -E 'say 12-$$||die'
Died at -e line 1.
#

la source
Sous quel système d'exploitation travaillez-vous? Je suis sous Ubuntu Linux 14.04 et unsharene supporte aucun des drapeaux -Urfp.
isaacg
@isaacg: Ubuntu 16.04. unshareest assez nouveau (c'est une interface avec un système d'exploitation qui est tout aussi nouveau) et les bugs n'ont vraiment été corrigés qu'au cours de la dernière année. Si vous utilisez une version de 2 ans et demi, il n’est pas surprenant que ses fonctionnalités soient très limitées.
14

Bash + sed, 41 40 38 octets

echo $[n=10/1]
sed -i s/$n/$[n-1]/g $0

Essayez-le en ligne!

Dennis
la source
Le lien TIO a un en-tête et un pied de page, ceux-ci ne s'ajoutent-ils pas au nombre d'octets?
Pavel
2
Non, ce sont juste pour exécuter le programme 11 fois.
Dennis
Je reçois sed: invalid option -- '/'. sed (GNU sed) 4.2.2
rétréci
@shrx Huh. J'ai la même version de sed localement et sur TIO, et ils ne montrent pas cette erreur.
Dennis
9

Javascript, 42 octets

y=localStorage;y.a=y.a||10;alert(y.a--||a)

Testez-le avec ce violon - assurez-vous de vider votre mémoire de stockage locale pour réinitialiser le compte à rebours.

Merci à steenbergh, Lmis et obarakon pour de nombreux octets!

Mego
la source
y=localStorage;y.a=y.a||10;alert(y.a>0?y.a--:a)peut vous faire économiser un octet.
Oliver
Vous pouvez utiliser sessionStoragepour tester avec une réinitialisation plus facile (utilisez simplement un nouvel onglet) mais bien sûr +2 octets.
Kevin Reid
Ouch, désolé, je viens de voir votre réponse, j'ai fini par faire presque la même chose. Si vous voulez, vous pouvez utiliser l=localStorage;l.l=-~l.l;alert(10-l.l||l)pour enregistrer un octet, je supprimerais le mien
C5H8NNaO4
@ Mego Bien sûr :) Je ne vois pas de solution console.logici, mais je préférerais que ce soit
C5H8NNaO4
1
@obarakon Oui, et le court-circuitage booléen empêche l' aévaluation d'évaluer si la valeur dans le stockage local n'est pas égale à 0.
Mego
8

C #, 197 160 159 125 octets

namespace System.IO{class P{static void Main(){int n=11;for(;File.Exists(""+--n););File.Create(""+n);Console.Wr‌​ite(n*n/n);}}}

Économisé 34 octets grâce au lait

Et une version formatée (avec ReadKeyajouté pour que vous puissiez voir la sortie):

namespace System.IO
{
    class P
    {
        static void Main()
        {
            int n=11;
            for(;File.Exists(""+--n););
            File.Create(""+n);
            Console.Wr‌​ite(n*n/n);
        }
    }
}

Il est plus long que je ne le pensais, il y a donc de la place pour le golf.

TheLethalCoder
la source
2
File.Existset File.Createau lieu de ReadAllTextet WriteAllText. Il suffit de vérifier si un nom de fichier existe, ne pas les deux avec le contenu du fichier. En outre, namespace System.IOet vous pouvez supprimer l'espace de noms de System.Console.Write. 125 octets:namespace System.IO{class P{static void Main(){var n=11;for(;File.Exists(""+--n););File.Create(""+n);Console.Write(n*n/n);}}}
lait
@milk Merci beaucoup! Je ne peux pas croire que je n'ai pas pensé à utiliser le nom de fichier seulement! Et je ne connaissais pas cette astuce d'espace de noms, génial.
TheLethalCoder
8

Dyalog APL , 33 28 22/20? octets

Je ne suis pas sûr que ce soit valide, car il s'agit d'une fonction (qui doit être appelée avec un argument factice). Cependant, tous les programmes APL (purement fonctionnels ou non) ont le même statut et certaines versions de APL n’ont pas de programmes traditionnels, mais seulement des fonctions. En compensation, j'ai ajouté deux octets pour le nommer, bien que cela ne soit pas nécessaire pour obtenir l'effet désiré.

f←{6::⊢c∘←10⋄÷÷c∘←c-1}

Notez que cela repose sur un caprice non officiel, qui ∘←affecte globalement.

6:: en cas d'erreur de valeur

⊢cretour c

∘←10 qui est globalement fixé à 10

maintenant

÷÷c retourne le double inversé (erreurs sur zéro) c

∘← qui est globalement mis à

c-1un de moins que c

TryAPL en ligne!


Version de 28 octets certainement valable:

f
'c←11'/⍨0=⎕NC'c'
c←÷÷c-1

Fonctionne en définissant c sur 11 en cas d’absence, puis en soustrayant 1 de c , en inversant deux fois (ce qui donne une erreur div par zéro si c -1 est égal à 0), en affectant à c et en affichant la nouvelle valeur.


Ancienne version à 33 octets:

F
≢2 ↓ r⊣⎕FX¯1 r ← NR'f '










Fonctionne en se redéfinissant à chaque exécution, mais avec une nouvelle ligne inférieure. Affiche le nombre de lignes restantes deux fois inversé (moins deux), générant ainsi une erreur div par zéro lorsqu'il ne reste que deux lignes (l'en-tête et le code réel).

Adam
la source
1
Euh ... pourquoi y a-t-il tant de nouvelles lignes?
Kritixi Lithos
4
@KritixiLithos Le programme se redéfinit avec une ligne de moins pour chaque exécution.
Adám
7

Perl, 37 36 octets

9=~//;print$'-sysopen$~,$0,print$'+1

Se bloque lorsque la valeur initiale atteint -1 (ce qui aurait imprimé 0), car il écrit sur l' =~opérateur.

Enregistré un octet en utilisant sysopenplutôt que open. Cela me permet d’imprimer en STDOUTpremier, en utilisant la valeur de retour comme mode de fichier ( 1, aka O_WRONLY), avant que cette valeur ne $~soit réaffectée.

Exemple d'utilisation

$ perl crash-off.pl
10
$ perl crash-off.pl
9
$ perl crash-off.pl
8

...

$ perl crash-off.pl
2
$ perl crash-off.pl
1
$ perl crash-off.pl
syntax error at crash-off.pl line 1, near "1~"
Execution of crash-off.pl aborted due to compilation errors.
primo
la source
6

Perl 6 ,  60  58 octets

put 10-$=finish.lines||die;
$*PROGRAM.open(:a).put;
=finish
 
open($*PROGRAM,a=>put 10-$=finish.lines||die).put
=finish
 

Nécessite un caractère de nouvelle ligne après =finish.

diepeut être remplacé par 1/0.

Explication:

Il obtient une liste de lignes après que =finish( $=finish.lines) le soustrait 10, et si le résultat n’est pas obtenu, 0il l’imprime, sinon il dies.

La dernière chose qu'il fait est de s'ouvrir en mode ajout et d'ajouter une autre ligne à la fin.

Brad Gilbert b2gills
la source
Permalink pour ceux qui n'ont pas Perl 6.
Dennis
@Dennis Au moins celui-ci n'est pas aussi démodé que ce que Ideone a (course say $*PERL.compiler.version)
Brad Gilbert b2gills
1
2014.7 ... wow! Est-ce que 2016.11 est très différent de 2016.7? Si c'est le cas, je peux le construire à partir de la source.
Dennis
@Dennis La version officielle de Perl 6 était le 2015-12-25. Il y a eu un grand changement à la fin de 2015 appelé The Great List Refactor (GLR). Il est donc presque impossible que le code fonctionne également en 2014.7. La plupart de ce qui s'est passé en 2016 est lié aux performances, bien qu'il y ait eu beaucoup de corrections de conditions de bord. La plupart du code golfé devrait fonctionner sur n'importe quoi après la publication de Rakudo 2015.12. Donc, je pense que v2016.07 est bien.
Brad Gilbert b2gills
6

Python 2, 65 octets

f=open(__file__,"r+")
x=75-len(f.read())
x/x
print x
f.write('#')

Inspiré par la réponse de L3viathan .

Peut être réduit à 60 octets si vous pouvez choisir de nommer le fichier avec un seul caractère x, puis de le remplacer __file__par 'x'. Dans ce cas, remplacez 75par 70.

Alex Hall
la source
@ Flp.Tkc oui, mais n'est-ce pas le même nombre d'octets?
Alex Hall
oh, c'est vrai: P
FlipTack
4

Jolf, 20 octets

γ-@▲lqΈ?␡γ?γaγ0₯I₯C1

Essayez-le ici! Erreurs quand 0est imprimé. Modifie le code. Explication à venir.

Conor O'Brien
la source
Je ne connais pas très bien Jolf, mais cela ne semble pas immédiatement fonctionner avec l'interprète en ligne.
Fruit Esolanging
1
@ Challenger5 La langue ne fonctionne généralement que sur Firefox.
Conor O'Brien
4

Applesoft BASIC, 21 octets (en jetons)

0  PRINT 9 + 1: CALL 2066: END : OR <CTRL-F><CTRL-H>`

Remplacez <CTRL-F>et <CTRL-H>avec leurs versions littérales. Notez que cela ne modifie que le programme en mémoire; le recharger à partir du disque réinitialisera le compte à rebours.


Échantillon échantillon

]RUN
10

]RUN
9

]RUN
8

]RUN
7

]RUN
6

]RUN
5

]RUN
4

]RUN
3

]RUN
2

]RUN
1

]RUN

?SYNTAX ERROR IN 0

Explication

PRINT 9 + 1fait ce que vous attendez. CALL 2066appelle la routine de langage machine 6502 à l'emplacement de mémoire 2066, qui est après END :. ENDinterrompt le programme pour que la routine en langage machine (qui, pour l'interpréteur Applesoft, ne soit pas ordonnée) ne soit pas exécutée.

La routine en langage machine décrémente simplement 9dans PRINT 9 + 1. Démontage:

0812-   CE 06 08    DEC $0806
0815-   60          RTS

Lorsque le compteur atteint 0, il est "décrémenté" à /; tenter d'exécuter le programme provoquera alors une erreur de syntaxe.

nom_insertion_ici
la source
4

*> <> , 20 18 octets

a1Fi:0(?b1-:?:1Fn;

Cela fonctionne réellement sur Linux (et tout ce qui supporte des fichiers nommés, \nje suppose). Il crée un fichier nommé \nlors de la première exécution et des sorties 10. Il produit en sortie un nombre en moins à chaque exécution ultérieure, sauf en 0cas de blocage .

Explication

a1F                   open file named "\n"
   i:                 recieve input and duplicate it (-1 if empty)
     0(?b             if the file is empty, push 11 to the stack
         1-           subtract one
           :          duplicate the number
            ?:        if the number isn't 0, duplicate it again
              1F      save the number to the file
                n     output the number (crash if non-existant)
                 ;    exit
Redstarcoder
la source
2
Pratique que *> <> ajoute IO
Alfie Goodacre
4

PHP 57 octets

echo$n=($f=file(f))?$f[0]:10?:die;fputs(fopen(f,w),--$n);

ne plante pas vraiment mais quitte (sans décompter) quand il frappe 0. Est-ce suffisant?

Courez avec -r.

Titus
la source
4

C #, 156 octets

J'ai joué au golf @ TheLethalCoder pendant un moment et j'ai pu économiser 3 octets en réordonnant les instructions et en éliminant int.parse (). Il y a encore place à amélioration, j'en suis sûr.

using System.IO;class P{static void Main(){int n;try{n=File.ReadAllText("f")[0]-48;}catch{n=10;}System.Console.Write(n/n*n);File.WriteAllText("f",""+--n);}}

Ungolfed:

using System.IO;
class P
{
    static void Main()
    {
        int n;
        try
        {
            n = File.ReadAllText("f")[0] - 48;
        }
        catch {
            n = 10;
        }
        System.Console.Write(n / n * n);
        File.WriteAllText("f", "" + --n);
    }
}

Méta-question: Il peut être difficile de prendre le travail de TheLethalCoder comme point de départ de ma réponse. Serait-il préférable (une fois que j'ai le représentant) d'ajouter ceci comme commentaire sur leur réponse? Je n'essaie pas de rivaliser avec eux, je veux juste montrer mon golf, pour une édification mutuelle.

Bence Joful
la source
Les gens laissent habituellement des commentaires sous les réponses des autres personnes suggérant des améliorations, mais à cause des améliorations suggérées par la mine de lait, la mienne est maintenant très différente, de sorte que le vôtre va bien tout seul
TheLethalCoder
Je passe habituellement par là s'il y a des améliorations au commentaire de réponse de quelqu'un d'autre mais si c'est assez différent du sien, alors postez votre propre réponse
TheLethalCoder
3

Powershell V2.0, 49 octets

(Le tout premier code de golf, impossible de trouver les règles sur la façon de calculer les octets. J'ai utilisé une calculatrice Chaîne en octets en ligne)

if(!$n){$n=10;$n}else{$n-=1;if($n-eq0){throw};$n}

Fonctionnement:

PS C:\Users\***> if(!$n){$n = 10;$n}else{$n=$n-1;if($n-eq0){throw};$n;}
10

____________________________________________________________________________________________________________________________________________________________________
PS C:\Users\***> if(!$n){$n = 10;$n}else{$n=$n-1;if($n-eq0){throw};$n;}
9

____________________________________________________________________________________________________________________________________________________________________
PS C:\Users\***> if(!$n){$n = 10;$n}else{$n=$n-1;if($n-eq0){throw};$n;}
8

____________________________________________________________________________________________________________________________________________________________________
PS C:\Users\***> if(!$n){$n = 10;$n}else{$n=$n-1;if($n-eq0){throw};$n;}
7

____________________________________________________________________________________________________________________________________________________________________
PS C:\Users\***> if(!$n){$n = 10;$n}else{$n=$n-1;if($n-eq0){throw};$n;}
6

____________________________________________________________________________________________________________________________________________________________________
PS C:\Users\***> if(!$n){$n = 10;$n}else{$n=$n-1;if($n-eq0){throw};$n;}
5

____________________________________________________________________________________________________________________________________________________________________
PS C:\Users\***> if(!$n){$n = 10;$n}else{$n=$n-1;if($n-eq0){throw};$n;}
4

____________________________________________________________________________________________________________________________________________________________________
PS C:\Users\***> if(!$n){$n = 10;$n}else{$n=$n-1;if($n-eq0){throw};$n;}
3

____________________________________________________________________________________________________________________________________________________________________
PS C:\Users\***> if(!$n){$n = 10;$n}else{$n=$n-1;if($n-eq0){throw};$n;}
2

____________________________________________________________________________________________________________________________________________________________________
PS C:\Users\***> if(!$n){$n = 10;$n}else{$n=$n-1;if($n-eq0){throw};$n;}
1

____________________________________________________________________________________________________________________________________________________________________
PS C:\Users\***> if(!$n){$n = 10;$n}else{$n=$n-1;if($n-eq0){throw};$n;}
ScriptHalted
At line:1 char:49
+ if(!$n){$n = 10;$n}else{$n=$n-1;if($n-eq0){throw <<<< };$n;}
    + CategoryInfo          : OperationStopped: (:) [], RuntimeException
    + FullyQualifiedErrorId : ScriptHalted
Kieron Davies
la source
Bienvenue chez PPCG! Les règles de calcul des octets dépendent du codage de caractères utilisé par la langue. Powershell utilise probablement l'encodage ASCII ou UTF-8, et donc pour un script contenant uniquement des codes ASCII, comme c'est le cas ici, chaque caractère occupe un octet
Luis Mendo
Bienvenue chez PPCG! Selon l'auteur du défi, toutes les soumissions doivent être un programme complet, ce qui n'est pas le cas. Il est essentiellement exécuté dans l'équivalent d'un REPL de PowerShell.
AdmBorkBork
Si j'ai écrit ceci à l'intérieur d'un fichier .ps1 et que j'ai exécuté 10 fois crash-off.ps1 par exemple, cela compte-t-il comme un programme complet?
Kieron Davies
@KieronDavies Oui, à condition que si vous fermiez et rouvriez le shell entre les deux, vous obteniez toujours le même résultat. Conserver les éléments "en mémoire" dans le shell entre les exécutions est ce qui définit "l'environnement REPL" de PowerShell à partir d'un environnement "programme complet".
AdmBorkBork
3

Java, 343 octets

Ma première tentative de golf

import java.io.PrintWriter;class M{public static void main(String[] a) throws Exception{if(!new java.io.File("x").exists()) try(PrintWriter p=new java.io.PrintWriter("x")){p.write("10");}int b=new java.util.Scanner(new java.io.File("x")).nextInt();try(PrintWriter p=new java.io.PrintWriter("x")){p.print(b/b*b-1+"");System.out.print(b+"");}}}

non-golfé

import java.io.PrintWriter;

class M {
    public static void main(String[] a) throws Exception {
        if (!new java.io.File("x").exists()) {
            try (PrintWriter p = new java.io.PrintWriter("x")) {
                p.write("10");
            }
        }
        int b = new java.util.Scanner(new java.io.File("x")).nextInt();
        try (PrintWriter p = new java.io.PrintWriter("x")) {
            p.print(b / b * b - 1 + "");
            System.out.print(b + "");
        }
    }
}
Viktor Mellgren
la source
Vous pouvez le réduire à 300 octets en important java.io.*et en évitant d'utiliser des noms de constructeur pleinement qualifiés. Vous pouvez également en couper 8 en utilisant le fait que "print" va automatiquement ficeler ses arguments:import java.io.*;class M{public static void main(String[] a) throws Exception{if(!new File("x").exists()) try(PrintWriter p=new PrintWriter("x")){p.print(10);}int b=new java.util.Scanner(new File("x")).nextInt();try(PrintWriter p=new PrintWriter("x")){p.print(b/b*b-1);System.out.print(b);}}}
Glen
Vous pouvez le réduire à 237 octets en n'écrivant pas le "10" dans le fichier, mais en utilisant simplement l' ?opérateur basé sur l'existence du fichier lorsque vous lisez b:import java.io.*;class M{public static void main(String[] a) throws Exception{int b=new File("x").exists()?new java.util.Scanner(new File("x")).nextInt():10;try(PrintWriter p=new PrintWriter("x")){p.print(b/b*b-1);System.out.print(b);}}}
Glen
Le plus optimisé que je puisse faire: 220 octets. Voici la bête:import java.io.*;class A{public static void main(String[]a)throws Exception{File f=new File("f");int b=f.exists()?new FileInputStream(f).read()-48:10;new PrintWriter(f).printf("%d",b/b*b-1).close();System.out.print(b);}}
Olivier Grégoire
merci pour les suggestions :)
Viktor Mellgren
3

SQLite, 142 137

Cela pourrait probablement être fait beaucoup plus intelligemment. 141 136 caractères pour le code:

create table if not exists t(n not null);insert into t select 11;update t set n=case n when 1 then null else n-1 end;select min(n)from t

Plus 1 pour le nom xde fichier dans sqlite3 x '…'.

Jon Purdy
la source
1
Agréable! Je n'ai pas vu SQLite utilisé comme ça avant. Vous pouvez utiliser quelques octets en remplaçant "values ​​(11)" par "select 11", et "select n from t limit 1" par "select min (n) from t"
Bence Joful
3

JavaScript, 74 octets

x=typeof x!=typeof 1?10:x!=1?x-=1:_

l=localStorage;l.a=typeof l.a!=typeof""?10:l.a!=1?l.a=--l.a:_;aler‌​t(l.a)

Oliver
la source
5
Le PO a précisé (dans les commentaires) qu'un programme complet est requis.
Dennis
1
@Dennis Est-ce que ma soumission révisée est considérée comme un programme complet?
Oliver
Je ne sais pas , mais je ne le pense pas. Je dirais que sans un appel alertou similaire, il ne s'agit que d'un extrait de code REPL.
Dennis
2
Cela me semble correct. (Je ne peux pas le tester depuis mon téléphone.)
Dennis
3

Ruby, 94 87 84 61 59 octets

j=File.open(?a,"a+");1/(i=j.readlines.size-14);p -i;j.puts

S'il vous plaît laissez des suggestions ci-dessous.

Merci @ ConorO'Brien pour les idées (certaines arrachées sans vergogne à sa réponse).

dkudriavtsev
la source
puts i=>p i
Conor O'Brien
Utilisez newet sizeau lieu de openet length.
Lee W
2

Ruby, 52 + 1 = 53 octets

Suppose que le fichier est nommé a(+1 octet).

q=File.read ?a
0/h=62-q.size
p h
File.write ?a,q+?1#

Fonctionnement

C:\Users\Conor O'Brien\Documents\Programming
λ type a
q=File.read ?a
0/h=62-q.size
p h
File.write ?a,q+?1#
C:\Users\Conor O'Brien\Documents\Programming
λ ruby a
10

C:\Users\Conor O'Brien\Documents\Programming
λ ruby a
9

C:\Users\Conor O'Brien\Documents\Programming
λ ruby a
8

C:\Users\Conor O'Brien\Documents\Programming
λ ruby a
7

C:\Users\Conor O'Brien\Documents\Programming
λ ruby a
6

C:\Users\Conor O'Brien\Documents\Programming
λ ruby a
5

C:\Users\Conor O'Brien\Documents\Programming
λ ruby a
4

C:\Users\Conor O'Brien\Documents\Programming
λ ruby a
3

C:\Users\Conor O'Brien\Documents\Programming
λ ruby a
2

C:\Users\Conor O'Brien\Documents\Programming
λ ruby a
1

C:\Users\Conor O'Brien\Documents\Programming
λ ruby a
a:2:in `/': divided by 0 (ZeroDivisionError)
        from a:2:in `<main>'
Conor O'Brien
la source
... vous pouvez assumer des noms?
dkudriavtsev
Vous pouvez utiliser $ 0 au lieu de a et 'echo >> # $ 0' (avec des backticks) sur la dernière ligne.
GB
@GB C'est encore plus d'octets que de supposer a(ce qui n'est que +1).
wizzwizz4
? a correspond à 2 octets, $ 0 à 2 octets, mais n’a pas besoin de blancs.
GB
2

Python 2, 89 octets

x=10
x/x
print x
f=open(__file__,"r+")
s=f.read()
f.seek(0)
f.write(s.replace(`x`,`x-1`))
L3viathan
la source
J'ai aimé votre idée d'ouverture __file__alors je me suis servi de cela dans ma réponse.
Alex Hall
@AlexHall Excellente idée delen
L3viathan
@ Flp.Tkc Je ne sauverai aucun personnage avec ça. J'ai encore besoin d'utiliser la variable s, car j'ai besoin de lire, puis de chercher, puis d'écrire. Le print x/x*xfonctionnerait, mais n'améliore pas le nombre d'octets.
L3viathan
2

TI-BASIC (TI-84 Plus) (15 octets)

If not(Ans
11
Ans-1
AnsAns/Ans

Ans doit être égal à 0 (valeur par défaut) avant la première exécution.

Étant donné que AnsAns/Ansc'est la dernière ligne du programme, celui-ci sera sorti et stocké dans Ans à moins que Ans ne soit à 0, auquel cas une erreur de division par 0 se produit.

tratchy
la source
2

JavaScript, 41

l=localStorage;l.l=-~l.l;alert(11-l.l||I)

C5H8NNaO4
la source
@ Mego Oui, évidemment, je ne sais pas comment cela pourrait se produire ... J'ai eu un changement aau lieu de lquand je l'ai écrit et je l'ai modifié sans réfléchir, parce que je pensais que ça avait l'air plus amusant ... c'était trop tard et ici , Merci d'avoir fait remarquer cela.
C5H8NNaO4
1

GNU Smalltalk, 70, 68 octets

Code de 66 octets +2 octets pour l'indicateur "-S"

EDITS

  • Suppression des parenthèses inutiles, -2 octets

Golfé

X=Y ifTrue:[Smalltalk at:#X put:10]ifFalse:[X:=X-1].(X*X/X)printNl

Tester

>seq 11|xargs -L1 sudo gst -S fail.st 2>/dev/null
10
9
8
7
6
5
4
3
2
1
Object: 0 error: The program attempted to divide a number by zero
ZeroDivide(Exception)>>signal (ExcHandling.st:254)
SmallInteger(Number)>>zeroDivide (SysExcept.st:1426)
SmallInteger>>/ (SmallInt.st:277)
UndefinedObject>>executeStatements (fail.st:1)

Important

Vous devez exécuter gst en tant que root pour pouvoir modifier l'image par défaut ou spécifier votre propre image avec -I .

Zeppelin
la source
1

PHP, 45 octets

Honnêtement, je ne sais pas si celui-ci compte.

<?session_start();echo10-$_SESSION[0]++?:die;

Je posterais un lien vers un exemple, mais tous les testeurs en ligne que je connais ne permettent session_start()pas son utilisation.

Cela continuera à décompter chaque fois que vous actualiserez la page jusqu'à 0, lorsque la diecommande sera exécutée.

Xanderhall
la source
0

QBIC , 70 octets

open"r",1,"a.b" $get#1,1,e|~e=0|e=z\e=e-1]?e~e=0|$error 1|]$put#1,1,e|

Ouvre le fichier a.b(ou le crée s’il n’a pas été trouvé lors de la première utilisation), lit l’enregistrement 1 dans e. Si cet enregistrement n’est pas trouvé, supposons 10, sinon sous 1. At e==0, déclenche une erreur. Écris eà a.b.

L’accès aux fichiers n’est pas intégré à QBIC, cela dépend fortement du QBasic sous-jacent.

Steenbergh
la source
0

Lot, 72 octets

@call:l
@if %n%==0 goto g
@echo %n%
@cmd/cset/a-1>>%0
:l
@set/an=10

Doit être appelé en utilisant le nom de fichier complet, extension comprise. La dernière ligne ne doit pas avoir de fin de ligne. Fonctionne en écrivant -1à la fin de la dernière ligne pour qu’elle soit évaluée à 1 de moins à chaque fois. goto gerreurs sur parce qu'il n'y a pas d'étiquette :g.

Neil
la source
0

R, 52 octets

`if`(!"x"%in%ls(),cat(x<-10),`if`(x>0,cat(x<-x-1),))

Utilise essentiellement la ls()liste des noms de tous les objets stockés globalement. Si nous supposons que l'environnement global est vide et "x"n'existe pas déjà, générez x=10, sinon, x!=0soustrayez 1sinon, appelez un argument manquant qui renvoie une erreur.

Billywob
la source
Vous pouvez sauvegarder un octet en supprimant le !et en inversant l'ordre des arguments then et else, et deux autres en remplaçant x>0par x. (En outre, exists("x")est un peu plus propre que "x"%in%ls(), bien que égal en nombre d'octets.)
rturnbull
Ah, en relisant les commentaires dans la spécification, il semblerait qu'un programme complet soit requis, ce qui signifie que vous ne pouvez pas compter sur la persistance des objets entre les exécutions.
rturnbull
@rturnbull Bien que je ne trouve pas où cela est explicitement indiqué. Je vais supprimer la réponse si vous pouvez me l'indiquer.
Billywob
C'est mentionné ici , bien que cela n'ait pas été modifié dans les spécifications.
rturnbull
0

Lot Windows, 61 octets

@if %n%.==. set n=10
@if %n%==0 goto.
@set /a n-=1&@echo %n%
Peter Ferrie
la source
0

JavaScript, 44 octets

function* f(n=11){for(;--n;yield n);throw''}

p=f()
console.log(p.next().value)
console.log(p.next().value)
console.log(p.next().value)
console.log(p.next().value)
console.log(p.next().value)
console.log(p.next().value)
console.log(p.next().value)
console.log(p.next().value)
console.log(p.next().value)
console.log(p.next().value)
console.log(p.next().value)

guest271314
la source