Bạn nên viết chương trình hoặc hàm lấy số nguyên không âm Nlàm đầu vào và đầu ra hoặc trả về hai số nguyên (âm, không hoặc dương) Xvà Y.

Các số nguyên có nghĩa là theo nghĩa toán học vì có vô số trong số chúng.

Các chức năng thực hiện phải được tính toán . Điều này có nghĩa là với mỗi Nnó phải xuất ra một X Ycặp khác nhau và mỗi X Ycặp nên được xuất ra cho một số đầu vào, Ntức là tất cả các cặp sau đây sẽ được xuất ra cho một số N:

                 ...
    ┌─────┬─────┬────┬────┬────┐
    │-2 -2│-2 -1│-2 0│-2 1│-2 2│
    ├─────┼─────┼────┼────┼────┤
    │-1 -2│-1 -1│-1 0│-1 1│-1 2│
    ├─────┼─────┼────┼────┼────┤
... │0 -2 │0 -1 │0 0 │0 1 │0 2 │ ...
    ├─────┼─────┼────┼────┼────┤
    │1 -2 │1 -1 │1 0 │1 1 │1 2 │
    ├─────┼─────┼────┼────┼────┤
    │2 -2 │2 -1 │2 0 │2 1 │2 2 │
    └─────┴─────┴────┴────┴────┘
                 ...

Lưu ý rằng U Vvà V Ulà các cặp khác nhau nếu U!=V.

Chi tiết

• Nếu ngôn ngữ của bạn không hỗ trợ các số nguyên lớn tùy ý thì điều đó tốt nhưng thuật toán của bạn sẽ hoạt động với kiểu dữ liệu số nguyên lớn tùy ý. Mã của bạn vẫn nên hỗ trợ các giá trị đầu vào ít nhất 2^31-1.
• Nếu bạn chọn in hoặc trả lại đầu ra dưới dạng chuỗi, không có dấu hiệu 0hoặc +dấu hiệu hàng đầu nào được phép. Nếu không, đại diện số nguyên tiêu chuẩn của ngôn ngữ của bạn là tốt.

Thí dụ

Nếu nhiệm vụ là tạo một hàm tính toán lấy một số nguyên không âm Nvà xuất ra một số nguyên thì Xmột giải pháp có thể là hàm

if (input mod 2 == 0) return N/2 else return -(N+1)/2,

thực hiện trong một số ngôn ngữ. Hàm này trả về X = 0 -1 1 -2 2...cho N = 0 1 2 3 4....

Bình thường, 15

u,-HyeGhGjQ2,ZZ

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

u             reduce
                lambda G,H:    [implicit]
  ,-HyeGhG         (H-2*G[-1],G[0])
  jQ2           base(input(),2)
  ,ZZ           (0,0)
              print result     [implicit]

Bản dịch Python:

g=lambda Z,n:(n-2*Z[1],Z[0])
print reduce(g,binlist(input()),(0,0))

hoặc lặp đi lặp lại:

(x,y)=(0,0)
for b in binlist(input()):
    (x,y)=(b-2*y,x)
print (x,y)

trong đó binlistchuyển đổi một số thành một danh sách các chữ số như thế nào binlist(4) = [1,0,0].

Vì vậy, làm thế nào để làm việc này? Nó diễn giải các chữ số nhị phân của số là hai số xen kẽ trong hai số âm cơ bản giống như trong giải pháp Python của tôi .$n$

