Buenas tardes agentes de golf,

Su misión es en nombre del famoso gigante del entretenimiento Eviltronic Arts. Como parte de su nefasto plan de esclavitud y entretenimiento mundial, deben vender tantas copias de SimStation V como sea posible. Esto significa que el software debe dejar de funcionar misteriosamente, después de iniciarlo varias veces.

Su objetivo es escribir un programa que cuente la cantidad de veces que se ha ejecutado. El programa no debe hacer nada más que escribir el número entero en stdout. La primera vez que se ejecuta, debe devolver "1". El próximo "2" y así sucesivamente. El programa debe poder alcanzar al menos el número "14", pero no hay un límite superior requerido.

Sin embargo, su programa no debe escribir ningún archivo nuevo. Acceder a sí mismo, al registro o incluso a Internet está absolutamente bien. ¡Pero algunos de nuestros usuarios sospechan de nuevos archivos, y simplemente los sobrescribirán! ¡El nervio! ¡Derrotando las limitaciones del software que compraron legítimamente!

El programa no puede asumir un intérprete o shell estable; el programa aún debe funcionar si se reinicia todo el intérprete, más allá de la computadora.

Como debe ser lo más indetectable posible, el código fuente más corto ganará.

Buena suerte agentes. La industria del entretenimiento cuenta contigo.

guión bash, 39 , 37 , 21 18

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

Corto y dulce, mi primera presentación en código golf :)

Python, 40 , 39 , 38 caracteres

Además, no existe dicho límite superior en el tiempo de ejecución:

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

Como puede ver, el tamaño del programa aumenta gradualmente, pero no hubo tal restricción en el problema original. Creo que el tamaño del programa presentado es todo lo que importa

PHP 48 bytes

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

Un enfoque simple de auto modificación. Después de correr 99 veces, se bloqueará espectacularmente.

$ 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

guión bash, 37

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

Rubí: 31 21 caracteres

(Esta es una reescritura de la solución Python de Abhijit . Si le gusta la idea base, vote su respuesta, como a mí).

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

Ejecución de muestra:

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 un servicio web, un enfoque diferente al de las otras soluciones existentes hasta ahora. Límite: la memoria de mi máquina.

JavaScript, 40

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

Apenas cuenta como un programa, pero de todos modos es bastante largo. No funciona en Firefox en un archivo local. Límite: 2 ^ 31.

PHP 31 37 caracteres

Auto modificante. Cuenta en unario. Tenga cuidado de que su editor de texto no intente ser útil e inserte un carácter de nueva línea después del 1. Solo funcionará (correctamente) en PHP <5.3.2 porque se basa en php para cerrar los descriptores de archivos abiertos al apagar. ¿O es aceptable filtrar descriptores de archivos?

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

Versión original (36 caracteres), todas las versiones de PHP:

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

Python, 50

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

Utiliza el mismo enfoque que la respuesta de primo y se bloquea de manera similar en la carrera número 100.

J (58)

Necesita ejecutar esto como un script, obviamente no funcionará desde la línea de comando J.

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

En J, el tokenizer que utiliza el intérprete está disponible como la ;:función, por lo que si xcontiene código J, ;:xcontiene los tokens J, es decir:

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

Asi que:

