ЗАВДАННЯ

друкуйте цілі числа n, де 12 <= n <= 123456789і всі пари послідовних цифр у n мають однакову позитивну різницю між собою (наприклад, 2468, але не 2469).

НЕ ВХОДИТЬ.

Вихід:

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

Правила

1. Застосовуються стандартні лазівки.
2. немає вводу

виграє найкоротший код.

Кредити анархічного гольфу

Желе , 12 11 байт

9œcḊẎIE$ÐfY

Спробуйте в Інтернеті!

Як це працює

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 байт

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

Спробуйте в Інтернеті!

Моє рішення з анархічного гольфу. Ідея полягає в перегляді всіх можливих трійки довжини, початкового значення та кроку, що дає відсортовані результати. Трійка кодується як значення rвід 72до 647, а компоненти витягуються якk/72 , k/8%9і k%8. Починаючиk достатньо високого рівня дозволяє уникнути виведення одноцифрових чисел.

xsot врятував два байти від цього, замінившиrange рядок цифр'123456789' .

Це було написано під обмеженням двох секунд тривалості виконання. Більш повільна стратегія, яка фільтрує числа, а не створює їх, може бути коротшою.

C, 166 152 байт

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 байт збережено завдяки @KevinCruijssen!

8 байт збережено завдяки @JonathanFrech!

Спробуйте в Інтернеті

Повністю відформатовану версію вищевказаного коду можна побачити нижче.

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

Желе , 14 , 13 байт

DIµEȧ>0Ȧ
Ç77#

Спробуйте в Інтернеті!

Один байт збережено завдяки @MrXcoder!

Це вкрай неефективно, тому він вичерпається в TIO, але якщо він коли-небудь закінчиться, він дасть правильний вихід. Ви можете спробувати з меншими цифрами тут: Спробуйте в Інтернеті!

Пояснення:

            # 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 байти

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

Спробуйте в Інтернеті!

Замініть •7=›ζ•на 7000, щоб він закінчив TIO, або просто натисніть кнопку "завершити", перш ніж вона вичерпається, в результаті чого цифри надрукуються до цього моменту.

Математика, 79 байт

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

Спробуйте в Інтернеті!з меншим числом, тому що це дуже повільно

ось ще один підхід, який будує всі числа в 1сек

Математика, 123 байти

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

Спробуйте в Інтернеті! всі цифри в секунду

Лушпиння , 14 13 байт

ÖifȯεuẊ≠Ṗ…"19

Друкує номери, розділені рядками, в STDOUT. Спробуйте в Інтернеті!

-1 байт завдяки натхненню від H.PWiz.

Пояснення

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

Мова Вольфрама (Mathematica) , 76 байт

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

Спробуйте в Інтернеті!

APL (Діалог) , 37 28 байт

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

Спробуйте в Інтернеті! (із меншим діапазоном, із-за тайм-ауту)

Як?

x←11+⍳123456789- 11, 12... 1e9вx

¨ - для кожного

    ⍎¨⍕⍵ - розбити на цифри

    2-/ - отримати список відмінностей

    ∪ - отримати унікальні елементи

    1=≢ - довжина == 1?

x/⍨ - використовувати це як маску на створеному діапазоні

⍪ - і колумфікувати

Лушпиння , 14 байт

ÖifoEẊ≠ftṖ…"19

Спробуйте в Інтернеті!

Пакетна, 210 200 байт

Оптимізацій немає, тому дуже повільно - до 12345 потрібно близько 25 секунд, тож для повного виходу потрібно зачекати близько 3 днів.

@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 байт

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

Порт @Jacobinski C відповідь (після того, як я його трохи пограв у гольф).
-23 байти завдяки @Nevay .

Пояснення:

Спробуйте тут. (Близько занадто повільно наприкінці, тому не друкує остаточне число на TIO. Однак друкує кінцеве число локально приблизно за 20 секунд.)

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 байт

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

Спробуйте в Інтернеті!

Пітон 2 , 103 97 95 байт

-2 байти завдяки @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

Спробуйте в Інтернеті!

Python 2 , 76 75 байт

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

Місце займає близько 3 хвилин.

Спробуйте в Інтернеті! (змінено для друку всіх номерів, крім останнього)

JavaScript (Firefox 30-57), 105 байт

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

Петлі по довжинах від 2 до 10 (x - індекс останнього символу і, отже, на 1 менше довжини), починаючи цифри від 1 до 9 та крок від 1 до 9, потім фільтри на кінцевій цифрі менше 10, і якщо таким чином генерує результат, фільтруючи цифри з цифрового рядка.

Pyth , 21 байт

Розумний підхід порту Денніса .

jjLkf!t{.+Tsm.cS9dtS9

Спробуйте тут!

Pyth , 23 байти

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

Це час виходить з інтернету, але працює, якщо дано достатньо часу та пам'яті.

Спробуйте в Інтернеті з меншою кількістю .

MATL , 17 16 байт

1e9:"@Vdu0>TX=?@

Спробуйте в Інтернеті! з1e9заміненим на1e3так, щоб він не вийшов у онлайн-компіляторі.

JavaScript (ES6), 121 байт

Не настільки короткий, як відповідь Ніла , але я подумав, що все-таки варто опублікувати.

Працює, будуючи набір живлення, '123456789'де усі невідповідні записи усічені та встановлені префіксом 0, сортування результатів у числовому порядку та збереження лише 77 відповідних.

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

Демо

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 байт

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

Спробуйте в Інтернеті!

Негольована (попередньо) версія:

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 байт

Працює шляхом генерації всіх можливих чисел: циклів через кожен приріст від 8 до 1 (змінної i), циклів через кожну стартову цифру від 8 до 1 (змінної j), циклів через кожну цифру між jта 10-i(змінної k) та генерує рядок t, додаючи kдо струму t. На кожному кроці tдодається до вихідного масиву.

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

Спробуйте в Інтернеті!

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

Мова Вольфрама (Mathematica) , 71 байт

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

Спробуйте в Інтернеті!

Блискавка швидше завдяки побудові, а не вибору виходу.

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

Try it online!

JavaScript (ES6), 145 bytes

A straight-forward approach with little magic.

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

Running the snippet will consume a lot of memory...

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

try it online.

sorting cost 17 bytes. This version prints the results ordered differently:

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