Buona sera agenti di golf,

La tua missione è per conto del famigerato gigante dell'intrattenimento Eviltronic Arts. Come parte del loro piano nefasto per la schiavitù e l'intrattenimento mondiale, devono vendere quante più copie possibile di SimStation V. Ciò significa che il software deve misteriosamente smettere di funzionare, dopo averlo avviato alcune volte.

Il tuo obiettivo è scrivere un programma che conteggi il numero di volte in cui è stato eseguito. Il programma non deve fare altro che scrivere l'intero su stdout. La prima volta che viene eseguito, dovrebbe restituire "1". Il prossimo "2" e così via. Il programma deve essere in grado di raggiungere almeno il numero "14", ma non è richiesto un limite superiore.

Tuttavia, il programma non deve scrivere nuovi file. Accedere a se stesso, al registro o persino a Internet è assolutamente OK. Ma alcuni dei nostri utenti sono sospettosi di nuovi file e li sovrascriveranno semplicemente! Il nervo! Sconfiggere le limitazioni sul software che hanno legittimamente acquistato!

Il programma non può assumere un interprete o una shell stabile - il programma deve comunque funzionare se l'intero computer dell'interfaccia non funziona quando la macchina viene riavviata.

Poiché deve essere il più inosservabile possibile, vincerà il codice sorgente più breve.

Buona fortuna agenti. L'industria dell'intrattenimento conta su di te.

bash script, 39 , 37 , 21 18

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

Breve e dolce, la mia prima presentazione in codice golf :)

Python, 40 , 39 , 38 caratteri

Inoltre, non esiste un limite superiore al runtime:

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

Come puoi vedere, le dimensioni del programma aumentano gradualmente, ma il problema originale non presentava alcuna limitazione. Credo che la dimensione del programma presentato sia tutto ciò che conta

PHP 48 byte

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

Un semplice approccio automodificante. Dopo aver eseguito 99 volte, si bloccherà in modo spettacolare.

$ 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

bash script, 37

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

Rubino: 31 21 caratteri

(Questa è una riscrittura di Abhijit 's soluzione Python . Se vi piace l'idea di base, upvote la sua risposta, come ho fatto io.)

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

Esecuzione di esempio:

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

Utilizzando un servizio web, un approccio diverso rispetto alle altre soluzioni esistenti finora. Limite: la memoria della mia macchina.

JavaScript, 40

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

Difficilmente conta come programma, ma è comunque piuttosto lungo. Non funziona in Firefox in un file locale. Limite: 2 ^ 31.

PHP 31 37 caratteri

Auto-modifica. Conta in unario. Fai attenzione che il tuo editor di testo non tenti di essere utile e inserisci un carattere di nuova riga dopo 1. Funzionerà (correttamente) solo in PHP <5.3.2 perché si basa su php per chiudere i descrittori di file aperti allo spegnimento. O è accettabile perdere descrittori di file?

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

Versione originale (36 caratteri), tutte le versioni di PHP:

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

Python, 50

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

Utilizza lo stesso approccio della risposta di Primo e si arresta in modo simile alla 100a corsa.

J (58)

Devi eseguirlo come uno script, ovviamente non funzionerà dalla riga di comando J.

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

In J, il tokenizer utilizzato dall'interprete è disponibile come ;:funzione, quindi se xcontiene codice J, ;:xcontiene i token J, ovvero:

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

Così:

