TAREA

print enteros n, where 12 <= n <= 123456789y todos los pares de dígitos consecutivos en n tienen la misma diferencia positiva entre ellos (por ejemplo, 2468 pero no 2469).

SIN ENTRADA.

Salida:

12
13
14
15
16
17
18
19
23
24
25
26
27
28
29
34
35
36
37
38
39
45
46
47
48
49
56
57
58
59
67
68
69
78
79
89
123
135
147
159
234
246
258
345
357
369
456
468
567
579
678
789
1234
1357
2345
2468
3456
3579
4567
5678
6789
12345
13579
23456
34567
45678
56789
123456
234567
345678
456789
1234567
2345678
3456789
12345678
23456789
123456789

Reglas

1. Se aplican lagunas estándar.
2. sin entrada

el código más corto gana.

Créditos anarquía golf

Jalea , 12 11 bytes

9œcḊẎIE$ÐfY

Pruébalo en línea!

Cómo funciona

9œcḊẎIE$ÐfY  Main link. No arguments.

9            Set the argument and return value to 9.
   Ḋ         Dequeue; yield [2, ..., 9].
 œc          Take all k-combinations of [1, ..., 9], for each k in [2, ..., 9].
    Ẏ        Concatenate the arrays of k-combinations.
        Ðf   Filter the result by the link to the left.
     IE$         Compute the increments (I) of the combination / digit list and
                 tests if all are equal (E).
          Y  Join the results, separating by linefeeds.

Python 2 , 81 bytes

k=71
exec"k+=1;r=range(k/8%9+1,10,k%8+1)\nif r[k/72:]:print`r`[1:k/24+2:3]\n"*576

Pruébalo en línea!

Mi solución desde la anarquía del golf. La idea es iterar sobre todos los triples posibles de longitud, valor inicial y paso, lo que da resultados ordenados. La triple se codifica como un valor rde 72a 647, y los componentes se extraen como k/72, k/8%9, y k%8. Comenzar klo suficientemente alto evita que se generen números de un solo dígito.

xsot ahorró dos bytes de esto reemplazando el rangecon una cadena de dígitos codificada '123456789'.

Esto fue escrito bajo la restricción de un límite de tiempo de ejecución de dos segundos. Una estrategia más lenta que filtra los números en lugar de generarlos puede ser más corta.

C, 166152 bytes

p,l,d,i=11;main(){for(char s[10];i<=1e9;){sprintf(s,"%d",++i);p=0;for(l=strlen(s);--l>0;){d=s[l]-s[l-1];if(!p)p=d;if(p^d|d<1)break;p=d;}if(!l)puts(s);}}

¡6 bytes guardados gracias a @KevinCruijssen!

¡8 bytes guardados gracias a @JonathanFrech!

Pruébalo en línea

La versión completamente formateada del código anterior se puede ver a continuación.

#include <string.h>
#include <stdio.h>

int main( void )
{
int prev_diff, diff, len;
int num = 11;
char str[10];

while(num<123456789)
    {
    prev_diff = 0;
    sprintf(str,"%d",++num);
    len = strlen(str)-1;
    for( ; len > 0; len-- )
        {
        diff = str[len] - str[len-1];
        if( prev_diff == 0 )
            {
            prev_diff = diff;
            }
        if( prev_diff != diff || diff < 1 )
            {
            break;
            }
        prev_diff = diff;
        }
    if ( len == 0 )
        {
        puts(str);
        }
    }
}

Jalea , 14 , 13 bytes

DIµEȧ>0Ȧ
Ç77#

Pruébalo en línea!

¡Un byte guardado gracias a @MrXcoder!

Esto es extremadamente ineficiente, por lo que caducará en TIO, pero si alguna vez termina, producirá la salida correcta. Puede probarlo con números más pequeños aquí: ¡ Pruébelo en línea!

Explicación:

            # Helper link:
            #
D           # The Digits of 'n'
 I          # The increments (deltas, differences) between digits
  µ         # Give that array as an argument to the rest of this link:
   E        # Are all elements equal?
    ȧ       #   AND
     >0     # Are all elements greater then 0?
       Ȧ    # And is there at least one element?
            # (in the differences, so that numbers < 10 are false)
            #
            # Main link:
            #
 77#        # Return the first 77 'n's for which
Ç           #   The helper link is truthy

05AB1E , 23 bytes

•7=›ζ•FNS¥DËs0›PN11›&&–

Pruébalo en línea!

Reemplace •7=›ζ•con 7000 para que termine en TIO, o simplemente presione el botón "terminar" antes de que se agote el tiempo, lo que da como resultado los números impresos hasta ese punto.

Mathematica, 79 bytes

