Bắt đầu từ những cái

18

Cho một số nguyên dương n , hãy làm theo các bước sau:

  1. Tạo một mảng A với n 1 s.
  2. Nếu A chỉ có một phần tử, chấm dứt. Mặt khác, bắt đầu từ phần tử đầu tiên, thay thế mỗi cặp A bằng tổng của nó, để phần tử cuối cùng như thể độ dài của A là số lẻ và lặp lại bước này.

Đầu ra phải chứa trạng thái của A sau mỗi bước theo thứ tự từ bước đầu tiên đến bước cuối cùng. Sử dụng sơ hở tiêu chuẩn bị cấm. Đây là một thử thách chơi gôn , vì vậy giải pháp có ít byte nhất trong mỗi ngôn ngữ sẽ thắng.

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

Mỗi dòng trong đầu ra của các ví dụ này là một trạng thái. Bạn có thể xuất thông qua bất kỳ định dạng hợp lý.

Đầu vào: 1

[1]

Đầu vào: 4

[1, 1, 1, 1]
[2, 2]
[4]

Đầu vào: 13

[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
[2, 2, 2, 2, 2, 2, 1]
[4, 4, 4, 1]
[8, 5]
[13]

Đầu vào: 15

[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
[2, 2, 2, 2, 2, 2, 2, 1]
[4, 4, 4, 3]
[8, 7]
[15]
code-golf  arithmetic 
— Erik là người vượt trội
nguồn
Tôi có thể sao chép ý tưởng câu hỏi này cho thứ tự ngược lại không? Cho số n, đầu ra từng bước A, và cứ thế cho đến khi bạn đạt n 1s?
— pixma140
9
@ pixma140 Điều đó về cơ bản là cùng một thách thức, chỉ với đầu ra bị đảo ngược sau đó. Việc sửa đổi là tầm thường.
— Erik the Outgolfer

Câu trả lời:

4

MATL , 10 byte

:g`t2estnq

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

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

:     % Input n (implicit). Range [1 2 ... n]
g     % Convert to logical. Gives [1 1 ... 1]
`     % Do...while
  t   %   Duplicate
  2   %   Push 2
  e   %   Reshape as 2-column matrix, in column-major order, padding with 0 if needed
  s   %   Sum of each column
  t   %   Duplicate
  n   %   Number of elements
  q   %   Subtract 1. This will be used as loop condition
      % End (implicit). If top of the stack is not zero run new iteration
      % Display stack, bottom to top (implicit)
— Luis Mendo
nguồn
4

Python 3 , 57 byte

def f(i,j=1):print(i//j*[j]+[i%j][:i%j]);i>j and f(i,j*2)

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

Python 2 , 51 byte

def f(i,j=1):print i/j*[j]+[i%j][:i%j];i>j>f(i,j*2)

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

Tổng số -6 byte nhờ tsh

Hàm đệ quy. Đối với mỗi bước, nó xây dựng một danh sách các quyền hạn 2, sao cho tổng nhỏ hơn hoặc bằng số nguyên đã cho. Sau đó nó sẽ nối phần còn lại, nếu nó lớn hơn 0.

— Jitse
nguồn
1
Python 3 61 byte : def f(i,j=1):l=i//j*[j]+[i%j][:i%j];print(l);i>j and f(i,j*2); Python 2 55 byte:def f(i,j=1):l=i/j*[j]+[i%j][:i%j];print l;i>j>f(i,j*2)
— tsh
@tsh Tất nhiên rồi, cảm ơn! i>jđã không làm việc trong giải pháp trước đây của tôi và tôi đã quên thử nó sau đó.
— Jitse
3

R , 65 byte

-1 byte nhờ Giuseppe.

n=scan();while(T<2*n){cat(rep(+T,n%/%T),if(n%%T)n%%T,"\n");T=2*T}

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

%/%%%k=2^in%/%kkn%%k2n-1

Ở đây tôi đang sử dụng Tthay vì k, vì nó được khởi tạo khi TRUEđược chuyển đổi thành 1. Tôi vẫn cần in +Tthay vì Tđể tránh một vectơ TRUEs trong đầu ra.

— Robin Ryder
nguồn
Đánh bại tôi khoảng 5 phút và gần 60 byte ... Nhưng Giuseppe đã đúng, nó không xuất ra bước cuối cùng.
— Sumner18
@ Sumner18 Nên sửa ngay.
— Robin Ryder
+Tngắn hơnT+0
— Giuseppe
@Giuseppe Cảm ơn, tôi biết mình đã quên một điều gì đó.
— Robin Ryder
3

Bình thường , 10 byte

.u+McN2m1

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

.u          # Apply until a result is repeated, return all intermediate steps: lambda N,Y:
  +M        # map by + (reduce list on +):
    cN2     # chop N (current value) into chunks of 2, last one is shorter if needed
       m1Q  # map(1, range(Q)) (implicit Q = input)

-1 byte nhờ FryAmTheEggman

— ar4093
nguồn
2

JavaScript, 55 byte

f=(n,t=1,r=n)=>r>t?t+[,f(n,t,r-t)]:n>t?r+`
`+f(n,t+t):r

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

Về cơ bản, đây là phiên bản chơi gôn của các mã sau:

function f(n) {
  var output = '';
  t = 1;
  for (t = 1; ; t *= 2) {
    for (r = n; r > t; r -= t) {
      output += t + ',';
    }
    output += r;
    if (n <= t) break;
    output += '\n';
  }
  return output;
}
— tsh
nguồn
2

Brachylog , 17 byte

;1j₍ẹẉ₂{ġ₂+ᵐ}ⁱ.ẉȮ

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

Như khủng khiếp dài vì đây là, tôi vẫn cảm thấy một chút thông minh cho việc sử dụng .ẉȮ: cách rõ ràng để in cái gì, sau đó kiểm tra nếu chiều dài của nó là 1 sẽ là ẉ₂l1, ẉ₂~ghoặc ẉ₂≡Ȯ, nơi ≡ở cuối cùng là cần thiết vì ẉ₂thống nhất đầu vào và đầu ra của nó trước khi in chúng và Ȯbị ràng buộc trước là danh sách có độ dài 1, do đó, việc hợp nhất không thành công nếu đầu vào không phải là danh sách có độ dài 1. ẉ₂Tuy nhiên, ở cuối một vị ngữ, tính năng này có thể bị phá vỡ sử dụng biến đầu ra thay vì đăng ký ẉ: .ẉȮtrước tiên thống nhất đầu vào của nó với biến đầu ra, sau đó in biến đầu ra và chỉ sau đó thống nhất biến đầu ra với Ȯ.

— Chuỗi không liên quan
nguồn
2

Stax , 10 byte

Çë⌐ⁿ┤5π»Å╡

Chạy và gỡ lỗi nó

Thủ tục:

  1. Tạo phạm vi dựa trên 0.
  2. Liên tục giảm một nửa mỗi phần tử cho đến khi tất cả các mục bằng không.
  3. Tính toán độ dài chạy cho mỗi mảng duy nhất.

Nguồn chú thích:

r       main:[0 .. 5] 
{{hmgu  main:[[0 .. 5], [0, 0, 1, 1, 2, 2], [0, 0, 0, 0, 1, 1], [0, 0, 0, 0, 0, 0]] 
m:GJ    main:"1 1 1 1 1 1"
— đệ quy
nguồn
1

Than , 19 byte

ＮθＩＥ↨⊖⊗θ²Ｅ⪪Ｅθ¹Ｘ²κＬλ

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Sử dụng định dạng đầu ra mặc định của Char than, là một số trên mỗi dòng, với các phân đoạn được đặt cách nhau hai lần. Giải trình:

Ｎθ                  Input `n` into a variable
       θ            `n`
      ⊗             Doubled
     ⊖              Decremented
    ↨   ²           Converted to base 2 (i.e. ceil(log2(input)))
   Ｅ                Map
           Ｅθ¹      List of `1`s of length `n`
          ⪪         Split into sublists of length
               ²    Literal `2`
              Ｘ     To power
                κ   Loop index
         Ｅ          Map over each sublist
                 Ｌλ Take the length
  Ｉ                 Cast to string for implicit print
— Neil
nguồn
1

Perl 6 , 38 byte

{1 xx$_,*.rotor(2,:partial)>>.sum...1}

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

Có một số phím tắt để quay một phần mà tôi không nhớ ngay bây giờ ...

Giải trình:

{                                    }  # Anonymous code block
                                 ...    # Return a sequence
 1 xx$_,            # Starting with a list of 1s with input length
        *           # Where each element is
         .rotor(2,:partial)        # The previous list split into chunks of 2 or less
                           >>.sum  # And each chunk summed
                                    1  # Until the list is length 1
— Jo vua
nguồn
1

Haskell , 75 byte

g.pure
g x|x!!0<2=[x]|1>0=(g$(\z->filter(0/=)[-div(-z)2,div z 2])=<<x)++[x]

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

Hoạt động ngược từ danh sách [n]cho đến khi nó đạt đến một danh sách chỉ những người.

Đi tiếp, tôi có thể nhận được 80 byte bằng cách sử dụng chunksoftừ Data.List.Split:

import Data.List.Split
f x=g$1<$[1..x]
g[n]=[[n]]
g x=x:(g$map sum$chunksOf 2 x)

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

— Jo vua
nguồn
0

Gaia , 12 byte

ċ)¦⟨:q2/Σ¦⟩ª

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

ċ)¦		| generate array of n 1's (really, generate array of n 0's and increment each)
   ⟨      ⟩ª	| do the following until you get to a fixed point:
    :q		| dup and print with a newline
      2/	| split into groups of 2, with last group possibly being smaller
	Σ¦	| take the sum
— Giuseppe
nguồn
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookie và Chính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.