Cuenta para siempre

71

Escriba un programa que cuente para siempre, comenzando desde uno.

Reglas:

  • Su programa debe iniciar sesión STDOUTo una alternativa aceptable, si STDOUTno está disponible.
  • Su programa debe ser un programa completo y ejecutable, y no una función o fragmento.
  • Su programa debe generar cada número con un carácter separador (una nueva línea, espacio, tabulación o coma), pero esto debe ser coherente para todos los números.
  • Puede imprimir los números en decimal, en unario o en base 256, donde cada dígito está representado por un valor de byte .
  • Su programa debe contar al menos hasta 2 128 (inclusive) sin problemas y sin quedarse sin memoria en una PC de escritorio razonable. En particular, esto significa que si está usando unary, no puede almacenar una representación unaria del número actual en la memoria.
  • A diferencia de nuestras reglas habituales, siéntase libre de usar un idioma (o versión de idioma) incluso si es más nuevo que este desafío. Los idiomas escritos específicamente para enviar una respuesta de 0 bytes a este desafío son juegos justos pero no particularmente interesantes.

    Tenga en cuenta que debe haber un intérprete para que se pueda probar el envío. Se permite (e incluso se recomienda) escribir este intérprete usted mismo para un idioma previamente no implementado.

  • No se trata de encontrar el idioma con la solución más corta para esto (hay algunos en los que el programa vacío hace el truco), se trata de encontrar la solución más corta en cada idioma. Por lo tanto, ninguna respuesta se marcará como aceptada.

Catálogo

El Fragmento de pila al final de esta publicación genera el catálogo a partir de las respuestas a) como una lista de la solución más corta por idioma yb) como una tabla de clasificación general.

Para asegurarse de que su respuesta se muestre, comience con un título, utilizando la siguiente plantilla de Markdown:

## Language Name, N bytes

¿Dónde Nestá el tamaño de su envío? Si mejora su puntaje, puede mantener los puntajes antiguos en el título, tachándolos. Por ejemplo:

## Ruby, <s>104</s> <s>101</s> 96 bytes

Si desea incluir varios números en su encabezado (por ejemplo, porque su puntaje es la suma de dos archivos o desea enumerar las penalizaciones de la bandera del intérprete por separado), asegúrese de que el puntaje real sea el último número en el encabezado:

## Perl, 43 + 2 (-p flag) = 45 bytes

También puede hacer que el nombre del idioma sea un enlace que luego aparecerá en el fragmento:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

vrwim
fuente
29
No estoy seguro de cómo combinar debe dar salida a cada número con un carácter de separación entre y puede imprimir los números [...] en la base 256 .
Dennis
66
Para futuros desafíos, ¿ puedo recomendar el entorno limitado de modo que todos estos detalles se puedan resolver antes de que las personas comiencen a publicar respuestas? :)
Martin Ender
3
@IlmariKaronen Interpreto que es un límite de memoria, no un límite de tiempo. posiblemente un límite de tiempo por incremento. solo configure el contador en 2 ** 128-10 y vea cuánto tiempo lleva tomar los últimos diez pasos.
Sparr
55
¿Podemos tener ceros a la izquierda en la salida?
Paŭlo Ebermann
44
Ugh !!! Tengo una respuesta para TI-89 (56b), pero no puedo publicar b / c. Soy nuevo en el sitio y no tengo Rep 10+.
gregsdennis

Respuestas:

63

Laberinto , 5 bytes

):
\!

♫ La IP en el código da vueltas y vueltas ♫

Instrucciones relevantes:

)       Increment top of stack (stack has infinite zeroes at bottom)
:       Duplicate top of stack
!       Output top of stack
\       Output newline
Sp3000
fuente
77
El programa está triste porque no se detiene ...
Optimizer
77
@Optimizer def triste (de hecho):
YoYoYonnY
1
¿Por qué no son 4 bytes?
Aurel Bílý
2
@ Aurel300 El quinto byte es la nueva línea entre :y\
Sp3000
@ Sp3000 Ah, sí. Tonto de mí. :)
Aurel Bílý
46

> <> , 8 bytes

01+:nao!

