Sua tarefa é escrever um programa completo que continuará a contagem decrescente de 10 toda vez que for executado.

• A primeira vez que você executa o programa, ele deve ser impresso 10.
• A próxima vez, deve sair 9.
• Na próxima vez, ele deve sair 8e assim por diante.
• Em vez de imprimir 0, o programa deve falhar. Você não precisa lidar com o programa em execução mais vezes depois disso.
• Qualquer instalação usada para armazenamento pode ser considerada vazia antes da primeira execução do programa.

Aqui está um exemplo de implementação no 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))

Isso é código-golfe , então a resposta mais curta (medida em bytes) vence.

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

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

Deve começar às $8000. Falha no monitor do sistema quando a contagem atinge 0.

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

Deve começar às $B1. Isso economiza um byte, pois eu posso usar a versão de página zero (dois bytes) DEC, mas sobrescreve a rotina crítica da Applesoft CHRGET; você precisará carregá-lo e chamá-lo do monitor e usar CTRL+ BReturnpara reinicializar o BASIC assim que terminar. Não tenho certeza se isso invalida ou não.

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

Deve começar às $8000. Isso não inicializa $9E, economizando dois bytes. No entanto, isso significa que você não deve chamá-lo com um endereço negativo (ou, se o chamar pelo monitor, precisará chamá-lo com um endereço positivo). Se fizer isso, de Applesoft CALLrotina irá armazenar FFem $9E, causando-lo para adicionar 65280 para o número quando imprimi-lo. Novamente, não tenho certeza se isso invalida a solução ou não.

C6 B6 F0 01 A2 0B 4C 26 ED

Deve começar às $B1. Essa é uma combinação dos dois programas acima, economizando um total de três bytes; você precisará ligar para o monitor com um endereço positivo, carregá-lo e executá-lo a partir daí e usar Ctrl+ BReturnpara reinicializar o BASIC assim que terminar.

Observe que esses programas apenas modificam o programa na memória; recarregar o programa do disco redefinirá a contagem regressiva. Isso funciona porque a Apple] [(e] [+, // e e // c) não possuem sistema de proteção de memória; o programa (e suas auto-modificações) permanecerá na memória mesmo depois de sair, para que você possa continuar executando-o da memória até substituir essa memória por outra coisa.

Amostra de execução

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

Explicação

     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

Explicação da versão 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 ERRe emite um sinal sonoro quando a contagem chega a 0

Normal - 15 bytes

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

Substituições CHRGET- 14 bytes

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

Não inicializa $9E- 13 bytes

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

Substitui CHRGETe não inicializa $9E- 12 bytes

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

Congela quando a contagem chega a 0

Normal - 12 bytes

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

Substituições CHRGET- 11 bytes

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

Não inicializa $9E- 10 bytes

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

Substitui CHRGETe não inicializa $9E- 9 bytes

C6 B6 F0 FE A2 0B 4C 26 ED

Perl no Linux, 17 bytes

Eu pensei que poderia ser interessante criar um programa que não mantém nenhum estado em si e não modifica seu próprio código-fonte; em outras palavras, na verdade, verifica com que frequência é executada solicitando ao sistema operacional. A pergunta diz que "qualquer recurso usado para armazenamento pode estar vazio antes da primeira execução do programa" e, portanto, queremos iniciar com um sistema operacional completamente em branco. Como tal, é melhor eu explicar como você faz isso, caso contrário, é difícil testar o programa.

Na verdade, existem duas maneiras de configurar a execução do programa. De qualquer forma, o sistema operacional mínimo para esse objetivo não estaria executando nada além de um shell (para permitir executar o Perl por sua vez) e o shell mais simples possível (para que ele não faça nada sofisticado que torne o SO não- em branco). /bin/dashé uma boa escolha aqui, pois foi planejado como um shell mínimo para recuperação do sistema. Então, precisamos iniciar o Linux de forma que ele não funcione mais dash. Podemos fazer isso reinicializando o computador init=/bin/dashna linha de comando do Linux, para que ele não inicie nada além dashou (muito mais conveniente) criando um contêiner Linux usando unshare -Urfp /bin/dashum terminal ( unsharena verdade, não cria um sistema operacional em branco, mas simula1; notavelmente, o interior do contêiner pensa que é raiz, dashacha que é init etc., assim como aconteceria em um sistema operacional em branco real). Disclaimer: Na verdade, eu ainda não testei isso no bare metal, apenas por dentro unshare, mas deve funcionar nos dois sentidos em teoria.

Finalmente, uma vez que configuramos isso, simplesmente precisamos olhar para o PID; como estamos em um sistema em branco, o sistema init (aqui, o shell) terá o PID 1; portanto, as execuções do Perl terão PIDs de 2 a 12, inclusive. Portanto, nosso programa é assim:

say 12-$$||die

Aqui está uma amostra de execução:

$ 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

Experimente online!

Javascript, 42 bytes

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

Teste-o com este violino - certifique-se de limpar o armazenamento local para redefinir a contagem regressiva.

Obrigado a steenbergh, Lmis e obarakon por muitos 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);}}}

