AUFGABE

Geben Sie die Ganzzahlen n, wobei 12 <= n <= 123456789und alle Paare aufeinanderfolgender Ziffern in n die gleiche positive Differenz aufweisen (z. B. 2468, aber nicht 2469).

KEINE EINGABE.

Ausgabe:

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

Regeln

1. Es gelten Standardlücken.
2. keine Eingabe

kürzester Code gewinnt.

Credits Anarchie Golf

Jelly , 12 11 Bytes

9œcḊẎIE$ÐfY

Probieren Sie es online!

Wie es funktioniert

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

Probieren Sie es online!

Meine Lösung aus Anarchie Golf. Die Idee besteht darin, alle möglichen Dreifache von Länge, Startwert und Schritt zu durchlaufen, was sortierte Ausgaben ergibt. Die dreifache wird als ein Wert codiert rvon 72zu 647, und die Komponenten werden extrahiert , wie k/72, k/8%9, und k%8. Wenn Sie khoch genug starten, werden keine einstelligen Zahlen ausgegeben.

xsot sparte zwei Bytes ein , indem es die rangeZeichenfolge durch eine fest codierte Ziffernfolge ersetzte '123456789'.

Dies wurde unter der Bedingung einer Laufzeitbegrenzung von zwei Sekunden geschrieben. Eine langsamere Strategie, bei der Zahlen gefiltert und nicht generiert werden, ist möglicherweise kürzer.

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 gespart dank @KevinCruijssen!

8 Bytes gespart dank @JonathanFrech!

Probieren Sie es online aus

Die vollständig formatierte Version des obigen Codes ist unten zu sehen.

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

Jelly , 14 , 13 Bytes

DIµEȧ>0Ȧ
Ç77#

Probieren Sie es online!

Ein Byte gespart dank @MrXcoder!

Dies ist äußerst ineffizient, daher tritt bei TIO eine Zeitüberschreitung auf. Sollte dies jedoch jemals zu Ende gehen, wird die korrekte Ausgabe erzeugt. Sie können es hier mit kleineren Zahlen versuchen: Probieren Sie es online!

Erläuterung:

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

Probieren Sie es online!

Ersetzen Sie es •7=›ζ•durch 7000, um es auf TIO zu beenden, oder klicken Sie einfach auf die Schaltfläche "Beenden", bevor das Zeitlimit überschritten wird, was dazu führt, dass die Zahlen bis zu diesem Punkt gedruckt werden.

Mathematica, 79 Bytes

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

Probieren Sie es online! mit einer niedrigeren Zahl, weil es sehr langsam ist

Hier ist ein weiterer Ansatz, der alle Zahlen in 1 Sekunde aufbaut

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

Probieren Sie es online! alle zahlen in einer sek

Schale , 14 13 Bytes

ÖifȯεuẊ≠Ṗ…"19

Gibt durch Zeilenumbrüche getrennte Zahlen in STDOUT aus. Probieren Sie es online!

-1 Byte aufgrund der Inspiration von H.PWiz.

Erläuterung

Ö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

Probieren Sie es online!

APL (Dyalog) , 37 28 Bytes

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

Probieren Sie es online! (mit kürzerer Reichweite, wegen Zeitüberschreitung)

Wie?

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

¨ - für jedes

    ⍎¨⍕⍵ - in Ziffern aufbrechen

    2-/ - Unterschiedsliste abrufen

    ∪ - Holen Sie sich einzigartige Elemente

    1=≢ - Länge == 1?

x/⍨ - Verwenden Sie dies als Maske für den erstellten Bereich

⍪ - und kolumnifizieren

Schale , 14 Bytes

ÖifoEẊ≠ftṖ…"19

Probieren Sie es online!

Batch, 210 200 Bytes

Keine Optimierungen, also sehr langsam - dauert ca. 25 Sekunden bis 12345, sodass Sie für die vollständige Ausgabe ca. 3 Tage warten müssen.

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

Port von @Jacobinski C antworten (nachdem ich ein bisschen Golf gespielt habe).
-23 Bytes dank @Nevay .

Erläuterung:

Probieren Sie es hier aus. (Gegen Ende ist es etwas zu langsam, sodass die endgültige Nummer nicht auf TIO gedruckt wird. Die endgültige Nummer wird jedoch lokal in etwa 20 Sekunden gedruckt.)

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Ë&

Probieren Sie es online!

Python 2 , 103 97 95 Bytes

-2 Bytes dank @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

Probieren Sie es 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

Dauert ca. 3 Minuten vor Ort.

Probieren Sie es online! (geändert, um alle Zahlen außer der letzten zu drucken)

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

Schleifen über Längen von 2 bis 10 (x ist der Index des letzten Zeichens und daher 1 kleiner als die Länge), Startziffern von 1 bis 9 und Schritt von 1 bis 9, dann Filtern nach der Endziffer kleiner als 10 und wenn So wird das Ergebnis durch Herausfiltern von Ziffern aus der Ziffernfolge generiert.

Pyth , 21 Bytes

Port of Dennis 'kluger Ansatz .

jjLkf!t{.+Tsm.cS9dtS9

Probieren Sie es hier aus!

Pyth , 23 Bytes

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

Beim Online-Interpreter tritt eine Zeitüberschreitung auf, dies funktioniert jedoch, wenn genügend Zeit und Speicherplatz zur Verfügung stehen.

Versuchen Sie es online mit einer niedrigeren Nummer .

MATL , 17 16 Bytes

1e9:"@Vdu0>TX=?@

Probieren Sie es online! wird durch1e9ersetzt1e3, damit im Online-Compiler keine Zeitüberschreitung auftritt.

JavaScript (ES6), 121 Byte

Nicht annähernd so kurz wie Neils Antwort , aber ich dachte, es lohnt sich immer noch, etwas zu posten.

Erstellen Sie ein Powerset, bei '123456789'dem alle nicht übereinstimmenden Einträge abgeschnitten und mit einem Präfix versehen werden 0. Sortieren Sie die Ergebnisse in numerischer Reihenfolge, und behalten Sie nur die 77 relevanten Einträge bei .

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

Probieren Sie es online!

Die ungolfed (prettified) Version:

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

Generiert alle möglichen Zahlen: Durchläuft jedes Inkrement von 8 bis 1 (variabel i), durchläuft jede Startziffer von 8 bis 1 (variabel j), durchläuft jede Ziffer zwischen jund 10-i(variabel k) und generiert eine Zeichenfolge tdurch Anhängen kan die aktuelle t. Bei jedem Schritt twird das Ausgabearray hinzugefügt.

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

Probieren Sie es 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}]

Probieren Sie es online!

Blitzschnell durch Konstruieren statt Auswählen des Ausgangs.

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

Probieren Sie es online!

JavaScript (ES6), 145 Byte

Ein direkter Ansatz mit wenig Magie.

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

Das Ausführen des Snippets verbraucht viel Speicherplatz ...

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

versuche es online .

Das Sortieren kostet 17 Bytes. Diese Version druckt die Ergebnisse anders sortiert aus:

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