Pasos:

  • Empuja 0 en la pila
  • Agregue 1 al elemento de la pila superior
  • Elemento de pila superior duplicado
  • Salida de la parte superior de la pila como número
  • Salida de una nueva línea
  • Vaya al paso 2 envolviéndose y saltando la siguiente instrucción (paso 11)

(Un programa menos eficiente en memoria (por lo tanto, no válido) es llnao).

randomra
fuente
66
+1 para el impaciente demanda de votos implícitos en una línea de código que básicamente dice "¡más uno, ahora!".
Janus Bahs Jacquet
24

Haskell, 21 bytes

main=mapM_ print[1..]

Los enteros de precisión arbitraria y las listas infinitas facilitan esto :-)

Por suerte mapM_está en el preludio. Si Data.Traversablefuera así, incluso podríamos reducirlo a 19 bytes:

main=for_[1..]print
Bergi
fuente
¿No hay un símbolo que generalice map / mapM, etc.?
JDługosz
@ JDługosz: no que yo sepa
Bergi
Ah, porque todavía tendría que tener sequenceel resultado para que la salida realmente suceda.
JDługosz
simplemente no está [1..]permitido, ya que imprime todos los números con una coma entre ellos? o el primero lo [arruina todo?
Baconaro
@Baconaro: esa es una lista, no imprime nada. GHCi imprime el resultado si ingresa el término en la respuesta, pero ese no es un programa ejecutable. Y sí, el liderazgo [tampoco está permitido.
Bergi
23

Gol> <> , 3 bytes

P:N

Pasos:

  • Agregue 1 al elemento de la pila superior (al inicio es un 0 implícito)
  • Elemento de pila superior duplicado
  • Pop y salida la parte superior de la pila como número y una nueva línea
  • Pase al paso 1 cuando lleguemos al final de la línea
randomra
fuente
21

Maravillosa , 11450 4632 bytes

¡Imprimir decimales es un dolor!

Definitivamente no ganaré con este, pero pensé en intentarlo. Espero que esté bien que rellene la salida a 40 ceros (para ajustar 2 ^ 128).

00@0..@1..@2..@3..@4..@5..@6..@7..@8..@9..@A..@B..@C..@D..@E..@F..@G..@H..@I..@J
\\++..00..00..00..00..00..00..00..00..00..00..00..00..00..00..00..00..00..00..00
..EhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhunEhun
....AddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddtAddt
..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7..&7\/
../\&8..........................................................................
....@0..........................................................................
....../\&8......................................................................
....//..@1......................................................................
........../\&8..................................................................
......////..@2..................................................................
............../\&8..............................................................
........//////..@3..............................................................
................../\&8..........................................................
..........////////..@4..........................................................
....................../\&8......................................................
............//////////..@5......................................................
........................../\&8..................................................
..............////////////..@6..................................................
............................../\&8..............................................
................//////////////..@7..............................................
................................../\&8..........................................
..................////////////////..@8..........................................
....................................../\&8......................................
....................//////////////////..@9......................................
........................................../\&8..................................
......................////////////////////..@A..................................
............................................../\&8..............................
........................//////////////////////..@B..............................
................................................../\&8..........................
..........................////////////////////////..@C..........................
....................................................../\&8......................
............................//////////////////////////..@D......................
........................................................../\&8..................
..............................////////////////////////////..@E..................
............................................................../\&8..............
................................//////////////////////////////..@F..............
................................................................../\&8..........
..................................////////////////////////////////..@G..........
....................................................................../\&8......
....................................//////////////////////////////////..@H......
........................................................................../\&8..
......................................////////////////////////////////////..@I..
............................................................................../\&8
........................................//////////////////////////////////////..@J
&9&9&9&9&9&9&9&9&9&9&9&9&9&9&9&9&9&9&9&9
Sixteenbytedecimalprintermodulewitharegi

:Sixteenbytedecimalprintermodulewitharegi
}J}J}I}I}H}H}G}G}F}F}E}E}D}D}C}C}B}B}A}A}9}9}8}8}7}7}6}6}5}5}4}4}3}3}2}2}1}1}0}00A
/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A/A%A
%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..%A..
+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O..
+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O+O..

