Anda harus menulis sebuah program atau fungsi yang menggunakan integer non-negatif Nsebagai input dan output atau mengembalikan dua integer (negatif, nol atau positif) Xdan Y.

Bilangan bulat dimaksudkan dalam arti matematika karena ada banyak dari mereka.

Fungsi yang diimplementasikan harus bijective . Ini berarti bahwa untuk setiap pasangan harus Nmengeluarkan X Ypasangan yang berbeda dan setiap X Ypasangan harus dikeluarkan untuk beberapa input Nyaitu semua pasangan berikut harus dikeluarkan untuk beberapa 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 │
    └─────┴─────┴────┴────┴────┘
                 ...

Perhatikan bahwa U Vdan V Uadalah pasangan yang berbeda jika U!=V.

Detail

• Jika bahasa Anda tidak mendukung bilangan bulat besar yang sewenang-wenang, itu bagus, tetapi algoritme Anda harus bekerja dengan tipe data bilangan bulat besar yang sewenang-wenang. Kode Anda setidaknya harus mendukung nilai input 2^31-1.
• Jika Anda memilih untuk mencetak atau mengembalikan output sebagai string, tidak ada tanda 0atau +tanda-tanda yang diizinkan. Kalau tidak, representasi integer standar bahasa Anda baik-baik saja.

Contoh

Jika tugasnya adalah membuat fungsi bijective mengambil integer non-negatif Ndan output satu integer Xsolusi bisa menjadi fungsi

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

diimplementasikan dalam beberapa bahasa. Fungsi ini kembali X = 0 -1 1 -2 2...untuk N = 0 1 2 3 4....

Pyth, 15

u,-HyeGhGjQ2,ZZ

Cobalah online.

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

Terjemahan Python:

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

atau secara iteratif:

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

di mana binlistmengkonversi nomor ke daftar digit seperti binlist(4) = [1,0,0].

Jadi, bagaimana cara kerjanya? Ini menginterpretasikan digit biner dari angka sebagai dua angka yang disisipkan dalam basis negatif dua seperti dalam solusi Python saya .$n$

