직무

정수 n을 인쇄하십시오. 여기서 n의 12 <= n <= 123456789모든 연속 자릿수 쌍은 동일한 양의 차이를 갖습니다 (예 : 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.

파이썬 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 는 하드 코딩 된 문자열 로 대체하여 2 바이트를 절약했습니다.range'123456789' .

이것은 2 초의 런타임 제한의 제약으로 작성되었습니다. 숫자를 생성하는 대신 숫자를 필터링하는 느린 전략은 더 짧을 수 있습니다.

C, 166152 바이트

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

@KevinCruijssen 덕분에 6 바이트가 절약되었습니다!

@JonathanFrech 덕분에 8 바이트가 절약되었습니다!

온라인으로 사용해보십시오

위 코드의 전체 형식 버전은 아래에서 확인할 수 있습니다.

#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 덕분에 1 바이트가 절약되었습니다!

이것은 매우 비효율적이므로 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 초에 모든 숫자를 구성하는 또 다른 접근법이 있습니다.

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에 인쇄합니다. 온라인으로 사용해보십시오!

H.PWiz의 영감으로 인한 -1 바이트.

설명

Ö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 바이트

최적화가 없으므로 매우 느리다-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

자바 (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 포트 포트 ( 골프 후 약간). @Nevay
덕분에 -23 바이트 .

설명:

여기에서 시도하십시오. (끝 부분이 너무 느리므로 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 바이트

@JonathanFrech 덕분에 -2 바이트

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

온라인으로 사용해보십시오!

파이썬 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 분이 걸립니다.

온라인으로 사용해보십시오! (마지막 숫자를 제외한 모든 숫자를 인쇄하도록 수정)

자바 스크립트 (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보다 작으며 숫자 문자열에서 숫자를 필터링하여 결과를 생성합니다.

피스, 21 bytes

데니스 항구의 영리한 접근 .

jjLkf!t{.+Tsm.cS9dtS9

여기 사용해보십시오!

Pyth , 23 바이트

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

온라인 인터프리터에서 시간이 초과되지만 시간과 메모리가 충분하면 작동합니다.

낮은 번호로 온라인으로 시도하십시오 .

MATL, 17 16 bytes

1e9:"@Vdu0>TX=?@

Try it online! with 1e9 replaced by 1e3 so that it doesn't time out in the online compiler.

JavaScript (ES6), 121 bytes

Not nearly as short as Neil's answer, but I thought it was still worth posting.

Works by building a powerset of '123456789' where all non-matching entries are truncated and prefixed with 0, sorting the results in numerical order and keeping only the 77 relevant ones.

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

Try it online!

The 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 bytes

Works by generating all possible numbers: loops through each increment from 8 to 1 (variable i), loops through each starting digit from 8 to 1 (variable j), loops through each digit between j and 10-i (variable k) and generates a string t by appending k to the current t. At each step t is added to the output array.

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

Try it 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 bytes

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

Try it online!

Lightning fast due to constructing rather than selecting the output.

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;