विशेषण फ़ंक्शन ℤⁿ → ℤ

Question

Z (सभी पूर्णांकों का सेट) से Z (उदाहरण के लिए पहचान फ़ंक्शन) से एक विशेषण फ़ंक्शन बनाना बहुत ही संभव है ।$\mathbb{Z}$$\mathbb{Z}$

से Z 2 (2 पूर्णांक के सभी जोड़े का सेट; Z और Z का कार्टेशियन उत्पाद) का एक विशेषण फ़ंक्शन बनाना भी संभव है । उदाहरण के लिए, हम एक 2 डी तल पर पूर्णांक बिंदुओं का प्रतिनिधित्व करने वाले जाली को ले सकते हैं, 0 से एक सर्पिल खींच सकते हैं, और फिर पूर्णांक के जोड़े को सर्पिल के साथ दूरी के रूप में सांकेतिक शब्दों में बदलना जब यह उस बिंदु को प्रतिच्छेद करता है।$\mathbb{Z}$$\mathbb{Z}^2$$\mathbb{Z}$$\mathbb{Z}$

(एक फ़ंक्शन जो प्राकृतिक संख्याओं के साथ ऐसा करता है, एक युग्मन फ़ंक्शन के रूप में जाना जाता है ।)

वास्तव में, इन विशेषण कार्यों का एक परिवार मौजूद है:

$$f_k(x) : \mathbb{Z} \to \mathbb{Z}^k$$

चुनौती

कार्यों में से एक परिवार को परिभाषित (जहां कश्मीर संपत्ति उस के साथ एक सकारात्मक पूर्णांक है) च कश्मीर ( एक्स ) bijectively पूर्णांकों नक्शे को k पूर्णांकों का -tuples।$f_k(x)$$k$$f_k(x)$$k$

आपका सबमिशन, इनपुट और x , रिटर्न f k ( x ) दिया जाना चाहिए ।$k$$x$$f_k(x)$

यह कोड-गोल्फ है , इसलिए सबसे छोटा वैध उत्तर (बाइट्स में मापा गया) जीतता है।

विशेष विवरण

• किसी भी परिवार का उपयोग तब तक किया जा सकता है जब तक वह उपरोक्त मानदंडों को पूरा नहीं करता है।$f_k(x)$
• आपको यह बताने के लिए प्रोत्साहित किया जाता है कि आपका फ़ंक्शन परिवार कैसे काम करता है, साथ ही फ़ंक्शन के व्युत्क्रम की गणना करने के लिए एक स्निपेट (यह आपकी बाइट गिनती में शामिल नहीं है)।
• यह ठीक है अगर उलटा फ़ंक्शन अपरिहार्य है, जब तक आप यह साबित कर सकते हैं कि यह फ़ंक्शन विशेषण है।
• आप अपनी भाषा के लिए हस्ताक्षरित पूर्णांक और हस्ताक्षरित पूर्णांकों की सूचियों के लिए किसी भी उपयुक्त प्रतिनिधित्व का उपयोग कर सकते हैं, लेकिन आपको अपने कार्य के इनपुट को अनुमति देना चाहिए।
• आपको केवल मूल्यों को 127 तक समर्थन करने की आवश्यकता है ।$k$

Comments

यह एक स्ट्रिंग संस्करणों में से लेने के लिए ठीक है kऔर xबजाय पूर्णांकों का?

— जुंगह्वान मिन नोव

@JungHwanMin स्ट्रिंग्स का प्रतिनिधित्व करने वाले इनपुट नंबर ठीक हैं।

— बजे फल

Answer 1

ऐलिस , 14 12 बाइट्स

/O
\i@/t&Yd&

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

उलटा कार्य (गोल्फ नहीं):

/o     Q
\i@/~~\ /dt&Z

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

व्याख्या

ऐलिस में ℤ और which ^{2 के} बीच एक अंतर्निहित आक्षेप है , जिसे Y(अनपैक) और इसके व्युत्क्रम Z (पैक) के साथ गणना की जा सकती है । यहाँ डॉक्स से एक अंश है जो कि जीव को समझा रहा है:

