25

आपको एक प्रोग्राम या फ़ंक्शन लिखना चाहिए जो Nइनपुट और आउटपुट के रूप में एक गैर-नकारात्मक पूर्णांक लेता है या दो पूर्णांक (नकारात्मक, शून्य या सकारात्मक) Xऔर देता है Y।

इंटेगर गणितीय अर्थों में होते हैं क्योंकि उनमें से कई अनंत हैं।

कार्यान्वित फ़ंक्शन को विशेषण होना चाहिए । इसका मतलब यह है कि प्रत्येक के लिए Nएक अलग X Yजोड़ी का उत्पादन X Yकरना होगा और प्रत्येक जोड़ी को कुछ इनपुट के लिए आउटपुट किया जाना चाहिए, Nअर्थात निम्नलिखित सभी जोड़े को कुछ के लिए आउटपुट किया जाना चाहिए 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 │
    └─────┴─────┴────┴────┴────┘
                 ...

ध्यान दें कि U Vऔर V Uविभिन्न जोड़े हैं यदि U!=V।

विवरण

यदि आपकी भाषा मनमाने ढंग से बड़े पूर्णांक का समर्थन नहीं करती है जो ठीक है, लेकिन आपका एल्गोरिथ्म एक बड़े पैमाने पर बड़े पूर्णांक डेटा-प्रकार के साथ काम करना चाहिए। आपके कोड को अभी भी कम से कम इनपुट मानों का समर्थन करना चाहिए 2^31-1।
यदि आप आउटपुट को प्रिंट करने या वापस करने का चयन करते हैं, तो स्ट्रिंग के रूप में कोई अग्रणी 0या +संकेत की अनुमति नहीं है। अन्यथा आपकी भाषा का मानक पूर्णांक प्रतिनिधित्व ठीक है।

उदाहरण

यदि कार्य एक गैर-ऋणात्मक पूर्णांक Nऔर आउटपुट एक पूर्णांक बनाने के लिए एक विशेषण फ़ंक्शन बनाने के लिए होगा, तो Xसमाधान एक फ़ंक्शन हो सकता है

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

कुछ भाषा में लागू किया गया। इस समारोह के लिए लौटता X = 0 -1 1 -2 2...है N = 0 1 2 3 4...।

code-golf math number

— randomra
स्रोत

क्या आउटपुट में किसी भी पूर्णांक को अलग-अलग इनपुट के लिए दोहराया जा सकता है? उदाहरण 10=>11 12, 9=>10 11यह अमान्य है क्योंकि 11 को दोहराया जाता है?

— 14 नवंबर को ब्रेनसेल

1

जहाँ तक "बायजेक्टिव" को "11 12" के रूप में परिभाषित किया गया है, "10 11" के समान नहीं है और इसलिए मान्य है। इसका कारण यह है कि एक विशेषण फ़ंक्शन को एक फ़ंक्शन के रूप में परिभाषित किया जाता है "जहां एक सेट के प्रत्येक तत्व को दूसरे सेट के बिल्कुल एक तत्व के साथ जोड़ा जाता है, और दूसरे सेट के प्रत्येक तत्व को पहले सेट के बिल्कुल एक तत्व के साथ जोड़ा जाता है। अप्रकाशित तत्व। "( en.wikipedia.org/wiki/Bijection )। यदि आप अपने फ़ंक्शन को "11 12" से उलटा करना चाहते हैं तो 10 का उत्पादन करना चाहिए और "10 का 11" का उत्पादन 9. करना चाहिए

— GiantTree

@BrainSteel आपका उदाहरण मान्य है। केवल (आदेशित) जोड़े दोहराए नहीं जा सकते। GiantTree सही है। प्रश्न के लिए कुछ और स्पष्टीकरण जोड़ा गया।

— बेतरतीब

क्या यह दी गई भाषा के पूर्णांक सीमा के भीतर एक आपत्ति है या इसे सभी पूर्णांकों के लिए काम करना चाहिए?

— 17

1

@LegionMammal के पास कार्य का एक अच्छा गणितीय विवरण था: "आपको एक विशेषण फ़ंक्शन $ f: N + → Z ^ 2 $ को परिभाषित करने की आवश्यकता है। - LegionMammal978।" मुझे लगता है कि बयान में कहीं फायदेमंद होगा

— ब्रायन जे

15

अजगर, १५

u,-HyeGhGjQ2,ZZ

इसे ऑनलाइन आज़माएं।

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

एक पायथन अनुवाद:

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

या पुनरावृति:

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

