Giới thiệu (có thể bỏ qua)

Đặt tất cả các số dương theo thứ tự thông thường của nó (1, 2, 3, ...) là một chút nhàm chán, phải không? Vì vậy, đây là một loạt các thách thức xung quanh hoán vị (chia sẻ lại) của tất cả các số dương. Đây là thử thách thứ hai trong loạt bài này. Thử thách đầu tiên có thể được tìm thấy ở đây .

Trong thử thách này, chúng tôi sử dụng mã Gray để sắp xếp lại các số tự nhiên. Mã màu xám, hoặc "mã nhị phân được phản ánh" là mã hóa nhị phân theo cách hai giá trị liên tiếp chỉ khác nhau trong một bit. Một ứng dụng thực tế của mã hóa này là sử dụng nó trong các bộ mã hóa quay , do đó tôi tham khảo "Turn My Way" .

Lưu ý rằng mã hóa này để lại một số mức độ tự do. Ví dụ: theo sau nhị phân 1100, có bốn mã sau có thể có: 1101, 1110, 1000 và 0100. Đây là lý do tại sao tôi sẽ định nghĩa $a(n)$ là giá trị nhỏ nhất, không được sử dụng trước đây chỉ khác nhau một ký tự trong mã hóa nhị phân. Trình tự này tương ứng với A163252 .

Vì đây là một thách thức "chuỗi thuần", nên nhiệm vụ là xuất ra $a(n)$ cho $n$ cho trước làm đầu vào, trong đó $a(n)$ là A163252 .

Bài tập

Cho một đầu vào số nguyên $n$ , đầu ra $a(n)$ ở định dạng số nguyên ( không phải ở định dạng nhị phân).

$a(n)$ được định nghĩa là số nguyên dương nhỏ nhất không xảy ra trước đó trong chuỗi sao cho$a(n-1)$ và$a(n)$ khác nhau một bit khi được viết ở dạng nhị phân.

Lưu ý: lập chỉ mục dựa trên 1 được giả định ở đây; bạn có thể sử dụng lập chỉ mục dựa trên 0, vì vậy $a(0) = 1; a(1) = 3$ , v.v. Hãy đề cập đến điều này trong câu trả lời của bạn nếu bạn chọn sử dụng nó.

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

Input | Output
--------------
1     | 1
5     | 4
20    | 18
50    | 48
123   | 121
1234  | 1333
3000  | 3030
9999  | 9997

Quy tắc

• Đầu vào và đầu ra là các số nguyên (chương trình của bạn ít nhất phải hỗ trợ đầu vào và đầu ra trong phạm vi từ 1 đến 32767)
• Đầu vào không hợp lệ (0, số float, chuỗi, giá trị âm, v.v.) có thể dẫn đến đầu ra không dự đoán được, lỗi hoặc (không) hành vi được xác định. Trong A163252 , $a(0)$ được định nghĩa là 0. Đối với thử thách này, chúng tôi sẽ bỏ qua điều này.
• Mặc định I / O quy tắc áp dụng.
• Lỗ hổng mặc định bị cấm.
• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất tính bằng byte sẽ thắng

Lưu ý cuối cùng

Xem các câu hỏi PP & CG liên quan (nhưng không bằng nhau) sau đây:

• Tìm mã Gray tiếp theo (đầu vào và đầu ra ở dạng nhị phân)
• Tạo tất cả các mã màu xám có độ dài n

Stax , 19 17 byte