अधिकांश उपयोग के मामलों के लिए जीव के विवरण अप्रासंगिक हैं। मुख्य बिंदु यह है कि यह उपयोगकर्ता को एक में दो पूर्णांक को सांकेतिक शब्दों में बदलना और बाद में फिर से दो पूर्णांक निकालने देता है। पैक कमांड को बार-बार लागू करने से, पूर्ण सूची या पूर्णांक के पेड़ों को एक ही संख्या में संग्रहीत किया जा सकता है (हालांकि विशेष रूप से मेमोरी-कुशल तरीके से नहीं)। पैक ऑपरेशन द्वारा गणना की गई मैपिंग एक जीवनात्मक फ़ंक्शन है ℤ ² → by (यानी एक-से-एक मैपिंग)। सबसे पहले, पूर्णांक {..., -2, -1, 0, 1, 2, ...} को {..., 3, 1, 0, 2, 4 जैसे प्राकृतिक संख्याओं (शून्य सहित ) में मैप किया जाता है। , ...}(दूसरे शब्दों में, ऋणात्मक पूर्णांकों को विषम नलिकाओं पर मैप किया जाता है और गैर-ऋणात्मक पूर्णांकों को भी नलिकाओं में मैप किया जाता है)। फिर दो प्राकृतिक संख्याओं को कैंटर पेयरिंग फ़ंक्शन के माध्यम से एक में मैप किया जाता है , जो पूर्णांक ग्रिड के पहले चतुर्थांश के विकर्णों के साथ-साथ नलिकाएं लिखता है। विशेष रूप से, {(0,0), (1,0), (0,1), (2,0), (1,1), (0,2), (3,0), ...} हैं {0, 1, 2, 3, 4, 5, 6, ...} पर मैप किया गया । परिणामी प्राकृतिक संख्या को फिर से पूर्व के बायजेन्स के विलोम का उपयोग करके पूर्णांकों में वापस मैप किया जाता है। अनपैक कमांड इस मैपिंग के व्युत्क्रम की गणना करता है।

जैसा कि ऊपर उल्लेख है, हम मैप करने के लिए इस खोल आपरेशन का उपयोग कर सकते ℤ को ℤ ^{कश्मीर} में अच्छी तरह से। प्रारंभिक पूर्णांक पर इसे लागू करने के बाद, हम परिणाम के दूसरे पूर्णांक को फिर से अनपैक कर सकते हैं, जो हमें तीन पूर्णांकों की सूची देता है। तो k-1 एप्लिकेशन Yहमें परिणाम के रूप में k पूर्णांक देते हैं ।

हम सूची Zको अंत से पैक करके उलटा गणना कर सकते हैं ।

तो कार्यक्रम में ही यह संरचना है:

/O
\i@/...d&

यह एक प्रोग्राम के लिए सिर्फ एक मूल टेम्पलेट है जो दशमलव पूर्णांक की एक चर संख्या को इनपुट के रूप में पढ़ता है और परिणाम के रूप में एक चर संख्या को प्रिंट करता है। तो वास्तविक कोड वास्तव में सिर्फ है:

t   Decrement k.
&   Repeat the next command k-1 times.
Y   Unpack.

एक बात जो मैं संबोधित करना चाहता हूं, वह यह है कि "ऐलिस में ℤ → address ² बायजेन्स के लिए अंतर्निहित ऐलिस क्यों होगा , क्या वह गोल्फिंग भाषा क्षेत्र नहीं है"? जैसा कि ऐलिस के अधिकांश वाइडर बिल्ट-इन के साथ है, इसका मुख्य कारण ऐलिस का डिज़ाइन सिद्धांत है कि हर कमांड के दो अर्थ होते हैं, एक कार्डिनल (पूर्णांक) मोड के लिए और दूसरा ऑर्डिनल (स्ट्रिंग) मोड के लिए, और ये दो अर्थ किसी न किसी तरह से संबंधित होने चाहिए। कार्डिनल और ऑर्डिनल यह महसूस करते हैं कि वे दर्पण ब्रह्मांड हैं जहां चीजें समान हैं, लेकिन अलग-अलग भी हैं। और बहुत बार मेरे पास दो मोडों में से एक के लिए एक कमांड थी जिसे मैं जोड़ना चाहता था, और फिर यह पता लगाना था कि इसे किस अन्य कमांड के साथ जोड़ा जाना है।

