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

Đặt tất cả các số nguyên 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ố nguyên dương. Đây là thử thách thứ sáu trong loạt bài này (liên kết đến thử thách thứ nhất , thứ hai , thứ ba , thứ tư và thứ năm ).

Thử thách này có chủ đề Phục Sinh nhẹ (vì đó là Lễ Phục Sinh). Tôi lấy cảm hứng từ quả trứng ngỗng được trang trí rất cao (và theo ý kiến ​​cá nhân của tôi khá xấu xí).

Nó làm tôi nhớ đến vòng xoắn ốc Ulam , nơi tất cả các số nguyên dương được đặt trong một vòng xoắn ngược chiều kim đồng hồ. Vòng xoắn ốc này có một số tính năng thú vị liên quan đến số nguyên tố, nhưng điều đó không liên quan đến thử thách này.

Chúng ta có được sự hoán vị của các số nguyên dương nếu chúng ta lấy các số trong vòng xoắn ốc Ulam và theo dõi tất cả các số nguyên theo vòng xoắn theo chiều kim đồng hồ , bắt đầu từ 1. Bằng cách này, chúng ta có được:

1, 6, 5, 4, 3, 2, 9, 8, 7, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 25, 24, 23, etc.

Nếu bạn vẽ cả hai hình xoắn ốc, bạn sẽ nhận được một loại lưới vô hạn (vỏ trứng) ( lưu ý tham chiếu Đơn hàng mới ở đó ).

Trình tự này có mặt trong OEIS dưới số A090861 . Vì đây là một thách thức "chuỗi thuần", nên nhiệm vụ là xuất $a(n)$ cho $n$ cho trước làm đầu vào, trong đó là A090861 .$a(n)$

Bài tập

Cho một đầu vào số nguyên$n$ , đầu ra$a(n)$ ở định dạng số nguyên, trong đó$a(n)$ làA090861.

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) = 6$ , 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     |  3
20    |  10
50    |  72
78    |  76
123   |  155
1234  |  1324
3000  |  2996
9999  |  9903
29890 |  29796

Quy tắc

• Đầu vào và đầu ra là số nguyên.
• Chương trình của bạn ít nhất phải hỗ trợ đầu vào 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.
• 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

Thạch ,  16 14 11 10 9  8 byte

-1 cảm ơn Lynn (mod-2; logic KHÔNG; thêm vào bản thân: Ḃ¬+-> bitwise HOẶC với 1 |1:)

|1×r)ẎQi

Một liên kết đơn nguyên chấp nhận một số nguyên, nmang lại một số nguyên , a(n).

$\lceil\frac n2\rceil$

½‘|1×rƲ€ẎQi$\lceil\frac{\lfloor\sqrt n\rfloor+1}2\rceil$

Làm sao?

Hoán vị là lấy các số tự nhiên trong các lát có độ dài đảo ngược [1,5,3,11,5,17,7,23,9,29,11,35,13,...]- các số nguyên dương lẻ xen kẽ với các số nguyên dương đồng dạng với năm modulo sáu, tức là [1, 2*3-1, 3, 4*3-1, 5, 6*3-1, 7, 8*3-1, 9, ...].

Điều này cũng giống như ghép và sau đó lặp lại các phạm vi đảo ngược [1..x]trong đó xtổng tích lũy của các độ dài lát cắt này (tức là tối đa của mỗi lát) - [1,6,9,20,25,42,49,72,81,110,121,156,169,...], đó là các số nguyên lẻ bình phương xen kẽ với các số chẵn nhân với số nhân của chúng, tăng lên [1*1, 2*3, 3*3, 4*5, 5*5, 6*7, 7*7,...].

Vì sự khác biệt đều lớn hơn 1, chúng ta có thể lưu một byte (đảo ngược) bằng cách xây dựng phạm vi [x..k]trực tiếp, trong đó kchỉ mục 1 được lập chỉ mục của lát cắt.

$P(n) = v \iff P(v) = n$n|1×r)ẎQị@n|1×r)ẎQi

|1×r)ẎQi - Link: integer, n       e.g. 10
    )    - for each k in [1..n]:  vs = [ 1, 2, 3, 4, 5, 6, 7, 8, 9,10]
|1       -   bitwise-OR (k) with 1     [ 1, 3, 3, 5, 5, 7, 7, 9, 9,11]
  ×      -   multiply (by k)           [ 1, 6, 9,20,25,42,49,72,81,110]
   r     -   inclusive range (to k)    [[1],[6..2],[9..3],[20..4],...,[110..10]]
     Ẏ   - tighten                     [1,6,5,4,3,2,9,8,7,6,5,4,3,20,...,4,......,110,...,10]
      Q  - de-duplicate                [1,6,5,4,3,2,9,8,7,20,...,10,......,110,...82]
       i - first index with value (n)  20

JavaScript (ES7),  46 45  41 byte