Economizou 34 bytes graças ao leite

E uma versão formatada (com ReadKeyadicionado para que você possa ver a saída):

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

É mais longo do que eu pensava, então provavelmente há espaço para jogar golfe.

Dyalog APL , 33 28 22/20? bytes

Não tenho certeza se isso é válido, pois consiste em uma função (que deve ser chamada com um argumento fictício). No entanto, todos os programas APL (puramente funcionais ou não) têm o mesmo status e, de fato, algumas versões do APL não possuem programas tradicionais, apenas funções. Em compensação, adicionei dois bytes para nomeá-lo, embora isso não seja necessário para o efeito desejado.

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

Observe que isso depende de uma peculiaridade não oficial, ∘←atribuída globalmente.

6:: sobre qualquer erro de valor

⊢cretornar c

∘←10 globalmente definido como 10

⋄ agora

÷÷c retorna o c invertido duas vezes (erros em zero) c

∘← globalmente definido como

c-1um a menos que c

TryAPL online!

Certamente versão de 28 bytes válida:

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

Funciona definindo c como 11 se estiver ausente, subtraindo 1 de c , invertendo duas vezes (o que gera erro div-por-zero se c -1 for 0), atribuindo a c e gerando o novo valor.

Versão antiga de 33 bytes:

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

Funciona redefinindo-se a cada execução, mas com menos uma nova linha à direita. Emite o número duas vezes invertido de linhas restantes (menos duas), resultando em um erro div-por-zero quando restam apenas duas linhas (o cabeçalho e o código real).

Perl, 37 36 bytes

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

Trava quando o valor inicial atinge -1 (o que teria impresso 0), conforme ele escreve sobre o =~operador.

Salva um byte usando em sysopenvez de open. Isso me permite imprimir STDOUTprimeiro, usando o valor de retorno como o modo de arquivo ( 1, aka O_WRONLY), antes de $~ser reatribuído.

Uso da amostra

$ 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
 

Precisa de um caractere de nova linha depois =finish.

diepode ser substituído por 1/0.

Explicação:

Ele obtém uma lista de linhas depois de =finish( $=finish.lines) subtrai isso de 10e, se o resultado não for, 0ele será impresso, caso contrário, será die.

A última coisa que faz é abrir-se no modo de acréscimo e adicionar outra linha ao final.

Python 2, 65 bytes

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

Inspirado pela resposta de L3viathan .

Pode ser reduzido para 60 bytes se você optar por nomear o arquivo com um único caractere xe substituí-lo __file__por 'x'. Nesse caso, substitua 75por 70.

Jolf, 20 bytes

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

Experimente aqui! Erros quando 0é impresso. Modifica o código. Explicação para vir.

Applesoft BASIC, 21 bytes (tokenizado)

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

Substitua <CTRL-F>e <CTRL-H>por suas versões literais. Observe que isso apenas modifica o programa na memória; recarregá-lo a partir do disco redefinirá a contagem regressiva.