के मामले में Yऔर Zऑर्डिनल मोड पहले आया: मैं दो तारों (जिप) को इंटरलेव करने और उन्हें फिर से (अनज़िप) अलग करने के लिए एक फ़ंक्शन चाहता था। इस बात की गुणवत्ता कि मैं कार्डिनल मोड में कब्जा करना चाहता था, दो से एक पूर्णांक बनाना और बाद में फिर से दो पूर्णांक निकालने में सक्षम होना चाहिए, जो इस तरह के पूर्वाग्रह को प्राकृतिक विकल्प बनाता है।

मुझे यह भी लगा कि यह वास्तव में गोल्फ के बाहर बहुत उपयोगी होगा, क्योंकि यह आपको मेमोरी की एक इकाई (स्टैक एलिमेंट, टेप सेल या ग्रिड सेल) में पूरी सूची या पूर्णांक के पेड़ को स्टोर करने देता है।

Comments

हमेशा की तरह शानदार व्याख्या

— लुइस मेंडू

ढूँढना Yऔर Zऐलिस डॉक्स में वास्तव में क्या मुझे के लिए कहा जाए इस चुनौती पोस्ट करने के लिए (मैं थोड़ी देर के लिए इस बारे में सोच रहा था, लेकिन यह मुझे याद दिलाया) है।

— २३:२६ को फल

Answer 2

पायथन, 96 93 बाइट्स

def f(k,x):
 c=[0]*k;i=0
 while x:v=(x+1)%3-1;x=x//3+(v<0);c[i%k]+=v*3**(i//k);i+=1
 return c

यह सिद्धांत में इनपुट संख्या xको संतुलित टर्नरी में परिवर्तित करके , और फिर राउंड-रॉबिन फैशन में अलग-अलग निर्देशांक के बीच कम से कम महत्वपूर्ण रूप से ट्रिट (टर्नरी अंक) वितरित करके काम करता है । इसलिए k=2उदाहरण के लिए, हर पोस्ट ट्रिट भी xसमन्वय में योगदान देगा , और हर विषम स्थिति ट्रिट yसमन्वय में योगदान देगा । के लिए k=3आप, पहले चौथे और सातवें trits (आदि ...) के लिए योगदान होगा x, जबकि दूसरे, पांचवें और आठवें में योगदान yहै, और तीसरे, छठे और नौवें में योगदान z।

उदाहरण के लिए, के साथ k=2देखो x=35। संतुलित त्रिगुट में, 35है 110T(विकिपीडिया लेख के संकेतन जहां का उपयोग कर Tएक प्रतिनिधित्व करता -1अंकों)। समन्वित के लिए विभाजन को विभाजित करना 1T(पहली और तीसरी पंक्ति, दाईं ओर से गिनती करना) देता है और xसमन्वय के लिए 10(दूसरा और चौथा ट्रिट) y। प्रत्येक निर्देशांक को दशमलव में बदलकर, हम प्राप्त करते हैं 2, 3।

बेशक, मैं वास्तव में पूरी संख्या को संतुलित कोडन में परिवर्तित नहीं कर रहा हूँ, एक बार में गॉल्फर्ड कोड में। मैं एक बार ( vचर में) एक ट्रिट की गणना कर रहा हूं , और इसके मूल्य को सीधे उपयुक्त समन्वय में जोड़ रहा हूं ।

यहां एक अनगुल्ड उलटा फ़ंक्शन है जो निर्देशांक की एक सूची लेता है और एक नंबर देता है:

def inverse_f(coords):
    x = 0
    i = 0
    while any(coords):
        v = (coords[i%3]+1) % 3 - 1
        coords[i%3] = coords[i%3] // 3 + (v==-1)
        x += v * 3**i
        i += 1
    return x

मेरा fकार्य संभवतः इसके प्रदर्शन के लिए उल्लेखनीय है। यह केवल O(k)मेमोरी का उपयोग करता है और O(k) + O(log(x))परिणाम खोजने में समय लगता है, इसलिए यह बहुत बड़े इनपुट मानों के साथ काम कर सकता है। प्रयास करें f(10000, 10**10000)उदाहरण के लिए, और आप एक जवाब काफी तुरन्त (प्रतिपादक के लिए एक अतिरिक्त शून्य जोड़ने तो मिल जाएगा xहै 10**100000बनाता है यह मेरे पुराने पीसी पर 30 सेकंड या तो लेने के लिए)। उलटा कार्य इतनी तेजी से नहीं होता है, ज्यादातर इसलिए क्योंकि जब यह किया जाता है तो यह बताना मुश्किल होता है (यह प्रत्येक परिवर्तन के बाद सभी निर्देशांक को स्कैन करता है, इसलिए यह O(k*log(x))समय की तरह कुछ लेता है )। यह संभवतः तेज़ होने के लिए अनुकूलित किया जा सकता है, लेकिन पहले से ही सामान्य मापदंडों के लिए यह काफी तेज़ है।

