Imprimir todos los enteros

48

Escriba un programa o función que pueda imprimir todos los enteros exactamente una vez dado un tiempo y memoria infinitos.

Los posibles resultados pueden ser:

0, 1, -1, 2, -2, 3, -3, 4, -4, …

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -2, -3, -4, -5, -6, -7, -8, -9, 10, 11, …

Esta no es una salida válida, ya que esto nunca enumeraría números negativos:

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,…

  • La salida debe estar en decimal, a menos que su idioma no admita enteros decimales (en ese caso, use la representación natural de enteros que usa su idioma).

  • Su programa tiene que trabajar hasta los números con la mayor magnitud del tipo entero estándar de su idioma.

  • Cada número entero debe separarse del siguiente utilizando cualquier separador (un espacio, una coma, un salto de línea, etc.) que no sea un dígito ni el signo negativo de su idioma.

  • El separador no debe cambiar en ningún momento.

  • El separador puede constar de varios caracteres, siempre que ninguno de ellos sea un dígito ni el signo negativo (por ejemplo, es tan válido como solo ,).

  • Cualquier número entero admitido debe imprimirse después de un período de tiempo finito.

Puntuación

Este es el , por lo que gana la respuesta más corta en bytes

Tabla de clasificación

Fatalizar
fuente
3
Si nuestro lenguaje admite listas infinitas, ¿podemos generar la lista desde una función en lugar de imprimirla? (Llamar a imprimir en una lista así imprimiría sus elementos uno a la vez para siempre.)
xnor
55
Siento que el requisito de los enteros de tamaño arbitrario no hace más que desalentar los idiomas sin que dichos enteros participen. Deben tener una importación que puedan usar o resolver un desafío totalmente diferente al de los demás.
xnor
2
@xnor Cambió, aunque ese tipo de ruinas arruina el nombre del desafío.
Fatalize
55
@xnor, los idiomas con números enteros de precisión arbitraria aún tienen que resolver un problema diferente al de todos los demás, por lo que todo ese cambio se ha logrado es hacer que este problema sea aburrido y trivial en muchos idiomas.
Peter Taylor
2
@PeterTaylor Sí, esto es lamentable. Las soluciones de envoltura no me parecen que estén imprimiendo ningún negativo, pero no veo una manera de especificar con firmeza la diferencia cuando se trata de una representación.
xnor

Respuestas:

19

Sesos , 11 3 3 bytes

0000000: c4ceb9                                            ...

Pruébalo en línea! Verifique la depuración para ver el código SBIN generado.

Asamblea Sesos

El archivo binario anterior se ha generado al ensamblar el siguiente código SASM.

set numout

jmp ; implicitly promoted to nop
    put,   fwd 1
    sub 1, put
    rwd 1, add 1
; jnz (implicit)
Dennis
fuente
¿Cómo son estos 3 bytes?
HopefulHelpful
1
El archivo Léame en GitHub (vinculado en el encabezado) explica en detalle cómo se codifican las instrucciones.
Dennis
1
6 dígitos hexadecimales / 2 = 3 bytes @HopefullyHelpful
Stan Strum
@StanStrum gracias
HopefullyHelpful
47

Haskell, 19 bytes

do n<-[1..];[1-n,n]

