Cho hai số nguyên dương p và q , nhiệm vụ của bạn là trả về mảng A được tạo bằng cách áp dụng thuật toán sau:

1. Bắt đầu với A = [p, q] và d = 2
2. Với mỗi cặp (x, y) các số liền kề trong A có tổng chia hết cho d , hãy chèn (x + y) / d giữa x và y .
3. Nếu tìm thấy ít nhất một cặp phù hợp, hãy tăng d và tiếp tục với bước # 2. Nếu không, dừng lại và quay trở lại Một .

Thí dụ

Dưới đây là chi tiết của quá trình cho p = 1 và q = 21 .

  1  21             | Iteration #1: we start with d = 2 and A = [1, 21]
   \/               |               1 + 21  is divisible by 2 -> we insert 11
 22/2=11            |
                    |
  1  11 21          | Iteration #2: d = 3, A = [1, 11, 21]
   \/               |               1 + 11  is divisible by 3 -> we insert 4
 12/3=4             |
                    |
  1 4 11  21        | Iteration #3: d = 4, A = [1, 4, 11, 21]
        \/          |               11 + 21 is divisible by 4 -> we insert 8
      32/4=8        |
                    |
  1    4    11 8 21 | Iteration #4: d = 5, A = [1, 4, 11, 8, 21]
    \/   \/         |               1 + 4   is divisible by 5 -> we insert 1
  5/5=1 15/5=3      |               4 + 11  is divisible by 5 -> we insert 3
                    |
  1 1 4 3 11 8 21   | Iteration #5: d = 6, A = [1, 1, 4, 3, 11, 8, 21]
                    |               no sum of two contiguous numbers is divisible by 6
                    |               -> we stop here

Do đó, đầu ra dự kiến: [1, 1, 4, 3, 11, 8, 21]

Làm rõ và quy tắc

• Đầu vào và đầu ra có thể được xử lý trong bất kỳ định dạng hợp lý. Các số nguyên p và q được đảm bảo lớn hơn 0. Nếu điều đó có ích, bạn có thể giả sử q p .
• Bước thứ 2 của thuật toán không nên được áp dụng đệ quy cho các phần tử vừa được chèn vào cùng một lần lặp. Chẳng hạn, A = [1, 1] và d = 2 sẽ dẫn đến [1, 1, 1] (không phải là danh sách vô hạn của 1).
• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte sẽ thắng!

Các trường hợp thử nghiệm

  p |   q | Output
----+-----+-------------------------------------------------------------------------------
  1 |   1 | [1,1,1]
  1 |   2 | [1,2]
  1 |   3 | [1,1,2,3]
  2 |   6 | [2,1,2,1,4,1,2,6]
  3 |  13 | [3,1,8,1,3,1,7,1,2,1,5,1,3,2,13]
  9 |   9 | [9,6,9,6,9]
 60 |  68 | [60,13,1,4,31,2,3,5,2,19,64,7,13,1,2,5,2,27,44,3,4,8,2,1,12,1,5,3,28,2,4,16,1,
    |     |  2,12,1,2,1,10,1,6,68]
144 | 336 | [144,68,3,4,8,1,12,1,4,2,28,13,128,44,17,92,240,58,108,5,17,1,2,5,3,28,3,1,11,
    |     |  60,3,6,2,42,2,4,26,192,54,132,7,1,15,1,3,1,18,1,4,2,30,3,1,12,1,9,78,46,336]

Nếu bạn muốn kiểm tra mã của mình trong trường hợp thử nghiệm lớn hơn một chút, đây là đầu ra dự kiến ​​cho:

• p = 12096 (2 ⁶ * 3 ³ * 7)
• q = 24192 (2 ⁷ * 3 ³ * 7)

05AB1E , 28 19 18 byte

[Ðü+NÌ/‚ζ˜ʒ.ï}DŠQ#

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

eh, chắc chắn có thể được cải thiện Hardcore. vẫn làm việc để tái cấu trúc.

Có lẽ là tốt như tôi nhận được nó.

-1 cảm ơn, ai khác nhưng, Emigna! Để chỉ ra trao đổi làm việc tốt hơn so với các thanh ghi.