Amostra de execução

]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

Explicação

PRINT 9 + 1faz o que você esperaria. CALL 2066chama a rotina do idioma da máquina 6502 no local da memória 2066, que é posterior END :. ENDinterrompe o programa para que a rotina de linguagem de máquina (que, para o intérprete da Applesoft, seja lixo) não seja executada.

A rotina de linguagem de máquina simplesmente diminui o 9no PRINT 9 + 1. Desmontagem:

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

Depois que o contador atinge 0, ele é "decrementado" para /; tentar executar o programa causará um erro de sintaxe.

*> <> , 20 18 bytes

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

Isso realmente funciona no Linux (e qualquer que seja o suporte a arquivos chamados, \neu acho). Ele cria um arquivo nomeado \nna primeira execução e saídas 10. Ele procede à saída de um número a menos em cada execução subseqüente, exceto 0onde ocorre o travamento.

Explicação

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 não trava, mas sai (sem contagem regressiva) quando bate 0. Isso é suficiente?

Corra com -r.

C #, 156 bytes

Joguei a resposta do @ TheLethalCoder um pouco e pude salvar 3 bytes reordenando as instruções e eliminando o int.parse (). Ainda há espaço para melhorias, tenho certeza.

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

Meta-pergunta: Pode ser complicado tomar o trabalho de TheLethalCoder como ponto de partida para minha resposta. Seria melhor (depois que eu tiver o representante) adicionar isso como um comentário na resposta deles? Não estou tentando competir com eles, só quero mostrar meu golfe, para edificação mútua.

Powershell V2.0, 49 bytes

(O primeiro código de golfe, não foi possível encontrar as regras sobre como calcular bytes. Eu usei uma calculadora de String para bytes online)

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

Corrida:

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

Minha primeira tentativa de golfe

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

destroçado

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

Provavelmente isso poderia ser feito de maneira muito mais inteligente. 141 136 caracteres para o 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

Mais 1 para o nome do arquivo xem 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, deixe sugestões abaixo.

Obrigado @ ConorO'Brien pelas idéias (algumas vergonhosamente arrancadas de sua resposta).

Ruby, 52 + 1 = 53 bytes

Supõe que o arquivo seja nomeado a(+1 byte).

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

Corrida

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

A resposta deve ser igual a 0 (o valor padrão) antes da primeira execução.

Como AnsAns/Ansé a última linha do programa, ele será gerado e armazenado em Ans, a menos que Ans seja 0; nesse caso, ocorrerá um erro de divisão 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 o sinalizador "-S"

EDITAR% S

• Removidos parênteses desnecessários, -2 bytes

Golfe

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

Teste

>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

Você deve executar o gst como root, para poder modificar a imagem padrão ou especificar sua própria imagem com -I .

PHP, 45 bytes

Honestamente não tenho certeza se este conta.

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

Eu postaria um link para um exemplo, mas todos os testadores on-line que conheço não permitem o session_start()uso.

Isso continuará a contagem regressiva sempre que você atualizar a página até 0, quando o diecomando for executado.

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 o arquivo a.b(ou cria quando não encontrado na primeira execução), lê o registro 1 no e. Se esse registro não for encontrado, assuma 10, ou seja, sub 1. Em e==0, gere um erro. Escreva de volta epara a.b.

O acesso a arquivos não está embutido no QBIC, isso depende muito do QBasic subjacente.

Lote, 72 bytes

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

Precisa ser chamado usando o nome completo do arquivo, incluindo a extensão. A última linha não deve ter uma nova linha à direita. Funciona escrevendo -1no final da última linha, para avaliar 1 a menos a cada vez. goto gerros porque não há etiqueta :g.

R, 52 bytes

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

Utiliza essencialmente ls()para listar os nomes de todos os objetos armazenados globalmente. Se assumirmos que o ambiente global está vazio e "x"ainda não existe, gere x=10; caso contrário, se x!=0subtrair 1, chamará um argumento ausente que retornará um erro.

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