:/A
..}0..}0..
..>>}0....
..>>>>\\..
....//..//
../\>>\\..
....>>..//
....>>\\..
....>>....
\\>>//....
..>>......
..>>......
../\......
..../\<<..
......<<..
..\\<<//..
....~~....
....++....
....\\..//
\\....>9\/
..\\..?0..
......++..
....\\....
......{0..

:%A
@0..
}0..
<A-A
{0@0

:Eg
}0}0}0}0}0}0}0}0
^7^6^5^4^3^2^1^0
~~....~~~~..~~~~
^0^0^0^0^0^0^0^0
{0{0{0{0{0{0{0{0

:Ehun
}0..}0
Eg..&0
=8&0{0
&1\/00
0100&0
&1&1{1
{1{0

:Addt
}0}1
{1{1
TheDoctor
fuente
¿La impresión binaria sería más corta?
SuperJedi224
3
(o ¿qué pasa con unario?)
Pomo
@Doorknob que muestra la salida no es el problema. Es algo en el Ehuntablero que se supone que incrementa el siguiente dígito, pero no funciona correctamente
TheDoctor
1
¿Sabía que puede omitir los puntos al final de cada línea y las líneas en blanco entre las tablas y usar caracteres individuales para los nombres de las tablas? Solo tiene que repetir ese carácter individual la cantidad de tiempo adecuada para invocarlo. Esto puede reducir su respuesta a aproximadamente 3000 bytes.
overactor
Eventualmente voy a empujar un commit a marbelous.py que incluye todo include/por defecto
Sparr
18

C (solo arquitectura de 64 bits), 53 bytes

Se basa en punteros de al menos 64 bits y los imprime en hexadecimal utilizando el %pespecificador. El programa volvería justo cuando llegue a 2 ^ 128.

char*a,*b;main(){for(;++b||++a;)printf("%p%p ",a,b);}
Feersum
fuente
1
Entonces, si esos punteros están en cada 64 bits, solo podría contar hasta 2 ^ 128-1, ¿verdad?
defecto
66
Inválido ya que no puede contar hasta 2 ^ 128
edc65
14
Me gusta CodeGolf cuando se trata de expresar y recompensar la creatividad. Feersum claramente no está compitiendo por la victoria aquí. Ver muchos votos negativos sobre un tecnicismo y modificar la redacción de la pregunta para asegurarme de que su respuesta está en violación me entristece.
flodel
3
Pensé que las palabras "al menos hasta 2 ^ 128" eran lo suficientemente claras ...
vrwim
55
@vrwim No escribiste eso. Escribiste "hasta 2 ^ 128". SuperJedi lo editó hace unos minutos.
fiesta
17

Hexagonía , 12 11 10 7 bytes

Gracias a alephalpha por ajustar el código en la longitud lateral 2.

10})!';

Desplegado:

 1 0
} ) !
 ' ;

Este es bastante simple. 10escribe un 10, es decir, un salto de línea al borde de memoria inicial. Luego })!';se ejecuta repetidamente en un bucle:

  • } pasar al siguiente borde de memoria.
  • ) incrementarlo
  • ! imprímalo como un entero.
  • ' volver a los 10.
  • ; imprímalo como un personaje.

Creo que esto es óptimo (aunque de lejos no es único). Dejé que el script de fuerza bruta que escribí para esta respuesta buscara soluciones de 6 bytes bajo el supuesto de que tendría que contener al menos uno de cada uno de ;y !y o (o ), y no contendría ?, ,o @, y no lo hizo. Encuentra cualquier solución.

Martin Ender
fuente
13

Pyth, 4 bytes

.V1b

Explicación:

.V1    for b in range(1 to infinity):
   b      print b
Jakube
fuente
f!\n( Enlace TIO ) funcionará para 3 bytes, aunque no estoy seguro de si está usando alguna función que se haya agregado después de su respuesta.
Sok
@Sok Clever. Sin embargo, no cambiaré la respuesta porque creo que fera una característica de Pyth hace 4 años.
Jakube
Yo también lo pensé, por eso lo dejé como comentario: las nuevas características del lenguaje para superar una respuesta anterior siempre se sienten baratas OMI
Sok
13

a. C., 10

for(;;)++i

Inusual que bces más corto que dc.

De man bc:

DESCRIPCIÓN

bc es un lenguaje que admite números de precisión arbitrarios

Trauma digital
fuente
¿Dónde se imprime esto?
Bálint
@ Bálint ++ies una expresión, pero no una asignación, y por lo tanto se emite explícitamente. ¿Intentaste ejecutarlo? echo 'for(;;)++i' | bcen tu terminal de Linux más cercana.
Trauma digital
No tengo una sola terminal de Linux en mi casa. Solo tenía curiosidad.
Bálint
66
@ Bálint Cada casa debe tener un terminal Linux.
Trauma digital
1
@ Bálint Ejecutar este programa es tu uso;)
Insane
12

Java, 139 138 127 123 bytes

class K{public static void main(String[]a){java.math.BigInteger b=null;for(b=b.ZERO;;)System.out.println(b=b.add(b.ONE));}}
SuperJedi224
fuente
2
Un bucle infinito más pequeño en Java es for(;;)para 3 bytes fáciles.
ankh-morpork
También puede guardar otros 2 con BigInteger b=null;b=b.ZERO;, lamentablemente, =nulles necesario, incluso si se trata de un acceso estático.
TWiStErRob
Y luego otros 9, porque puedes deshacerte de la importación haciendo referencia BigIntegera FQCN solo una vez.
TWiStErRob
@TWiStErRob De alguna manera, no me había dado cuenta de que sería más corto.
SuperJedi224
2
Para Java 8 o posterior, puede reemplazar la clase con interfacey eliminar publicde la función. No quiera copiar su código y publicarlo como una nueva respuesta.
Luca H
10

Mathematica, 22 bytes

i=0;While[Echo[++i]>0]

Echo es una nueva función en Mathematica 10.3.

alephalpha
fuente
Echoda cuatro caracteres de separación: nueva línea más ">> ". No estoy seguro de que esto sea válido, ¿puede usarlo Printen su lugar? Además, guarde un byte con i=0;While[Echo@++i>0].
Roman
7

Ruby, 15 12 bytes

loop{p$.+=1}
  • p, cuando se le da un número entero, imprime el número entero tal como está (cortesía de @philomory )
  • $.es una variable mágica que contiene el número de líneas leídas de stdin. Obviamente se inicializa a 0, y también se puede asignar :)