[                   // Infinite loop.
 Ð                  // Triplicate [p, ..., q]
  U                 // Pop 1 of 3 copies into register X.
   ü+               // Pairwise addition.
     NÌ/            // Divide by current iteration + 2 (which is d).
        ‚           // Group original [p, ..., q] with pairwise additives.
         ζ˜         // Transpose together and flatten.
           ʒ.ï}     // Filter out non-integer entities (includes the space added by zip).
               DXQ  // Dupe result, see if equal to original.
                  # // If new array is original array, nothing happened, quit & return.

Gỡ lỗi cho [p,q] = [1,3]:

Full program: [ÐUü+NÌ/‚ζ˜ʒ.ï}DXQ#
current >> [  ||  stack: []
ÐUü+NÌ/‚ζ˜ʒ.ï}DXQ#
Full program: ÐUü+NÌ/‚ζ˜ʒ.ï}DXQ#
current >> Ð  ||  stack: []
current >> U  ||  stack: [[1, 3], [1, 3], [1, 3]]
current >> ü  ||  stack: [[1, 3], [1, 3]]
Full program: +
current >> +  ||  stack: [1, 3]
stack > [4]
current >> N  ||  stack: [[1, 3], [4]]
current >> Ì  ||  stack: [[1, 3], [4], 0]
current >> /  ||  stack: [[1, 3], [4], 2]
current >> ‚  ||  stack: [[1, 3], [2.0]]
current >> ζ  ||  stack: [[[1, 3], [2.0]]]
current >> ˜  ||  stack: [[[1, 2.0], [3, ' ']]]
current >> ʒ  ||  stack: [[1, 2.0, 3, ' ']]
Filter: .ï
Full program: .ï
current >> .  ||  stack: [1]
stack > [1]
Full program: .ï
current >> .  ||  stack: [2.0]
stack > [1]
Full program: .ï
current >> .  ||  stack: [3]
stack > [1]
Full program: .ï
current >> .  ||  stack: [' ']
invalid literal for int() with base 10: ' '
stack > []
current >> D  ||  stack: [[1, 2.0, 3]]
current >> X  ||  stack: [[1, 2.0, 3], [1, 2.0, 3]]
current >> Q  ||  stack: [[1, 2.0, 3], [1, 2.0, 3], [1, 3]]
current >> #  ||  stack: [[1, 2.0, 3], 0]
stack > [[1, 2.0, 3]]
Full program: ÐUü+NÌ/‚ζ˜ʒ.ï}DXQ#
current >> Ð  ||  stack: [[1, 2.0, 3]]
current >> U  ||  stack: [[1, 2.0, 3], [1, 2.0, 3], [1, 2.0, 3]]
current >> ü  ||  stack: [[1, 2.0, 3], [1, 2.0, 3]]
Full program: +
current >> +  ||  stack: [1, 2.0]
stack > [3.0]
Full program: +
current >> +  ||  stack: [3.0, 2.0, 3]
stack > [3.0, 5.0]
current >> N  ||  stack: [[1, 2.0, 3], [3.0, 5.0]]
current >> Ì  ||  stack: [[1, 2.0, 3], [3.0, 5.0], 1]
current >> /  ||  stack: [[1, 2.0, 3], [3.0, 5.0], 3]
current >> ‚  ||  stack: [[1, 2.0, 3], [1.0, 1.6666666666666667]]
current >> ζ  ||  stack: [[[1, 2.0, 3], [1.0, 1.6666666666666667]]]
current >> ˜  ||  stack: [[[1, 1.0], [2.0, 1.6666666666666667], [3, ' ']]]
current >> ʒ  ||  stack: [[1, 1.0, 2.0, 1.6666666666666667, 3, ' ']]
Filter: .ï
Full program: .ï
current >> .  ||  stack: [1]
stack > [1]
Full program: .ï
current >> .  ||  stack: [1.0]
stack > [1]
Full program: .ï
current >> .  ||  stack: [2.0]
stack > [1]
Full program: .ï
current >> .  ||  stack: [1.6666666666666667]
stack > [0]
Full program: .ï
current >> .  ||  stack: [3]
stack > [1]
Full program: .ï
current >> .  ||  stack: [' ']
invalid literal for int() with base 10: ' '
stack > []
current >> D  ||  stack: [[1, 1.0, 2.0, 3]]
current >> X  ||  stack: [[1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3]]
current >> Q  ||  stack: [[1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3], [1, 2.0, 3]]
current >> #  ||  stack: [[1, 1.0, 2.0, 3], 0]
stack > [[1, 1.0, 2.0, 3]]
Full program: ÐUü+NÌ/‚ζ˜ʒ.ï}DXQ#
current >> Ð  ||  stack: [[1, 1.0, 2.0, 3]]
current >> U  ||  stack: [[1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3]]
current >> ü  ||  stack: [[1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3]]
Full program: +
current >> +  ||  stack: [1, 1.0]
stack > [2.0]
Full program: +
current >> +  ||  stack: [2.0, 1.0, 2.0]
stack > [2.0, 3.0]
Full program: +
current >> +  ||  stack: [2.0, 3.0, 2.0, 3]
stack > [2.0, 3.0, 5.0]
current >> N  ||  stack: [[1, 1.0, 2.0, 3], [2.0, 3.0, 5.0]]
current >> Ì  ||  stack: [[1, 1.0, 2.0, 3], [2.0, 3.0, 5.0], 2]
current >> /  ||  stack: [[1, 1.0, 2.0, 3], [2.0, 3.0, 5.0], 4]
current >> ‚  ||  stack: [[1, 1.0, 2.0, 3], [0.5, 0.75, 1.25]]
current >> ζ  ||  stack: [[[1, 1.0, 2.0, 3], [0.5, 0.75, 1.25]]]
current >> ˜  ||  stack: [[[1, 0.5], [1.0, 0.75], [2.0, 1.25], [3, ' ']]]
current >> ʒ  ||  stack: [[1, 0.5, 1.0, 0.75, 2.0, 1.25, 3, ' ']]
Filter: .ï
Full program: .ï
current >> .  ||  stack: [1]
stack > [1]
Full program: .ï
current >> .  ||  stack: [0.5]
stack > [0]
Full program: .ï
current >> .  ||  stack: [1.0]
stack > [1]
Full program: .ï
current >> .  ||  stack: [0.75]
stack > [0]
Full program: .ï
current >> .  ||  stack: [2.0]
stack > [1]
Full program: .ï
current >> .  ||  stack: [1.25]
stack > [0]
Full program: .ï
current >> .  ||  stack: [3]
stack > [1]
Full program: .ï
current >> .  ||  stack: [' ']
invalid literal for int() with base 10: ' '
stack > []
current >> D  ||  stack: [[1, 1.0, 2.0, 3]]
current >> X  ||  stack: [[1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3]]
current >> Q  ||  stack: [[1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3]]
current >> #  ||  stack: [[1, 1.0, 2.0, 3], 1]
[1, 1.0, 2.0, 3]
stack > [[1, 1.0, 2.0, 3]]