Produce la lista infinita. [0,1,-1,2,-2,3,-3,4,-4,5,-5,6,-6,7,-7...

Haskell permite infinitas listas de forma nativa. Imprimir dicha lista imprimirá sus elementos uno por vez para siempre.

xnor
fuente
2
Amor I [n,1-n]!
flawr
3
En mi humilde opinión [1-n,n]produciría una mejor producción.
Neil
@Neil Estoy de acuerdo, lo cambié.
xnor
2
Ah, eso es monadese concatMap (\n -> [1-n, n]) [1..], ¿verdad? ¡Agradable!
Carsten S
@CarstenS Sí, exactamente.
xnor
29

Brainfuck, 6 bytes

Esto hace uso del ajuste de celda e imprime todos los valores posibles. En Brainfuck, la representación entera nativa es por valor de byte .

.+[.+]

Pruébalo en línea!

falla
fuente
2
Bien, esta es la respuesta más corta de Brainfuck que he visto hasta ahora en PPCG.
Kevin Cruijssen
1
Esto no funcionará para versiones de brainfuck con células ilimitadas. Por favor, solucione (aunque sea como una respuesta separada)
John Dvorak
16
Las respuestas de @JanDvorak no necesitan funcionar en todas las implementaciones, solo en cualquiera de ellas.
Martin Ender
77
¿Podría obtener una explicación de por qué esto es válido? No hay separadores como se menciona en la pregunta y no hay negativos. Además del hecho de que puede generar valores superiores a 9 en brainfuck. Soy inexperto en el golf de código y comencé a trabajar en algo que generaba resultados negativos y positivos separados hasta números más altos antes de darse cuenta.
gtwebb
55
@SQB Incluso con memoria ilimitada, el tipo nativo de enteros sigue siendo de 8 bits. Un Java intno tiene repentinamente más o menos bits solo porque agregó o quitó algo de ram.
flawr
26

Cubix , 14 12 bytes

.(.\OSo;?.>~

¡Pruébelo en línea! Ahora puede ajustar la velocidad si desea que funcione más rápido o más lento.

Cómo funciona

Lo primero que hace el intérprete es eliminar todo el espacio en blanco y rellenar el código con no-ops .hasta que encaje perfectamente en un cubo. Eso significa que el código anterior también se puede escribir así:

    . (
    . \
O S o ; ? . > ~
. . . . . . . .
    . .
    . .

Ahora se ejecuta el código. El IP (puntero de instrucción) comienza en la esquina superior izquierda de la cara izquierda, apuntando al este. Estas son las rutas que toma durante el transcurso de la ejecución del programa:

ingrese la descripción de la imagen aquí

La IP comienza en el camino rojo en el extremo izquierdo de la imagen. Luego se ejecuta OSo;, lo que hace lo siguiente:

  • OImprima los TOS (top-of-stack) como un número entero. Al comienzo del programa, la pila contiene ceros infinitos, por lo que se imprime 0.
  • SEmpuje 32, el código de char para el carácter de espacio.
  • oImprime los TOS como un personaje. Esto imprime un espacio.
  • ;Pop the TOS. Elimina el 32de la pila.

Ahora la IP golpea el ?, que lo dirige hacia la izquierda, la derecha o la recta según el signo de los TOS. En este momento, el TOS es 0, por lo que va directo. Este es el camino azul; .no hace nada, y la IP golpea la flecha >, que lo dirige al este a lo largo del camino rojo nuevamente. ~toma el NOT bit a bit del TOS, cambiándolo a -1.

Aquí la IP llega al borde derecho de la red, que la envuelve de nuevo a la izquierda; esto nuevamente imprime los TOS (esta vez -1) y un espacio.

Ahora la IP golpea de ?nuevo. Esta vez, el TOS es -1; Como esto es negativo, la IP gira a la izquierda, tomando el camino verde. El espejo \desvía la IP hacia el (, lo que disminuye el TOS, cambiándolo a -2. Vuelve y golpea la flecha; ~toma bit a bit NO de nuevo, girando el -2a 1.

Una vez más se imprime el TOS y se imprime un espacio. Esta vez, cuando la IP llega a ?, el TOS es 1; Como esto es positivo, la IP gira a la derecha, tomando el camino amarillo. El primer operador que encuentra es Sempujar un extra 32; el ;aparece antes de que pueda causar problemas.

Ahora la IP vuelve a la flecha y realiza su rutina, ~cambiando el TOS -2e Oimprimiéndolo. Dado que el TOS es negativo nuevamente, la IP toma el camino verde una vez más. Y sigue ciclando así para siempre *: rojo, verde, rojo, amarillo, rojo, verde, rojo, amarillo ..., imprimiéndose en el siguiente ciclo:

0 -1 1 -2 2 -3 3 -4 4 -5 5 -6 6 -7 7 -8 8 -9 9 -10 10 ...

TL; DR

Este programa realiza repetidamente estos 3 sencillos pasos:

  1. Salida del número actual y un espacio.
  2. Si el número actual es negativo, disminuya en 1.
  3. Tome bit a bit NO del número actual.

Versión no separada, 6 bytes

nO?~>~

Eliminar la separación simplifica tanto el programa que puede caber en un cubo unitario:

  n
O ? ~ >
  ~

* Nota : Ninguno de los programas es realmente infinito, ya que solo cuentan hasta 2 52 (donde JavaScript comienza a perder precisión entera).

ETHproducciones
fuente
44
Bonito diagrama! :) ¿Creaste eso a mano o escribiste una herramienta para generarlo?
Martin Ender
55
@ MartinDender ¡Gracias! Fue inspirado por sus diagramas de Hexagony. Lo creé a mano; aunque me gustaría escribir una herramienta para generarlos cuando tenga tiempo suficiente para hacerlo.
ETHproductions
18

MATL , 8 bytes

0`@_@XDT

Utiliza el tipo de datos predeterminado de MATL, que es double, por lo que funciona 2^53en valor absoluto. La salida es

0
-1
1
-2
2
···

Pruébalo en línea!

Explicación

0            % Push 0
  `     T    % Do...while true: infinite loop
   @_        % Push iteration index and negate
     @       % Push iteration index
      XD     % Display the whole stack
Luis Mendo
fuente
¿Por qué hay un retraso tan grande antes de que comience a imprimir?
Fatalize
@Fatalize Creo que Octave debe reiniciarse cada vez que ejecutas un programa MATL en TIO, y eso lleva algo de tiempo.
flawr
@Fatalize No estoy seguro. Sucede en el compilador en línea, no fuera de línea. Pensé que podría tener que ver con Octave paginación de la salida, pero ahora no estoy seguro de si esa es la razón
Luis Mendo
1
Idea inteligente para hacer en @_@XDlugar de @_D@Dpara que pueda incluir el 0 en la primera ejecución.
Sanchises
3
XD+1 para smiley
TuxCrafting
16

Lenguaje de programación Shakespeare , 227 bytes

.
Ajax,.
Puck,.
Act I:
Scene I:
[Enter Ajax,Puck]
Puck:You ox!
Ajax:Be me without myself.Open thy heart.
Scene II:      
Ajax:Be thyself and ash.Open thy heart.Be me times you.Open thy heart.Be me times you.Let us return to scene II.

Obviamente, esta respuesta no está cerca de ganar, pero me gustó que este es un caso de uso para el que el SPL es relativamente adecuado.

Explicado:

// Everything before the first dot is the play's title, the parser treats it as a comment.
.

// Dramatis personae. Must be characters from Shakespeare's plays, again with a comment.
Ajax,.
Puck,.

// Acts and scenes serve as labels. Like the whole play, they can have titles too,
// but for the sake of golfing I didn't give them any.
Act I:

// This scene would've been named "You are nothing"
Scene I:

// Characters can talk to each other when on stage
[Enter Ajax,Puck]

// Characters can assign each other values by talking. Nice nouns = 1, ugly nouns = -1.
Puck: You ox!                 // Assignment: $ajax = -1;
Ajax: Be me without myself.   // Arithmetic: $puck = $ajax - $ajax;
      Open thy heart.         // Standard output in numerical form: echo $puck;

// Working title "The circle of life"
Scene II:

// Poor Ajax always doing all the work for us
Ajax: Be thyself and ash.          // $puck = $puck + (-1);
      Open thy heart.              // echo $puck;
      Be me times you.             // $puck *= $ajax;  (remember $ajax==-1 from scene I)
      Open thy heart.              // echo $puck;
      Be me times you.             // negate again
      Let us return to scene II.   // infinite goto loop

Como puede ver al comparar este código con mi respuesta al desafío relacionado de contar para siempre (es decir, imprimir todos los números naturales), la longitud del código SPL crece bastante mal cuando aumenta el tamaño del problema ...

Christallkeks
fuente
1
Me gusta esto. Es terrible para jugar al golf, pero maravilloso para leer.
porcinos
Error tipográfico en la última línea de la explicación. Let us return to scene II.debería ser scene I.
Oliver Ni
¡Gracias por señalar la diferencia! El error tipográfico estaba realmente en el código superior: no debemos repetir la escena I porque se restablecería $pucka 0 y luego el conteo ya no funcionaría. Agregué lo que faltaba Ien el código y corregí la longitud del byte (que de todos modos estaba un poco fuera de lugar)
Christallkeks
14

Python 2, 27 bytes

n=0
while 1:print~n,n,;n+=1

Huellas dactilares -1 0 -2 1 -3 2 -4 3 ...

xnor
fuente
10

05AB1E , 9 6 bytes

Guardado 3 bytes gracias a Adnan

[ND,±,

Pruébalo en línea!

Impresiones 0, -1, 1, -2, 2 ...separadas por líneas nuevas.

Emigna
fuente
2
Yo era capaz de conseguirlo hasta 6 bytes utilizando un poco de magia a nivel de bits: [N,N±,.
Adnan
1
@Adnan: ¡Qué bien! Traté de hacer algo similar antes, pero no lo usé ±y terminó 3 bytes más que el tuyo.
Emigna
Sé que ha pasado un tiempo, pero D,se puede reemplazar =por guardar un byte.
Kevin Cruijssen
10

GNU sed, 189 + 2 (rn flags) = 191 bytes

Esta es probablemente la solución más larga, ya que sed no tiene tipo entero ni operaciones aritméticas. Como tal, tuve que emular un operador de incremento de tamaño arbitrario usando solo expresiones regulares.

s/^/0/p
:
:i;s/9(@*)$/@\1/;ti
s/8(@*)$/9\1/
s/7(@*)$/8\1/
s/6(@*)$/7\1/
s/5(@*)$/6\1/
s/4(@*)$/5\1/
s/3(@*)$/4\1/
s/2(@*)$/3\1/
s/1(@*)$/2\1/
s/0(@*)$/1\1/
s/^@+/1&/;y/@/0/
s/^/-/p;s/-//p
t

Correr:

echo | sed -rnf all_integers.sed

Salida:

0
-1
1
-2
2
-3
3
etc.
seshoumara
fuente
10

Brainfuck, 127 bytes

+[-->+>+[<]>-]>-->+[[.<<<]>>-.>>+<[[-]>[->+<]++++++++[-<++++++>>-<]>--[++++++++++>->-<<[-<+<+>>]]>+>+<]<<<[.<<<]>>.+.>[>>>]<<<]

Pruébalo en línea!

Dada una cinta infinita, teóricamente funcionaría para siempre.

0,1,-1,2,-2,3,-3,4,-4,5,-5,6,-6,7,-7,8,-8,9,-9,10,-10,11,-11,12,-12,13,-13,14,-14,15,-15,16,-16,17,-17,18,-18,19,-19,20,-20,21,-21,22,-22,23,-23,24,-24,25,-25,26,-26,27,-27,28,-28,29,-29,30,-30,31,-31,32,-32,33,-33,34,-34,35,-35,36,-36,37,-37,38,-38,39,-39,40,-40,41,-41,42,-42,43,-43,44,-44,45,-45,46,-46,47,-47,48,-48,49,-49,50,-50,51,-51,52,-52,53,-53,54,-54,55,-55,56,-56,57,-57,58,-58,59,-59,60,-60,61,-61,62,-62,63,-63,64,-64,65,-65,66,-66,67,-67,68,-68,69,-69,70,-70,71,-71,72,-72,73,-73,74,-74,75,-75,76,-76,77,-77,78,-78,79,-79,80,-80,81,-81,82,-82,83,-83,84,-84,85,-85,86,-86,87,-87,88,-88,89,-89,90,-90,91,-91,92,-92,93,-93,94,-94,95,-95,96,-96,97,-97,98,-98,99,-99,...

Sin comprimir

+[-->+>+[<]>-]>-->+
[
  [.<<<]>>-.>>+<
  [[-]>[->+<]
    ++++++++[-<++++++>>-<]>--
    [++++++++++>->-<<[-<+<+>>]]>+>+<
  ]<<<
  [.<<<]>>.+.>
  [>>>]<<<
]
primo
fuente
9

ShadyAsFuck , 3 bytes

FVd

Explicación:

F     prints the current cell value (0) and increases it by 1
 V    starts a loop and prints the current value
  d   increases the current value and ends the loop

Esto hace uso del ajuste de celda e imprime todos los valores posibles. En SAF, la representación entera nativa es por valor de byte .

falla
fuente
55
Esta respuesta es ... sombría.
Conor O'Brien
1
Me preguntaba quién se le ocurrió el nombre del idioma, luego me di cuenta de qué idioma descendía.
John Dvorak
8

R, 25 24 bytes

Golfé un byte gracias a @JDL.

repeat cat(-F,F<-F+1,'')

Pruébalo en línea!

Salida de ejemplo:

0 1 -1 2 -2 3 -3 4 -4 5 -5 6 -6 7 -7 8 -8 9 -9 10 
rturnbull
fuente
2
Puede reemplazar while(1)con repeat para guardar un personaje.
JDL
@JDL ¡Gracias! Olvidé que la construcción existe a veces.
rturnbull
7

Lote, 56 bytes

@set n=0
:l
@echo %n%
@set/an+=1
@echo -%n%
@goto l

Salida:

0
-1
1
-2
2
-3

etc. Funciona hasta 2147483647; 58 bytes si desea (-) 2147483648 en la salida:

@set n=0
:l
@echo %n:-=%
@set/an-=1
@echo %n%
@goto l

44 bytes si se imprimen todos los enteros positivos admitidos, entonces todos los enteros negativos admitidos, y luego se repiten sin fin, es aceptable:

@set n=0
:l
@echo %n%
@set/an+=1
@goto l
Neil
fuente
7

Java 7, 151 134 122 118 bytes

import java.math.*;void c(){for(BigInteger i=BigInteger.ONE,y=i;;i=i.add(y))System.out.println(y.subtract(i)+"\n"+i);}

12 bytes guardados gracias a @flawr (y @xnor indirectamente)

Después del cambio de regla .. ( 59 56 63 bytes)

void c(){for(int i=0;i>1<<31;)System.out.println(~--i+"\n"+i);}

Dado que en Java 2147483647 + 1 = -2147483648, no podemos simplemente hacer i++y continuar infinitamente, ya que el desafío era imprimir todos los números una vez. Con el código anterior con rango añadido, será su lugar muestra todos los números enteros de -2147483648a 2147483647una vez cada uno, en el orden siguiente: 0, -1, 1, -2, 2, -3, 3, -4, ..., 2147483646, -2147483647, 2147483647, -2147483648. Gracias a @ OlivierGrégoire por señalar el comportamiento de Java con respecto a MIN_VALUE-1/ MAX_VALUE+1. Pruébalo aquí

Ungolfed y código de prueba:

Pruébelo aquí: se produce un error de tiempo de ejecución

import java.math.*;
class M{
  static void c() {
    for(BigInteger i = BigInteger.ONE, y = i; ; i = i.add(y)){
      System.out.println(y.subtract(i) + "\n" + i);
    }
  }

  public static void main(String[] a){
    c();
  }
}

Salida:

0
1
-1
2
-2
3
-3
4
-4
5
-5
...
Kevin Cruijssen
fuente
1
Creo que podría guardar algunos bytes imprimiendo ny 1-n al mismo tiempo, de esta manera podría eliminar la compra. @xnor fue el primero en usar esta idea aquí.
flawr
1
Su intprograma de versión, dado un tiempo infinito, imprimirá cada número entero una cantidad infinita de tiempo.
Olivier Grégoire
1
@ OlivierGrégoire Ah, por supuesto, MAX_VALUE + 1 es MIN_VALUE .. suspiro. Lo he editado, gracias por señalarlo.
Kevin Cruijssen
1
Si quiere jugar más al golf (es decir, deshacerse de él MAX_VALUE, puede consultar mi respuesta (probablemente todavía en la última página).)
Olivier Grégoire
1
Su solución de 53 bytes es un fragmento, no una función o programa, y ​​por lo tanto no es válida.
Mego
6

DC (sabor GNU u OpenBSD) - 16 bytes

Esta versión no es más corta que la versión siguiente, pero debería poder ejecutarse sin que la pila explote en su PC. Sin embargo, infinitos números grandes ocuparán cantidades infinitas de memoria ... en algún momento ...

Debido al rcomando necesita GNU-DC u OpenBSD-DC .

0[rp1+45Pprdx]dx

Prueba:

$ dc -e '0[rp1+45Pprdx]dx' | head
0
-1
1
-2
2
-3
3
-4
4
-5

DC - 16 bytes

Un poco malo ahora. ;-)

Esta versión está abusando de la longitud de la pila como contador mientras deja que la pila crezca.

z[pz45Ppllx]dslx

Prueba:

$ dc -e 'z[pz45Ppllx]dslx' | head
0
-1
1
-2
2
-3
3
-4
4
-5

DC - 17 bytes

Sin trucos sucios.

0[p1+45Ppllx]dslx

Prueba:

$ dc -e '0[p1+45Ppllx]dslx' | head
0
-1
1
-2
2
-3
3
-4
4
-5
yeti
fuente
+? por "tarde o temprano ... antes de lo que cabría esperar"
Greg Martin
2
En lugar de [-]Phacerlo 45P. "GNU-Dc u OpenBSD-Dc" - ¿Hay alguna otra versión comúnmente encontrada en la naturaleza?
Trauma digital
1
Tengo otra solución (o algunas), pero involucran números negativos reales. ¿Puedo publicarlos en una nueva respuesta? Lo pregunto porque se parecen mucho a estos, ya que dcsolo tiene unos pocos operadores. Los desarrollé independientemente de estos.
Joe
@DigitalTrauma ... claro ... el Dc original tiene / no tenía rcomo "intercambio". A veces me confundo al mirar las diferentes versiones. Probablemente ya nadie quiera codificar en Dc antiguo (y allí rse eliminaría la pila). ¿Quizás cambiaría "Dc" a "AT&T dc"? ... y gracias por la 45Ppista ...
yeti
2
@yeti Acabo de poner "dc" en mis respuestas. No creo que la gente aquí esté demasiado preocupada, especialmente dada la ubicuidad de los sabores de CC "modernos".
Trauma digital
6

C # 74 bytes

class P{void Main(){for(var x=0m;;System.Console.Write(x+++","+-x+","));}}

class P
{
    void Main()
    {
        for(var x = 0m; ; System.Console.Write(x++ + "," + -x + ","));
    }
}

Salida:

0,-1,1,-2,2,-3,3,-4,4,-5,5,-6,6,-7,7,-8,8,-9,9,-10,10,...

Intentalo:

dotnetfiddle.net (limitado a 1000)

alex
fuente
¿No son estos fragmentos y no funciones / programas completos?
pinkfloydx33
Lo sentimos, se agregó el programa completo
alex
2
Puede omitir los publicmodificadores y guardar 14 bytes. Los valores predeterminados lo harán igualmente bien.
Alejandro
@Alejandro gracias, es mi primer post :)
alex
6

Ruby, 26 22 19 16 bytes

Imprime números separados por nuevas líneas. -3 bytes de @manatwork. -3 bytes de @ m-chrzan.

0.step{|n|p~n,n}
Tinta de valor
fuente
Aquí está generando valores numéricos, por plo que también lo hará.
manatwork
0.step{|n|p n,~n}por 17 bytes.
m-chrzan
1
@ m-chrzan porque el orden no importa tanto, ¡pude eliminar un byte adicional, además de tu sugerencia!
Value Ink
6

JavaScript, 29 26 bytes

Versión no infinita, 26 bytes.

Guardado 3 bytes gracias a ETHproductions

for(n=1;;)alert([1-n,n++])

mostrará todos los enteros entre -9007199254740991 y 9007199254740992.

Versión infinita (ES6), 114 112 bytes

Ahorró 2 bytes gracias a ETHproductions

for(n=[-1];1;alert(n[a||n.unshift(1),0]?(x=n.join``)+' -'+x:0))for(i=n.length,a=0;i--;a=(n[i]+=1-a)>9?n[i]=0:1);

mostrará todos los enteros, dado el tiempo y la memoria infinitos.

Arnauld
fuente
Puede soltar la función repetitiva y llamarla un programa completo.
Conor O'Brien
@ ConorO'Brien - Oh, tienes razón. Gracias :)
Arnauld
n[a,b,c]devuelve n[c], por lo que puede colocar los paréntesis n[(a||n.unshift(1),0)].
ETHproductions
Tampoco necesita el 1bucle for; for(;;)corre por siempre. Puede guardar dos bytes más con for(n=1;;)alert([1-n,n++]). Además, esto ya no usa ninguna función de ES6 ;-)
ETHproductions
5

> <> , 19 15 bytes

1::1$-naonao1+!

Esto imprime lo siguiente:

0
1
-1
2
-2
3
-3

... y así. El separador es una nueva línea.

Reescrito después de leer la respuesta de @ xnor para usar una versión de ese algoritmo. Comenzando en n=1, el programa imprime 1-ny n, cada uno seguido de una nueva línea, antes de incrementar n. Después de desbordar el valor máximo, el programa terminará con un error de something smells fishy.... Exactamente cuándo ocurrirá esto depende de la implementación del intérprete.


Versión previa:

0:nao0$-:10{0(?$~+!

A partir de 0, el programa se repite indefinidamente. En cada bucle, el valor actual se imprime junto con una nueva línea. Luego se niega y se incrementa si es positivo.

Sok
fuente
¿Es xnor inequívocamente un "él"? ¿O están mostrando nuestros prejuicios inconscientes ...?
Greg Martin
2
@ GregMartin Es interesante, no creo que haya mencionado un género.
xnor
5

Bash + GNU utilidades, 26

seq NaN|sed '1i0
p;s/^/-/'
Trauma digital
fuente
Nunca he visto seq utilizado de esa manera, ¿es esto como un error? Además, ¿comenzará a repetir números después de un desbordamiento de tipo? Sé que lo $[++i]hace en bash.
seshoumara
Parece una característica más nueva: vea el código fuente . Agregar 1 a NaN no debería causar una envoltura.
Trauma digital
Salí seq NaNa correr y después de 999999 la impresión se realiza en notación científica con precisión de 5 dígitos. Con respecto al desafío, ese valor es el mayor número entero que imprime, lo cual está bien ya que el resto no repetirá un número anterior. También noté que puede ejecutar seq con infmayúsculas y minúsculas al igual que para nan. +1
seshoumara
5

a. C., 17 16 bytes

Editar: 1 byte menos gracias a Digital Trauma .

Agregando a la diversidad de lenguajes usados ​​hasta ahora, presento una solución bc que funciona con enteros de tamaño arbitrario . Se requiere una nueva línea después del código y se cuenta en el total de bytes.

for(;;){i;-++i}

En la primera iteración ino está definida, pero la impresión da 0 para mi sorpresa.

seshoumara
fuente
1 byte más corto:for(;;){i;-++i}
Trauma digital
@ DigitalTrauma Gracias, actualicé mi respuesta. Lo curioso es que usé esa construcción de bucle hoy en mi otra respuesta bash , pero olvidé que también la bctenía.
seshoumara
O for(;;){i++;-i}(misma longitud).
sch
5

Laberinto , 9 bytes

!`
\:"
 (

Pruébalo en línea!

Esto también funciona y es esencialmente lo mismo:

 "
`:(
\!

Explicación

El flujo de control en este código es bastante divertido. Recuerde que el puntero de instrucción (IP) en un programa Labyrinth sigue la ruta de los caracteres que no son espacios y examina la parte superior de la pila en cualquier cruce para decidir qué ruta tomar:

  • Si la parte superior de la pila es positiva, gire a la derecha.
  • Si la parte superior de la pila es cero, sigue avanzando en línea recta.
  • Si la parte superior de la pila es negativa, gire a la izquierda.

Cuando la IP llega a un punto muerto, se da la vuelta (ejecutando el comando al final solo una vez). Y la IP comienza en la esquina superior izquierda hacia el este. También tenga en cuenta que la pila está implícitamente llena con una cantidad infinita de ceros para empezar.

El programa comienza con este breve fragmento:

!    Print top of stack (0).
`    Multiply by -1 (still 0).
:    Duplicate.

Ahora la IP está en la unión relevante y avanza directamente hacia la (que disminuye la parte superior de la pila -1. La IP llega a un callejón sin salida y se da vuelta. :duplica la parte superior de la pila una vez más. Ahora la parte superior de la pila es negativa y la IP gira a la izquierda (oeste). Ahora ejecutamos una iteración más del bucle principal:

\   Print linefeed.
!   Print top of stack (-1).
`   Multiply by -1 (1).
:   Duplicate.

Esta vez, la parte superior de la pila es positiva, por lo que IP gira a la derecha (oeste) e inmediatamente ejecuta otra iteración del bucle principal, que imprime el 1. Luego, después de que se niega nuevamente, golpeamos :con -1en la pila.

Esta vez la IP gira a la izquierda (este). El "es simplemente un no-op y la IP se da vuelta en el callejón sin salida. :hace otra copia y esta vez la IP gira hacia el sur. (disminuye el valor a -2, la IP vuelve a girar. Con la parte superior de la pila aún negativa, la IP ahora gira hacia el oeste :y realiza la siguiente iteración del bucle principal.

De esta manera, la IP ahora iterará entre una iteración de bucle cerrado, imprimiendo un número positivo y una iteración que atraviesa ambos callejones sin salida para disminuir el valor antes de imprimir un número negativo.

Puede preguntarse por qué está "en la segunda línea si en realidad no hace nada: sin ella, cuando la IP alcanza :un valor negativo, no puede girar a la izquierda (este), por lo que en su lugar giraría a la derecha (oeste) (como regla general, si la dirección habitual en un cruce no está disponible, la IP tomará la dirección opuesta). Eso significa que la IP nunca alcanzaría la (parte inferior y no podríamos distinguir las iteraciones positivas de las negativas.

Martin Ender
fuente
Esto es lo que se me ocurrió antes de ver su respuesta: pastebin.com/VHzAvABe
Robert Hickman
5

JavaScript (ES5), 32 31 30 29 bytes

for(i=0;;)[i++,-i].map(alert)

Huellas dactilares 0 -1 1 -2 2 -3 3 -4 4 -5 5 ...

¡Salvado 1 byte gracias a Patrick Roberts! ¡Ahorré 2 bytes gracias a Conor O'Brien!

Paul Schmitz
fuente
1
¿Qué tal en [i++,-i].map(alert)lugar de alert(i++),alert(-i)?
Conor O'Brien
for(;;)es un byte más corto quewhile(1)
Patrick Roberts
@ ConorO'Brien mapes ES6
Paul Schmitz
@PaulSchmitz Nope, 5ta edición.
Conor O'Brien
Puede mover el i=0;bit dentro del bucle for para guardar un byte.
Conor O'Brien
4

Java, 65 54 bytes

i->{for(;;)System.out.print(i+++" "+(-i<i?-i+" ":""));

Código de prueba sin golf

public static void main(String[] args) {
    Consumer<Integer> r = i -> {
        for (;;) {
            System.out.print(i++ + " " + (-i < i ? -i + " " : ""));
        }
    };

    r.accept(0);
}
Shaun Wild
fuente
3
biggest magnitude of the standard integer type of your language intes el tipo entero estándar de Java.
Shaun Wild
1
Lo siento, los requisitos han cambiado mientras tanto ...
flawr
2
Puede jugar golf ()->{for(int i=0;;)System.out.print(i+" "+(1-i++));};( 53 bytes )
Kevin Cruijssen
@KevinCruijssen Eso arruina el espacio ...
Shaun Wild
1
Dado un tiempo infinito, imprimirá cada número entero una cantidad infinita de veces cada uno.
Olivier Grégoire
4

C #, 83 bytes

void f(){for(decimal n=0;;n++){Console.Write(n+",");if(n>0)Console.Write(-n+",");}}

Sin golf:

void f()
{
  for (decimal n=0;;n++)
  {
    Console.Write(n + ",");
    if (n > 0) Console.Write(-n + ",");
   }
}

Salidas:

0,1,-1,2,-2,3,-3,4,-4,5,-5,6,-6.......
Pete Arden
fuente
Hay bastantes cosas que se pueden hacer para reducir los caracteres. Primero, su programa no necesita un espacio de nombres. Segundo, el nombre de la clase no necesita ser tan largo. También realiza dos llamadas a console.writeline que se pueden simplificar a un delegado. El while true se puede simplificar a aa para (;;) y la instrucción if se puede eliminar con la salida del valor de cero primero a través del delegado.
Nico
Gracias. ¿No sabía si un delegado podría estar "haciendo trampa"?
Pete Arden
Hola, bienvenido a PPCG! Creo que puede resultarle interesante leer esto: consejos para jugar al golf en C # . Además, no necesita un programa completo, solo una función servirá (a menos que el desafío indique lo contrario). Entonces void f(){code_present_in_main}es suficiente para el conteo de bytes. En cuanto al código en sí, puede jugarlo un poco más de esta manera: void f(){for(decimal n=1;;)Console.Write((1-n)+","+n+++",");}( 61 bytes )
Kevin Cruijssen
1
Oh genial, ahora es un 85 mucho más saludable, ¡gracias! ¡No me sentiría bien usando toda su respuesta, pero definitivamente es una mejora y esos consejos ayudarán a mi futuro golf!
Pete Arden
@PeteArden Entiendo por no usar mi código, ya que es un enfoque diferente. Hmm, aún puedes jugar 2 bytes en tu propia respuesta colocando el decimal n=0y n++;dentro del ciclo for: void f(){for(decimal n=0;;n++){Console.Write(n+",");if(n>0)Console.Write(-n+",");}}:)
Kevin Cruijssen
4

C # 86 66 bytes

Nueva respuesta:

void b(){for(var i=0;;i++)Console.Write(i==0?","+i:","+i+",-"+i);}

Claro:

void b() 
{
    for(var i=0;;i++)
        Console.Write(i == 0 ? "," + i : "," + i + ",-" + i);
}

Respuesta anterior (86 bytes):

void a(){Console.Write(String.Join(",",Enumerable.Range(int.MinValue,int.MaxValue)));}

Sin golf:

void a()
{
    Console.Write(String.Join(",", Enumerable.Range(int.MinValue, int.MaxValue)));
}
Daniel Lerps
fuente
1
Hay 2 espacios en blanco inútiles. Uno antes Enumerable.Rangey otro antes int.MaxValue.
Yytsi
1
Bienvenido a PPCG! +1 Puede resultarle interesante leer esto: consejos para jugar al golf en C # . En su (s) respuesta (s) actual (es), se pueden eliminar los corchetes para el ciclo for, ya que solo hay una línea adentro. Alternativamente, este es un enfoque más corto: void f(){for(var n=1;;)Console.Write((1-n)+","+n+++",");}( 57 bytes ) .
Kevin Cruijssen
@KevinCruijssen Gracias. Los brackets se han ido.
Daniel Lerps
4

J, 25 bytes

([:$:1:`-`(1+-)@.*[echo)0

Funciona en el sitio en línea , pero todavía no puedo verificarlo en la computadora. Imprime números como:

0
1
_1
2
_2
3
_3
4

etc.

Conor O'Brien
fuente
4

Powershell, 20 19 18 bytes

Mejorado al robar descaradamente de la respuesta de TimmyD

0;for(){-++$i;$i}

Salida:

0
-1
1
-2
2
-3
3
-4
4

Versión antigua:

for(){-$i;$i++;$i}

No estoy seguro de por qué tbh, pero - la variable no declarada (o - $ null) se evalúa como 0, lo que nos ahorró 2 bytes en esta versión ...

lo que sea
fuente
1
Bienvenido a PPCG!
AdmBorkBork
4

Brachylog , 2 bytes

ẉ⊥

Pruébalo en línea!

ẉ     Print with a newline
      the input,
 ⊥    then try again.

Como el programa no recibe ninguna entrada, la variable de entrada del predicado principal se deja sin restricciones. Al principio, se supone que es 0, pero cuando la ejecución golpea , retrocede al único punto posible de falla: la elección del valor para la variable de entrada. Entonces, intenta 1, y -1, y todos los demás enteros, imprimiendo cada uno separado por nuevas líneas para siempre porque siempre fuerza el retroceso, y el efecto de se ejecuta de inmediato.

Cadena no relacionada
fuente