Select[Range@123456789,Min[s=Union@Differences@IntegerDigits@#]>0&&Tr[1^s]==1&]

Pruébalo en línea! con un número más bajo porque es muy lento

Aquí hay otro enfoque que construye todos los números en 1 segundo

Mathematica, 123 bytes

Union[FromDigits/@(F=Flatten)[Table[Partition[#,i,1],{i,2,9}]&/@Select[F[Table[Range[j,9,k],{j,9},{k,9}],1],Tr[1^#]>1&],2]]   

Pruébalo en línea! todos los números en un segundo

Casco , 14 13 bytes

ÖifȯεuẊ≠Ṗ…"19

Imprime números separados por nueva línea en STDOUT. Pruébalo en línea!

-1 byte debido a la inspiración de H.PWiz.

Explicación

ÖifȯεuẊ≠Ṗ…"19
         …"19  The string "19" rangified: "123456789"
        Ṗ      Powerset: ["","1","2","12","3",...,"123456789"]
  fȯ           Filter by function: (input is sublist, say "2469")
      Ẋ≠        Consecutive codepoint differences: [2,2,3]
     u          Remove duplicates: [2,3]
    ε           Is it a one-element list? No, so "2469" is dropped.
Öi             Sort the result by integer value, implicitly print separated by newlines.

Wolfram Language (Mathematica) , 76 bytes

Differences@IntegerDigits@#~MatchQ~{a_?Positive..}&&Print@#&~Array~123456789

Pruébalo en línea!

APL (Dyalog) , 37 28 bytes

⍪x/⍨{1=≢∪2-/⍎¨⍕⍵}¨x←11+⍳1E9

Pruébalo en línea! (con un rango más corto, debido al tiempo de espera)

¿Cómo?

x←11+⍳123456789- 11, 12... 1e9enx

¨ - para cada

    ⍎¨⍕⍵ - romper en dígitos

    2-/ - obtener lista de diferencias

    ∪ - obtener elementos únicos

    1=≢ - longitud == 1?

x/⍨ - use esto como una máscara en el rango creado

⍪ - y columnify

Casco , 14 bytes

ÖifoEẊ≠ftṖ…"19

Pruébalo en línea!

Lote, 210 200 bytes

Sin optimizaciones, muy lento: toma aproximadamente 25 segundos hasta 12345, por lo que para la salida completa tendría que esperar unos 3 días.

@set z=@set/a
%z%c=12
:a
@echo %c%
:c
%z%c+=1&if %c%==123456790 exit/b
%z%n=c
%z%d=n%%10-n/10%%10
@if %d% leq 0 goto c
:d
%z%n=n/10
@if %n% leq 9 goto a
%z%e=n%%10-n/10%%10
@if %e%==%d% goto d
@goto c

Java 8, 169 168 145 bytes

v->{byte[]a;for(int i=9,d,l;++i<1e9;System.out.print(l<1?i+"\n":""))for(a=(i+"").getBytes(),d=0,l=a.length;--l>0&&d*(d^(d=a[l]-a[l-1]))<1&d>0;);}

Respuesta del puerto de @Jacobinski C (después de jugar un poco al golf).
-23 bytes gracias a @Nevay .

Explicación:

Pruébalo aquí. (Es un poco demasiado lento cerca del final, por lo que no imprime el número final en TIO. Sin embargo, imprime el número final localmente en unos 20 segundos).

v->{                         // Method with empty unused parameter and no return-type
  byte[]a;                   //  Byte-array
  for(int i=9,               //  Index integer, starting at 9
          d,                 //  Difference-integer
          l;                 //  Length integer
      ++i<1e9;               //  Loop (1) from 10 to 1,000,000,000 (exclusive)
      System.out.print(      //    After every iteration: print:
        l<1?                 //     If `l` is 0:
         i+"\n"              //      The current integer + a new-line
        :                    //     Else:
         ""))                //      Nothing
    for(a=(i+"").getBytes(), //   Convert the current item as String to a byte-array
        d=0,                 //   Reset the previous integer to 0
        l=a.length;          //   Set `l` to the length of the byte-array
        --l>0                //   Inner loop (2) from `l-1` down to 0 (exclusive)
        &&d*(d^(d=a[l]-a[l-1]))<1
                             //    As long as the previous difference is either 0
                             //    or the current diff is not equal to the previous diff
        &d>0;                //    and the current diff is larger than 0
    );                       //   End of inner loop (2)
                             //  End of loop (1) (implicit / single-line body)
}                            // End of method

05AB1E , 14 bytes

TžhŸʒS¥D0›PsË&

Pruébalo en línea!

Pitón 2 , 103 97 95 bytes

-2 bytes gracias a @JonathanFrech

n=11
while n<1e9:
 n+=1;Q=`n`[1:]
 if`n`<Q>1==len({int(a)-int(b)for a,b in zip(`n`,Q)}):print n

Pruébalo en línea!

Python 2 , 76 75 bytes

n=9
while n<2e8:
 n+=1
 if`n`in`range(n%10,0,~n%100%11-11)`[-2::-3]:print n

Toma alrededor de 3 minutos localmente.

Pruébalo en línea! (modificado para imprimir todos los números excepto el último)

JavaScript (Firefox 30-57), 105 bytes

document.write(`<pre>`+(

_=>[for(x of s=`123456789`)for(y of s)for(z of s)if(x*z<10-y)s.replace(/./g,c=>c<y|(c-y)%z|c-y>x*z?``:c)]

)().join`\n`+`</pre>`);

Recorre longitudes de 2 a 10 (x es el índice del último carácter y, por lo tanto, 1 menos que la longitud), comienza los dígitos del 1 al 9 y pasa del 1 al 9, luego los filtros en el dígito final son menores que 10 y si genera el resultado filtrando dígitos de la cadena de dígitos.

Pyth , 21 bytes

Enfoque inteligente del puerto de Dennis .

jjLkf!t{.+Tsm.cS9dtS9

Pruébalo aquí!

Pyth , 23 bytes

j.f&!tl{K.+jZT*F>R0K77T

Esto agota el tiempo en el intérprete en línea, pero funciona si se le da suficiente tiempo y memoria.

Pruébelo en línea con un número menor .

MATL , 17 16 bytes

1e9:"@Vdu0>TX=?@

Pruébalo en línea! con1e9reemplazado por1e3para que no se agote el tiempo en el compilador en línea.

JavaScript (ES6), 121 bytes

No tan corto como la respuesta de Neil , pero pensé que aún valía la pena publicarlo.

Funciona mediante la construcción de un conjunto de poder '123456789'donde todas las entradas no coincidentes se truncan y se prefijan 0, ordenando los resultados en orden numérico y manteniendo solo las 77 relevantes.

_=>[...'123456789'].reduce((a,x)=>[...a,...a.map(y=>y[1]-y[0]+(y.slice(-1)-x)?'0':y+x)],['']).sort((a,b)=>a-b).slice(-77)

Manifestación

let f =

_=>[...'123456789'].reduce((a,x)=>[...a,...a.map(y=>y[1]-y[0]+(y.slice(-1)-x)?'0':y+x)],['']).sort((a,b)=>a-b).slice(-77)

console.log(f().join` `)

C (gcc) , 106 bytes

main(i,j,k,l){for(i=1;i<9;i++)for(j=8;j;j--)for(k=0;k<j/i;puts(""))for(l=0*k++;l<=i;)putchar(57-j+k*l++);}

Pruébalo en línea!

La versión sin golf (prettified):

int main() {
  int length, start_with, max_step, step, nth;
  for (length = 2; length <= 9; length++) {
    for (start_with = 1; start_with < 9; start_with++) {
      max_step = (9 - start_with) / (length - 1);
      for (step = 1; step <= max_step; step++) {
        for (nth = 0; nth < length; nth++) {
          putchar('0' + start_with + step * nth);
        }
        puts("");
      }
    }
  }
  return 0;
}

JavaScript (ES6), 109 bytes

Funciona generando todos los números posibles: recorre cada incremento de 8 a 1 (variable i), recorre cada dígito inicial de 8 a 1 (variable j), recorre cada dígito entre jy 10-i(variable k) y genera una cadena tagregando kal actual t. En cada paso tse agrega a la matriz de salida.

(o=[],i=9)=>{while(--i){j=9;while(k=--j){t=""+k;while(k<10-i)o.push(t+=k+=i)}}return o.sort((a,b)=>a-b)}

Pruébalo en línea!

f=

(o=[],i=9)=>{while(--i){j=9;while(k=--j){t=""+k;while(k<10-i)o.push(t+=k+=i)}}return o.sort((a,b)=>a-b)}

;
console.log(f().join("\n"))

Wolfram Language (Mathematica) , 71 bytes

Flatten@Array[If[(x=#2+#3 #)<10,FromDigits@Range[#2,x,#3],{}]&,{8,8,8}]

Pruébalo en línea!

Rápido como un rayo debido a la construcción en lugar de seleccionar la salida.

(Java OpenJDK 8) , 228 174 170 163 bytes

o->{int i=11,x,y,z,l;for(;i++<1e9;){char[]w=(""+i).toCharArray();for(x=w[1]-w[0],y=1,z=0;y<w.length;z+=l>0&l==x?0:1)l=w[y]-w[y++-1];if(z<1)System.out.println(i);}}

Pruébalo en línea!

JavaScript (ES6), 145 bytes

Un enfoque directo con poca magia.

Array(123456790).fill().map((x,i)=>(''+i).split('')).map((a,i,d) => {d=a[1]-a[0];d>0&a.every((n,j)=>j<1||n-a[j-1]==d)?console.log(a.join('')):0})

Ejecutar el fragmento consumirá mucha memoria ...

PHP, 85 84 bytes

for(;++$d<9||++$a<9*$d=1;sort($r))for($x=$y=$a+1;10>$y+=$d;)$r[]=$x.=$y;print_r($r);

pruébalo en línea .

el costo de clasificación es de 17 bytes. Esta versión imprime los resultados ordenados de manera diferente:

while(++$d<9||++$a<9*$d=1)for($x=$y=$a+1;10>$y+=$d;)echo"
",$x.=$y;