êÑ{╚α8è╙mc┼σ▀»É▲ü

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

Nó dừng hoạt động tại một số điểm sau miền được chỉ định do lặp lại chỉ số bit được mã hóa cứng. (32767)

Giải nén, không được chỉnh sửa và nhận xét, nó trông như thế này.

z0,         push an empty array, literal zero, and the input, in that order
             - the zero represents the last calculated value in the sequence
             - the array contains all the previous ones
D           repeat the rest of the program n times (from input)
  +         append the last calculated value to the array
  17r       [0 .. 16] (these are the bit indices necessary to cover the input range)
  {|2nH|^m  calculate candidate values; previous value with each of these bits toggled 
  n-        remove all values previously calculated
  |m        keep the minimum candidate remaining

Chạy cái này

JavaScript (ES6), 65 byte

1 chỉ mục.

n=>{for(o=p=[k=1];o[k]|~-(i=p^k)&i?k++:k=o[p=k]=!!n--;);return p}

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

Đã bình luận

n => {                  // n = index of requested term
  for(                  // for loop:
    o =                 //   o = storage object for the terms of the sequence
    p =                 //   p = last term found in the sequence
      [k = 1];          //   k = current term
    o[k] |              //   if k was already encountered
    ~-(i = p ^ k) & i ? //   or (p XOR k) has more than 1 bit set:
      k++               //     increment k
    :                   //   else:
      k = o[p = k]      //     set o[k], set p to k
        = !!n--;        //     stop if n is equal to 0 or set k to 1; decrement n
  );                    // end of for()
  return p              // return p
}                       // end

Thạch , 26 20 byte

ṀBLŻ2*^1ị$ḟ⁸Ṃ;
0Ç⁸¡Ḣ

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

Một chương trình đầy đủ lấy n làm đối số duy nhất. Hoạt động cho tất cả các trường hợp thử nghiệm. Cũng lưu ý rằng, mặc dù không bắt buộc, nó xử lý n = 0.

Giải trình

Liên kết người trợ giúp: tìm thuật ngữ tiếp theo và trả trước

Ṁ              | maximum of list so far
 B             | convert to binary
  L            | number of binary digits
   Ż           | 0..above number
    2*         | 2 to the power of each of the above
      ^        | exclusive or with...
       1ị$     | ... the most recent term in the list so far
          ḟ⁸   | filter out anything used already
            Ṃ  | find the minimum
             ; | prepend to existing list

Liên kết chính

0              | start with zero
 Ç             | call the above link
  ⁸¡           | and repeat n times
    Ḣ          | take the last term added

Java (JDK) , 142 138 124 123 132 130 98 byte

• tăng lên tài khoản để nhập, đã lưu một byte nhờ @ kevin-cruijssen
• chuyển bộ sưu tập sang mảng int nhờ vào @ olivier-grégoire

n->{int s[]=new int[9*n],j,k=0;for(;n-->0;s[k=j]++)for(j=0;s[++j]>0|n.bitCount(j^k)>1;);return k;}

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

Con trăn 2 , 81 byte

Lập chỉ mục 1

l=[0];p=0
exec"n=0\nwhile(p^n)&(p^n)-1or n in l:n+=1\np=n;l+=p,;"*input()
print p

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

Con trăn 2 , 79 byte

Điều này mất rất nhiều thời gian (9999 chưa kết thúc sau khi chạy cục bộ trong 7 phút)

l={0};p=0;n=input()
exec'p=min({p^2**k for k in range(n)}-l);l|={p};'*n
print p

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

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

Last@Nest[#~Join~{Min[BitXor[Last@#,2^Range[0,20]]~Complement~#]}&,{0},#]&

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

APL (Dyalog Extended) , 46 byte

{⍵⌷2∘{(~⍺∊⍵)∧1=≢⍸≠⌿↑⌽∘⊤¨⍺,⊃⌽⍵:⍵,⍺⋄⍵∇⍨⍺+1}⍣⍵⊢1}

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

Than , 65 byte

≔⁰θＦＮ«⊞υθ≔¹ηＷ¬‹θ⊗η≦⊗ηＷ∧›η¹∨¬＆θη№υ⁻θη≧÷²ηＷ№υ⁻｜θη＆θη≦⊗η≔⁻｜θη＆θηθ»Ｉθ

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

≔⁰θ

Khởi tạo kết quả về 0.

ＦＮ«

Vòng lặp nthời gian.

⊞υθ

Lưu kết quả trước đó để chúng tôi không sử dụng lại.

≔¹ηＷ¬‹θ⊗η≦⊗η

Tìm bit cao nhất trong kết quả trước đó.

Ｗ∧›η¹∨¬＆θη№υ⁻θη≧÷²η

Trong khi bit đó lớn hơn 1, nếu bit được đặt trong kết quả trước đó, hãy thử trừ bit đó để xem kết quả có phải là kết quả không nhìn thấy hay không. Điều này đảm bảo rằng các kết quả tiềm năng được thử theo thứ tự tăng dần của giá trị.

Ｗ№υ⁻｜θη＆θη≦⊗η

Bây giờ hãy thử XORing bit đó với kết quả trước đó, nhân đôi bit cho đến khi tìm thấy kết quả không nhìn thấy. Điều này xử lý các trường hợp khi một bit cần được thiết lập, một lần nữa theo thứ tự giá trị tăng dần, nhưng cũng là trường hợp khi bit đáng kể nhất cần được chuyển đổi, điều mà vòng lặp trước không bận tâm để kiểm tra (bởi vì nó là golfer để kiểm tra ở đây). Nếu vòng lặp trước tìm thấy kết quả không nhìn thấy thì vòng lặp này không bao giờ chạy; nếu không thì vòng lặp này sẽ vô dụng kiểm tra lại các kết quả đó.

≔⁻｜θη＆θηθ

Cập nhật kết quả bằng cách thực sự XOR bit với nó.

»Ｉθ

Xuất kết quả cuối cùng ở cuối vòng lặp.

05AB1E , 21 20 18 byte

ÎFˆ∞.Δ¯θy^bSO¯yå_*

Khá kém hiệu quả, vì vậy đầu vào càng lớn thì càng mất nhiều thời gian để có kết quả. Không làm việc cho đầu vào 0là tốt, mặc dù.

Dùng thử trực tuyến hoặc xác minh đầu tiên$n$điều khoản .

Giải trình:

Î                # Push 0 and the input
 F               # Loop the input amount of times:
  ˆ              #  Pop the current number and add it to the global_array
  ∞.Δ            #  Inner loop starting at 1 to find the first number which is truthy for:
     ¯θy^        #   XOR the last number of the global_array with the loop-number `y`
         b       #   Convert it to binary
          SO     #   Sum it's binary digits
     ¯yå_        #   Check if the loop-number `y` is NOT in the global_array yet
            *    #   Multiply both (only if this is 1 (truthy), the inner loop will stop)
                 # (after the loops, output the top of the stack implicitly)

Haskell , 101 byte

import Data.Bits
(u!n)0=n
(u!n)m|q<-minimum[x|r<-[0..62],x<-[xor(2^r)n],notElem x u]=(n:u)!q$m-1
[]!0

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

Có vẻ xấu hổ khi chỉ phải nhập khẩu xor, nhưng tôi vẫn chưa tìm được cách giải quyết tốt. Tôi cũng tự hỏi nếu có một cách tốt hơn để thể hiện vòng lặp.

R , 90 byte

function(n){A=1
while(sum(A|1)<n)A=c(min((x=bitwXor(A[1],2^(0:30)))[x>0&!x%in%A]),A)
A[1]}

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