daniero
fuente
@philomory Por lo general, se sugiere a los usuarios que dejen un comentario que sugiera su solución de ahorro de bytes. Además, me gustaría ver una explicación para este. c:
Addison Crump
7

Python 3, 33 25 bytes

Por lo que yo entiendo, los enteros de Pythons son de precisión arbitraria y print()producen automáticamente nuevas líneas.

¡Gracias por @Jakub y @ Sp3000 y @wnnmaw! Realmente no sé mucho de Python, lo único que sabía era que admite enteros de tamaño arbitrario =)

k=1
while 1:print(k);k+=1
falla
fuente
1es un valor verdadero en Python (y en la mayoría de los otros lenguajes). Entonces while 1:es suficiente.
Jakube
Además, puede poner el todo whileen una línea
Sp3000,
Puede guardar un byte utilizando en repr(k)lugar de print(k). Además, cuento el tamaño de su byte como 25 (sin mi cambio sugerido)
wnnmaw
1
No se puede usar en reprlugar de print. reprno da salida a nada. @wnnmaw
Zach Gates
¿Qué hace reprentonces?
falla
6

Procesamiento , 95 85 71 bytes

java.math.BigInteger i;{i=i.ZERO;}void draw(){println(i=i.add(i.ONE));}

Intenté algo con un ciclo while pero hace que todo el procesamiento se bloquee, por lo que me quedaré con esto por ahora.

(Gracias a @ SuperJedi224 y @TWiStErRob por sus sugerencias).

geokavel
fuente
¿Qué pasa con los espacios? Estoy bastante seguro de import java.math.*;BigInteger i=BigInteger.ZERO;void draw(){println(i=i.add(BigInteger.ONE));}que funcionará.
SuperJedi224
Sí, solo arreglé eso.
geokavel
¿El procesamiento permite BigInteger.ONEque se cambie i.ONE?
SuperJedi224
@ SuperJedi224 Sí, lo hace. ¡Gracias!
geokavel
Muy bien, ten un voto a favor.
SuperJedi224
6