जहाँ binlistएक संख्या को अंकों की सूची में परिवर्तित किया जाता है जैसे binlist(4) = [1,0,0]।

यह कैसे काम करता है? यह संख्या के द्विआधारी अंकों की व्याख्या में दो interleaved संख्या के रूप में आधार नकारात्मक दो मेरी तरह पायथन समाधान । $n$

द्विआधारी संख्या युग्म मेल खाती है

n = ... ख_{5} ख_{4} ख_{3} ख_{2} ख_{1} ख_{0}

$n=\dots b_5 b_4 b_3 b_2 b_1 b_0$

(एक्स, y) = (ख_{0} - 2 ख_{2} + 4 ख_{4} - 8 ख_{6} + \dots, ख_{1} - 2 ख_{3} + 4 ख_{5} - 8 ख_{7} + \dots) ।

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

हम अभी तक पिछले अंक संसाधित नहीं किया था, तो से , हम सभी सूचकांकों $ 1 $ से अधिक होगा, जोड़ी के लिए इसी $b_0$ $n$

n^{'} = ... ख_{5} ख_{4} ख_{3} ख_{2} ख_{1}

$n'=\dots b_5 b_4 b_3 b_2 b_1$

({एक्स}^{'}, y^{'}) = (ख_{1} - 2 ख_{3} + 4 ख_{5} - 8 ख_{7} + \dots, ख_{2} - 2 ख_{4} + 4 ख_{6} - 8 ख_{8} + \dots) ।

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

पुराने मानों के संदर्भ में पढ़ने के बाद हम नए मानों को व्यक्त कर सकते हैं $b_0$

(एक्स, y) = (ख_{0} - 2 y^{'}, {एक्स}^{'}) ।

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

$(x,y) \to (b - 2y, x)$ $b$ $n$ $(x,y)$

— XNOR
स्रोत

ध्यान दें कि MathJax समर्थन अक्षम किया गया है। आप पठनीयता के लिए अपने स्पष्टीकरण के संपादन पर विचार करना चाह सकते हैं।

— एलेक्स ए।

32

CJam, 24 22 21 बाइट्स

मेरे मस्तिष्क को गणित के अन्य समाधानों का उपयोग करने में परेशानी हो रही है। लेकिन मेरा मस्तिष्क निश्चित रूप से द्विआधारी को समझता है, इसलिए यहां थोड़ा हेरफेर के आधार पर एक आत्मा है!

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

इसे ऑनलाइन आज़माएं।

व्याख्या

यह दृष्टिकोण इनपुट को दो interleaved बाइनरी मानों के रूप में मानता है, प्रत्येक आउटपुट संख्या के लिए। सभी लेकिन कम से कम महत्वपूर्ण बिट प्रत्येक एक परिमाण को सांकेतिक शब्दों में बदलना, और कम से कम महत्वपूर्ण बिट संकेत इस परिमाण के बिटवाइज़ पूरक लेने के लिए या नहीं। इस कार्यान्वयन में, विषम-स्थित बिट्स पहले आउटपुट नंबर (और सम-बिट बिट्स दूसरे के अनुरूप हैं) और 0पूरक लेने के लिए संकेतों के एक LSB के अनुरूप हैं।

उदाहरण के लिए, के इनपुट को देखते हुए 73, इसके द्विआधारी प्रतिनिधित्व को 1001001bउत्पन्न करता है 0 1|0(विषम-स्थित बिट्स) और 1 0 0|1(यहां तक कि-बिट बिट्स)। पहले मान का परिमाण होता है 01b = 1और अंतिम मान के लिए पूरक होना चाहिए ~1 = -2, और दूसरे मान का परिमाण होता है 100b = 4और पूरक नहीं होना चाहिए।

शुद्धता का अनौपचारिक प्रदर्शन

मैंने एक परीक्षण कार्यक्रम बनाया जो शून्य से प्रत्येक इनपुट को एक उपयोगकर्ता द्वारा निर्दिष्ट संख्या में माइनस एक में 2 डी ग्रिड पर रखता है। आप इसे ऑनलाइन भी आज़मा सकते हैं । यहाँ इस कार्यक्रम का एक आउटपुट दिखाया गया है कि एल्गोरिथ्म मैप कैसे करता है 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

भरण पैटर्न थोड़ा अजीब लगता है, लेकिन यह वास्तव में विशेषण है! 4 की प्रत्येक क्रमिक शक्ति के साथ, यह पिछली तरफ की लंबाई को दोगुना करके एक वर्ग भरता है। उदाहरण के लिए, यहाँ एल्गोरिथ्म के नक्शे कैसे हैं 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

यह 8x8 वर्ग के बीच में 4x4 वर्ग बनाता है 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 वर्ग के मध्य में 8x8 वर्ग को बनाता है 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

— Runer112
स्रोत

3

बहुत चालाक! के li4b2fmd2/बजाय का उपयोग करके आप दो बाइट्स बचा सकते हैं 0li2b+W%2/W%। यह एक ही पूर्णांक देता है, लेकिन उलटा क्रम में।

— डेनिस

@ डेनिस यह भी बहुत चालाक है। मैंने उस ट्रिक का उपयोग करने का उत्तर अपडेट कर दिया है। धन्यवाद!

— रनवीर ११

12

पायथन 2, 49

संपादित करें: आधार -2 के लिए बेहतर एक-चरण पुनरावृत्ति का उपयोग करके 49 में सुधार हुआ है।

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

यहाँ एक पायथ संस्करण का उपयोग किया गया है reduce।

संपादित करें: संतुलित ternary से बेस -2 पर स्विच करके 52 में सुधार ।

अजगर 2, 52

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

अजगर 2, 54

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

यह Runer112 के सॉल्यूशन की तरह डिजिट इंटरलेइंग का उपयोग करता है , लेकिन हस्ताक्षरित बाइनरी के बजाय संतुलित टर्नरी के साथ। पायथन में अंतर्निहित आधार रूपांतरण नहीं है, इसलिए कोड इसे पुनरावृत्ति करता है।

हेल्पर फ़ंक्शन h(के 3स्थान पर 9) एक प्राकृतिक संख्या लेता है और इसे अंकन से अंकन से संतुलित त्रिगुट में परिवर्तित करता है

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

तो, उदाहरण के लिए, 19, जो कि आधार में 201 है, संतुलित टर्नरी में (-1) (0) (+ 1) हो जाता है, जो (-1) * 3 ^ 2 + (0) * 3 ^ 1 + (+) है 1) * 3 ^ 0 = -8।