Hãy thử trực tuyến với gỡ lỗi!

Toán học, 72 64 59 58 byte

(d=2;#//.x_:>Riffle[x,(x+{##2,}&@@x)/d++]~Cases~_Integer)&

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

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

Chúng tôi lấy đầu vào là một danh sách {p,q}. Bước lặp được định dạng lại là:

1. Chèn (a+b)/dgiữa mỗi hai phần tử avà b: (x+{##2,}&@@x)tính toán chuỗi a+b, với a+Nullphần cuối. Chúng tôi chia theo d, và Rifflechèn mỗi (a+b)/dgiữa avà b. Tăng d.
2. Chọn ra các Integeryếu tố của danh sách kết quả. (Điều này cũng được loại bỏ Nullbởi giới thiệu {##2,}.)

Điều này được lặp lại cho đến khi kết quả không thay đổi (điều này chỉ có thể xảy ra do chúng tôi đã xóa tất cả các phần tử mới, vì không có phần tử nào trong số chúng là số nguyên).

-8 byte nhờ @MartinEnder sử dụng //.thay vì FixedPoint(và lấy đầu vào làm danh sách).

-6 nhiều hơn bởi vì ListConvolvethực sự không phải là tuyệt vời

Ruby , 80 byte

->a,d=2{*b=a[0];a.each_cons 2{|x,y|z=x+y;b+=z%d>0?[y]:[z/d,y]};b==a ?a:f[b,d+1]}

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

Hàm đệ quy flấy đầu vào là mảng [p, q].

Haskell, 85 81 byte

(a:b:c)#d=a:[div(a+b)d|mod(a+b)d<1]++(b:c)#d
l#d=l
l%d|l==l#d=l|e<-d+1=l#d%e
(%2)

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

Đầu vào được lấy dưới dạng một danh sách, ví dụ [1,2].

Chỉnh sửa: -4 byte nhờ @Laikoni.

Python 2 , 112 110 108 105 103 byte

^{-2 byte nhờ Jonathan Frech
-5 byte nhờ Erik the Outgolfer}

y=input()
x=d=1
while x!=y:
 d+=1;x=y;y=x[:1]
 for a,b in zip(x,x[1:]):c=a+b;y+=[c/d,b][c%d>0:]
print x

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

Python 2 , 98 byte

f=lambda A,B=0,d=2:A*(A==B)or f(sum([[(l+r)/d,r][(l+r)%d>0:]for l,r in zip(A,A[1:])],A[:1]),A,d+1)

Gọi như f([p,q]). Hãy thử trực tuyến!

Jonathan Allan đã lưu 12 byte. Cảm ơn ~!

Giải trình

flà một hàm đệ quy: f(A, B, d)đánh giá f(next_A, A, d+1), trừ khi A == B, trong trường hợp đó nó trả về A. (Điều này được xử lý bởi A*(A==B)or …: nếu A ≠ B, A*(A==B)đây là danh sách rỗng, mà là sai-y, do đó …một phần được đánh giá; nếu A = B thì A*(A==B)là A, mà không bị để trống và do đó truthy, và nó được trả lại.)

next_A được tính là:

sum([[(l+r)/d,r][(l+r)%d>0:]for l,r in zip(A,A[1:])],A[:1])

Điều này được giải thích tốt nhất bằng ví dụ. Khi ví dụ d = 5 và A = [1, 4, 11, 8, 21]:

  sum([[(l+r)/d,r][(l+r)%d>0:]for l,r in zip(A,A[1:])],A[:1])
= sum([[(1+4)/d, 4], [(4+11)/d, 11], [8], [21]], [1])
= [1] + [1, 4] + [3, 11] + [8] + [21]
= [1, 1, 4, 3, 11, 8, 21]

Python 2 , 111 byte

A=input()
m=d=1
while m:
 m=o=0;d+=1
 while A[o+1:]:
	o+=1;s=A[o-1]+A[o]
	if s%d<1:A[o:o]=s/d,;m=1;o+=1
print A

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

-8 cảm ơn Rod .
-2 cảm ơn Lynn .

Husk , 22 byte

→UG`λf£NΣẊṠeo/⁰+:.)⁰tN

Lấy danh sách 2 phần tử, trả về danh sách số nguyên và số float. Hãy thử trực tuyến!

Giải trình

→UG`λf£NΣẊṠeo/⁰+:.)⁰tN  Input is a list L.
  G                 tN  Cumulative reduce over the list [2,3,4..
                   ⁰    with initial value L
   `λ             )     using flipped version of this function:
     f£NΣẊṠeo/⁰+:.       Arguments are a list, say K=[1,3,3], and a number, say d=4.
                :.       Prepend 0.5: [0.5,1,2,3]
         Ẋ               For each adjacent pair,
               +         take their sum,
            o/⁰          divide by d,
          Ṡe             and pair it with the right number in the pair: [[0.375,1],[1.0,3],[1.5,3]]
        Σ                Concatenate: [0.375,1,1.0,3,1.5,3]
     f£N                 Remove non-integers: [1,1.0,3,3]
                        Now we have an infinite list of L threaded through 2,3,4.. using the expansion operation.
 U                      Take longest prefix of unique elements,
→                       then last element of that.

Perl 5 , 92 + 1 ( -a) = 93 byte

do{$c=0;@n=shift@F;$.++;push@n,($t=$_+$n[-1])%$.?$_:($c=$t/$.,$_)for@F;@F=@n}while$c;say"@F"

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

Võng mạc , 111 byte

\d+
$*1;
^
11@
{+`(1+); (1+);
$1; $1$2 $2;
(?<=(?=(1+)).*) (\1)+ 
 a$#2$*1; 
 1+ 
 
.*a
1$&
)`a

1+@

1+
$.&
;

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

Lấy đầu vào là các số được phân tách bằng dấu cách. Khá ngây thơ tuân theo thuật toán đã cho, với kỹ thuật đáng chú ý duy nhất là sử dụng ký hiệu đánh dấu a, để lưu ý khi bất kỳ số nào được giữ. Điều này được sử dụng để làm việc với các khả năng lặp có phần hạn chế của Retina, chỉ cho phép bạn lặp cho đến khi một tập hợp các giai đoạn không có thay đổi tổng thể đối với đầu vào cho các giai đoạn đó.

Giải trình:

Điều này sẽ sử dụng ví dụ tương tự như trong câu hỏi.

\d+
$*1;

Chúng tôi thay đổi mảng đầu vào của số thành mảng đơn phân tách dấu chấm phẩy, vì vậy chúng tôi có:

1; 111111111111111111111;

^
11@

Đặt dmã của chúng tôi ngay từ đầu, cho chúng tôi:

11@1; 111111111111111111111;

{+`(1+); (1+);
$1; $1$2 $2;

Điều này hơi phức tạp hơn một chút. {bắt đầu một nhóm các giai đoạn sẽ được thực hiện cho đến khi chúng đạt đến một điểm cố định. Sau đó, +chỉ ra rằng giai đoạn này nên được thực hiện cho đến khi một điểm cố định. Giai đoạn này thêm từng cặp số liền kề nhưng chèn chúng mà không có dấu chấm phẩy bổ sung. Bây giờ chúng tôi sẽ có:

11@1; 1111111111111111111111 111111111111111111111;

(?<=(?=(1+)).*) (\1)+ 
 a$#2$*1;

Giai đoạn khó khăn khác, giai đoạn này tích lũy ước số của chúng tôi trong nhóm bắt giữ đầu tiên và thay thế bất kỳ số nào trong danh sách của chúng tôi mà không có dấu chấm phẩy với số đó chia cho d. Chúng tôi cũng thêm một dẫn ađến những con số này, để chỉ ra rằng một cái gì đó đã được lưu giữ, cùng với ;dấu hiệu cho thấy nó phải là một phần vĩnh viễn của mảng. Bây giờ chúng tôi sẽ có:

11@1; a11111111111; 111111111111111111111;

 1+ 

Điều này xóa các số không chia hết dvà cũng không nằm trong mảng trước vòng này. Điều này làm cho không có thay đổi trong ví dụ của chúng tôi.

.*a
1&$

Điều này tham lam khớp từ đầu chuỗi đến chữ cái cuối cùng atrong đầu vào. Điều này có nghĩa là có thể có nhiều nhất một trận đấu. Nếu chúng tôi thực hiện bất kỳ thay đổi nào, chúng tôi sẽ thêm một thay đổi, dnếu không để nó giống nhau để chúng tôi có thể thoát khỏi vòng lặp.

111@1; a11111111111; 111111111111111111111;

)`a

Việc )đóng vòng lặp bắt đầu bằng cách {(đừng hỏi nó!) Và nếu không thì giai đoạn này chỉ xóa các điểm đánh dấu mà chúng ta đã đặt trước đó. Vì đây là kết thúc của vòng lặp, chúng tôi sẽ lặp lại các giai đoạn trên nhiều lần, tuy nhiên tôi sẽ tiếp tục như thể tôi đã quên vòng lặp, vì nó làm cho ví dụ liên tục hơn.

111@1; 11111111111; 111111111111111111111;

1+@

Giai đoạn này loại bỏ khỏi đầu ra của chúng tôi:

1; 11111111111; 111111111111111111111;

1+
$.&

Giai đoạn này thay thế các số đơn nguyên bằng số thập phân:

1; 11; 21;

;

Giai đoạn cuối cùng được loại bỏ dấu chấm phẩy:

1 11 21

Rõ ràng, bỏ qua vòng lặp làm cho chúng ta có một kết quả không chính xác ở đây, nhưng hy vọng điều đó không quá khó hiểu.

JavaScript (ES6), 89 87 82 byte

Cảm ơn @Arnauld về -2 byte và đã giúp lưu thêm 5 byte.

f=(a,d=2,r)=>a.map(v=>b.push(v,...(v+=a[++i])%d<1?[r=v/d]:[]),b=i=[])|r?f(b,d+1):a

Đưa đầu vào dưới dạng một mảng : f([p,q]).

Các trường hợp thử nghiệm

f=(a,d=2,r)=>a.map(v=>b.push(v,...(v+=a[++i])%d<1?[r=v/d]:[]),b=i=[])|r?f(b,d+1):a

;[[1,1],[1,2],[1,3],[2,6],[3,13],[9,9],[60,68],[144,336],[12096,24192]]
.forEach(test=>O.innerText+=JSON.stringify(test)+" -> "+JSON.stringify(f(test))+"\n")

<pre id=O></pre>

Röda , 90 byte

f a,d=2{A=[a()|slide 2|[_,(_1+_)/d]if[(_1+_2)%d=0]else[_1]]+a[-1]f A,d=d+1 if[a!=A]else A}

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

Java 8, 180 byte

import java.util.*;p->q->{List<Integer>r=new Stack();r.add(p);r.add(q);for(int d=1,f=d,i;f==d++;)for(i=1;i<r.size();i++)if((q=r.get(i)+r.get(i-1))%d<1)r.add(i++,q/(f=d));return r;}

Giải trình:

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

import java.util.*;           // Required import for List and Stack

p->q->{                       // Method with two integer parameters and List return-type
  List<Integer>r=new Stack(); //  Result-list
  r.add(p);r.add(q);          //  Add the two input-integers to the List
  for(int d=1,                //  Divisible integer (starting at 1)
          f=d,                //  Temp integer (starting at `d` / also 1)
          i;                  //  Index-integer
      f==d++;)                //  Loop (1) as long as `f` and `d` are equal
                              //  (and raise `d` by 1 so it starts at 2 inside the loop)
    for(i=1;                  //   Reset index-integer to 1
        i<r.size();i++)       //   Inner loop (2) over the List
      if((q=r.get(i)+r.get(i-1)) 
                              //    If the current + previous items (stored in `q`)
         %d<1)                //    are divisible by `d`:
        r.add(i++,q/(f=d));   //     Insert `q` divided by `d` to the List at index `i`
                              //     (and raise `i` by 1 and set `f` to `d` in the process)
                              //   End of inner loop (2) (implicit / single-line body)
                              //  End of loop (1) (implicit / single-line body)
  return r;                   //  Return the result-List
}                             // End of method

C #, 280 byte

using System.Linq;class A{static void Main(string[] p){var l=new System.Collections.Generic.List<int>(p.Select(int.Parse));int r,d=2,c;do{c=0;for(int i=1;i<l.Count;++i){if((r=l[i-1]+l[i])%d==0){l.Insert(i++,r/d);++c;}}++d;}while(c>0);l.ForEach(v=>System.Console.Write((v+" ")));}}

Nỗ lực đầu tiên tại mã golf, đó là toàn bộ chương trình. Kiểm tra nó

Cố gắng 2, 159 byte

Lấy đi giàn giáo, vì nhiệm vụ là cung cấp một hàm có thể lấy một cặp số (một mảng hoạt động) và trả về một mảng. Cho rằng một Func <int [], int []> F có thể được sử dụng để đáp ứng các yêu cầu, chỉ cần xác định F :

F=v=>{var l=new List<int>(v);int i,r,d=2,c;do{c=0;for(i=1;i<l.Count;++i){if((r=l[i-1]+l[i])%d==0){l.Insert(i++,r/d);++c;}}++d;}while(c>0);return l.ToArray();};

Kiểm tra toàn bộ chương trình tại đây

Điều này có thể nhỏ hơn nếu Danh sách chung được coi là đầu ra hợp lệ (bỏ .ToArray () để lưu 10 byte).

Nếu đầu vào cũng có thể được sửa đổi, thì việc chuyển vào Danh sách <int> thay vì một mảng sẽ loại bỏ yêu cầu khởi tạo đầu ra (xuất hiện ở mức 126 byte).

Thực hiện bước này một bước xa hơn, thực sự không cần phải có giá trị trả về trong trường hợp này. Sử dụng một hành động thay vì loại bỏ 9 byte được sử dụng bởi câu lệnh return.

Thạch , 19 byte

®‘©‘÷@+2\⁸żFfṀR$µÐL

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