BÀI TẬP

in các số nguyên n, trong đó 12 <= n <= 123456789và tất cả các cặp chữ số liên tiếp trong n có sự khác biệt dương giống nhau giữa chúng (ví dụ 2468 nhưng không phải 2469).

KHÔNG VÀO.

Đầu ra:

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

Quy tắc

1. Tiêu chuẩn áp dụng.
2. không có đầu vào

mã ngắn nhất thắng.

Tín dụng golf vô chính phủ

Thạch , 12 11 byte

9œcḊẎIE$ÐfY

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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 byte

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

Hãy thử trực tuyến!

Giải pháp của tôi từ golf vô chính phủ. Ý tưởng là lặp đi lặp lại trên tất cả các bộ ba chiều dài, giá trị bắt đầu và bước có thể, cho kết quả đầu ra được sắp xếp. Các ba được mã hóa như một giá trị rtừ 72đến 647, và các thành phần được chiết xuất như k/72, k/8%9, và k%8. Bắt đầu kđủ cao để tránh các số có một chữ số được xuất ra.

xsot đã lưu hai byte khỏi điều này bằng cách thay thế rangebằng một chuỗi các chữ số được mã hóa cứng '123456789'.

Điều này đã được viết dưới sự ràng buộc của giới hạn thời gian chạy hai giây. Chiến lược chậm hơn lọc các số thay vì tạo các số này có thể ngắn hơn.

C, 166 152 byte

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 byte được lưu nhờ @KevinCruijssen!

8 byte được lưu nhờ @JonathanFrech!

Dùng thử trực tuyến

Phiên bản được định dạng đầy đủ của mã trên có thể được nhìn thấy dưới đây.

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

Thạch , 14 , 13 byte

DIµEȧ>0Ȧ
Ç77#

Hãy thử trực tuyến!

Một byte được lưu nhờ @MrXcoder!

Điều này cực kỳ không hiệu quả, vì vậy nó sẽ hết thời gian trên TIO, nhưng nếu nó kết thúc, nó sẽ tạo ra đầu ra chính xác. Bạn có thể thử nó với số lượng nhỏ hơn ở đây: Hãy thử trực tuyến!

Giải trình:

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

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

Hãy thử trực tuyến!

Thay thế •7=›ζ•bằng 7000 để hoàn thành trên TIO hoặc chỉ cần nhấn nút "chấm dứt" trước khi hết thời gian, dẫn đến các số được in cho đến thời điểm đó.

Toán học, 79 byte

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

Hãy thử trực tuyến! với số thấp hơn vì nó rất chậm

Đây là một cách tiếp cận khác để xây dựng tất cả các số trong 1 giây

Toán học, 123 byte

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

Hãy thử trực tuyến! tất cả các số trong một giây

Husk , 14 13 byte

ÖifȯεuẊ≠Ṗ…"19

In các số được phân tách bằng dòng mới thành STDOUT. Hãy thử trực tuyến!

-1 byte do cảm hứng từ H.PWiz.

Giải trình

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

Ngôn ngữ Wolfram (Mathicala) , 76 byte

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

Hãy thử trực tuyến!

APL (Dyalog) , 37 28 byte

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

Hãy thử trực tuyến! (với phạm vi ngắn hơn, do hết thời gian)

Làm sao?

x←11+⍳123456789- 11, 12... 1e9vàox

¨ - cho mỗi

    ⍎¨⍕⍵ - chia thành các chữ số

    2-/ - nhận danh sách khác biệt

    ∪ - có được các yếu tố độc đáo

    1=≢ - chiều dài == 1?

x/⍨ - sử dụng điều này như một mặt nạ trên phạm vi được tạo

⍪ - và cột

Husk , 14 byte

ÖifoEẊ≠ftṖ…"19

Hãy thử trực tuyến!

Mẻ, 210 200 byte

Không tối ưu hóa, rất chậm - mất khoảng 25 giây cho đến 12345, vì vậy để có đầu ra hoàn chỉnh, bạn phải chờ khoảng 3 ngày.

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

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

Cổng @Jacobinski C trả lời (sau khi tôi đánh gôn một chút).
-23 byte nhờ @Nevay .

Giải trình:

Hãy thử nó ở đây. (Tuy nhiên, hơi quá chậm khi kết thúc, do đó, không in số cuối cùng trên TIO. Tuy nhiên, nó sẽ in số cuối cùng cục bộ trong khoảng 20 giây.)

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 byte

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

Hãy thử trực tuyến!

Python 2 , 103 97 95 byte

-2 byte nhờ @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

Hãy thử trực tuyến!

Python 2 , 76 75 byte

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

Mất khoảng 3 phút tại địa phương.

Hãy thử trực tuyến! (sửa đổi để in tất cả các số nhưng cuối cùng)

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

Vòng lặp có độ dài từ 2 đến 10 (x là chỉ số của ký tự cuối cùng và do đó nhỏ hơn 1 so với độ dài), bắt đầu các chữ số từ 1 đến 9 và bước từ 1 đến 9, sau đó các bộ lọc trên chữ số cuối nhỏ hơn 10 và nếu do đó tạo ra kết quả bằng cách lọc ra các chữ số từ chuỗi chữ số.

Bình thường , 21 byte

Cách tiếp cận thông minh của cảng Dennis .

jjLkf!t{.+Tsm.cS9dtS9

Hãy thử nó ở đây!

Bình thường , 23 byte

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

Điều này lần ra trên trình thông dịch trực tuyến, nhưng hoạt động nếu được cung cấp đủ thời gian và bộ nhớ.

Hãy thử nó trực tuyến với một số thấp hơn .

MATL , 17 16 byte

1e9:"@Vdu0>TX=?@

Hãy thử trực tuyến! với1e9thay thế bằng1e3để nó không hết thời gian trong trình biên dịch trực tuyến.

JavaScript (ES6), 121 byte

Không ngắn như câu trả lời của Neil , nhưng tôi nghĩ nó vẫn đáng để đăng.

Hoạt động bằng cách xây dựng một quyền hạn trong '123456789'đó tất cả các mục không khớp được cắt bớt và tiền tố 0, sắp xếp các kết quả theo thứ tự số và chỉ giữ lại 77 mục có liên quan.

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

Bản giới thiệu

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 byte

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

Hãy thử trực tuyến!

Phiên bản chưa được chỉnh sửa (đã được chỉnh sửa):

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

Hoạt động bằng cách tạo tất cả các số có thể: các vòng lặp qua từng mức tăng từ 8 đến 1 (biến i), các vòng lặp qua từng chữ số bắt đầu từ 8 đến 1 (biến j), lặp qua từng chữ số giữa jvà 10-i(biến k) và tạo ra một chuỗi tbằng cách nối kvào dòng điện t. Tại mỗi bước tđược thêm vào mảng đầu ra.

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

Hãy thử trực tuyến!

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

Ngôn ngữ Wolfram (Mathicala) , 71 byte

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

Hãy thử trực tuyến!

Nhanh như chớp do xây dựng hơn là chọn đầu ra.

Java (OpenJDK 8) , 228 174 170 163 byte

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

Hãy thử trực tuyến!

JavaScript (ES6), 145 byte

Một cách tiếp cận đơn giản với ít phép thuật.

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

Chạy đoạn trích sẽ tiêu tốn rất nhiều bộ nhớ ...

PHP, 85 84 byte

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

dùng thử trực tuyến .

phân loại chi phí 17 byte. Phiên bản này in kết quả theo thứ tự khác nhau:

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