Bir negatif olmayan bir sayıyı alır, bir program ya da işlev yazmak gerekir Ngiriş ve çıkışları veya geri dönüş, iki tamsayı (negatif sıfır ya da pozitif) olarak Xve Y.

Tamsayılar matematiksel anlamda kastedilir, çünkü bunların çoğu sonsuzdur.

Uygulanan fonksiyonun önyargılı olması gerekir . Bu, her Nbiri için farklı bir X Yçift X Yüretmesi gerektiği ve bazı girdiler için her çiftin çıkması gerektiği anlamına gelir; Nyani, aşağıdaki çiftlerin bazıları için çıktı alınmalıdır 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 │
    └─────┴─────┴────┴────┴────┘
                 ...

Bunu unutmayın U Vve V Ueğer farklı çiftlerdir U!=V.

ayrıntılar

• Diliniz keyfi olarak büyük tamsayıları desteklemiyorsa sorun değil, ancak algoritmanızın keyfi büyük bir tamsayı veri türüyle çalışması gerekir. Kodunuz hala en azından giriş değerlerini desteklemelidir 2^31-1.
• Yazdırmak veya dize hiçbir lider olarak çıktı dönmesi için seçerseniz 0'ın veya+ işaretlere izin verilmez. Aksi halde, dilinizin standart tamsayı gösterimi iyi olur.

Örnek

Eğer görev negatif olmayan bir tamsayı alarak bir bijective işlevini yapmak olacaktır Nve çıkış tek tamsayıX çözüm bir çözüm olabilir.

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

bir dilde uygulanır. Bu işlev döndürür X = 0 -1 1 -2 2...için N = 0 1 2 3 4....

Pyth, 15

u,-HyeGhGjQ2,ZZ

Çevrimiçi deneyin.

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

Python çevirisi:

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

veya yinelemeli olarak:

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

burada binlistbasamaklı bir listesi gibi bir numara çevirirbinlist(4) = [1,0,0] .

Peki bu nasıl çalışıyor? sayısının ikili basamağını Python çözümümdeki gibi taban iki negatif iki ara eklenmiş sayı olarak yorumlar.$n$ .