• echo m=.1: impostare msu 1 e scriverlo sullo schermo
• k=.1{ARGV: memorizza il secondo elemento in ARGV(il nome dello script) in k.
• ... 1!:2[k: scrivi la seguente stringa nel file in k:
• ;:1!:1[k: leggi k, lo script corrente e tokenize
• (<":m+1)(<3)}: sostituisce il terzo token con la rappresentazione in formato stringa di m + 1
• ;:^:_1: esegue il tokenizer al contrario, producendo una stringa
• exit: esce dall'interprete (non lo fa da solo anche se si esegue uno script)

PHP, 34 33 caratteri

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

Grazie a Tim per l'aggiornamento! La mia vecchia soluzione:

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

Il problema è che $_SESSION[A]è ""- stringa vuota - in prima iterazione, ma comesession_start() restituisce 1, è possibile aggiungerlo e prendere due o tre mosche in un solo colpo!

Soluzione con sintassi corretta (35 caratteri):

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

Haskell - 36 byte

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

Aggiunge semplicemente +1alla fine del file sorgente, che si presume sia chiamato a.hs. L' .hsestensione è obbligatoria sia in ghc che in ghci.

TI-Basic, 9 caratteri

:X+1->X:X

Lotto - 41

Dato il caso d'uso di esempio, probabilmente non presumo che questa tecnica sia valida - Rinomina il file .bat contenente lo script -

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

Salvalo in un file chiamato 0.bat- e chiama usando 0.bat 2>nul.2>nulreindirizza stderr a nul che è necessario perché questo script rinominerà il file contenente lo script, una volta che lo fa cmd ovviamente non può più vedere lo script (prima che colpisca EOF) e restituirà l'erroreThe batch file cannot be found.

Ovviamente ogni chiamata consecutiva della sceneggiatura dovrà essere 1.bat 2>nul ... 2.bat 2>nul ... 3.bat 2>nul ... etc ...

script mIRC, 28/22 byte

Se inserito nella scheda "alias", "alias" può essere omesso creando 22 byte.

alias x inc %i | echo -ag %i

Python, 49 48 caratteri

Mi sono reso conto che questo sarà solo 48 caratteri su Windows a causa del \r\n. Altrimenti dovrebbe essere 49.

n=1

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

Un ripoff economico del metodo di @grc

C, 190 personaggi. Funziona solo su 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 caratteri

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

Tcl, 63 o 73 byte

• Con alcuni servizi web è 73:

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

• modificarsi è 63:

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

C # - 201 239 234 caratteri

Funziona per le prime 255 volte, quindi passa a 0. Non emetterà nulla alla prima esecuzione.

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

Salva come Main.cs, compila con

gmcs Main.cs

Testato con gmcs 2.10.8.1 e Mono runtime 2.10.8.1-5ubuntu2

Powershell, 47 byte

presuppone che lo script sia denominato a.ps1

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

Lo script sovrascrive sostituendosi al 0sulla prima riga con 1, 2, 3e così via.

potrebbe anche salvare altri 8 byte sostituendo entrambe le istanze di a.ps1con 1e salvando lo script come un file chiamato 1anche se questo è un po 'lontano per me.

Sostituisci la seconda riga con questa se il file non viene salvato come 'a.ps1'.

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

0 sulla prima riga per inizializzare il conteggio

Linebreak fornisce il modo più semplice per dividere il file in due

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

questo prende il file 'a.ps1' e lo legge come un array di linee, quindi lo passiamo attraverso [0..1]e lo impostiamo sulle variabili $nche sono espresse come [int]e $trispettivamente, in modo che 0la prima riga diventi $ne il 'codice 'sulla seconda riga diventa$t

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

Questo ha usato la ,1,2notazione di matrice, per creare una matrice di due elementi, uno dei quali è il numero memorizzato in $npre-incrementato e trasmesso allo stdout mediante l'uso di parentesi implicite, il secondo è la seconda riga di testo dal file e quindi anche l'output nel file denominato "a.ps1"

poiché sia ​​l'input che l'output sono array di stringhe, è richiesta una formattazione minima e quasi tutto viene assunto dall'interprete.

Zsh (no coreutils), 32 byte

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

(Nota la nuova riga finale) Utilizza la lunghezza dello script. Ad ogni invocazione, l'ultima riga mostrata sopra aggiungerà :(identica a true) e una nuova riga allo script, quindi il /2.

Provalo online!

Script ruggine / carico, 283 byte

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

Salva come wed esegui con cargo-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

Non iterare troppo velocemente o rimarrà bloccato .

Parzialmente non golfato:

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

Si romperà dopo 99999;

GNU sed, 13 + 1 (n flag) = 14 byte

$=;$eecho>>s

Correre: sed -nf ss

Il presupposto è che viene chiamato il nome file sorgente s. È necessaria una nuova riga finale dopo il codice, che è stato conteggiato nel totale dei byte. Spiegazione:

$=           # 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'