TÂCHE

affiche les entiers n, où 12 <= n <= 123456789et toutes les paires de chiffres consécutifs dans n ont la même différence positive entre eux (par exemple 2468 mais pas 2469).

PAS D'ENTRÉE.

Production:

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

Règles

1. Des échappatoires standard s'appliquent.
2. pas d'entrée

le code le plus court gagne.

Crédits anarchy golf

Gelée , 12 11 octets

9œcḊẎIE$ÐfY

Essayez-le en ligne!

Comment ça fonctionne

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 octets

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

Essayez-le en ligne!

Ma solution de l'anarchy golf. L'idée est d'itérer sur tous les triplets possibles de longueur, de valeur de départ et de pas, ce qui donne des sorties triées. La triple est codée comme une valeur rde 72à 647, et les composants sont extraits en tant que k/72, k/8%9etk%8 . Un démarrage ksuffisamment élevé évite la sortie de nombres à un chiffre.

xsot a économisé deux octets en remplaçant lerange par une chaîne de chiffres codée en dur '123456789'.

Cela a été écrit sous la contrainte d'une limite d'exécution de deux secondes. Une stratégie plus lente qui filtre les nombres plutôt que d'en générer peut être plus courte.

C, 166 152 octets

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 octets enregistrés grâce à @KevinCruijssen!

8 octets économisés grâce à @JonathanFrech!

Essayez-le en ligne

La version entièrement formatée du code ci-dessus peut être vue ci-dessous.

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

Gelée , 14 , 13 octets

DIµEȧ>0Ȧ
Ç77#

Essayez-le en ligne!

Un octet sauvé grâce à @MrXcoder!

C'est extrêmement inefficace, donc ça va s'arrêter sur TIO, mais si jamais ça se termine, ça produira la sortie correcte. Vous pouvez l'essayer avec de plus petits nombres ici: Essayez-le en ligne!

Explication:

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

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

Essayez-le en ligne!

Remplacez-le •7=›ζ•par 7000 pour le terminer sur TIO, ou appuyez simplement sur le bouton "Terminer" avant qu'il n'expire, ce qui entraîne l'impression des chiffres jusqu'à ce point.

Mathematica, 79 octets

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

Essayez-le en ligne!avec un nombre inférieur car il est très lent

voici une autre approche qui construit tous les nombres en 1sec

Mathematica, 123 octets

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

Essayez-le en ligne! tous les nombres en une seconde

Husk , 14 13 octets

ÖifȯεuẊ≠Ṗ…"19

Imprime les numéros séparés par des sauts de ligne dans STDOUT. Essayez-le en ligne!

-1 octet en raison de l'inspiration de H.PWiz.

Explication

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

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

Essayez-le en ligne!

APL (Dyalog) , 37 28 octets

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

Essayez-le en ligne! (avec une plage plus courte, en raison de la temporisation)

Comment?

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

¨ - pour chaque

    ⍎¨⍕⍵ - divisez en chiffres

    2-/ - obtenir la liste des différences

    ∪ - obtenez des éléments uniques

    1=≢ - longueur == 1?

x/⍨ - utilisez-le comme masque sur la gamme créée

⍪ - et colonne

Husk , 14 octets

ÖifoEẊ≠ftṖ…"19

Essayez-le en ligne!

Lot, 210 200 octets

Aucune optimisation, donc très lent - prend environ 25 secondes jusqu'à 12345, donc pour la sortie complète, vous devrez attendre environ 3 jours.

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

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 de @Jacobinski C réponse (après l'avoir un peu joué au golf ).
-23 octets grâce à @Nevay .

Explication:

Essayez-le ici. (C'est un peu trop lent vers la fin, donc n'imprime pas le numéro final sur TIO. Il imprime le numéro final localement en environ 20 secondes, cependant.)

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 octets

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

Essayez-le en ligne!

Python 2 , 103 97 95 octets

-2 octets grâce à @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

Essayez-le en ligne!

Python 2 , 76 75 octets

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

Prend environ 3 minutes localement.

Essayez-le en ligne! (modifié pour imprimer tous les numéros sauf le dernier)

JavaScript (Firefox 30-57), 105 octets

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

Boucles sur des longueurs de 2 à 10 (x est l'index du dernier caractère et donc 1 de moins que la longueur), en commençant les chiffres de 1 à 9 et les pas de 1 à 9, puis les filtres sur le dernier chiffre étant inférieur à 10 et si génère donc le résultat en filtrant les chiffres de la chaîne de chiffres.

Pyth , 21 octets

L'approche intelligente de Port of Dennis .

jjLkf!t{.+Tsm.cS9dtS9

Essayez-le ici!

Pyth , 23 octets

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

Cela expire sur l'interpréteur en ligne, mais fonctionne si on lui donne suffisamment de temps et de mémoire.

Essayez-le en ligne avec un nombre inférieur .

MATL , 17 16 octets

1e9:"@Vdu0>TX=?@

Essayez-le en ligne! avec1e9remplacé par1e3afin qu'il n'expire pas dans le compilateur en ligne.

JavaScript (ES6), 121 octets

Pas aussi court que la réponse de Neil , mais je pensais que cela valait toujours la peine d'être publié.

Fonctionne en créant un ensemble de pouvoirs '123456789'où toutes les entrées non correspondantes sont tronquées et préfixées 0, en triant les résultats dans l'ordre numérique et en ne gardant que les 77 pertinentes.

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

Démo

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 octets

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

Essayez-le en ligne!

La version non golfée (raffinée):

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 octets

Fonctionne en générant tous les nombres possibles: boucle à travers chaque incrément de 8 à 1 (variable i), boucle à travers chaque chiffre de départ de 8 à 1 (variable j), boucle à travers chaque chiffre entre jet 10-i(variable k) et génère une chaîne ten ajoutant kau courant t. À chaque étape, test ajouté au tableau de sortie.

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

Essayez-le en ligne!

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 octets

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

Essayez-le en ligne!

Rapide comme l'éclair en construisant plutôt qu'en sélectionnant la sortie.

Java (OpenJDK 8) , 228 174 170 170 163 octets

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

Essayez-le en ligne!

JavaScript (ES6), 145 octets

Une approche directe avec peu de 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})

L'exécution de l'extrait consommera beaucoup de mémoire ...

PHP, 85 84 octets

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

essayez-le en ligne .

le tri coûte 17 octets. Cette version imprime les résultats classés différemment:

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