Boa noite, agentes de golfe,

Sua missão é em nome da famosa empresa de entretenimento Eviltronic Arts. Como parte de seu plano nefasto de escravidão e entretenimento no mundo, eles devem vender o maior número possível de cópias do SimStation V. Isso significa que o software deve misteriosamente parar de funcionar, após iniciá-lo algumas vezes.

Seu objetivo é escrever um programa que conte a quantidade de vezes que foi executado. O programa não deve fazer nada além de escrever o número inteiro em stdout. Na primeira vez em que é executado, ele deve retornar "1". O próximo "2" e assim por diante. O programa deve poder atingir pelo menos o número "14", mas não há limite superior necessário.

No entanto, seu programa não deve gravar novos arquivos. Acessar-se, ou o registro, ou mesmo a internet é absolutamente bom. Mas alguns de nossos usuários suspeitam de novos arquivos e apenas os substituem! O nervo! Derrotar as limitações do software que eles compraram legitimamente!

O programa não pode assumir um interpretador ou shell estável - o programa ainda deve funcionar se todo o interpretador ou o computador for reiniciado entre a execução.

Como deve ser o mais indetectável possível, o menor código-fonte vencerá.

Agentes de boa sorte. A indústria do entretenimento está contando com você.

script bash, 39 , 37 , 21 18

wc -l<$0;echo>>$0

Curto e doce, minha primeira apresentação no código de golfe :)

Python, 40 , 39 , 38 caracteres

Além disso, não existe esse limite superior no tempo de execução:

open(__file__,'a').write("+1");print 1

Como você pode ver, o tamanho do programa aumenta gradualmente, mas não havia essa restrição no problema original. Eu acredito que o tamanho do programa enviado é tudo o que importa

PHP 48 bytes

<?=$n=1 ;fputs(fopen(__FILE__,c),'<?=$n='.++$n);

Uma abordagem simples de modificação automática. Depois de executar 99 vezes, ele travará espetacularmente.

$ php increment.php
1
$ php increment.php
2
$ php increment.php
3

⋮

$ php increment.php
97
$ php increment.php
98
$ php increment.php
99
$ php increment.php
PHP Parse error:  syntax error, unexpected T_STRING, expecting ',' or ';' in increment.php on line 1

script bash, 37

n=1;echo $n;sed -ie s/$n/$((n+1))/ $0

Ruby: 31 21 caracteres

