ЗАДАЧА

выведите целые числа 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, или просто нажмите кнопку «Завершить» до истечения времени ожидания, в результате чего цифры будут напечатаны до этой точки.

Mathematica, 79 байтов

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

Попробуйте онлайн! с меньшим числом, потому что это очень медленно

вот еще один подход, который строит все числа в 1сек

Mathematica, 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.

Wolfram Language (Mathematica) , 76 байт

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

Попробуйте онлайн!

APL (Dyalog) , 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 байтов

Без оптимизации, так что очень медленный - занимает около 25 секунд до 12345, поэтому для полного вывода вам придется подождать около 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Ë&

Попробуйте онлайн!

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

Wolfram Language (Mathematica) , 71 байт

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

Попробуйте онлайн!

Молниеносно из-за создания, а не выбора выхода.

Java (OpenJDK 8) , 228 174 170 163 байта

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

Попробуйте онлайн!

JavaScript (ES6), 145 байт

Прямой подход с небольшим количеством магии.

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

Запуск сниппета будет занимать много памяти ...

PHP, 85 84 байта

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

попробуйте это онлайн .

сортировка стоит 17 байт. Эта версия печатает результаты, упорядоченные по-другому:

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