COMPITO

stampa numeri interi n, dove 12 <= n <= 123456789e tutte le coppie di cifre consecutive in n hanno la stessa differenza positiva tra loro (ad es. 2468 ma non 2469).

NESSUN INGRESSO.

Produzione:

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

Regole

1. Si applicano scappatoie standard.
2. nessun input

vince il codice più breve.

Riconoscimenti anarchia golf

Gelatina , 12 11 byte

9œcḊẎIE$ÐfY

Provalo online!

Come funziona

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 byte

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

Provalo online!

La mia soluzione dal golf dell'anarchia. L'idea è di iterare su tutte le possibili triple di lunghezza, valore iniziale e step, che fornisce output ordinati. La tripla è codificato come valore rda 72a 647, ei componenti vengono estratti come k/72, k/8%9e k%8. L'avvio kabbastanza alto evita che vengano emessi numeri a una cifra.

xsot ha salvato due byte da questo sostituendo il rangecon una stringa di cifre codificata '123456789'.

Questo è stato scritto sotto il vincolo di un limite di runtime di due secondi. Una strategia più lenta che filtra i numeri anziché generarli potrebbe essere più breve.

C, 166 152 byte

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 byte salvati grazie a @KevinCruijssen!

8 byte salvati grazie a @JonathanFrech!

Provalo online

La versione completamente formattata del codice sopra può essere vista sotto.

#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 byte

DIµEȧ>0Ȧ
Ç77#

Provalo online!

Un byte salvato grazie a @MrXcoder!

Questo è estremamente inefficiente, quindi scadrà su TIO, ma se mai finisce, produrrà l'output corretto. Puoi provarlo con numeri più piccoli qui: provalo online!

Spiegazione:

            # 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 byte

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

Provalo online!

Sostituisci •7=›ζ•con 7000 per terminare su TIO, o premi semplicemente il pulsante "termina" prima che scada, con conseguente stampa dei numeri fino a quel punto.

Mathematica, 79 byte

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

Provalo online! con un numero inferiore perché è molto lento

ecco un altro approccio che costruisce tutti i numeri in 1sec

Mathematica, 123 byte

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

Provalo online! tutti i numeri in un secondo

Buccia , 14 13 byte

ÖifȯεuẊ≠Ṗ…"19

Stampa i numeri separati da nuova riga su STDOUT. Provalo online!

-1 byte a causa dell'ispirazione di H.PWiz.

Spiegazione

Ö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 byte

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

Provalo online!

APL (Dyalog) , 37 28 byte

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

Provalo online! (con intervallo più breve, a causa del timeout)

Come?

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

¨ - per ciascuno

    ⍎¨⍕⍵ - rompere in cifre

    2-/ - ottieni l'elenco delle differenze

    ∪ - Ottieni elementi unici

    1=≢ - lunghezza == 1?

x/⍨ - usa questa come maschera sull'intervallo creato

⍪ - e columnify

Buccia , 14 byte

ÖifoEẊ≠ftṖ…"19

Provalo online!

Lotto, 210 200 byte

Nessuna ottimizzazione, quindi molto lenta, impiega circa 25 secondi fino a 12345, quindi per l'output completo dovresti aspettare circa 3 giorni.

@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 byte

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

Port of @Jacobinski C risponde (dopo averlo giocato un po 'a golf).
-23 byte grazie a @Nevay .

Spiegazione:

Provalo qui. (È un po 'troppo lento verso la fine, quindi non stampa il numero finale su TIO. Tuttavia, stampa il numero finale localmente in circa 20 secondi.)

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 byte

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

Provalo online!

Python 2 , 103 97 95 byte

-2 byte grazie 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

Provalo online!

Python 2 , 76 75 byte

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

Dura circa 3 minuti a livello locale.

Provalo online!(modificato per stampare tutti i numeri tranne l'ultimo)

JavaScript (Firefox 30-57), 105 byte

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

Passa per lunghezze da 2 a 10 (x è l'indice dell'ultimo carattere e quindi 1 in meno della lunghezza), iniziando le cifre da 1 a 9 e passando da 1 a 9, quindi i filtri sulla cifra finale sono inferiori a 10 e se quindi genera il risultato filtrando le cifre dalla stringa di cifre.

Pyth , 21 byte

L'approccio intelligente di Port of Dennis .

jjLkf!t{.+Tsm.cS9dtS9

Provalo qui!

Pyth , 23 byte

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

Questo si interrompe sull'interprete online, ma funziona se viene concesso tempo e memoria sufficienti.

Provalo online con un numero inferiore .

MATL , 17 16 byte

1e9:"@Vdu0>TX=?@

Provalo online! con1e9sostituito da in1e3modo che non scada nel compilatore online.

JavaScript (ES6), 121 byte

Non è così breve come la risposta di Neil , ma ho pensato che valesse la pena pubblicare.

Funziona creando un gruppo di potenze in '123456789'cui tutte le voci non corrispondenti vengono troncate e precedute da 0, ordinando i risultati in ordine numerico e mantenendo solo i 77 pertinenti.

_=>[...'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)

dimostrazione

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 byte

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

Provalo online!

La versione ungolfed (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 104 byte

Funziona generando tutti i numeri possibili: scorre attraverso ogni incremento da 8 a 1 (variabile i), scorre attraverso ogni cifra iniziale da 8 a 1 (variabile j), scorre attraverso ogni cifra tra je 10-i(variabile k) e genera una stringa taggiungendo kalla corrente t. Ad ogni passaggio tviene aggiunto l'array di output.

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

Provalo 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 byte

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

Provalo online!

Velocissimo grazie alla costruzione piuttosto che alla selezione dell'output.

Java (OpenJDK 8) , 228 174 170 163 byte

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

Provalo online!

JavaScript (ES6), 145 byte

Un approccio diretto 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})

L'esecuzione dello snippet consumerà molta memoria ...

PHP, 85 84 byte

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

provalo online .

l'ordinamento costa 17 byte. Questa versione stampa i risultati ordinati in modo diverso:

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