संतुलित त्रिगुट प्रत्येक पूर्णांक को सांकेतिक शब्दों में बदलना, और इसलिए प्राकृतिक संख्याओं से पूर्णांक तक मानचित्रण देता है।

पूर्णांकों के जोड़े में जाने के लिए, हम अंकों को अंदर रखते हैं n। ऐसा करने के लिए, हमने रिकर्सिव स्टेप के बजाय hहर दूसरे अंक को देखा n/9है n/3। फिर, एक समन्वय के लिए, हम nफर्श से विभाजित करके विभाजित करते हैं 3।

यहां पहले 81 आउटपुट हैं, जो इस क्षेत्र को कवर करते हैं [-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)

क्वार्टर-काल्पनिक के साथ एक वैकल्पिक कोडिंग लंबे समय तक निकला, हालांकि यह बहुत सुंदर है।

अजगर 2, 63

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

जटिल रूपांतरण की कम क्लंकी हैंडलिंग वाली भाषा में, यह संभवतः एक बेहतर दृष्टिकोण होगा। यदि हम जटिल संख्याओं का उत्पादन कर सकते हैं, तो हम कर सकते हैं:

अजगर 2, 38

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

— XNOR
स्रोत

1

आपके मूल आधार -2 फ़ंक्शन का अर्थ होगा पाइथ उत्तर। L&b-%b2*2y/b4,yQy/Q2केवल 20 बाइट्स लंबी है।

— डेनिस

4

@ डेनिस I ने सिर्फ 15-char Pyth सॉल्यूशन लिखा है।

— xnor

संतुलित टर्नरी और क्वार्टर-काल्पनिक। मेरे दो पसंदीदा ठिकाने। केवल बेस-ई द्वारा अनुसरण किया गया।

— ब्रायन मिंटन

11

पायथन 2, 98 बाइट्स

चलो एक सरल दृष्टिकोण के साथ शुरू करते हैं:

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)

यह सिर्फ N2d ग्रिड पर एक आयताकार सर्पिल इकाइयाँ बनाता है , जो मूल से शुरू होता है, और अंतिम बिंदु के निर्देशांक को लौटाता है।

समारोह के बाद से विशेषण है:

प्रत्येक बिंदु को कवर किया जा सकता है, एक लंबा पर्याप्त सर्पिल दिया जाता है
प्रत्येक बिंदु केवल एक बार सर्पिल द्वारा प्रतिच्छेद किया जाएगा

सर्पिल कुछ इस तरह दिखता है (1 के बजाय 0 से शुरू होने के अलावा):

