TAREFA

imprima números inteiros n, onde 12 <= n <= 123456789e todos os pares de dígitos consecutivos em n têm a mesma diferença positiva entre eles (por exemplo, 2468, mas não 2469).

SEM ENTRADA.

Resultado:

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

Regras

1. Aplicam-se brechas padrão.
2. sem entrada

o código mais curto vence.

Créditos anarquia golfe

Geléia , 12 11 bytes

9œcḊẎIE$ÐfY

Experimente online!

Como 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

Experimente online!

Minha solução do anarchy golf. A idéia é iterar sobre todos os triplos possíveis de comprimento, valor inicial e etapa, o que fornece resultados classificados. O triplo é codificado como um valor rde 72a 647, e os componentes são extraídos como k/72, k/8%9e k%8. Iniciar kalto o suficiente evita a saída de números de um dígito.

O xsot salvou dois bytes disso, substituindo o rangepor uma sequência de dígitos codificada '123456789'.

Isso foi escrito sob a restrição de um limite de tempo de execução de dois segundos. Uma estratégia mais lenta que filtre números em vez de gerá-los pode ser mais curta.

C, 166 152 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 salvos graças a @KevinCruijssen!

8 bytes salvos graças a @JonathanFrech!

Experimente online

A versão totalmente formatada do código acima pode ser vista abaixo.

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

Gelatina , 14 , 13 bytes

DIµEȧ>0Ȧ
Ç77#

Experimente online!

Um byte salvo graças ao @MrXcoder!

Isso é extremamente ineficiente, portanto o tempo limite será excedido no TIO, mas, se alguma vez terminar, produzirá a saída correta. Você pode experimentá-lo com números menores aqui: Experimente on-line!

Explicação:

            # 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›&&–

Experimente online!

Substitua •7=›ζ•por 7000 para finalizar no TIO ou apenas pressione o botão "Terminar" antes que o tempo limite se esgote, resultando nos números impressos até esse ponto.

Mathematica, 79 bytes

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

Experimente online! com um número mais baixo porque é muito lento

aqui está outra abordagem que constrói todos os números em 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]]   

Experimente online! todos os números em um segundo

Casca , 14 13 bytes

ÖifȯεuẊ≠Ṗ…"19

Imprime números separados por nova linha em STDOUT. Experimente online!

-1 byte devido à inspiração do H.PWiz.

Explicação

Ö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

Experimente online!

APL (Dyalog) , 37 28 bytes

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

Experimente online! (com alcance menor, devido ao tempo limite)

Quão?

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

¨ - para cada

    ⍎¨⍕⍵ - divida em dígitos

    2-/ - obtenha lista de diferenças

    ∪ - obtenha elementos únicos

    1=≢ - comprimento == 1?

x/⍨ - use isso como uma máscara no intervalo criado

⍪ - e columnify

Casca , 14 bytes

ÖifoEẊ≠ftṖ…"19

Experimente online!

Lote, 210 200 bytes

Nenhuma otimização, muito lenta - leva cerca de 25 segundos até 12345, portanto, para a saída completa, você terá que esperar cerca de 3 dias.

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

Porto da resposta @Jacobinski C (depois de jogar um pouco).
-23 bytes graças a @Nevay .

Explicação:

Experimente aqui. (É um pouco lento demais no final, portanto, não imprime o número final no TIO. No entanto, imprime o número final localmente em cerca de 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Ë&

Experimente online!

Python 2 , 103 97 95 bytes

-2 bytes graças 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

Experimente online!

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

Demora cerca de 3 minutos localmente.

Experimente online! (modificado para imprimir todos os números, exceto o ú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>`);

Loops em comprimentos de 2 a 10 (x é o índice do último caractere e, portanto, 1 a menos que o comprimento), iniciando os dígitos de 1 a 9 e passando de 1 a 9, depois filtra o dígito final com menos de 10 e, se gera o resultado filtrando dígitos da sequência de dígitos.

Pitão , 21 bytes

Abordagem inteligente do Porto de Dennis .

jjLkf!t{.+Tsm.cS9dtS9

Experimente aqui!

Pitão , 23 bytes

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

Isso atinge o tempo limite no intérprete online, mas funciona se houver tempo e memória suficientes.

Experimente online com um número menor .

MATL , 17 16 bytes

1e9:"@Vdu0>TX=?@

Experimente online! com1e9substituído pelo1e3modo que ele não expirar no compilador online.

JavaScript (ES6), 121 bytes

Não é tão curta quanto a resposta de Neil , mas achei que ainda valia a pena postar.

Trabalha construindo um conjunto de potências de '123456789' onde todas as entradas não correspondentes são truncadas e prefixadas 0, classificando os resultados em ordem numérica e mantendo apenas os 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)

Demo

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

Experimente online!

A versão não destruída (prettificada):

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 104 bytes

Funciona gerando todos os números possíveis: passa por cada incremento de 8 a 1 (variável i), passa por cada dígito inicial de 8 a 1 (variável j), passa por cada dígito entre je 10-i(variável k) e gera uma string tanexando kà corrente t. Em cada etapa té adicionado à matriz de saída.

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

Experimente online!

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}]

Experimente online!

Rápido como um relâmpago devido à construção, em vez de selecionar a saída.

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

Experimente online!

JavaScript (ES6), 145 bytes

Uma abordagem direta com pouca mágica.

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

A execução do snippet consumirá muita memória ...

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

experimente online .

a classificação custa 17 bytes. Esta versão imprime os resultados ordenados de maneira diferente:

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