Samau , 2 bytes

N)

Explicación:

N     push the infinite list [0 1 2 ...] onto the stack
 )    increase by 1

Cuando la salida de un programa es una lista, se omiten los corchetes externos.

alephalpha
fuente
¿Una lista no imprime todo su contenido a la vez? Si esta lista es infinita , entonces no puede caber en la memoria o en la pantalla , y nunca dejará de generarse, por lo que nunca se imprimirá.
gato
1
@cat Samau está escrito en Haskell, y es vago . No generará la lista completa antes de imprimirla.
alephalpha
Solo un aviso. En la página de GitHub para Samau, en la descripción de @"push" está mal escrito.
Carcigenicate
@Carcigenicate Gracias.
alephalpha
6

JavaScript (ES6), 99 94 67 bytes

for(n=[i=0];;)(n[i]=-~n[i++]%10)&&alert([...n].reverse(i=0).join``)

alertes el STDOUTequivalente generalmente aceptado para JavaScript, pero usarlo significa que los números consecutivos se separan automáticamente. Supuse que no es necesario generar un carácter después del número debido a esto.

usuario81655
fuente
12
Es por eso que tengo un bloqueador de ventanas emergentes.
Comintern
1
solo digo: para (i = 0 ;;) alerta (i ++) No creo que necesite todos esos controles
towc
3
@towc Eso no funcionará. Todos los números son flotantes de 64 bits en JavaScript que tienen un valor entero máximo seguro de, 2^53pero la pregunta requiere que suba 2^128.
user81655
1
oh, punto justo ...
towc
5

Matlab, 132 bytes

a=0;while 1;b=a==9;n=find(cumsum(b)-(1:numel(b)),1);a(n)=a(n)+1;a(1:n-1)=0;if ~numel(n);a=[0*a,1];end;disp([a(end:-1:1)+'0','']);end

Ok, creo que esta es la primera respuesta seria que lleva a cabo esta tarea sin un entero trivial de tamaño abitano incorporado. Este programa implementa un número entero de tamaño arbitrario como una matriz de enteros. Cada entero siempre está entre 0 y 9, por lo que cada elemento de matriz representa un dígito decimal. El tamaño de la matriz se incrementará en uno tan pronto como estemos, por ejemplo 999. El tamaño de la memoria no es un problema aquí, ya que2^128 solo requiere una matriz de longitud 39.

a=0;
while 1
    b=a==9;
    %first number that is not maxed out
    n=find(cumsum(b)-(1:numel(b)),1);
    %increase that number, and sett all maxed out numbers to zero
    a(n)=a(n)+1; 
    a(1:n-1)=0;
    if ~numel(n) %if we maxed out all entries, add another digit
        a=[0*a,1];
    end    
    disp([a(end:-1:1)+'0',''])%print all digits
end
falla
fuente
5

C ++, 146 141 138 bytes

El uso de una biblioteca bigint estándar es quizás el más aburrida de responder esta pregunta, pero alguien tuvo que hacerlo.

#include<stdio.h>
#include<boost/multiprecision/cpp_int.hpp>
int main(){for(boost::multiprecision::uint512_t i=1;;){printf("%u\n",i++);}}

Sin golf:

#include<cstdio>
#include<boost/multiprecision/cpp_int.hpp>

int main()
{
    for(boost::multiprecision::uint512_t i=1;;)
    {
        std::printf("%u\n", i++);
    }
}

La razón por la cual la versión de golf usa stdio.h y no cstdioes para evitar tener que usar el std::espacio de nombres.

Esta es mi primera vez jugando al golf en C ++, avíseme si hay algún truco para acortar esto aún más.

Felixphew
fuente
Tal vez podría usar en '\n'lugar de std::endl, le ahorraría 8 bytes. También puede haber una manera de usar CPP #define para comprimir algunas repeticiones,
Kenney
@ Kenney ¡Gracias por eso! (Solo ahorra 5 bytes, no 8.) Sin embargo, creo que podría haber ideado una forma de ajustar esa sección aún más corta.
Felixphew
No conozco el impulso (y tampoco diría que es estándar), pero ¿no se iconstruye por defecto con el valor de 0? Luego, podría quitar la definición y cambiar el postincremento a preincremet, lo que ahorraría 2b
Zereges el
¿Qué tal el obsoleto #import ?
connectyourcharger
5