• echo m=.1: establecer men 1 y escribirlo en la pantalla
• k=.1{ARGV: almacena el segundo elemento en ARGV(el nombre del script) en k.
• ... 1!:2[k: escriba la siguiente cadena en el archivo en k:
• ;:1!:1[k: leer k, el script actual y tokenizar
• (<":m+1)(<3)}: reemplaza el tercer token por la representación de cadena de m + 1
• ;:^:_1: ejecuta el tokenizer en reversa, produciendo una cadena
• exit: sale del intérprete (no lo hace solo, incluso si ejecuta un script)

PHP, 34 33 caracteres

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

¡Gracias a Tim por la actualización! Mi vieja solución:

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

El problema es que $_SESSION[A]es ""- cadena vacía - en la primera iteración, pero como session_start()devuelve 1, puede agregarlo y matar dos o tres moscas de una sola vez.

Solución con la sintaxis correcta (35 caracteres):

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

Haskell - 36 bytes

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

Simplemente agrega +1al final del archivo fuente, que se supone que tiene nombre a.hs. La .hsextensión es obligatoria tanto en ghc como en ghci.

TI-Basic, 9 caracteres

:X+1->X:X

Lote - 41

Dado el caso de uso del ejemplo, probablemente no asumiría que esta técnica es viable. Cambia el nombre del archivo .bat que contiene el script.

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

Guarde esto en un archivo llamado 0.bat- y llame usando0.bat 2>nul . 2>nulredirige stderr a nul, lo cual es necesario porque esta secuencia de comandos cambiará el nombre del archivo que contiene la secuencia de comandos, una vez que lo hace, obviamente cmd ya no puede ver la secuencia de comandos (antes de que llegue a EOF) y devolverá el errorThe batch file cannot be found.

Por supuesto, cada llamada consecutiva del guión tendrá que ser 1.bat 2>nul ... 2.bat 2>nul ... 3.bat 2>nul ... etc ...

script mIRC, 28/22 bytes

Si se coloca en la pestaña "alias", se puede omitir "alias" haciendo 22 bytes.

alias x inc %i | echo -ag %i

Python, 49 48 caracteres

Me di cuenta de que esto solo serán 48 caracteres en Windows debido a \r\n. De lo contrario, debería ser 49.

n=1

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

Una estafa barata del método por @grc

C, 190 personajes. Funciona solo en 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 o 73 bytes

• Con algún servicio web es 73:

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

• modificarse es 63:

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

C # - 201 239 234 caracteres

Funciona las primeras 255 veces, luego se ajusta a 0. No generará nada en la primera ejecución.

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

Guardar como Main.cs, compilar con

gmcs Main.cs

Probado con gmcs 2.10.8.1 y Mono runtime 2.10.8.1-5ubuntu2

Powershell, 47 bytes

asume que el script se llama a.ps1

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

El guión se sobreponen a la sustitución de la misma 0en la primera línea con 1, 2, 3y así sucesivamente.

También podría ahorrar otros 8 bytes por replaceing ambas instancias de a.ps1con 1y guardar el script como un archivo con el nombre 1aunque esto es un poco lejos para mí.

Reemplace la segunda línea con esto si el archivo no se guarda como 'a.ps1'.

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

0 en primera línea para inicializar el recuento

Linebreak proporciona la forma más fácil de dividir el archivo en dos

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

esto toma el archivo 'a.ps1' y lo lee como una matriz de líneas, luego iteramos a través de él [0..1]y lo configuramos en las variables $nque se convierten como [int]y $trespectivamente, de modo que se 0convierte en la primera línea $ny el 'código 'en la segunda línea se convierte$t

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

Esto usó la ,1,2notación de matriz, para crear una matriz de dos elementos, uno es el número almacenado en $npre-incrementado y enviado a stdout mediante el uso de corchetes implícitos, el segundo es la segunda línea de texto del archivo, y luego también sale al archivo llamado 'a.ps1'

Como tanto la entrada como la salida son conjuntos de cadenas, se requiere un formato mínimo y el intérprete asume casi todo.

Zsh (sin coreutils), 32 bytes

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

(Tenga en cuenta la nueva línea final) Utiliza la longitud de la secuencia de comandos. En cada invocación, la última línea que se muestra arriba agregará :(idéntica a true) y una nueva línea al script, de ahí el /2.

Pruébalo en línea!

Rust / cargo-script, 283 bytes

Un trazador de líneas:

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

Guardar como wy ejecutar 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

No iteres demasiado rápido o se atascará .

Parcialmente no golfista:

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

Se romperá después de 99999;

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

$=;$eecho>>s

Ejecute: sed -nf ss

La suposición es que se llama al nombre del archivo fuente s. Se necesita una nueva línea final después del código, que se contó en el total de bytes. Explicación:

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