उलाम सर्पिल

— gRC
स्रोत

@AlexA। 0**0 == 1अजगर में, तो यह सिर्फ उसी तरह हैif a == 0: a = b/2

— grc

कूल, समझाने के लिए धन्यवाद।

— एलेक्स ए।

@AlexA। पता चला a=a or b/2कि छोटा है

— grc

0^0=1सभी गणित में @grc , सिर्फ अजगर नहीं।

— डेनिथ

1

@ डायनेथ 0**0वास्तव में गणित में अनिश्चित रूप है

— Sp3000

8

डीसी, ४ ९

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

यह ग्रिड पर गैर-नकारात्मक पूर्णांक की व्यवस्था करके शुरू होता है:

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

ध्यान दें कि ग्रिड की स्थिति को एन को बढ़ाने के साथ तिरछे तरीके से कैसे भरा जाता है N = X(X+1)/2। Y = 0 लाइन में त्रिकोणीय संख्या अनुक्रम होता है, जिसके द्वारा दिया गया है । यह एक द्विघात समीकरण है जिसे सामान्य सूत्र का उपयोग करके हल किया जाता है, बस + ve रूट का उपयोग करके, ताकि हम Y = 0 होने पर N से X निर्धारित कर सकें। अगला कुछ सरल अंकगणितीय फेरबदल है जो प्रत्येक N के लिए विशिष्ट {X, Y} देता है।

यह आवश्यक द्विदिश गुणवत्ता प्रदान करता है, लेकिन एक्स और वाई केवल गैर-नकारात्मक हैं, लेकिन प्रश्न के लिए सभी संभव पूर्णांक आवश्यक हैं। इसलिए ((t+1)/2)*((t+1)~2*2-1)सभी संभावित पूर्णांकों को देने के लिए X और Y का उपयोग किया जाता है।

dcइसमें मनमाने ढंग से सटीक संख्याएँ होती हैं, इसलिए इनपुट रेंज 2^31-1कोई समस्या नहीं है। यह भी ध्यान दें कि डिफ़ॉल्ट सटीकता 0 दशमलव अंक है, और नीचे sqrt()और /गोल है जो यहां आवश्यक व्यवहार है।

आउटपुट:

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

— डिजिटल आघात
स्रोत

5

मतलाब, 54 बाइट्स

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

यहां कुंजी है spiral, यह एक मनमाना आकार का एक सर्पिल मैट्रिक्स बनाता है।

spiral(3)

रिटर्न

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

— flawr
स्रोत

2

हास्केल, 78 74 बाइट्स

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

परीक्षण चालन:

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

यह कैसे काम करता है: निम्नलिखित क्रम में पहले चतुर्थांश में सभी जोड़ों को सूचीबद्ध करें

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

4 तत्व सूचियों की एक सूची बनाने के लिए प्रत्येक बिंदु को अन्य क्वाड्रंट में दर्पण करें। सभी को एक सूची में सम्‍मिलित करें और nवें तत्व को लें।

संपादित करें: फ़ंक्शन को एक नाम की आवश्यकता नहीं है, गणित को फिर से लिखना भाव।

— nimi
स्रोत

do-Notation का उपयोग करके आप 4 बाइट्स बचा सकते हैं : इसे ऑनलाइन आज़माएं!

— 13

1

हास्केल , 50 बाइट्स

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

इसे ऑनलाइन आज़माएं या इसके उलटा करके देखें!

Ungolfed

ntoN2 n = 0 ! (n + 1)

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

व्याख्या

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

ध्यान दें कि वास्तविक कार्य f( ntoN2) प्रक्रिया से शुरू होने से पहले इनपुट को बढ़ाता है।

— ბიმო
स्रोत

1

05AB1E , 35 बाइट्स

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

इसे ऑनलाइन आज़माएं! या टेस्ट सूट के रूप में

व्याख्या

विचार करें

\begin{aligned} च : एन & ⟶ एन \times एन \\ n & ⟼ (एक्स, y), \end{aligned}

$\begin{align*} f: \mathbb{N} &\longrightarrow \mathbb{N} \times \mathbb{N} \\ n&\longmapsto (x,y)\, , \end{align*}$

x

$x$

2^{x}

$2^x$

n + 1

$n+1$

2 y + 1

$2y+1$

n + 1

$n+1$

f

$f$

f^{- 1} (x, y) = 2^{x} (2 y + 1) - 1

$f^{-1}(x,y) = 2^x(2y+1)-1$