Comments

आप लूप के अंदर रिक्त स्थान (

— नईलाइन्स

धन्यवाद, मैंने गलती से सोचा होगा कि एक लूप के बीच किसी प्रकार का विवाद था और ;एक लाइन पर चेन स्टेटमेंट का उपयोग कर रहा था।

— ब्लेककनथ

Answer 3

भूसी , 10 बाइट्स

§~!oΠR€Θݱ

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

उलटा फ़ंक्शन भी 10 बाइट्स है।

§o!ȯ€ΠRΘݱ

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

व्याख्या

आगे की ओर:

§~!oΠR€Θݱ  Implicit inputs, say k=3 and x=-48
        ݱ  The infinite list [1,-1,2,-2,3,-3,4,-4,..
       Θ    Prepend 0: [0,1,-1,2,-2,3,-3,4,-4,..
 ~    €     Index of x in this sequence: 97
§    R      Repeat the sequence k times: [[0,1,-1,..],[0,1,-1,..],[0,1,-1,..]]
   oΠ       Cartesian product: [[0,0,0],[1,0,0],[0,1,0],[1,1,0],[-1,0,0],[0,0,1],..
  !         Index into this list using the index computed from x: [-6,1,0]

विपरीत दिशा:

§o!ȯ€ΠRΘݱ  Implicit inputs, say k=3 and y=[-6,1,0]
     ΠRΘݱ  As above, k-wise Cartesian product of [0,1,-1,2,-2,..
   ȯ€       Index of y in this sequence: 97
§o!         Index into the sequence [0,1,-1,2,-2,.. : -48

कार्टेशियन निर्मित उत्पाद Πअनंत सूचियों के लिए अच्छी तरह से व्यवहार करता है, प्रत्येक k -upuple को एक बार ठीक करता है।

Comments

[[0,1,-1,..],[[0,1,-1,..],[[0,1,-1,..]]क्या यह हिस्सा होना चाहिए [[0,1,-1,..],[0,1,-1,..],[0,1,-1,..]]?

— आउटगोल्फर

@EriktheOutgolfer उम्म हाँ, अब तय हो गया है।

— जर्बर्ग

ये सुन्दर है। एक जे प्रोग्रामर के रूप में, क्या आप जानते हैं कि इस तरह से एक आलसी सूची समाधान को जे में परिवर्तित करने का एक अच्छा तरीका है, जो उनका समर्थन नहीं करता है? ^:^:_प्रकार के समाधान आमतौर पर बहुत अधिक बोझिल हो जाते हैं ...

— योना

@ जोनाह मुझे यकीन नहीं है। आप प्रविष्टियों से सभी k -tuples के सरणी की गणना करने की कोशिश कर सकते हैं i: xऔर इसे पूर्ण मानों के योग द्वारा क्रमित कर सकते हैं, फिर उस में अनुक्रमित कर सकते हैं। विचार यह है कि ये सरणियाँ एक "अनंत सरणी" के उपसर्ग हैं, जिसमें सभी k -tuples शामिल हैं।

— जर्ब

Answer 4

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 61 बाइट्स

SortBy[Range[-(x=2Abs@#+Boole[#>=0]),x]~Tuples~#2,#.#&][[x]]&

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

(पूर्णांक बनाता है और फिर इनपुट के रूप में टपल की लंबाई।)

श्लोक में:

If[OddQ[#],#-1,-#]/2&@Tr@Position[SortBy[Range[-(x=Ceiling@Norm@#),x]~Tuples~Length@#,#.#&],#]&

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

यह काम किस प्रकार करता है

यह विचार सीधा है: हम पूर्णांक इनपुट को धनात्मक पूर्णांक में बदल देते हैं (0,1,2,3, ... 1,3,5,7, ... और -1, -2, -3, -3 की मैपिंग करके। ... 2,4,6, ...) और फिर सभी k में अनुक्रमणिका tuples में इंडेक्स, मूल से दूरी और फिर मैथेमेटिका के डिफ़ॉल्ट टाई-ब्रेकिंग द्वारा क्रमबद्ध।

लेकिन हम एक अनंत सूची का उपयोग नहीं कर सकते हैं, इसलिए जब हम के लिए देख रहे n ^वें कश्मीर -tuple, हम केवल उत्पन्न कश्मीर रेंज में पूर्णांक -tuples {- n , ..., n }। यह पर्याप्त होने की गारंटी है, क्योंकि आदर्श रूप से n ^वें सबसे छोटे k -uple का मान n से कम है , और इस मानक n या उससे कम के सभी tuples इस सूची में शामिल हैं।

उलटा के लिए, हम सिर्फ के एक काफी लंबे समय से सूची उत्पन्न कश्मीर , -tuples दिया की स्थिति का पता लगाने कश्मीर उस सूची में -tuple, और फिर "एक सकारात्मक पूर्णांक में एक तह" आपरेशन उलट।

Comments

इनपुट्स के साथ चलने से [15, 5]मेरा PC क्रैश हो गया ...

— JungHwan Min

वही होगा। सिद्धांत रूप में, एल्गोरिथ्म किसी भी चीज़ के लिए काम करता है, लेकिन आपके मामले में यह {5 -31, .., 31} रेंज से सभी 5-टुपल्स उत्पन्न करके और फिर 31 वां एक ले कर काम करता है, इसलिए यह स्मृति-गहन है।

— मिशा लावरोव

Answer 5

जे, 7 बाइट्स

#.,|:#:

जे कोड यह शर्मनाक सरल करने के लिए

एक बहुत ही सरल युग्मन फ़ंक्शन (या, ट्यूपिंग फ़ंक्शन) केवल प्रत्येक संख्याओं के द्विआधारी विस्तार के अंकों को इंटरलेव करना है। तो, उदाहरण के लिए (47, 79)इस तरह रखा जाएगा:

1_0_0_1_1_1_1
 1_0_1_1_1_1
-------------
1100011111111

या, 6399. जाहिर है, हम तुच्छ रूप से किसी भी n-tuple को सामान्य कर सकते हैं।

आइए देखें कि यह क्रिया क्रिया द्वारा कैसे काम करती है।

#:एंटी-बेस दो है, जब इस्तेमाल किया जाता है तो यह एक संख्या के द्विआधारी विस्तार देता है। #: 47 79परिणाम देता है:

0 1 0 1 1 1 1
1 0 0 1 1 1 1

|:ट्रांसपोज़ ऑपरेटर है, जो केवल एक सरणी को घुमाता है। परिणाम का घूर्णन #: 47 79:

0 1
1 0
0 0
1 1
1 1
1 1
1 1

जब मोनडली का उपयोग किया जाता है, तो रवेल ,ऑपरेटर होता है, यह एक तालिका से 1-आयामी सूची तैयार करता है:

0 1 1 0 0 0 1 1 1 1 1 1 1 1

अंत में, #.हमें परिणाम देते हुए बाइनरी विस्तार को वापस लाती है 6339।

यह समाधान पूर्णांक के किसी भी स्ट्रिंग के लिए काम करेगा।

Comments

यह नकारात्मक संख्याओं के लिए कैसे काम करता है?

— नील

Answer 6

पर्ल 6 , 148 बाइट्स

my@s=map ->\n{|grep {n==abs any |$_},(-n..n X -n..n)},^Inf;my&f={$_==1??+*!!do {my&g=f $_-1;my@v=map {.[0],|g .[1]},@s;->\n{@v[n>=0??2*n!!-1-2*n]}}}

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

Ungolfed:

sub rect($n) {
    grep ->[$x,$y] { abs($x|$y) == $n }, (-$n..$n X -$n..$n);
}

my @spiral = map { |rect($_) }, ^Inf;

sub f($k) {
    if ($k == 1) {
        -> $_ { $_ }
    } else {
        my &g = f($k-1);
        my @v = map -> [$x, $y] { $x, |g($y) }, @spiral;
        -> $_ { $_ >= 0 ?? @v[2*$_] !! @v[-1-2*$_] }
    }
}

स्पष्टीकरण:

• rect($n)एक सहायक कार्य है जो एक आयत के किनारे पर अभिन्न बिंदुओं के निर्देशांक को निर्देशांक से उत्पन्न करता (-$n,$n)है ($n, $n)।

• @spiral 0 से शुरू, बढ़ते आकार के आयतों के किनारों पर अभिन्न बिंदुओं की एक आलसी, अनंत सूची है।

• f($k)एक फ़ंक्शन देता है जो पूर्णांकों के पूर्णांक से-पूर्णांक का एक $kआक्षेप है।

यदि $kहै 1, fतो पहचान मानचित्रण लौटाता है -> $_ { $_ }।

अन्यथा, &g पूर्णांकों के पूर्णांकों से पुनरावर्ती मैपिंग को पुन: प्राप्त किया जाता है $k-1।

फिर, हम @spiralमूल से बाहर निकलते हैं, और प्रत्येक बिंदु पर $kएक्स-समन्वय और कॉलिंग के सपाट परिणाम लेकर एक- सूत्र बनाते हैंg Y- समन्वय के साथ । यह आलसी जनित मानचित्रण सरणी में संग्रहीत होता है @v।

@vसभी $k-tuples में अनुक्रमणिका 0 से शुरू होता है , इसलिए अनुक्रमण को ऋणात्मक पूर्णांकों तक विस्तारित करने के लिए, हम सिर्फ सकारात्मक संख्याओं को और समान संख्याओं को ऋणात्मक इनपुटों को मैप करते हैं। एक फ़ंक्शन (क्लोजर) लौटाया जाता है जो @vइस तरह से तत्वों को देखता है ।

Answer 7

जावास्क्रिप्ट, 155 बाइट्स

f=k=>x=>(t=x<0?1+2*~x:2*x,h=y=>(g=(v,p=[])=>1/p[k-1]?v||t--?0:p.map(v=>v&1?~(v/2):v/2):[...Array(1+v)].map((_,i)=>g(v-i,[...p,i])).find(u=>u))(y)||h(y+1))(0)

f=k=>x=>(t=x<0?1+2*~x:2*x,h=y=>(g=(v,p=[])=>1/p[k-1]?v||t--?0:p.map(v=>v&1?~(v/2):v/2):[...Array(1+v)].map((_,i)=>g(v-i,[...p,i])).find(u=>u))(y)||h(y+1))(0)

<p>k = <input id=k value=2>
<p>from <input id=a value=-5>
<p>to <input id=b value=5>
<p><button type="button" onclick="for(o.value='',i=+a.value;i<=b.value;i++)o.value+=[i,f(+k.value)(i)].join(':')+'\n';">generate</button>
<p><pre><output id=o>

Prettify संस्करण:

k => x => {
  // Map input to non-negative integer
  if (x > 0) t = 2 * x; else t = 2 * -x - 1;
  // we try to generate all triples with sum of v
  g = (v, p = []) => {
    if (p.length === k) {
      if (v) return null;
      if (t--) return null;
      // if this is the t-th one we generate then we got it
      return p;
    }
    for (var i = 0; i <= v; i++) {
      var r = g(v-i, [...p, i]);
      if (r) return r;
    }
  }
  // try sum from 0 to infinity
  h = x => g(x) || h(x + 1);
  // map tuple of non-negative integers back
  return h(0).map(v => {
    if (v % 2) return -(v + 1) / 2
    else return v / 2;
  });
}

• सबसे पहले, हम सभी पूर्णांकों को एक-एक करके सभी गैर-ऋणात्मक पूर्णांकों में मैप करते हैं:
  • अगर n> 0 तो परिणाम = n * 2
  • अन्यथा परिणाम = -n * 2 - 1
• दूसरा, हम सभी tuples को k-length गैर-नकारात्मक पूर्णांक के साथ एक ऑर्डर देते हैं:
  • सभी तत्व की गणना, पहले छोटा आता है
  • यदि राशि समान है, तो बाएं से दाएं की तुलना करें, छोटा पहले आता है
  • परिणामस्वरूप, हमें सभी गैर-नकारात्मक पूर्णांकों के लिए मानचित्र मिला, जो कि गैर-ऋणात्मक पूर्णांकों के साथ ट्यूपल्स के लिए थे
• अंत में, पहले चरण में समान सूत्र वाले सभी पूर्णांकों के लिए दूसरे चरण में दिए गए tuple में गैर-नकारात्मक पूर्णांकों को मैप करें

Comments

मुझे लगता x<0?~x-x:x+xहै कि 2 बाइट्स बचाता है।

— नील

Answer 8

वोल्फ्राम भाषा (गणितज्ञ) , 107 बाइट्स

(-1)^#⌈#/2⌉&@Nest[{w=⌊(√(8#+1)-1)/2⌋;x=#-w(w+1)/2,w-x}~Join~{##2}&@@#&,{2Abs@#-Boole[#<0]},#2-1]&

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

उलटा, 60 बाइट्स

(-1)^#⌈#/2⌉&@Fold[+##(1+##)/2+#&,2Abs@#-Boole[#<0]&/@#]&

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

स्पष्टीकरण:

Z -> N0 के माध्यम से f(n) = 2n if n>=0 and -2n-1 if n<0

N0 -> N0 ^ 2 के माध्यम से युग्मन फ़ंक्शन के व्युत्क्रम से

N0 -> N0 ^ k बार-बार बाईं ओर की सबसे बड़ी संख्या के ऊपर लागू करें जब तक कि हम लंबाई न प्राप्त कर लें k

N0 ^ k -> Z ^ k via f(n) = (-1)^n * ceil(n/2), तत्व-वार

---

गणितज्ञ, 101 बाइट्स

(-1)^#⌈#/2⌉&@Nest[{a=#~IntegerExponent~2+1,#/2^a+1/2}~Join~{##2}&@@#&,{2Abs@#+Boole[#<=0]},#2-1]&

उपरोक्त के समान (N0 के बजाय N का उपयोग करता है), लेकिन आपत्ति के विपरीत का उपयोग करता है f: N ^ 2 -> N के माध्यम से f(a, b) = 2^(a - 1)(2b - 1)

Comments

तुम्हारा मतलब है ... वहाँ कोई गणितीय बनाया गया है उस के लिए (जब ऐलिस एक है)? मैं अवाक हूं।

— JayCe

Answer 9

जावास्क्रिप्ट, 112 बाइट्स

k=>x=>(r=Array(k).fill(''),[...`${x<0?2*~x+1:2*x}`].map((c,i,s)=>r[(s.length-i)%k]+=c),r.map(v=>v&1?~(v/2):v/2))

1. गैर-नकारात्मक में परिवर्तित करें
2. (n * k + i) वें अंक से आई-वें नंबर
3. वापस बदलना

Comments

@HermanLauenstein को उल्टा करने की आवश्यकता नहीं है?

— tsh

मुझे लगता x<0?~x-x:x+xहै कि 2 बाइट्स बचाता है।

— नील

-5 बाइट्स का उपयोग करके [...BT${x<0?~x-x:x+x}BT].reverse().map((c,i)=>r[i%k]+=c),(@Neil के लिए क्रेडिट x<0?~x-x:x+x)। .reverse()इसके बजाय इसका उपयोग किया जाता है (s.length-i)क्योंकि यह sपहले के लिए अतिरिक्त पैरामीटर की आवश्यकता से बचा जाता है .map। अस्थायी सरणी का फिर से उपयोग नहीं किए जाने के बाद वापस लौटने की कोई आवश्यकता नहीं है। (मैंने इसका परीक्षण नहीं किया है, लेकिन शायद यह काम करना चाहिए)

— हरमन एल

एक और बाइट की जगह बचाया जा सकता है .fill('')के साथ .fill(0), के बाद से एक अग्रणी शून्य (कम से कम जब सफारी में परीक्षण नहीं) कोई फर्क नहीं पड़ता

— हरमन एल

@HermanLauenstein क्या आपने कोशिश की .fill`` ? यह बाइट्स के एक और जोड़े को बचा सकता है।

— नील

Answer 10

05AB1E , 20 बाइट्स

[D_#>3‰`<s])sô0ζεR3β

इसे ऑनलाइन आज़माएं! पोर्ट ऑफ @ ब्लाकेन्थ का जवाब। उलटा, 17 बाइट्स:

[Z_#>3‰ø`<s])˜R3β

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

Answer 11

जेली , 15 बाइट्स

µ<1ạḤðŒRṗAS$Þ⁸ị

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

1 अनुक्रमित।

श्लोक में:

AṀ×LŒRṗLAS$Þiµ:2NḂ}¡

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