C .NET 4.0, # 111 103 102 97 bytes

class C{static void Main(){System.Numerics.BigInteger b=1;for(;;)System.Console.WriteLine(b++);}}

No encontré ninguna respuesta de C # aquí, así que solo tuve que escribir una.

Se requiere .NET 4.0, porque es la primera versión que incluye BigInteger . Sin embargo, debe hacer referencia a System.Numerics.dll .

Con sangría:

class C
{
    static void Main()
    {   
        System.Numerics.BigInteger b = 1;
        for (;;)
            System.Console.WriteLine(b++);
    }
}

Gracias a sweerpotato, Kvam, Berend por guardar algunos bytes

Kazarp
fuente
Puede guardar 8 bytes con class C{static void Main(){var b=System.Numerics.BigInteger.One;for(;;)System.Console.WriteLine(b++);}}: ~)!
Sweerpotato
1
Mover la declaración de by Console.WriteLinela estructura de bucle:class C{static void Main(){for(var b=System.Numerics.BigInteger.One;;Console.WriteLine(b++));}}
Kvam
Aún lo necesitas System. ¡Eso ahorra un byte!
sweerpotato
Si, tienes razón.
Kvam
Si agrega using System;(13 bytes) puede eliminar los System.(7 bytes) dos veces, ahorrando 1 byte.
Kenney
5

Clojure, 17 bytes

(map prn (range))

Las secuencias perezosas y los enteros de precisión arbitraria facilitan esto (como para Haskell y CL). prnme ahorra algunos bytes ya que no necesito imprimir una cadena de formato. doseqprobablemente sería más idiomático ya que aquí solo tratamos con efectos secundarios; mapno tiene mucho sentido usarlo ya que creará una secuencia de nil(que es el valor de retorno de cadaprn llamada.

Suponiendo que cuento para siempre, la secuencia de puntero nulo que resulta de esta operación nunca se devuelve.

MONODA43
fuente
4

MarioLANG , 11 bytes

+<
:"
>!
=#

Inspirado por la respuesta de Martin Büttner en otra pregunta .

alephalpha
fuente
¿Estás seguro de que esto funciona sin problemas para 2 ^ 128?
defecto
1
Esto parece familiar. :)
Martin Ender
@flawr MarioLANG tiene un intérprete de Ruby, y el tipo entero de Ruby tiene una precisión arbitraria.
Martin Ender
@flawr Depende del intérprete. El intérprete que estoy usando está escrito en Ruby y admite precisión arbitraria.
alephalpha
4

CJam, 7 bytes

0{)_p}h

Explicación:

0         e# Push a zero to the stack
 {        e# Start a block
  )         e# Increment top of stack
   _        e# Duplicate top of stack
    p       e# Print top of stack
     }    e# End block
      h   e# Do-while loop that leaves the condition on the stack

Nota: Debe usar el intérprete de Java.

GamrCorps
fuente
4

C, 89 bytes

Un nuevo enfoque (implementando un incrementador de bits) en C:

b[999],c,i;main(){for(;;)for(i=c=0,puts(b);i++<998;)putchar(48+(c?b[i]:(b[i]=c=!b[i])));}

Menos golf

int b[999], c, i;
main() {
  for(;;)
    for(i=c=0, puts(b); i++ < 998;)
      putchar(48 + (c ? b[i] : (b[i] = c = !b[i])));
}

Terminar

Esta versión tiene un ligero defecto, que no termina (lo cual no es un requisito por el momento). Para hacer esto, deberías agregar 3 caracteres:

b[129],c=1,i;main(){for(;c;)for(i=c=0,puts(b);i++<128;)putchar(48+(c?b[i]:(b[i]=c=!b[i])));}
Helco
fuente
44
De hecho, no debe terminar. Ese es el significado deforever
edc65
4

Foo , 6 bytes

(+1$i)

Explicación

(    )    Loop
 +1       Add one to current element
   $i     Output current element as a decimal integer
Puertas de Zach
fuente
4

Minkolang , 4 bytes

1+dN

Pruébalo aquí (Bueno, en realidad, tenga cuidado. 3 segundos de tiempo de ejecución fueron suficientes para obtener hasta ~ 40,000).

