Su tarea es escribir un programa completo que continuará contando desde 10 cada vez que se ejecute.

• La primera vez que ejecute el programa, debería imprimirse 10.
• La próxima vez, debería salir 9.
• La próxima vez, debería salir 8, y así sucesivamente.
• En lugar de imprimir 0, el programa debería bloquearse. No tiene que manejar el programa que se ejecuta más veces después de eso.
• Se puede suponer que las instalaciones utilizadas para el almacenamiento están vacías antes de la primera ejecución del programa.

Aquí hay un ejemplo de implementación en 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))

Este es el código de golf , por lo que gana la respuesta más corta (medida en bytes).

6502 lenguaje máquina + Apple] [+ ROM, 12 (11? 10? 9?) Bytes

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

Debería comenzar a las $8000. Se bloquea en el monitor del sistema cuando el recuento llega a 0.

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

Debería comenzar a las $B1. Esto ahorra un byte ya que puedo usar la versión de cero páginas (dos bytes) DEC, pero sobrescribe la rutina crítica de Applesoft CHRGET; necesitará cargarlo y llamarlo desde el monitor, y usar CTRL+ BReturnpara reiniciar BASIC una vez que haya terminado. No estoy seguro si esto lo invalida o no.

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

Debería comenzar a las $8000. Esto no se inicializa $9E, ahorrando dos bytes. Sin embargo, esto significa que no debe llamarlo con una dirección negativa (o, si lo llama desde el monitor, debe llamar al monitor con una dirección positiva). Si lo hace, de Applesoft CALLrutina almacenará FFen $9E, haciendo que se añada al número 65280 al imprimirlo. Nuevamente, no estoy seguro si esto invalida la solución o no.

C6 B6 F0 01 A2 0B 4C 26 ED

Debería comenzar a las $B1. Esta es una combinación de los dos programas anteriores, ahorrando un total de tres bytes; tendrá que llamar al monitor con una dirección positiva, cargarlo y ejecutarlo desde allí, y usar Ctrl+ BReturnpara reiniciar BASIC una vez que haya terminado.

Tenga en cuenta que estos programas solo modifican el programa en la memoria; volver a cargar el programa desde el disco restablecerá la cuenta regresiva. Esto funciona porque Apple] [(y] [+, // e y // c) no tienen ningún sistema de protección de memoria; el programa (y sus auto-modificaciones) permanecerán en la memoria incluso después de salir, por lo que puede seguir ejecutándolo desde la memoria hasta que sobrescriba esa memoria con algo más.

Ejecución de la muestra

]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
*

Explicación

     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

Explicación de la versión de 10 bytes.

     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

Variantes

Imprime ERRy emite un pitido cuando el recuento llega a 0

Normal - 15 bytes

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

Sobrescribe CHRGET- 14 bytes

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

No se inicializa $9E- 13 bytes

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

Sobrescribe CHRGETy no se inicializa $9E- 12 bytes

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

Se congela cuando el recuento llega a 0

Normal - 12 bytes

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

Sobrescribe CHRGET- 11 bytes

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

No se inicializa $9E- 10 bytes

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

Sobrescribe CHRGETy no se inicializa $9E: 9 bytes

C6 B6 F0 FE A2 0B 4C 26 ED

Perl en Linux, 17 bytes

Pensé que podría ser interesante crear un programa que no mantenga ningún estado en sí mismo y que no modifique su propio código fuente; en otras palabras, en realidad comprueba con qué frecuencia se ha ejecutado preguntando al sistema operativo. La pregunta dice "Se puede suponer que todas las instalaciones utilizadas para el almacenamiento están vacías antes de la primera ejecución del programa", por lo que nos gustaría comenzar desde un sistema operativo completamente en blanco. Como tal, será mejor que te explique cómo lo haces, ya que de lo contrario probar el programa es difícil.

En realidad, hay dos formas de configurar para ejecutar el programa. De cualquier manera, el sistema operativo mínimo para este propósito no estaría ejecutando nada más que un shell (para permitirnos ejecutar Perl a su vez), y el shell más simple posible (para que no haga nada elegante que haga que el sistema operativo no sea blanco). /bin/dashes una buena opción aquí, ya que fue concebido como un shell mínimo para la recuperación del sistema. Entonces, necesitamos iniciar Linux de tal manera que no se ejecute nada más que dash. Podemos hacer esto reiniciando la computadora init=/bin/dashen la línea de comandos de Linux para que no comience nada más dash, o (mucho más convenientemente) creando un contenedor de Linux usando unshare -Urfp /bin/dashun terminal (en unsharerealidad no crea un SO en blanco, pero simulauno; notablemente, el interior del contenedor piensa que es root, dashpiensa que es init, etc., tal como sucedería en un SO en blanco real). Descargo de responsabilidad: aún no he probado esto en metal desnudo, solo por dentro unshare, pero debería funcionar en ambos sentidos en teoría.

Finalmente, una vez que tenemos eso configurado, simplemente tenemos que mirar el PID; Como estamos en un sistema en blanco, el sistema init (aquí, el shell) tendrá PID 1, por lo que las ejecuciones de Perl tendrán PID de 2 a 12 inclusive. Entonces nuestro programa se ve así:

say 12-$$||die

Aquí hay una muestra de ejecución:

$ 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.
#

Bash + sed, 41 40 38 bytes

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

Pruébalo en línea!

Javascript, 42 bytes

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

Pruébelo con este violín : asegúrese de borrar su almacenamiento local para restablecer la cuenta regresiva.

¡Gracias a steenbergh, Lmis y obarakon por muchos bytes!

C #, 197 160 159 125 bytes

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

Guardado 34 bytes gracias a la leche

Y una versión formateada (con ReadKeyagregado para que pueda ver la salida):

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

Es más largo de lo que pensaba, por lo que probablemente haya espacio para jugar al golf.

Dyalog APL , 33 28 22/20? bytes

No estoy seguro de si esto es válido, ya que consiste en una función (que debe llamarse con un argumento ficticio). Sin embargo, todos los programas APL (puramente funcionales o no) tienen el mismo estado y, de hecho, algunas versiones APL no tienen programas tradicionales, solo funciones. En compensación, he agregado dos bytes para nombrarlo, aunque eso no es necesario para el efecto deseado.

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

Tenga en cuenta que esto se basa en una peculiaridad no oficial, que ∘←asigna globalmente.

6:: ante cualquier error de valor

⊢cvolver c

∘←10 que se establece globalmente en 10

⋄ ahora

÷÷c devuelve el doble invertido (errores en cero) c

∘← que se establece globalmente en

c-1uno menos que c

TryAPL en línea!

Versión ciertamente válida de 28 bytes:

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

Funciona estableciendo c en 11 si falta, luego restando 1 de c , invirtiendo dos veces (lo que da un error div-por-cero si c -1 es 0), asignando a c y generando el nuevo valor.

Versión antigua de 33 bytes:

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

Funciona redefiniéndose en cada ejecución, pero con una nueva línea final menos. Emite el número dos veces invertido de líneas restantes (menos dos), dando así un error de división por cero cuando solo quedan dos líneas (el encabezado y el código real).

Perl, 37 36 bytes

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

Se bloquea cuando el valor inicial alcanza -1 (que habría impreso 0), ya que escribe sobre el =~operador.

Guardado un byte usando en sysopenlugar de open. Esto me permite imprimir STDOUTprimero, utilizando el valor de retorno como modo de archivo ( 1también conocido como O_WRONLY), antes de $~reasignarlo.

Uso de muestra

$ 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.

Perl 6 ,  60  58 bytes

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

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

Necesita carácter de nueva línea después =finish.

diepuede ser reemplazado con 1/0.

Explicación:

Obtiene una lista de líneas después de que =finish( $=finish.lines) resta eso 10, y si el resultado no es, 0lo imprime, de lo contrario es dies.

Lo último que hace es abrirse en modo agregar y agregar otra línea al final.

Python 2, 65 bytes

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

Inspirado por la respuesta de L3viathan .

Se puede reducir a 60 bytes si puede elegir nombrar al archivo como un solo carácter xy luego reemplazarlo __file__por 'x'. En ese caso, reemplace 75con 70.

Jolf, 20 bytes

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

Pruébalo aquí! Errores cuando 0se imprime. Modifica el código. Explicación por venir.

Applesoft BASIC, 21 bytes (tokenizado)

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

Reemplazar <CTRL-F>y <CTRL-H>con sus versiones literales. Tenga en cuenta que esto solo modifica el programa en la memoria; volver a cargarlo desde el disco restablecerá la cuenta regresiva.

Ejecución de la muestra

]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