Angka biner sesuai dengan pasangan ( x , y ) = ( b 0 - 2 b 2 + 4 b 4 - 8 b 6 + ⋯ , b 1 - 2 b 3 + 4 b 5 - 8 b 7 + ⋯

Jika kita belum memproses digit terakhir dari n , kita akan memiliki semua indeks lebih tinggi dengan $ 1 $, n ′ = ... b 5 b 4 b 3 b 2 b 1 yang sesuai dengan pasangan ( x ′ , y ′ ) = ( b 1 - 2 b 3 + 4 b 5 - 8 b 7 + ⋯ , b 2 - 2 b $b_0$$n$

Kami kemudian dapat mengekspresikan nilai-nilai baru setelah dibaca dalam hal nilai-nilai lama$b_0$

Jadi, dengan berulang kali melakukan transformasi pada setiap bit b dari n berturut-turut , kami membangun titik ( x , y ) yang berasal dari mengekstraksi digit-digitnya.$(x,y) \to (b - 2y, x)$$b$$n$$(x,y)$

CJam, 24 22 21 byte

Otak saya kesulitan memahami matematika yang digunakan solusi lain. Tapi otak saya pasti mengerti biner, jadi inilah soultion yang didasarkan pada manipulasi bit!

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

Cobalah online.

Penjelasan

Pendekatan ini memperlakukan input sebagai dua nilai biner yang disisipkan, satu untuk setiap nomor output. Semua kecuali bit paling signifikan dari masing-masing mengkodekan sebuah magnitudo, dan bit paling signifikan menandakan apakah akan mengambil komplemen bitwise dari magnitudo ini. Dalam implementasi ini, bit yang diposisikan ganjil sesuai dengan nomor output pertama (dan bit yang diposisikan sama dengan yang kedua) dan LSB 0sinyal untuk mengambil komplemen.

Sebagai contoh, diberi input 73, uninterleaving representasi biner dari 1001001bmenghasilkan 0 1|0(bit posisi aneh) dan 1 0 0|1(bit posisi genap). Nilai pertama memiliki besaran 01b = 1dan harus dilengkapi dengan nilai akhir ~1 = -2, dan nilai kedua memiliki besarnya 100b = 4dan tidak harus dilengkapi.

Demonstrasi informal tentang kebenaran

Saya membuat program pengujian yang menempatkan setiap input dari nol ke angka yang ditentukan pengguna dikurangi satu di lokasi outputnya pada kisi 2D. Anda dapat mencobanya secara online juga. Berikut ini adalah output dari program ini yang menunjukkan bagaimana algoritma memetakan 0-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                                                      

Pola isian terlihat sedikit aneh, tetapi sebenarnya bersifat kata sifat! Dengan masing-masing kekuatan berturut-turut dari 4, itu mengisi persegi dengan dua kali lipat panjang sisi sebelumnya. Misalnya, inilah cara algoritma memetakan 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                  

Ini membentuk kotak 4x4 di tengah-tengah kotak 8x8 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                              

Yang membentuk kotak 8x8 di tengah kotak 16x16 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                                                                        

Python 2, 49

Sunting: Ditingkatkan ke 49 dengan menggunakan rekursi satu langkah yang lebih baik untuk basis -2.

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

Inilah versi Pyth yang digunakan reduce.

Sunting: Ditingkatkan ke 52 dengan beralih ke basis -2 dari terner seimbang .

Python 2, 52

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

Python 2, 54

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

Ini menggunakan interleaving digit seperti solusi Runer112 , tetapi dengan biner seimbang daripada biner yang ditandatangani. Python tidak memiliki konversi basis bawaan, jadi kode mengimplementasikannya secara rekursif.

Fungsi helper h(dengan 3menggantikan 9) mengambil angka alami dan mengubahnya dari ternary ke terner seimbang dengan penggantian digit

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

Jadi, misalnya, 19, yang merupakan pangkalan 201, menjadi (-1) (0) (+ 1) dalam terner seimbang, yaitu (-1) * 3 ^ 2 + (0) * 3 ^ 1 + (+ 1) * 3 ^ 0 = -8.

Terner seimbang cukup untuk menyandikan setiap bilangan bulat, sehingga memberikan pemetaan dari bilangan asli ke bilangan bulat.

Untuk memetakan ke pasangan bilangan bulat, kami interleave digit n. Untuk melakukannya, kita harus hmelihat setiap digit lainnya dengan melakukan n/9sebagai langkah rekursif daripada n/3. Kemudian, untuk satu koordinat, kami bergeser ndengan pembagian lantai dengan 3.

Berikut adalah 81 keluaran pertama, yang mencakup wilayah [-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)

Pengodean alternatif dengan kuartal-imajiner ternyata lebih lama, meskipun sangat cantik.

Python 2, 63

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

Dalam bahasa dengan penanganan konversi kompleks yang kurang kikuk, ini mungkin akan menjadi pendekatan yang lebih baik. Jika kita bisa menampilkan bilangan kompleks, kita bisa melakukan

Python 2, 38

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

Python 2, 98 byte

Mari kita mulai dengan pendekatan sederhana:

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)

Itu hanya membentuk Nunit spiral persegi panjang pada grid 2d, mulai dari asal, dan mengembalikan koordinat titik terakhir.

Fungsi ini bersifat obyektif karena:

• Setiap titik dapat ditutup, diberi spiral yang cukup panjang
• Setiap titik hanya akan berpotongan dengan spiral sekali

Spiral terlihat seperti ini (kecuali mulai dari 0 daripada 1):

dc, 49

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

Ini dimulai dengan mengatur bilangan bulat non-negatif pada kisi sebagai berikut:

..| 
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 ...

Perhatikan bahwa bagaimana posisi kisi diisi secara diagonal dengan kenaikan N. Perhatikan garis Y = 0 berisi urutan bilangan segitiga, yang diberikan oleh N = X(X+1)/2. Ini adalah persamaan kuadrat yang diselesaikan dengan menggunakan rumus normal, hanya menggunakan + ve root, sehingga kita dapat menentukan X dari N ketika Y = 0. Berikutnya adalah beberapa pengocokan aritmatika sederhana untuk memberikan {X, Y} unik untuk setiap N.

Ini memberikan kualitas bijective yang diperlukan, tetapi X dan Y hanya non-negatif, tetapi pertanyaannya membutuhkan semua bilangan bulat yang mungkin. Jadi X dan Y dipetakan menggunakan ((t+1)/2)*((t+1)~2*2-1)untuk memberikan semua kemungkinan integer.

dcmemiliki angka presisi yang berubah-ubah, sehingga rentang input 2^31-1tidak menjadi masalah. Perhatikan juga bahwa presisi standar adalah 0 angka desimal, dan sqrt()dan /bulatkan yang merupakan perilaku yang diperlukan di sini.

Keluaran:

$ 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)

Kuncinya di sini adalah spiral, ini menciptakan matriks spiral dari ukuran yang sewenang-wenang.

spiral(3)

kembali

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]]!!)

Uji coba:

*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)

Cara kerjanya: daftarkan semua pasangan di kuadran pertama dengan urutan sebagai berikut

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

mirror setiap titik ke kuadran lain untuk membuat daftar 4 daftar elemen. Gabungkan semuanya menjadi satu daftar dan ambil nelemen th.

Sunting: fungsi tidak perlu nama, matematika yang disusun ulang. ekspresi.

Haskell , 50 byte

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

Cobalah online atau coba dengan kebalikannya!

Tidak disatukan

ntoN2 n = 0 ! (n + 1)

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

Penjelasan

$(x,y) \in \mathbb{N}^2$$2^x \cdot (2\cdot y + 1) - 1 \in \mathbb{N}$(!)$x$lxCountery

Perhatikan bahwa fungsi aktual f( ntoN2) menambah input sebelum memulai dengan prosedur.

05AB1E , 35 byte

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

Cobalah online! atau sebagai Test suite

Penjelasan

Mempertimbangkan

$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)]

Mathematica, 46

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

Urutkan vektor norma mereka, lalu ambil yang nke-1.

JavaScript, 166 168 byte / karakter

Pendekatan baru menggunakan spiral persegi panjang seperti yang digunakan orang lain.

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]}

Saya menggunakan jawaban ini pada Math.SE, menerjemahkannya ke JS dan mengompresnya menggunakan UglifyJS .

Pendekatan ini tidak menggunakan loop apa pun juga tidak menciptakan spiral dengan cara apa pun.

$f:\mathbb{N}^0\rightarrow \mathbb{Z}^2$

Perbarui: Disimpan 2 karakter dengan menyimpan Mathdalam b.

t-=1t+=4$f(0)=f(8)$$\mathbb{N}^0$$0$