İkili sayı çiftine karşılık gelir ( x , y ) = ( b 0 - 2 b 2 + 4 B 4 - 8 b 6 + ⋯ , b 1 - 2 b 3 + 4 b 5 - 8 b 7 + ⋯

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

Henüz son rakamı işlenen olmasaydı ait n , daha yüksek $ 1 $ bütün indeksleri var diye n ' = ... b 5 b 4 b 3'e b 2 b 1 çiftine karşılık gelen ( x ' , y ' ) = ( b 1 - 2 b 3 + 4 b 5 - 8 b 7 + ⋯ , b 2 - 2 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).$$

Daha sonra eski değerler açısından okunduğunda yeni değerleri ifade edebiliriz.$b_0$

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

Böylece, art arda dönüşümünü tekrar tekrar yaparak$(x,y) \to (b - 2y, x)$$b$$n$$(x,y)$

CJam, 24 22 21 bayt

Beynim, diğer çözümlerin kullandığı matematiği anlamakta zorlanıyor. Ama beynim kesinlikle ikiliyi anlıyor, işte biraz manipülasyona dayanan bir ruh!

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

Çevrimiçi deneyin.

açıklama

Bu yaklaşım, girişi, her çıkış numarası için bir tane olmak üzere, iki eklenmiş ikilik değer olarak ele alır. Her birinin en az anlamlı biti hariç tümü bir büyüklüğü kodlar ve en az önemli biti, bu büyüklüğün bitsel tamamlayıcısını alıp almamaya işaret eder. Bu uygulamada, tek konumlu bitler birinci çıktı numarasına karşılık gelir (ve çift konumlu bitler ikinciye karşılık gelir) ve0 tamamlayıcıyı almak için sinyallerin .

Örneğin, bir girdi 73verilirse, 1001001büretimin 0 1|0(tek pozisyonlu bitler) ikili temsilinin yegane gösterimini ve1 0 0|1 (çift . İlk değerin 01b = 1son değeri için büyüklüğü vardır ve tamamlanmalıdır ~1 = -2, ikinci değerin büyüklüğü vardır 100b = 4ve tamamlanmamalıdır.

İnformal doğruluğun gösterilmesi

Her girişi sıfırdan, bir 2B ızgara üzerinde çıktı konumuna kullanıcı tarafından belirtilen bir sayıya eksi bir girişe yerleştiren bir test programı yaptım. Şunları yapabilirsiniz çevrimiçi denemek de. İşte algoritmanın nasıl haritalandığını gösteren bu programın bir çıktısı 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                                                      

Doldurma düzeni biraz garip görünüyor, ama aslında hakikaten! Ardışık her 4'lük güçle, önceki kenar uzunluğunun iki katı olan bir kareyi doldurur. Örneğin, algoritma burada nasıl eşlenir0-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                  

Bu 8x8 kare ortasında 4x4 kare oluşturur 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                              

16x16 karenin ortasındaki 8x8 karesini oluşturan 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

Düzenleme: Temel -2 için daha iyi bir adım özyineleme kullanarak 49'a geliştirildi.

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

İşte kullanarak bir Pyth sürümüreduce .

Düzenleme: geçerek 52 Geliştirilmiş bir baz -2 gelen dengeli bir üçlü .

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

Bu, Runer112'nin çözümü gibi sayısal serpiştirmeyi kullanıyor , ancak imzalı ikiliden ziyade dengeli üçlüye sahip. Python'un yerleşik taban dönüşümü yoktur, bu nedenle kod yinelemeli olarak uygular.

Yardımcı işlev h( 3yerine 9) doğal bir sayı alır ve sayı değişimleriyle üçlü sayılardan dengeli üçlü sayıları dönüştürür.

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

Bu nedenle, örneğin, üssü 201 olan 19, üçlü olarak (-1) * 3 ^ 2 + (0) * 3 ^ 1 + (+ 1) * 3 ^ 0 = -8.

Dengeli üçlü her tamsayı kodlamak için yeterlidir ve bu nedenle doğal sayılardan tam sayılar için bir haritalama sağlar.

Tamsayı çiftleriyle eşlemek için içindeki rakamları harmanlıyoruz n. Bunu yapmak için, özyinelemeli adım olarak hyaparak diğer her haneye bakıyoruz . Sonra, bir koordinat için, zemine bölerek kayar .n/9n/3n3 .

[-4,4] ^ 2 bölgesini kapsayan ilk 81 çıktı.

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)

Çeyrek hayali olan alternatif bir kodlama çok güzel olmasına rağmen daha uzun çıktı.

Python 2, 63

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

Karmaşık dönüşümün daha az karmaşık bir şekilde ele alındığı bir dilde, bu muhtemelen daha iyi bir yaklaşım olacaktır. Eğer karmaşık sayıları çıkartabilseydik, şunu yapabilirdik:

Python 2, 38

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

Python 2, 98 bayt

Basit bir yaklaşımla başlayalım:

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)

Sadece dikdörtgen bir spiral oluşturur N bir 2d ızgarada uzunca bir başlangıç ​​yapan, başlangıç ​​noktasından başlayarak birimler oluşturur ve son noktanın koordinatlarını döndürür.

Bu işlev şu tarihten beri bijektif:

• Her nokta yeterince uzun bir sarmal verilen, kaplanabilir
• Her nokta yalnızca bir kez spiralle kesişir