(Esta é uma reescrita de Abhijit 's solução Python . Se você gosta da idéia base, upvote sua resposta, como eu fiz.)

open($0,?a)<<"+1";p 1

Exemplo de execução:

bash-4.2$ ruby increment.rb 
1

bash-4.2$ ruby increment.rb 
2

bash-4.2$ ruby increment.rb 
3

* sh, 17

curl -L x.co/z7Uk

Usando um serviço da Web, uma abordagem diferente das outras soluções existentes até o momento. Limite: a memória da minha máquina.

JavaScript, 40

alert(localStorage.a=~~localStorage.a+1)

Dificilmente conta como um programa, mas é bastante longo de qualquer maneira. Não funciona no Firefox em um arquivo local. Limite: 2 ^ 31.

PHP 31 37 caracteres

Auto-modificador. Conta em unário. Tenha cuidado para que o seu editor de texto não tente ser útil e insira um caractere de nova linha após o 1. Ele funcionará (corretamente) no PHP <5.3.2 porque depende do php para fechar os descritores de arquivos abertos no desligamento. Ou é aceitável vazar descritores de arquivo?

<?fputs(fopen(__FILE__,a),1)?>1

Versão original (36 caracteres), todas as versões do PHP:

<?file_put_contents(__FILE__,1,8)?>1

Python, 50

n=1;
print n
open(__file__,'r+').write("n="+`n+1`)

Ele usa a mesma abordagem da resposta do primo e trava de forma semelhante na 100ª corrida.

J (58)

Você precisa executar isso como um script, obviamente não funcionará na linha de comando J.

echo m=.1
exit(;:^:_1(<":m+1)(<3)};:1!:1[k)1!:2[k=.1{ARGV

Em J, o tokenizer usado pelo intérprete está disponível como ;:função, portanto, se xcontém código J, ;:xcontém os tokens J, ou seja:

    ;: 'echo 1 2 3+4 5 6'
+----+-----+-+-----+
|echo|1 2 3|+|4 5 6|
+----+-----+-+-----+

Tão:

• echo m=.1: defina mcomo 1 e grave-o na tela
• k=.1{ARGV: armazena o segundo elemento em ARGV(o nome do script) em k.
• ... 1!:2[k: escreva a seguinte string no arquivo em k:
• ;:1!:1[k: leia k, o script atual e tokenize
• (<":m+1)(<3)}: substitua o terceiro token pela representação de string de m + 1
• ;:^:_1: execute o tokenizer ao contrário, produzindo uma sequência
• exit: saia do intérprete (ele não faz isso sozinho, mesmo que você execute um script)

PHP, 34 33 caracteres

<?=$_SESSION[A]+=session_start();

Obrigado a Tim pela atualização! Minha solução antiga:

<?=session_start()+$_SESSION[A]++;

O problema é que $_SESSION[A]é ""- string vazia - na primeira iteração, mas como session_start()retorna 1, pode adicioná-lo e matar dois ou três moscas em um tiro!

Solução com sintaxe correta (35 caracteres):

<?=session_start()+$_SESSION[A]++?>

Haskell - 36 bytes

main=do appendFile"a.hs""+1";print$1

Simplesmente adiciona +1ao final do arquivo de origem, que é assumido como nomeado a.hs. A .hsextensão é obrigatória em ghc e ghci.

TI-Basic, 9 caracteres

:X+1->X:X

Lote - 41

Dado o exemplo de caso de uso, eu provavelmente não assumiria que essa técnica é viável - renomeia o arquivo .bat que contém o script -

@set/aa=%~n0+1
@echo %a%&@ren %0 %a%.bat

Salve isso em um arquivo chamado 0.bat- e ligue usando 0.bat 2>nul. 2>nulredireciona o stderr para nul, o que é necessário porque esse script renomeia o arquivo que contém o script, uma vez que o cmd obviamente não pode mais ver o script (antes de atingir o EOF) e retornará o erroThe batch file cannot be found.

É claro que cada chamada consecutiva do script deve ser 1.bat 2>nul ... 2.bat 2>nul ... 3.bat 2>nul ... etc ...

script mIRC, 28/22 bytes

Se colocado na aba "aliases", "alias" pode ser omitido, produzindo 22 bytes.

alias x inc %i | echo -ag %i

Python, 49 48 caracteres

Percebi que este será apenas 48 caracteres no Windows devido ao \r\n. Caso contrário, deve ser 49.

n=1

print n;print>>open(__file__,'r+'),"n=",n+1

Um ripoff barato do método por @grc

C, 190 caracteres. Funciona apenas no Win NT

#include <stdio.h>
int main(int c,char *v[]){
char f[100];sprintf(f,"%s:s",v[0]);
if (FILE *fp=fopen(f,"r"))fscanf(fp,"%d",&c);
FILE *fp=fopen(f,"w");printf("%d",c-1);fprintf(fp,"%d",++c);
}

C #, 142 caracteres

int v=(Microsoft.Win32.Registry.CurrentUser.GetValue("c") as int?)??0+1;Console.Write(v);Microsoft.Win32.Registry.CurrentUser.SetValue("c",v);

Tcl, 63 ou 73 bytes

• Com alguns serviços da web, são 73:

  package require http
  puts [set [http::geturl http://example.com/c](data)]
  

• modificar-se é 63:

  proc a a {puts [string le $a]};puts -nonewline [open $argv0 a] a; a a
  

C # - 201 239 234 caracteres

Funciona pelas primeiras 255 vezes e depois chega a 0. Ele não produzirá nada na primeira execução.

namespace System.IO{class s{static void Main (string[]a){char f='|';if(f!='|'){Console.Write (255);}string p=Reflection.Assembly.GetCallingAssembly().Location;byte[]d=File.ReadAllBytes(p);d[769]++;d[780]++;File.WriteAllBytes(p,d);}}}

Salve como Main.cs, compile com

gmcs Main.cs

Testado com gmcs 2.10.8.1 e Mono runtime 2.10.8.1-5ubuntu2

Powershell, 47 bytes

assume que o script é nomeado a.ps1

0
[int]$n,$t=(gc a.ps1)[0..1];,(++$n),$t>a.ps1

O script irá substituir-se substituir o 0na primeira linha, com 1, 2,3 e assim por diante.

também poderia economizar mais 8 bytes por replaceing ambas as instâncias de a.ps1com 1e salvar o script como um arquivo chamado1 embora este seja um pouco longe para mim.

Substitua a segunda linha por esta se o arquivo não for salvo como 'a.ps1'.

[int]$n,$t=(gc($s=$MyInvocation.MyCommand.Name))[0..1];,(++$n),$t>$s

0 na primeira linha para inicializar a contagem

A quebra de linha fornece a maneira mais fácil de dividir o arquivo em dois

[int]$n,$t=(gc a.ps1)[0..1]

isso pega o arquivo 'a.ps1' e o lê como uma matriz de linhas; então, iteramos nele [0..1]e definimos isso para as variáveis $nque são convertidas como [int]e $trespectivamente, para que 0a primeira linha se torne $ne o código ' 'na segunda linha se torna$t

,(++$n),$t>a.ps1

Isso utilizou a ,1,2notação de matriz, para criar uma matriz de dois elementos, um sendo o número armazenado em $npré-incrementado e gerado no stdout pelo uso de colchetes implícitos, o segundo sendo a segunda linha de texto do arquivo e, em seguida, também produzindo no arquivo chamado 'a.ps1'

como entrada e saída são matrizes de strings, é necessária uma formatação mínima e quase tudo é assumido pelo intérprete.

Zsh (sem coreutils), 32 bytes

a=`<$0`
<<<$[$#a/2-15]
>>$0<<<:

(Observe a nova linha à direita) Usa o comprimento do script. Em cada chamada, a última linha mostrada acima será anexada :(idêntica a true) e uma nova linha ao script, daí o /2.

Experimente online!

Rust / script de carga, 283 bytes

Oneliner:

use std::fs::File;use std::io::Write;fn main(){let c=     0; let mut v = vec![];::std::io::Read::read_to_end(&mut File::open("w").unwrap(),&mut v);let mut q=&mut File::create("w").unwrap();q.write(&v[..53]);q.write(format!("{:6}",c+1).as_bytes());q.write(&v[59..]);println!("{}",c);}

Salvar como we executar comcargo-script :

$ cargo-script script w
   Compiling w v0.1.0 (file:///home/vi/.cargo/script-cache/file-w-b4d6541706fabb11)
    (warnings skipped...)
    Finished release [optimized] target(s) in 1.47 secs
0
$ cargo-script script w
    (compilation output skipped)
1
$ cargo-script script w
...
2
$ cargo-script script w 2> /dev/null
3
$ cargo-script script w 2> /dev/null
4
$ cargo-script script w 2> /dev/null
5
$ cargo-script script w 2> /dev/null
6
$ cargo-script script w 2> /dev/null
7
$ cargo-script script w 2> /dev/null
8
$ cargo-script script w 2> /dev/null
9
$ cargo-script script w 2> /dev/null
10
$ cargo-script script w 2> /dev/null
11

Não itere muito rápido, senão preso .

Parcialmente sem golfe:

use std::fs::File;use std::io::Write;fn main(){let c=     0;
    let mut v = vec![];
    ::std::io::Read::read_to_end(&mut File::open("w").unwrap(),&mut v);
    let mut q = &mut File::create("w").unwrap();
    q.write(&v[..53]);
    q.write(format!("{:6}",c+1).as_bytes());
    q.write(&v[59..]);
    println!("{}", c);
}

Quebrará após 99999;

GNU sed, 13 + 1 (sinalizador n) = 14 bytes

$=;$eecho>>s

Corre: sed -nf ss

A suposição é que o nome do arquivo de origem seja chamado s. Uma nova linha à direita é necessária após o código, que foi contado no total de bytes. Explicação:

$=           # print the number of lines of the input file
$eecho>>s    # a shell echo call that appends an empty line to the source file 's'