1+agrega 1 a la parte superior de la pila, lo dduplica y Ngenera la parte superior de la pila como un entero con un espacio final. Esto se repite porque Minkolang es toroidal, por lo que cuando el contador del programa sale del borde derecho, vuelve a aparecer a la izquierda.

El'endia Starman
fuente
4

Conjunto Intel 8086+, 19 bytes

68 00 b8 1f b9 08 00 31 ff f9 83 15 00 47 47 e2 f9 eb f1

Aquí hay un desglose:

68 00 b8                push   0xb800             # CGA video memory
1f                      pop    ds                 # data segment
b9 08 00           L1:  mov    cx, 8              # loop count
31 ff                   xor    di, di             # ds:di = address of number
f9                      stc                       # set carry
83 15 00           L2:  adc    word ptr [di], 0   # add with carry
47                      inc    di
47                      inc    di
e2 f9                   loop   L2
eb f1                   jmp    L1

Emite el número de 128 bits en las 8 posiciones de la pantalla superior izquierda. Cada posición de la pantalla tiene un carácter ASCII de 8 bits y dos colores de 4 bits.

Nota: se ajusta a 2 128 ; simplemente cambie 8in mov cx, 8para 9mostrar un número de 144 bits, o incluso 80*25para mostrar números de hasta 2 32000 .

Corriendo

Imagen de disquete de arranque comprimida codificada en base64 de 1.44Mb bzip2

Genere la imagen del disquete copiando y pegando lo siguiente

QlpoOTFBWSZTWX9j1uwALTNvecBAAgCgAACAAgAAQAgAQAAAEABgEEggKKAAVDKGgAaZBFSMJgQa
fPsBBBFMciogikZcWgKIIprHJDS9ZFh2kUZ3QgggEEh/i7kinChIP7HrdgA=

en esta línea de comando:

base64 -d | bunzip2 > floppy.img

y correr con, por ejemplo, qemu -fda floppy.img -boot a

1.8Mb de arranque ISO

Esta es una imagen ISO comprimida bzip2 codificada en base64. Genera la iso pegando

QlpoOTFBWSZTWZxLYpUAAMN/2//fp/3WY/+oP//f4LvnjARo5AAQAGkAEBBKoijAApcDbNgWGgqa
mmyQPU0HqGCZDQB6mQ0wTQ0ZADQaAMmTaQBqekyEEwQaFA0AA0AxBoAAA9Q0GgNAGg40NDQ0A0Bi
BoDIAANNAA0AyAAABhFJNIJiPSmnpMQDJpp6nqeo0ZDQaAANB6IA0NAGj1EfIBbtMewRV0acjr8u
b8yz7cCM6gUUEbDKcCdYh4IIu9C6EIBehb8FVUgEtMIAuvACCiO7l2C0KFaFVABcpglEDCLmQqCA
LTCAQ5EgnwJLyfntUzNzcooggr6EnTje1SsFYLFNW/k+2BFABdH4c4vMy1et4ZjYii1FbDgpCcGl
mhZtl6zX+ky2GDOu3anJB0YtOv04YISUQ0JshGzAZ/3kORdb6BkTDZiYdBAoztZA1N3W0LJhITAI
2kSalUBQh60i3flrmBh7xv4TCMEHTIOM8lIurifMNJ2aXr0QUuLDvv6b9HkTQbKYVSohRPsTOGHi
isDdB+cODOsdh31Vy4bZL6mnTAVvQyMO08VoYYcRDC4nUaGGT7rpZy+J6ZxRb1b4lfdhtDmNwuzl
E3bZGU3JTdLNz1uEiRjud6oZ5kAwqwhYDok9xaVgf0m5jV4mmGcEagviVntDZOKGJeLjyY4ounyN
CWXXWpBPcwSfNOKm8yid4CuocONE1mNqbd1NtFQ9z9YLg2cSsGQV5G3EhhMXKLVC2c9qlqwLRlw4
8pp2QkMAMIhSZaSMS4hGb8Bgyrf4LMM5Su9ZnKoqELyQTaMAlqyQ3lzY7i6kjaGsHyAndc4iKVym
SEMxZGG8xOOOBmtNNiLOFECKHzEU2hJF7GERK8QuCekBUBdCCVx4SDO0x/vxSNk8gKrZg/o7UQ33
Fg0ad37mh/buZAbhiCIAeeDwUYjrZGV0GECBAr4QVYaP0PxP1TQZJjwT/EynlkfyKI6MWK/Gxf3H
V2MdlUQAWgx9z/i7kinChITiWxSo