Explicación

PRINT 9 + 1hace lo que esperarías. CALL 2066llama a la rutina de lenguaje de máquina 6502 en la ubicación de memoria 2066, que es posterior END :. ENDdetiene el programa para que la rutina de lenguaje máquina (que, para el intérprete de Applesoft, sea basura) no se ejecute.

La rutina de lenguaje de máquina simplemente disminuye el 9in PRINT 9 + 1. Desmontaje

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

Después de que el contador llega a 0, se "decrementa" a /; intentar ejecutar el programa provocará un error de sintaxis.

*> <> , 20 18 bytes

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

Esto realmente funciona en Linux (y lo que sea compatible con los archivos llamados \n, supongo). Crea un archivo nombrado \nen la primera ejecución y las salidas 10. Se procede a generar un número menos en cada ejecución subsiguiente, excepto 0donde se bloquea en su lugar.

Explicación

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

PHP 57 bytes

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

realmente no se bloquea, pero sale (sin contar atrás) cuando golpea 0. ¿Es eso suficiente?

Corre con -r.

C #, 156 bytes

Jugué al golf la respuesta de @ TheLethalCoder por un momento, y pude guardar 3 bytes reordenando las declaraciones y eliminando int.parse (). Todavía hay margen de mejora, estoy seguro.

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);}}