Chỉ số 0.

n=>((x=n**.5+1&~1)*2-(n<x*x+x)*4+3)*x+1-n

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

Làm sao?

Điều này dựa trên công thức 1 chỉ mục được sử dụng trong các chương trình ví dụ về A090861 .

$x_n$ là chỉ số lớp của hình xoắn ốc, bắt đầu bằng$0$ cho hình vuông trung tâm:

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

$k_n$$6$$-2$

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

$a_n$

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

Có thể được dịch thành:

n=>8*(x=(n-1)**.5+1>>1)*x+(n<=4*x*x+2*x?-2:6)*x+2-n

Làm cho nó 0 chỉ mục tiết kiệm 5 byte ngay lập tức:

n=>8*(x=n**.5+1>>1)*x+(n<4*x*x+2*x?-2:6)*x+1-n

Công thức có thể được đơn giản hóa hơn nữa bằng cách sử dụng:

có thể được biểu thị như sau:

x=n**.5+1&~1

dẫn tới:

n=>2*(x=n**.5+1&~1)*x+(n<x*x+x?-1:3)*x+1-n

và cuối cùng:

n=>((x=n**.5+1&~1)*2-(n<x*x+x)*4+3)*x+1-n

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

8(s=⌊(⌊Sqrt[#-1]⌋+1)/2⌋)^2-#+2+If[#<=4s^2+2s,-2,6]s&

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

MATL , 12 11 byte

Eq1YL!tPG=)

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

Rất kém bộ nhớ. Chuẩn bị X^klàm cho nó hiệu quả hơn .

C # (Trình biên dịch tương tác Visual C #) , 67 byte

n=>8*(x=(int)Math.Sqrt(--n)+1>>1)*x+(n<4*x*x+2*x?-2:6)*x+1-n;int x;

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

Python 3,8, 104 74 65 60 57 byte

lambda n:(-2,6)[n>4*(x:=(n**.5+1)//2)*x+2*x]*x+2+~n+8*x*x

Chỉnh sửa: Cảm ơn Johnathan Allan vì đã nhận được từ 74 đến 57 byte!

Giải pháp này sử dụng lập chỉ mục dựa trên 0.

Python 3.8 (tiền phát hành) , 53 byte

Một cổng trực tiếp của câu trả lời JavaScript của Arnauld , hãy đưa ra câu trả lời đó và / hoặc câu trả lời Mathicala của J42161217 và / hoặc câu trả lời Python của Kapocs :)

lambda n:((x:=int(n**.5+1)&-2)*2-(n<x*x+x)*4+3)*x+1-n

Chỉ số 0.

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

Befunge, 67 57 byte

Giải pháp này giả định lập chỉ mục dựa trên 0 cho các giá trị đầu vào.

p&v-*8p00:+1g00:<
0:<@.-\+1*g00+*<|`
0g6*\`!8*2+00g4^>$:0

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

Giải trình

Chúng tôi bắt đầu bằng cách tính "bán kính" mà tại đó đầu vào n được tìm thấy với một vòng lặp:

radius = 0
while n > 0
  radius += 1
  n -= radius*8

Ở cuối vòng lặp, giá trị trước đó của n là phần bù vào hình xoắn ốc tại bán kính đó:

offset = n + radius*8

Sau đó, chúng tôi có thể xác định xem chúng tôi ở phần trên cùng hoặc dưới cùng của hình xoắn ốc như sau:

bottom = offset >= radius*6

Và một khi chúng ta có tất cả các chi tiết này, giá trị xoắn ốc được tính bằng:

value = ((bottom?10:2) + 4*radius)*radius + 1 - offset

Bán kính là giá trị duy nhất mà chúng ta cần lưu trữ dưới dạng "biến", giới hạn nó ở giá trị tối đa 127 trong Befunge-93, vì vậy thuật toán này có thể xử lý các đầu vào lên tới 65024.

Japt , 15 byte

Giải pháp của Jonathan Jonathan Jelly. 1 chỉ mục.

gUòȲ+X*v)õÃcÔâ

Thử nó

gUòȲ+X*v)õÃcÔâ     :Implicit input of integer U
g                   :Index into
 Uò                 :  Range [0,U]
   È                :  Map each X
    ²               :    Square X
     +X*            :    Add X multiplied by
        v           :    1 if X is divisible by 2, 0 otherwise
         )          :    Group result
          õ         :    Range [1,result]
           Ã        :  End map
            c       :  Flatten
             Ô      :    After reversing each
              â     :  Deduplicate

C ++ (gcc) , 88 byte

#import<cmath>
int a(int n){int x=(sqrt(n-1)+1)/2;return x*(8*(x+(n>4*x*x+2*x))-2)+2-n;}

1 chỉ số; sử dụng công thức trên trang OEIS, nhưng được thao tác để lưu một vài byte.

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