Spiral şöyle bir şeye benziyor (1 yerine 0'dan başlamak hariç):

dc, 49

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

Bu, negatif olmayan tam sayıların bir ızgara üzerinde düzenlenmesiyle başlar;

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

Izgara konumlarının N artışında çapraz olarak nasıl doldurulduğuna dikkat edin. N = X(X+1)/2 . Bu, normal formül kullanılarak, sadece + ve root kullanılarak çözülen ikinci dereceden bir denklemdir, böylece X'i Y = 0 olduğunda N'den belirleyebiliriz. Sonraki, her N için benzersiz {X, Y} vermek için bazı basit aritmetik karıştırma

Bu, gereken bijektif kaliteyi sağlar, ancak X ve Y sadece negatif değildir, ancak soru tüm olası tam sayıları gerektirir. Böylece X ve Y ((t+1)/2)*((t+1)~2*2-1)tüm olası tam sayıları vermek için kullanılarak eşlenir .

dcisteğe bağlı hassas sayıları vardır, bu nedenle giriş aralığı 2^31-1sorun değildir. Varsayılan hassasiyet 0 ondalık basamak ve olduğunu da unutmayın sqrt()ve /burada gerekli davranıştır yuvarlak aşağı.

Çıktı:

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

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

Burada anahtar spiral, isteğe bağlı boyutta bir spiral matris oluşturur.

spiral(3)

döner

ans =

 7     8     9
 6     1     2
 5     4     3

Matlab'da, bu tamsayılar için işe yarar, ancak bundan önce hafıza sorunları elde edersiniz, (komutun spiralilk önce tam bir matris oluşturduğunu sanıyorum , büyüklüğü yaklaşık$4n^2$. Etrafında$n \simeq 10^4$bu matris 1GB'tan fazla yer kaplıyor. Yani 1TB RAM ile dolacaksınız$n \simeq 10^5$, ve hakkında $2.9\cdot 10^{11}$ GB RAM sizi alacaktır $n=2^{32}$.

Haskell, 78 74 bayt

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

Test sürüşü:

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

Nasıl çalışır: ilk kadranda tüm çiftleri aşağıdaki sırayla listeleyin

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

4 element listesinin bir listesini yapmak için her noktayı diğer kadranlara yansıtın. Tümünü tek bir listede birleştirin ve nth öğesini alın.

Düzenleme: işlev bir isim gerekmez, matematiği yeniden sıraladı. ifade.

Haskell , 50 bayt

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

Çevrimiçi deneyin ya da deneyin da tersi ile deneyin!

Ungolfed

ntoN2 n = 0 ! (n + 1)

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

açıklama

Bu her gerçeği kullanır $(x,y) \in \mathbb{N}^2$ 1'e 1 eşlenebilir $2^x \cdot (2\cdot y + 1) - 1 \in \mathbb{N}$. Yukarıdaki operatör (!)hesaplar$x$girişi eşit olduğu sürece bölerek sıfırdan başlatılan değişkenle l( xCounter) takip edin. Çift sayıya ulaştığımızda bir tamsayı bölümü hesaplanır y.

Gerçek işlevin f( ntoN2) işleme başlamadan önce girişi artırdığını unutmayın.

05AB1E , 35 bayt

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

Çevrimiçi deneyin! veya Test paketi olarak

açıklama

Düşünmek

$$\begin{align*} f: \mathbb{N} &\longrightarrow \mathbb{N} \times \mathbb{N} \\ n&\longmapsto (x,y)\, , \end{align*}$$ nerede $x$ en büyük sayı $2^x$ böler $n+1$, ve burada $2y+1$ ayıran en büyük tek sayıdır $n+1$. Tersi$f$ iyi bilinen bir itiraz $f^{-1}(x,y) = 2^x(2y+1)-1$.

O zaman düşün

$$\begin{align*} g: \mathbb{N} \times \mathbb{N} &\longrightarrow \mathbb{Z} \times \mathbb{Z} \\ (m,n)&\longmapsto (h(m),h(n))\, , \end{align*}$$ nerede $$\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*}$$ Dan beri $f$, $g$ ve $h$ hepsi biboloji, kompozisyon $g\circ f:\mathbb{N} \longrightarrow \mathbb{Z} \times \mathbb{Z}$ bir önyargıdır.

Program sadece hesaplar $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]&

Vektörleri kendi normlarına göre sıralayın, ardından nth.

JavaScript, 166 168 bayt / karakter

Diğerleri gibi dikdörtgen spiral kullanarak yeni yaklaşım.

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

Bu cevabı Math.SE'de kullandım , JS'ye tercüme ettim ve UglifyJS kullanarak sıkıştırdım .

Bu yaklaşım herhangi bir ilmek kullanmaz ve herhangi bir şekilde sarmal oluşturmaz.

Spiralin koordinatları tüm tamsayıları kapsadığından, fonksiyon anlamında münzevidir. $f:\mathbb{N}^0\rightarrow \mathbb{Z}^2$.

Güncelleme: Kayıtlı depolayarak 2 karakter Mathde b.

Güncelleme 2: Değiştirilen t-=1ile t+=4neden bu sorunu gidermek için$f(0)=f(8)$. Bu artık bir spiral oluşturmuyor, fakat negatif olmayan tüm sayılar için çalışıyor.$\mathbb{N}^0$ (dahil tüm doğal sayılar $0$).