Sin golf:

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);
    }
}

Meta-pregunta: Puede ser complicado tomar el trabajo de TheLethalCoder como punto de partida para mi respuesta. ¿Sería mejor (una vez que tenga el representante) agregar esto como un comentario en su respuesta? No estoy tratando de competir con ellos, solo quiero mostrar mi golf, para edificación mutua.

Powershell V2.0, 49 bytes

(Primer código de golf, no pude encontrar las reglas sobre cómo calcular bytes. Utilicé una calculadora de Cadena a bytes en línea)

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

Corriendo:

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

Java, 343 bytes

Mi primer intento 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+"");}}}

sin 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 + "");
        }
    }
}

SQLite, 142 137

Esto probablemente podría hacerse mucho más inteligentemente. 141 136 caracteres para el código:

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

Más 1 para el nombre xde archivo en sqlite3 x '…'.

JavaScript, 74 bytes

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)

Ruby, 94 87 84 61 59 bytes

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

Por favor, deje sugerencias a continuación.

Gracias @ ConorO'Brien por las ideas (algunas desvergonzadamente arrancadas de su respuesta).

Ruby, 52 + 1 = 53 bytes

Asume que el archivo se llama a(+1 byte).

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

Corriendo

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>'

Python 2, 89 bytes

x=10
x/x
print x
f=open(__file__,"r+")
s=f.read()
f.seek(0)
f.write(s.replace(`x`,`x-1`))

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

If not(Ans
11
Ans-1
AnsAns/Ans

Ans debería ser igual a 0 (el valor predeterminado) antes de la primera ejecución.

Como AnsAns/Anses la última línea del programa, se generará y almacenará en Ans a menos que Ans sea 0, en cuyo caso se produce un error de división por 0.

JavaScript, 41

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

GNU Smalltalk, 70, 68 bytes

Código de 66 bytes +2 bytes para el indicador "-S"

EDICIONES

• Se eliminaron paréntesis innecesarios, -2 bytes

Golfed

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

Prueba

>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)

Importante

Debe ejecutar gst como root, para que pueda modificar la imagen predeterminada o especificar su propia imagen con -I .

PHP, 45 bytes

Sinceramente, no estoy seguro si este cuenta.

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

Publicaría un enlace a un ejemplo, pero todos los probadores en línea que conozco no permiten session_start()su uso.

Esto hará una cuenta regresiva cada vez que actualice la página hasta 0, cuando diese ejecuta el comando.

QBIC , 70 bytes

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|

Abre el archivo a.b(o lo crea cuando no se encuentra en la primera ejecución), lee el registro 1 en e. Si no se encuentra ese registro, suponga 10, de lo contrario, sub 1. En e==0, generar un error. Escribir de nuevo ea a.b.

El acceso a archivos no está integrado en QBIC, esto depende en gran medida del QBasic subyacente.

Lote, 72 bytes.

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

Debe invocarse utilizando el nombre de archivo completo, incluida la extensión. La última línea no debe tener una nueva línea final. Funciona escribiendo -1al final de la última línea para que se evalúe a 1 menos cada vez. goto gerrores porque no hay etiqueta :g.

R, 52 bytes

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

Esencialmente se usa ls()para enumerar los nombres de todos los objetos almacenados globalmente. Si suponemos que el entorno global está vacío y "x"no existe, genere x=10, de lo contrario, si x!=0resta 1, llame a un argumento faltante que devuelve un error.

Lote de Windows, 61 bytes

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

JavaScript, 44 bytes

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)