dentro

base64 -d bunzip2 > cdrom.iso

y configurar una máquina virtual para arrancar desde ella.

DOS .COM

Este es un ejecutable DOS .COM codificado en base64 :

aAC4H7kIADH/+YMVAEdH4vnr8Q==

Genere un archivo .COM usando

/bin/echo -n aAC4H7kIADH/+YMVAEdH4vnr8Q== | base64 -d > COUNTUP.COM

y ejecutarlo en DOS (gratis).

Kenney
fuente
4

Perl , 34 32 30 28 26 23 bytes

-Mbigint -E '{say$_+=1;redo}'

Prueba con

perl -Mbigint -E '{say$_+=1;redo}'
Kenney
fuente
Se puede reemplazar for(,,){...}con {...;redo}para dos.
primo
Sí, vi (perl 5.18+), pero pensé que podría estar haciendo trampa; entonces las respuestas serían las mismas. Soy nuevo aquí, así que ;-)
Kenney
1
Las referencias escalares se auto-vivificarán como SV UNDEF, lo que cuando se incrementa no desencadenará la BigIntsobrecarga, porque no es un BigInt. Los literales enteros, sin embargo, se crean como BigInts. No es tan extraño realmente;)
primo
1
¿Podría usar $-para mantenerlo como un número entero y volver a usarlo ++$-?
Dom Hastings
1
@DomHastings probé perl -Mbigint -E '{say++$-;$-+=$-;redo}' | morey se ajusta a 1. Sigue siendo un int pero bigint no interviene, desafortunadamente.
Kenney
4

Maravilloso, 358 bytes

..@F..@E..@D..@C..@B..@A..@9..@8..@7..@6..@5..@4..@3..@2..@1..@001@Z01
..AddoAddoAddoAddoAddoAddoAddoAddoAddoAddoAddoAddoAddoAddoAddoAddo/\&I
00&I00&I00&I00&I00&I00&I00&I00&I00&I00&I00&I00&I00&I00&I00&I00&I....@Z
@FHd@EHd@DHd@CHd@BHd@AHd@9Hd@8Hd@7Hd@6Hd@5Hd@4Hd@3Hd@2Hd@1Hd@0Hd
0A@N
..&I
@N/\..
:Hd
}0
Hp
}0
..
{<
#include hex_out.mbl
#include arithmetic.mbl

16 medios sumadores encadenados, el más a la derecha realiza N ++ cada ciclo y cada sumador alimenta su desbordamiento (00 o 01) al siguiente en la cadena. La salida está en hexadecimal.

El intérprete de Python tiene un error en el que se pierde la salida de las funciones memorizadas, por lo que debe ejecutar esto con "-m 0" para que funcione correctamente. Sin ese parámetro, puede ver qué tan rápido se ejecutará sin el error, pero la salida no funcionará correctamente.

Nota personal: corrija ese error en marbelous.py Este error se ha solucionado en la última versión de marbelous.py

Sparr
fuente
4

R, 52 bytes

a=gmp::as.bigz(1);repeat{cat(paste(a,""));a=a+1}

(Nota: gmpes una biblioteca externa, por lo que puede que tenga que descargarla para que esta solución funcione)

Ronquidos
fuente
1
+1 ... perdón por todos los extras. Para recuperarte un par, puedes intentarlo a=gmp::as.bigz(0);repeat{cat(paste(a<-a+1,''))}. Es posible que desee hacer una nota que gmpes una biblioteca externa que puede necesitar descargarse.
MickyT
44 bytes :)
Giuseppe
4

BotEngine, 128 120 112 8x13 = 104

v2 2 01
>e>S SS
   e1e1
   e2 e0 12
   > > S SS P
  ^   <e0e1 R
     ^ < <lC^
^         <

La salida es en binario.

SuperJedi224
fuente