Các số nhị phân tương ứng với các cặp ( x , y ) = ( b 0 - 2 b 2 + 4 b 4 - 8 b 6 + ⋯ , b 1 - 2 b 3 + 4 b 5

$$n=\dots b_5 b_4 b_3 b_2 b_1 b_0$$ $$(x,y) = (b_0 - 2 b_2 + 4 b_4 - 8 b_6 + \cdots, b_1 - 2 b_3 + 4 b_5 - 8 b_7 + \cdots).$$

Nếu chúng ta chưa xử lý chữ số cuối cùng của n , chúng tôi có tất cả các chỉ số cao hơn bằng $ 1 $, n ' = ... b 5 b 4 b 3 b 2 b 1 tương ứng với cặp ( x ' , y ' ) = ( b 1 - 2 b 3 + 4 b 5 - 8 b 7 + ⋯ , b $b_0$$n$

$$n'=\dots b_5 b_4 b_3 b_2 b_1$$ $$(x',y') = (b_1 - 2 b_3 + 4 b_5 - 8 b_7 + \cdots, b_2 - 2 b_4 + 4 b_6 - 8 b_8 + \cdots).$$

Sau đó chúng ta có thể biểu thị các giá trị mới sau khi được đọc theo các giá trị cũ$b_0$

$$(x,y) = (b_0 - 2y', x').$$

$(x,y) \to (b - 2y, x)$$b$$n$$(x,y)$ xuất phát từ việc trích xuất các chữ số của nó.

CJam, 24 22 21 byte

Bộ não của tôi gặp khó khăn trong việc hiểu toán học mà các giải pháp khác đang sử dụng. Nhưng bộ não của tôi chắc chắn hiểu nhị phân, vì vậy đây là một linh hồn dựa trên thao tác bit!

li4b2fmd2/z{)(\2b^}%p

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

Giải trình

Cách tiếp cận này coi đầu vào là hai giá trị nhị phân xen kẽ, một giá trị cho mỗi số đầu ra. Tất cả trừ bit có ý nghĩa nhỏ nhất của mỗi mã hóa một cường độ và bit có ý nghĩa nhỏ nhất báo hiệu có hay không lấy phần bù bit của độ lớn này. Trong triển khai này, các bit có vị trí lẻ tương ứng với số đầu ra đầu tiên (và các bit có vị trí chẵn tương ứng với số thứ hai) và LSB của các 0tín hiệu để lấy phần bù.

Ví dụ, được cung cấp một đầu vào 73, không xen kẽ biểu diễn nhị phân của 1001001bsản phẩm0 1|0 (các bit có vị trí lẻ) và 1 0 0|1(các bit có vị trí chẵn). Giá trị đầu tiên có độ lớn 01b = 1và nên được bổ sung cho giá trị cuối cùng ~1 = -2và giá trị thứ hai có độ lớn 100b = 4và không nên được bổ sung.

Chứng minh không chính thức

Tôi đã thực hiện một chương trình thử nghiệm đặt từng đầu vào từ 0 đến một số do người dùng chỉ định trừ đi một ở vị trí đầu ra của nó trên lưới 2D. Bạn có thể thử nó trực tuyến là tốt. Đây là một đầu ra của chương trình này cho thấy cách bản đồ thuật toán0-99 :

      -8 -7 -6 -5 -4 -3 -2 -1  0  1  2  3  4  5  6  7  8

-8                      92 84 86 94                     
-7                      88 80 82 90                     
-6                      76 68 70 78                     
-5                   96 72 64 66 74 98                  
-4                60 52 28 20 22 30 54 62               
-3                56 48 24 16 18 26 50 58               
-2                44 36 12  4  6 14 38 46               
-1                40 32  8  0  2 10 34 42               
 0                41 33  9  1  3 11 35 43               
 1                45 37 13  5  7 15 39 47               
 2                57 49 25 17 19 27 51 59               
 3                61 53 29 21 23 31 55 63               
 4                   97 73 65 67 75 99                  
 5                      77 69 71 79                     
 6                      89 81 83 91                     
 7                      93 85 87 95                     
 8                                                      

Các mô hình điền có vẻ hơi kỳ lạ, nhưng thực tế nó là tính từ! Với mỗi sức mạnh liên tiếp là 4, nó sẽ lấp đầy một hình vuông với gấp đôi chiều dài cạnh trước. Ví dụ, đây là cách bản đồ thuật toán 0-15:

      -2 -1  0  1  2

-2    12  4  6 14   
-1     8  0  2 10   
 0     9  1  3 11   
 1    13  5  7 15   
 2                  

Điều này tạo nên hình vuông 4 x 4 ở giữa hình vuông 8 x 8 0-63:

      -4 -3 -2 -1  0  1  2  3  4

-4    60 52 28 20 22 30 54 62   
-3    56 48 24 16 18 26 50 58   
-2    44 36 12  4  6 14 38 46   
-1    40 32  8  0  2 10 34 42   
 0    41 33  9  1  3 11 35 43   
 1    45 37 13  5  7 15 39 47   
 2    57 49 25 17 19 27 51 59   
 3    61 53 29 21 23 31 55 63   
 4                              

Tạo nên hình vuông 8x8 ở giữa hình vuông 16x16 của 0-255:

         -8  -7  -6  -5  -4  -3  -2  -1   0   1   2   3   4   5   6   7   8

 -8     252 244 220 212 124 116  92  84  86  94 118 126 214 222 246 254    
 -7     248 240 216 208 120 112  88  80  82  90 114 122 210 218 242 250    
 -6     236 228 204 196 108 100  76  68  70  78 102 110 198 206 230 238    
 -5     232 224 200 192 104  96  72  64  66  74  98 106 194 202 226 234    
 -4     188 180 156 148  60  52  28  20  22  30  54  62 150 158 182 190    
 -3     184 176 152 144  56  48  24  16  18  26  50  58 146 154 178 186    
 -2     172 164 140 132  44  36  12   4   6  14  38  46 134 142 166 174    
 -1     168 160 136 128  40  32   8   0   2  10  34  42 130 138 162 170    
  0     169 161 137 129  41  33   9   1   3  11  35  43 131 139 163 171    
  1     173 165 141 133  45  37  13   5   7  15  39  47 135 143 167 175    
  2     185 177 153 145  57  49  25  17  19  27  51  59 147 155 179 187    
  3     189 181 157 149  61  53  29  21  23  31  55  63 151 159 183 191    
  4     233 225 201 193 105  97  73  65  67  75  99 107 195 203 227 235    
  5     237 229 205 197 109 101  77  69  71  79 103 111 199 207 231 239    
  6     249 241 217 209 121 113  89  81  83  91 115 123 211 219 243 251    
  7     253 245 221 213 125 117  93  85  87  95 119 127 215 223 247 255    
  8                                                                        

Con trăn 2, 49

Chỉnh sửa: Cải thiện thành 49 bằng cách sử dụng đệ quy một bước tốt hơn cho cơ sở -2.

def f(n):x,y=n and f(n/2)or(0,0);return n%2-2*y,x

Đây là phiên bản Pyth sử dụng reduce.

Chỉnh sửa: Cải thiện thành 52 bằng cách chuyển sang cơ sở -2 từ ternary cân bằng .

Con trăn 2, 52

h=lambda n:n and n%2-2*h(n/4)
lambda n:(h(n),h(n/2))

---

Con trăn 2, 54

h=lambda n:n and-~n%3-1+3*h(n/9)
lambda n:(h(n),h(n/3))

Điều này sử dụng xen kẽ chữ số như giải pháp của Runer112 , nhưng với ternary cân bằng thay vì nhị phân đã ký. Python không có chuyển đổi cơ sở tích hợp, vì vậy mã thực hiện theo cách đệ quy.

Hàm trợ giúp h( 3thay cho vị trí 9) lấy một số tự nhiên và chuyển đổi nó từ ternary sang ternary cân bằng với các thay thế chữ số

0 -> 0 
1 -> +1
2 -> -1

Vì vậy, ví dụ 19, là 201 trong cơ sở, trở thành (-1) (0) (+ 1) trong ternary cân bằng, đó là (-1) * 3 ^ 2 + (0) * 3 ^ 1 + (+ 1) * 3 ^ 0 = -8.

Ternary cân bằng đủ để mã hóa mọi số nguyên, và do đó đưa ra ánh xạ từ số tự nhiên sang số nguyên.

Để ánh xạ tới các cặp số nguyên, chúng tôi xen kẽ các chữ số trong n. Để làm như vậy, chúng tôi đã hxem xét mọi chữ số khác bằng cách thực hiện n/9như bước đệ quy hơn là n/3. Sau đó, đối với một tọa độ, chúng ta thay đổi ntheo cách chia tầng 3.

Dưới đây là 81 đầu ra đầu tiên, bao gồm vùng [-4,4] ^ 2.

0 (0, 0)
1 (1, 0)
2 (-1, 0)
3 (0, 1)
4 (1, 1)
5 (-1, 1)
6 (0, -1)
7 (1, -1)
8 (-1, -1)
9 (3, 0)
10 (4, 0)
11 (2, 0)
12 (3, 1)
13 (4, 1)
14 (2, 1)
15 (3, -1)
16 (4, -1)
17 (2, -1)
18 (-3, 0)
19 (-2, 0)
20 (-4, 0)
21 (-3, 1)
22 (-2, 1)
23 (-4, 1)
24 (-3, -1)
25 (-2, -1)
26 (-4, -1)
27 (0, 3)
28 (1, 3)
29 (-1, 3)
30 (0, 4)
31 (1, 4)
32 (-1, 4)
33 (0, 2)
34 (1, 2)
35 (-1, 2)
36 (3, 3)
37 (4, 3)
38 (2, 3)
39 (3, 4)
40 (4, 4)
41 (2, 4)
42 (3, 2)
43 (4, 2)
44 (2, 2)
45 (-3, 3)
46 (-2, 3)
47 (-4, 3)
48 (-3, 4)
49 (-2, 4)
50 (-4, 4)
51 (-3, 2)
52 (-2, 2)
53 (-4, 2)
54 (0, -3)
55 (1, -3)
56 (-1, -3)
57 (0, -2)
58 (1, -2)
59 (-1, -2)
60 (0, -4)
61 (1, -4)
62 (-1, -4)
63 (3, -3)
64 (4, -3)
65 (2, -3)
66 (3, -2)
67 (4, -2)
68 (2, -2)
69 (3, -4)
70 (4, -4)
71 (2, -4)
72 (-3, -3)
73 (-2, -3)
74 (-4, -3)
75 (-3, -2)
76 (-2, -2)
77 (-4, -2)
78 (-3, -4)
79 (-2, -4)
80 (-4, -4)

Một mã hóa thay thế với tưởng tượng quý xuất hiện lâu hơn, mặc dù nó rất đẹp.

Con trăn 2, 63

h=lambda n:n and n%4+2j*h(n/4)
lambda n:(h(n).real,h(n).imag/2)

Trong một ngôn ngữ có ít xử lý chuyển đổi phức tạp hơn, đây có thể là một cách tiếp cận tốt hơn. Nếu chúng ta có thể xuất số phức, chúng ta có thể làm:

Con trăn 2, 38

f=lambda n:n and n%2+n/2%2*1j-2*f(n/4)

Python 2, 98 byte

Hãy bắt đầu với một cách tiếp cận đơn giản:

def f(N):
 x=a=0;b=2
 while N:x+=1j**b;b+=a<1;a=a or b/2;N-=1;a-=1
 return int(x.real),int(x.imag)

Nó chỉ tạo thành một hình xoắn ốc hình chữ nhật N đơn vị dài trên lưới 2d, bắt đầu từ điểm gốc và trả về tọa độ của điểm cuối cùng.

Hàm này là tính từ:

• Mỗi điểm có thể được bao phủ, cho một vòng xoắn đủ dài
• Mỗi điểm sẽ chỉ được giao nhau bởi hình xoắn ốc một lần

Hình xoắn ốc trông giống như thế này (ngoại trừ bắt đầu từ 0 thay vì 1):

đc, 49

[1+2~2*1-*n]sm?dsa8*1+v1-2/dd1+*2/lar-dlmx32P-lmx

Điều này bắt đầu bằng cách sắp xếp các số nguyên không âm trên lưới, do đó:

..| 
4 | 14
3 |  9 13
2 |  5  8 12
1 |  2  4  7 11
0 |  0  1  3  6 10
Y +-----------------
  X  0  1  2  3  4 ...

Lưu ý rằng làm thế nào các vị trí lưới được điền theo đường chéo với tăng N. Lưu ý dòng Y = 0 chứa dãy số tam giác, được cho bởi N = X(X+1)/2 . Đây là một phương trình bậc hai được giải bằng cách sử dụng công thức bình thường, chỉ sử dụng gốc + ve, để chúng ta có thể xác định X từ N khi Y = 0. Tiếp theo là một số xáo trộn số học đơn giản để cung cấp {X, Y} duy nhất cho mỗi N.

Điều này cung cấp chất lượng tính toán cần thiết, nhưng X và Y chỉ không âm, nhưng câu hỏi yêu cầu tất cả các số nguyên có thể. Vì vậy, X và Y được ánh xạ bằng cách sử dụng ((t+1)/2)*((t+1)~2*2-1)để cung cấp cho tất cả các số nguyên có thể.

dccó số chính xác tùy ý, vì vậy phạm vi đầu vào 2^31-1là không có vấn đề. Cũng lưu ý rằng độ chính xác mặc định là 0 chữ số thập phân sqrt()và/ làm tròn xuống mà là hành vi cần thiết ở đây.

Đầu ra:

$ for i in {0..10}; do dc biject.dc <<< $i; echo; done
0 0
0 -1
-1 0
0 1
-1 -1
1 0
0 -2
-1 1
1 -1
-2 0
0 2
$

Matlab, 54 byte

n=input('')+1;[i,j]=find(spiral(2*n)==n);disp([i,j]-n)

Chìa khóa ở đây là spiral, điều này tạo ra một ma trận xoắn ốc có kích thước tùy ý.

spiral(3)

trả lại

ans =

 7     8     9
 6     1     2
 5     4     3

spiral$4n^2$$n \simeq 10^4$$n \simeq 10^5$$2.9\cdot 10^{11}$$n=2^{32}$

Haskell, 78 74 byte

(concat[[(x,i-x),(x,x-1-i),(-1-x,x-1-i),(-1-x,i-x)]|i<-[0..],x<-[0..i]]!!)

Chạy thử nghiệm:

*Main> mapM_ (print . (concat[[(x,i-x),(x,x-1-i),(-1-x,x-1-i),(-1-x,i-x)]|i<-[0..],x<-[0..i]]!!) ) [0..20]
(0,0)
(0,-1)
(-1,-1)
(-1,0)
(0,1)
(0,-2)
(-1,-2)
(-1,1)
(1,0)
(1,-1)
(-2,-1)
(-2,0)
(0,2)
(0,-3)
(-1,-3)
(-1,2)
(1,1)
(1,-2)
(-2,-2)
(-2,1)
(2,0)

Cách thức hoạt động: liệt kê tất cả các cặp trong góc phần tư thứ nhất theo thứ tự sau

  |
 2| #4
  |
 1| #2  #5
  | 
 0| #1  #3  #6
  +---------------
     0   1   2   3 

phản chiếu từng điểm vào các góc phần tư khác để tạo danh sách gồm 4 danh sách thành phần. Ghép tất cả vào một danh sách và lấy nphần tử thứ.

Chỉnh sửa: hàm không cần tên, toán được sắp xếp lại. biểu thức.

Haskell , 50 byte

(0!).succ
l!n=(last$(!).succ:[(,)|odd n])l$div n 2

Hãy thử trực tuyến hoặc thử với nghịch đảo của nó!

Bị đánh cắp

ntoN2 n = 0 ! (n + 1)

xCounter ! remainingNum
  | odd remainingNum = (xCounter, div remainingNum 2)
  | otherwise        = (xCounter + 1) ! div remainingNum 2

Giải trình

Điều này sử dụng thực tế là mỗi $(x,y) \in \mathbb{N}^2$ có thể được ánh xạ 1 đến 1 $2^x \cdot (2\cdot y + 1) - 1 \in \mathbb{N}$. Toán tử trên (!)tính toán$x$bằng cách chia đầu vào miễn là nó chẵn, theo dõi với biến không khởi tạo l( xCounter). Khi chúng tôi đạt đến số chẵn, một phép chia số nguyêny .

Lưu ý rằng hàm thực tế f( ntoN2) tăng đầu vào trước khi bắt đầu với thủ tục.

05AB1E , 35 byte

>©DÝʒo®sÖ}àsÅÉʒ®sÖ}à<2÷‚εDÈi2÷ë>2÷(

Hãy thử trực tuyến! hoặc là bộ thử nghiệm

Giải trình

Xem xét

$$\begin{align*} f: \mathbb{N} &\longrightarrow \mathbb{N} \times \mathbb{N} \\ n&\longmapsto (x,y)\, , \end{align*}$$ Ở đâu $x$ là số lớn nhất để $2^x$ chia $n+1$, và ở đâu $2y+1$ là số lẻ lớn nhất chia $n+1$. Nghịch đảo của$f$ là đồ trang sức nổi tiếng $f^{-1}(x,y) = 2^x(2y+1)-1$.

Sau đó xem xét

$$\begin{align*} g: \mathbb{N} \times \mathbb{N} &\longrightarrow \mathbb{Z} \times \mathbb{Z} \\ (m,n)&\longmapsto (h(m),h(n))\, , \end{align*}$$ Ở đâu $$\begin{align*} h: \mathbb{N} &\longrightarrow \mathbb{Z} \\ n&\longmapsto \begin{cases}\frac n2, & n \text{ even}\\ -\frac{n+1}2, & n \text{ odd}\end{cases}\, . \end{align*}$$ Kể từ khi $f$, $g$ và $h$ tất cả đều là đồ trang sức, thành phần $g\circ f:\mathbb{N} \longrightarrow \mathbb{Z} \times \mathbb{Z}$ là một sự lựa chọn

Chương trình chỉ đơn giản là tính toán $g\circ f$.

>©DÝʒo®sÖ}àsÅÉʒ®sÖ}à<2÷‚εDÈi2÷ë>2÷( # Full program

                                    # Implicit input: Integer n
>©                                  # Compute n+1 and save it to the register
  DÝ                                # Duplicate n+1 and push the list [0,...,n+1]
    ʒo®sÖ}                          # Only keep those numbers x so that 2^x divides n+1
          à                         # Get maximum element in the list.
           sÅÉ                      # Swap so that n+1 is on top and push [1,3,5,...,n+1]
              ʒ®sÖ}                 # Only keep those numbers z which divides n+1
                   à<2÷             # Compute y = (z-1)/2
                       ‚            # Push the pair [x,y]
                        ε           # Apply the function h to x (and y):
                           i        # if...
                         DÈ         # x is even
                            2÷      # then compute x/2
                              ë>2÷( # else compute -(x+1)/2
                                    # Implicit output: [h(x),h(y)]

Toán học, 46

SortBy[Tuples[Range[2#]-#,2],Norm][[#]]&[#+1]&

Sắp xếp các vectơ định mức của chúng, sau đó lấy cái nthứ nhất.

JavaScript, 166 168 byte / ký tự

Cách tiếp cận mới bằng cách sử dụng một hình xoắn ốc hình chữ nhật như những người khác đang sử dụng.

function f(n){return b=Math,k=b.ceil((b.sqrt(n)-1)/2),t=2*k+1,m=b.pow(t,2),t+=4,m-t>n?(m-=t,m-t>n?(m-=t,m-t>n?[k,k-(m-n-t)]:[-k+(m-n),k]):[-k,-k+(m-n)]):[k-(m-n),-k]}

Tôi đã sử dụng câu trả lời này trên Math.SE, đã dịch nó sang JS và nén nó bằng UglifyJS .

Cách tiếp cận này không sử dụng bất kỳ vòng lặp cũng như không tạo ra xoắn ốc theo bất kỳ cách nào.

Bởi vì tọa độ của hình xoắn ốc bao trùm tất cả các số nguyên, hàm có tính chất sinh học theo nghĩa $f:\mathbb{N}^0\rightarrow \mathbb{Z}^2$.

Cập nhật: Đã lưu 2 ký tự bằng cách lưu trữ Mathtrong b.

Cập nhật 2: Thay thế t-=1bằng t+=4để khắc phục sự cố gây ra$f(0)=f(8)$. Điều này không tạo ra một vòng xoắn nữa nhưng hoạt động cho tất cả các số nguyên không âm$\mathbb{N}^0$ (tất cả các số tự nhiên bao gồm $0$).