\begin{aligned} जी : एन \times एन & ⟶ जेड \times जेड \\ (मीटर, n) & ⟼ (ज (मीटर), ज (n)), \end{aligned}

$\begin{align*} g: \mathbb{N} \times \mathbb{N} &\longrightarrow \mathbb{Z} \times \mathbb{Z} \\ (m,n)&\longmapsto (h(m),h(n))\, , \end{align*}$

\begin{aligned} ज : एन & ⟶ जेड \\ n & ⟼ {\begin{cases} \frac{n}{2}, & n यहाँ तक की \\ - \frac{n + 1}{2}, & n अजीब \end{cases} । \end{aligned}

$\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*}$

f

$f$

g

$g$

h

$h$

g \circ f : N ⟶ Z \times Z

$g\circ f:\mathbb{N} \longrightarrow \mathbb{Z} \times \mathbb{Z}$

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

— Wisław
स्रोत

वाह, अच्छी व्याख्या के लिए upvoted। लेकिन निश्चित रूप से 05AB1E पायथ को हराने में सक्षम होना चाहिए?

— ASCII- केवल

g \circ f

$g\circ f$

0

गणितज्ञ, ४६

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

वैक्टर अपने आदर्श को क्रमबद्ध करें, फिर nवें को लें ।

— alephalpha
स्रोत

0

जावास्क्रिप्ट, 166 168 बाइट्स / अक्षर

एक आयताकार सर्पिल का उपयोग करके नया दृष्टिकोण, जैसे अन्य उपयोग कर रहे हैं।

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

मैंने Math.SE पर इस उत्तर का उपयोग किया , इसे JS में अनुवाद किया और UglifyJS का उपयोग करके इसे संकुचित कर दिया ।

यह दृष्टिकोण किसी भी छोरों का उपयोग नहीं करता है और न ही यह किसी भी तरह से सर्पिल बनाता है।

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

अद्यतन:Math में संग्रहीत करके 2 वर्ण सहेजे गए b।

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

— GiantTree
स्रोत

1) ठीक उसी प्रश्न को निरस्त करने से वास्तव में मदद नहीं मिलेगी। 2) एक अन्य उत्तर की नकल करना और फिर गोल्फ के लिए एक मिनिफ़ायर का उपयोग करना भी नहीं होगा :)

— ऑप्टिमाइज़र

कम से कम यह प्रश्न में वर्णित सभी नियमों का पालन करता है और यह एक अलग दृष्टिकोण है। इसके अलावा, मैं किसी दूसरे के काम को नहीं चुरा रहा हूं, लेकिन मैं इस बात का उल्लेख करता हूं कि मैंने यह जवाब कैसे दिया।

— GiantTree

@ ऑप्टिमाइज़र: 1) मैंने सुझाव दिया कि जाइंटट्री को रिपॉजिट करना चाहिए क्योंकि उसे अपने मूल, अमान्य दृष्टिकोण के लिए 3 (योग्य) डाउनवोट मिलते हैं। 2) उन्होंने Math.SE से जो कोड लिया था, वह भी जावास्क्रिप्ट नहीं है, इसलिए उन्होंने इसे मिनिफ़ायर में कॉपी करने से ज्यादा किया।

— डेनिस

@ डेनिस लोग अपने पतन को वापस ले सकते हैं, आप जानते हैं। इसके अलावा, कोड को छोटा करने के लिए एक मिनिफ़ायर का उपयोग करना वास्तव में imo को प्रोत्साहित नहीं करता है।

— ऑप्टिमाइज़र

@ ऑप्टिमाइज़र मैंने कोड को गोल्फ करने की कोशिश की, लेकिन एक कंप्रेसर का उपयोग करने से बेहतर परिणाम (कम वर्ण) का उपयोग हुआ, इसलिए मैंने इसके बजाय इसका उपयोग किया।

— 20

एक गैर-नकारात्मक से पूर्णांक की एक जोड़ी उत्पन्न करें

विवरण

उदाहरण

अजगर, १५

CJam, 24 22 21 बाइट्स

व्याख्या

शुद्धता का अनौपचारिक प्रदर्शन

पायथन 2, 49

पायथन 2, 98 बाइट्स

डीसी, ४ ९

आउटपुट:

मतलाब, 54 बाइट्स

हास्केल, 78 74 बाइट्स

हास्केल , 50 बाइट्स

Ungolfed

व्याख्या

05AB1E , 35 बाइट्स

व्याख्या

गणितज्ञ, ४६

जावास्क्रिप्ट, 166 168 बाइट्स / अक्षर