18

संबंधित, लेकिन इसके लिए केवल सकारात्मक पूर्णांक की आवश्यकता होती है और इसके लिए कम्यूटेटिव होना जरूरी नहीं है

इस विकिपीडिया लेख में कैंटर पेयरिंग फंक्शन का वर्णन किया गया है । अनिवार्य रूप से, यह एक ऐसा ऑपरेशन है कि जब इसे दो मूल्यों X और Y पर लागू किया जाता है, तो कोई भी मूल मान प्राप्त कर सकता है X और Y ने परिणाम दिया।

आपका काम दो कार्यों को डिजाइन करना है: एक जो प्रदर्शन करता है X, Y -> Zऔर दूसरा जो प्रदर्शन करता है Z -> X, Y। यहाँ पकड़ है: X, Y -> Zकम्यूटेटिव होना चाहिए। इसका मतलब है कि Z -> X, Yअगर इनपुट X, Yया था यह निर्धारित करने में सक्षम नहीं होगा Y, X।

इस चुनौती की औपचारिक परिभाषा यह होगी:

संख्याओं की एक गणना करने योग्य अनंत सेट चुनें।
निम्नलिखित कार्यों को करने वाले दो कार्यों को डिज़ाइन करें:

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

आवश्यकताएँ

परिणाम रन के बीच समान होना चाहिए।
{a, a} एक अनियंत्रित जोड़ी है

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

code-golf math function

— HyperNeutrino
स्रोत

क्या यह puzzling.stackexchange.com के लिए बेहतर नहीं है ?

— जकुबे

2

@Jakube ज़रूरी नहीं, क्योंकि आपको कोड लिखना आवश्यक है।

— श्री एक्सकोडर

मुझे लगता है कि जोड़े अद्वितीय हैं, लेकिन उन जोड़ियों में उपयोग किए गए नंबर नहीं हैं? तो जब 1,2जोड़े में से एक है, तो 1,3क्या एक संभावित जोड़ी (दोनों का उपयोग 1) भी हो सकती है ?

— केविन क्रूजसेन

@KevinCruijssen मुझे यकीन नहीं है कि आपका क्या मतलब है

— HyperNeutrino

@Giuseppe व्युत्क्रम को सही क्रम वापस करने में सक्षम होने की आवश्यकता नहीं है; यह सिर्फ इतना है कि समारोह के लिए है fऔर उसके व्युत्क्रम g, sorted((x, y))एक ही रूप में होना चाहिएsorted(g(f(x, y)))

— HyperNeutrino

13

हास्केल , 65 + 30 = 95 बाइट्स

a#b=length.fst$span(<(max a b,min a b))[(a,b)|a<-[1..],b<-[1..a]]

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

([(a,b)|a<-[1..],b<-[1..a]]!!)

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

नोट: जब दो फ़ंक्शन कोड साझा कर सकते हैं, यह केवल 75 बाइट्स है:

(l!!)
a#b=length.fst$span(<(max a b,min a b))l
l=[(a,b)|a<-[1..],b<-[1..a]]

इसे ऑनलाइन आज़माएं! डोमेन पॉजिटिव पूर्णांक है। फ़ंक्शन (#)पेयरिंग कार्य करता है, फ़ंक्शन (l!!)इसका व्युत्क्रम होता है। उपयोग उदाहरण: दोनों (#) 5 3और(#) 3 5 उपज 12, और (l!!) 12पैदावार (5,3)।

यह सभी प्रकार के जोड़े को स्पष्ट रूप से अनंत सूची में सूचीबद्ध करके काम करता है l :

l = [(1,1),(2,1),(2,2),(3,1),(3,2),(3,3),(4,1),(4,2),(4,3),(4,4),(5,1),(5,2),(5,3),(5,4),(5,5),(6,1), ...`

एन्कोडिंग तो इस सूची में सिर्फ सूचकांक है।

— Laikoni
स्रोत

ओपी द्वारा, साझा कोड को दो बार गिना जाना चाहिए

— गर्वित हेकलर

5

पायथ , 8 + 6 = 14 बाइट्स

ij\aSQ16

    SQ   # Sort the input
 j\a     # join with "a"
i     16 # convert from base 16 to base 10

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

c.HQ\a

 .HQ     # convert from base 10 to 16
c   \a   # split on "a"

इसे ऑनलाइन आज़माएं!
डोमेन: सकारात्मक पूर्णांक।

— छड़ी
स्रोत

अच्छा तरीका! +1

— हाइपरएनुट्रीनो

4

बहुत से नंबरों के लिए काम नहीं करता है जैसे कि 2और 10उदाहरण के लिए (जो कि डोमेन में हैं)

— Emigna

ज़रूर। Example1 , Example2

— Emigna

दूसरा फ़ंक्शन S के किसी भी मान के लिए काम करने वाला है , न कि केवल एक जो पहले फ़ंक्शन के साथ उत्पन्न हुआ था (मैंने वही गलती की थी)।

— अरनुलद

4

जेली , 8 + 11 = 19 बाइट्स

रॉड के एल्गोरिथ्म के काम नहीं करने के बाद से वापस लुढ़का।

यह धनात्मक पूर्णांक के डोमेन पर काम करता है।

लेता है xऔर y2 तर्क के रूप में, कोई फर्क नहीं पड़ता कि किस क्रम में, रिटर्न z।

»’RSð+ð«

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

ले जाता है zऔर लौट जाता है[min(x, y), max(x, y)]

R€Ẏ,Rx`$ị@€

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

— आउटगोल्फ को एरिक करें
स्रोत

1

क्यों घटता है? यह रॉड का एल्गोरिथ्म नहीं है।

— आउटगॉल्फ

4

जावास्क्रिप्ट (ईएस 7), 44 बाइट्स

(x,y)=>x>y?x*x+y:y*y+x
z=>[x=z**.5|0,y=z-x*x]

गैर-नकारात्मक पूर्णांकों से लेकर उसके उप-भाग तक के मानचित्र।

— नील
स्रोत

4

सी (जीसीसी) , 36 + 39 = 75 बाइट्स

@ बर्ट को दो बाइट बचाने के लिए धन्यवाद।

डोमेन गैर-नकारात्मक पूर्णांक है।

p(x,y){return y>x?p(y,x):-~x*x/2+y;}

लेता है xऔर y, लौटता है z।

u(int*r){for(*r=0;r[1]>*r;r[1]-=++*r);}

एक दो-तत्व intसरणी लेता है । zकॉल करने से पहले दूसरा तत्व सेट किया जाना चाहिए । कॉल के बाद rहोता है xऔर y।

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

— nwellnhof
स्रोत

(x+1)->-~x

— tsh

3

जेली , 13 11 बाइट्स

सकारात्मक पूर्णांक के लिए सकारात्मक पूर्णांक की जोड़ी, 5 बाइट्स

Ṁc2+Ṃ

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

सकारात्मक पूर्णांक की जोड़ी के लिए सकारात्मक पूर्णांक, 6 बाइट्स

ŒċṀÞị@

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

कलन विधि

यदि हम अपने पूर्णांक के द्वारा सभी पूर्णांक के धनात्मक जोड़े के सेट को सॉर्ट करते हैं और फिर उनकी राशि से, हमें निम्नलिखित अनुक्रम मिलते हैं।

{1,1}, {1,2}, {2,2}, {1,3}, {2,3}, {3,3}, {1,4}, {2,4}, {3 , 4}, {4,4}, {1,5}, {2,5}, {3,5}, {4,5}, {5,5},…

पहला फ़ंक्शन एक जोड़ी {x, y} लेता है और इस क्रम में इसका सूचकांक पाता है।

दूसरा फ़ंक्शन एक सकारात्मक पूर्णांक z लेता है और अनुक्रम के z ^वें आइटम को लौटाता है ।

ध्यान दें कि यह मानचित्रण @ EriktheOutgolfer के जेली उत्तर के समान है ।

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

Ṁc2+Ṃ   Main link. Argument: [x, y]
        Let m = max(x, y) and n = min(x, y).

Ṁ       Maximum; yield m.
 c2     2-combinations; yield mC2 = m(m-1)/2.
        Note that there's one pair with maximum 1 ({1,1}), two pairs with maximum 2
        ({1,2}, {2,2}), etc., so there are 1 + 2 + … + (m-1) = m(m-1)/2 pairs with
        maximum less than m.
    Ṃ   Minimum; yield n.
        Note that {x,y} is the n-th pair with maximum m.
   +    Add; yield mC2 + n.
        This finds {x,y}'s index in the sequence.

ŒċṀÞị@  Main link. Argument: z

Œċ      2-combinations w/replacement; yield all pairs [x, y] such that x ≤ y ≤ z.
  ṀÞ    Sort by maximum.
    ị@  Retrieve the pair at index z (1-based).

— डेनिस
स्रोत

2

कृपया स्पष्टीकरण दें। मुझे विश्वास नहीं हो रहा है कि यह वैध है ...

— एरिक आउटगॉल्फ

मैंने एल्गोरिथ्म जोड़ा है।

— डेनिस

कुछ मेरे लिए अच्छा नहीं है ... हालांकि मुझे यकीन नहीं है कि यह या तो अमान्य है। मूल रूप से यह अच्छी तरह से छड़ी नहीं करता है कि आप दोनों का उपयोग करें cऔर Œċ... हालांकि मैं गलत हो सकता हूं। BTW कि मेरा जवाब था कि आप outgolfed> _>

— 18

अंतर जोड़े के लिए न्यूनतम है। अगर सी प्रतिस्थापन के बिना संयोजन की गणना करता है और Ƈ , के साथ संयोजन की गणना करता है nƇ2 = NC2 + n ।

— डेनिस

2

गणितज्ञ (35 + 53) = 78 बाइट्स

((x=Min[#])+(y=Max[#]))(x+y+1)/2+y&

(i=Floor[(-1+Sqrt[1+8#])/2];{#-i(1+i)/2,i(3+i)/2-#})&

यह Z <-> ZxZ के लिए एक अच्छा ज्ञात द्विघात युग्मन कार्य है जो इसे क्रमहीन बनाने के लिए न्यूनतम और अधिकतम के साथ संयुक्त है।

— केली लोडर
स्रोत

2

रूबी, 66 बाइट्स

f=->x,y{2**~-x|2**~-y}
g=->n{x,y=(1..n).select{|i|n[i-1]>0};[x,y||x]}

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

हम f (x, y) = 2 ^x-1 बिटवाइज़-या 2 परिभाषित करते हैं^y-1 । डोमेन में 1,2 वाले सेट के रूप में परिभाषित किया गया है, और सेट में संख्याओं पर कॉल करके उत्पादित किए जा सकने वाले सभी नंबर (ध्यान दें कि f (1,1) = 1 और f (2,2) = 2) तो 1 और 2 में उलटा है)। परिणामी संख्याओं में उनके बाइनरी विस्तार में या तो एक या दो 1s होते हैं, सेट में संख्याओं के अनुरूप 1s के सूचकांकों के साथ। हम सूचकांक लेने के द्वारा मूल अनियंत्रित जोड़ी को निकाल सकते हैं। यदि केवल 1 है, तो इसका मतलब है कि जोड़ी के तत्व समान हैं।

उदाहरण के लिए, एफ (3,5) 20 है, क्योंकि बेस 2 में 20 10100 है, जिसमें 3 और 5 वें सबसे महत्वपूर्ण स्थानों में 1 एस है।

— histocrat
स्रोत

S = यह सेट (OEIS लिंक)

— Giuseppe

धन्यवाद, S वास्तव में उस OEIS अनुक्रम का एक उपसमूह है, क्योंकि इसमें केवल संख्याएँ शामिल हैं जिनके 1s में S. हैं

— histocrat

आह हाँ, बिल्कुल। खैर, कोई अन्य अनुक्रम पहले कुछ शब्दों (32 तक) से मेल नहीं खाता है।

— ग्यूसेप

0 से S को जोड़ें और आप कुछ गिरावट को बचा सकते हैं।

— nwellnhof

2

जावा 8, 153 146 141 137 + 268 224 216 205 बाइट्स

जोड़ी समारोह

a->{String f="";for(int i=(f+a[0]).length(),c=0,j;i>0;i-=c,f+=c,c=0)for(j=1;j<10;c+=i-j++<0?0:1);return new Integer(a[0]+""+a[1]+"0"+f);}

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

Depair फ़ंक्शन

r->{String a=r+"",t=a.substring(a.lastIndexOf('0')+1);int l=0,i=l,o=t.length();for(;i<o;l+=r.decode(t.charAt(i++)+""));return new int[]{r.decode(a.substring(0,l)),r.decode(a.substring(l,a.length()-o-1))};}

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

— रॉबर्टो ग्राहम
स्रोत

1

आप कुछ हिस्सों को गोल्फ कर सकते हैं। जोड़ी समारोह में: int i=(""+a[0]).length()हो सकता है int i=(f+a[0]).length(); के बीच का स्थान c=0,j;i>0;हटाया जा सकता है; a[0].parseIntहो सकता है new Integer। डिप्रेशन फंक्शन में: तीनों r.parseIntहो सकते हैं r.decode; और आप t.length()दो बार उपयोग करने के बाद से इसके लिए एक अंतर चर बना सकते हैं ।

— केविन क्रूज़सेन

1

05AB1E , 6 + 11 = 17 बाइट्स

मेरे जैली जवाब का पोर्ट।

डोमेन: सकारात्मक पूर्णांक।

[x, y]इनपुट के रूप में एक सूची लेता है , रिटर्न करता है z।

{`<LO+

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

zइनपुट के रूप में एक सकारात्मक पूर्णांक लेता है , रिटर्न करता है [min(x, y), max(x, y)]।

L2ã€{RÙR¹<è

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

-5 एमिगा को धन्यवाद ।

— आउटगोल्फ को एरिक करें
स्रोत

आपका दूसरा कार्यक्रम L2ã € {R <RI <è

— Emigna

@Eignigna के साथ अच्छी चाल 2ã€{RÙR!

— एग्री द आउटगोलर

1

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

f=a=>eval('0x'+a.sort().join`a`)
g=n=>n.toString(16).split`a`.map(x=>+x)

सकारात्मक पूर्णांकों के लिए काम करता है (सिद्धांत में)। काफी सरल विचार: कुछ (जादू) क्रम में दो नंबर सॉर्ट करें, उन्हें एक पत्र द्वारा स्ट्रिंग के रूप में कनेक्ट करें "a", इसे हेक्स पूर्णांक के रूप में पार्स करें।

कोड स्निपेट दिखाएं

f=a=>eval('0x'+a.sort().join`a`)
g=n=>n.toString(16).split`a`.map(x=>+x)

<pre oninput="p.value=f([+x.value, +y.value])">
     X = <input id="x" type="number" min="0" />
     Y = <input id="y" type="number" min="0" />
 f(X,Y)= <output id="p"></output>
</pre>

<pre oninput="q.value=g(+u.value).join(', ')">
     U = <input id="u" type="number" />
   g(U)= <output id="q"></output>
</pre>

स्निपेट का विस्तार करें

— TSH
स्रोत

1

MATL, 6 + 8 = 14 बाइट्स

एनकोडिंग फ़ंक्शन, दो इनपुट लेता है n, मी। Nth प्राइम और mth प्राइम का उत्पाद।

,iYq]*

कदम:

, - 7- करो
i - पुश इनपुट
Yq - पॉप इनपुट, धक्का input'th प्रधानमंत्री
]* - एंड दो बार करें, दोनों प्राइम पॉप करें और प्रोडक्ट को पुश करें

डिकोडिंग फ़ंक्शन, एक इनपुट मी लेता है। N के प्रत्येक प्रमुख कारकों के नीचे प्राइम की संख्या को आउटपुट करता है।

iYf"@Zqn

कदम:

i - पुश इनपुट
Yf - पॉप इनपुट, प्रमुख कारकों की पुश सरणी
" - सरणी में n के लिए
@Zq - एन के नीचे primes की पुश सरणी
n - पॉप सरणी, सरणी की लंबाई धक्का

यह सराहनीय है क्योंकि गुणा कम्यूटेटिव है, और इंजेक्टिव है क्योंकि प्राइम फैक्टरशिप अद्वितीय हैं। ऐसा नहीं है कि यह पूर्णांकों पर नहीं है।

— डेव
स्रोत

0

भूसी , 5 + 3 = 8 बाइट्स

मुझे वास्तव में उम्मीद है कि मुझे चुनौती सही मिली है, मैं कुछ हटाए गए उत्तर देखता हूं जो मुझे मान्य लगते हैं ...

एकल पूर्णांक में धनात्मक पूर्णांक के जोड़े:

¤*!İp

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

यह दिए गए सूचकांकों (1-अनुक्रमित) पर संख्याओं को अभाज्य संख्याओं की सूची से निकालकर और उन्हें गुणा करके काम करता है।

सकारात्मक पूर्णांकों के जोड़ों को पहले फ़ंक्शन का परिणाम:

mṗp

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

हम इनपुट नंबर को फैक्टर करते हैं और सूचकांक को उसके कारकों के सभी (दोनों) की सूची में लौटाते हैं।

काम का उदाहरण

यह देखते हुए (4,1)एक शुरू करने जोड़ी के रूप में, हम चौथे और पहले प्रधानमंत्री संख्या ले (7,2)और गुणा उन्हें → 14। यह गुणन वह है जो दो तत्वों के क्रम पर कार्य को अनिश्चित बनाता है।

से शुरू 14, हम इसे गुणनखंड (2,7)और के सूचकांकों लौटने 2और 7रूढ़ अंक → की सूची में (1,4)।

— सिंह
स्रोत

दरअसल, अरनौलड से हटाए गए उत्तर को देखते हुए, इसका एल्गोरिथ्म भी बेहतर है, और इसे हस्क में पोर्ट करने से 6 बाइट्स मिलेंगे ... क्या कोई पुष्टि कर सकता है कि इसका समाधान (और मेरा भी) वैध है या नहीं?

— सिंह

अपराधों के लिए काम नहीं करता है (जो कि सकारात्मक पूर्णांक के क्षेत्र में हैं)

— एमिग्ना

@ एनिमा दूसरा फंक्शन नहीं करती है, लेकिन प्राइम्स पहले कभी नहीं लौटती हैं ...

— लियो

आपका डोमेन सकारात्मक पूर्णांक है, इसलिए सकारात्मक पूर्णांकों के लिए दोनों विधियों को कार्य करने की आवश्यकता है। EDIT: या कम से कम जो एक आवश्यकता हुआ करती थी। वर्तमान नियम डोमेन के सबसेट को अनुमति देते हैं।

— एमिग्ना

0

सी # , 80 बाइट्स (38 + 42)

डेटा

एनकोडर

इनपुट Int32 l A नंबर
इनपुट Int32 r A नंबर
आउटपुट Int64 दोनों इंट्स एक साथ जुड़े

डिकोडर

इनपुट Int32 v मान
आउटपुट Int32[] दो मूल ints के साथ एक सरणी।

golfed

// Encoder
e=(l,r)=>{return(long)l<<32|(uint)r;};

// Decoder
d=v=>{return new[]{v>>32,v&0xFFFFFFFFL};};

Ungolfed

// Encoder
e = ( l, r ) => {
    return (long) l << 32 | (uint) r;
};

// Decoder
d = v => {
    return new[] {
        v >> 32,
        v & 0xFFFFFFFFL };
};

अनपढ़ पठनीय

// Encoder
// Takes a pair of ints
e = ( l, r ) => {

    // Returns the ints fused together in a long where the first 32 bits are the first int
    // and the last 32 bits the second int
    return (long) l << 32 | (uint) r;
};

// Decoder
// Takes a long
d = v => {

    // Returns an array with the ints decoded where...
    return new[] {

        // ... the first 32 bits are the first int...
        v >> 32,

        // ... and the last 32 bits the second int
        v & 0xFFFFFFFFL };
};

पूर्ण कोड

using System;
using System.Collections.Generic;

namespace TestBench {
    public class Program {
        // Methods
        static void Main( string[] args ) {
            Func<Int32, Int32, Int64> e = ( l, r ) => {
                return(long) l << 32 | (uint) r;
            };
            Func<Int64, Int64[]> d = v => {
                return new[] { v >> 32, v & 0xFFFFFFFFL };
            };

            List<KeyValuePair<Int32, Int32>>
                testCases = new List<KeyValuePair<Int32, Int32>>() {
                    new KeyValuePair<Int32, Int32>( 13, 897 ),
                    new KeyValuePair<Int32, Int32>( 54234, 0 ),
                    new KeyValuePair<Int32, Int32>( 0, 0 ),
                    new KeyValuePair<Int32, Int32>( 1, 1 ),
                    new KeyValuePair<Int32, Int32>( 615234, 1223343 ),
                };

            foreach( KeyValuePair<Int32, Int32> testCase in testCases ) {
                Console.WriteLine( $" ENCODER: {testCase.Key}, {testCase.Value} = {e( testCase.Key, testCase.Value )}" );
                Console.Write( $"DECODING: {e( testCase.Key, testCase.Value )} = " );
                PrintArray( d( e( testCase.Key, testCase.Value ) ) );

                Console.WriteLine();
            }

            Console.ReadLine();
        }

        public static void PrintArray<TSource>( TSource[] array ) {
            PrintArray( array, o => o.ToString() );
        }
        public static void PrintArray<TSource>( TSource[] array, Func<TSource, String> valueFetcher ) {
            List<String>
                output = new List<String>();

            for( Int32 index = 0; index < array.Length; index++ ) {
                output.Add( valueFetcher( array[ index ] ) );
            }

            Console.WriteLine( $"[ {String.Join( ", ", output )} ]" );
        }
    }
}

विज्ञप्ति

v1.0 - 80 bytes- प्रारंभिक समाधान।

अजगर: 41 + 45 = 86

एनकोडर: 41

e=lambda*x:int('1'*max(x)+'0'+'1'*min(x))

e(4, 3), e(3,4)
(11110111, 11110111)

डिकोडर: 45

d=lambda z:[len(i)for i in str(z).split('0')]

d(11110111)
[४, ३]

पुराना प्रयास:

पायथन: 114: 30 + 84

एनकोडर: 30

2 पूर्णांक स्वीकार करता है, एक स्ट्रिंग लौटाता है

e=lambda*x:2**max(x)*3**min(x)

e(3, 4), e(4, 3)
(432, 432)

डिकोडर: 86

def d(z):
 x=y=0
 while 1-z%2:
  x+=1
  z/=2
 while 1-z%3:
  y+=1
  z/=3
 return x,y

d(432)
४, ३

डिकोडर 2: 120

जनरेटर की समझ और योग के साथ एक और प्रयास

def d(z):
 x=sum(1 for i in range(z)if not z%(2**i))-1
 z/=2**x
 return x,sum(1 for i in range(int(z))if not z%(3**i))-1

— मार्टेन फ़ेबे
स्रोत

1

दूसरे प्रयास के आधार पर: e=lambda*x:10**sum(x)-10**min(x);d=lambda z:map(z .count,'09'); TIO

— tsh

@tsh बहुत अच्छा। मैं इसे बाद में अनुकूलित करूंगा, या आप अपना जवाब प्रस्तुत कर सकते हैं

— Maarten Fabré

किसी भी (प्रतिबंधित) अनंत सेट और अनियंत्रित जोड़े के बीच एक कम्यूटेटिव इंजेक्शन फ़ंक्शन डिज़ाइन करें

आवश्यकताएँ

हास्केल , 65 + 30 = 95 बाइट्स

पायथ , 8 + 6 = 14 बाइट्स

जेली , 8 + 11 = 19 बाइट्स

जावास्क्रिप्ट (ईएस 7), 44 बाइट्स

सी (जीसीसी) , 36 + 39 = 75 बाइट्स

जेली , 13 11 बाइट्स

सकारात्मक पूर्णांक के लिए सकारात्मक पूर्णांक की जोड़ी, 5 बाइट्स

सकारात्मक पूर्णांक की जोड़ी के लिए सकारात्मक पूर्णांक, 6 बाइट्स

कलन विधि

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

गणितज्ञ (35 + 53) = 78 बाइट्स

रूबी, 66 बाइट्स

जावा 8, 153 146 141 137 + 268 224 216 205 बाइट्स

05AB1E , 6 + 11 = 17 बाइट्स

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

MATL, 6 + 8 = 14 बाइट्स

भूसी , 5 + 3 = 8 बाइट्स

काम का उदाहरण

सी # , 80 बाइट्स (38 + 42)

डेटा

एनकोडर

डिकोडर

golfed

Ungolfed

अनपढ़ पठनीय

पूर्ण कोड

विज्ञप्ति

टिप्पणियाँ

अजगर: 41 + 45 = 86

एनकोडर: 41

डिकोडर: 45

पुराना प्रयास:

एनकोडर: 30

डिकोडर: 86

डिकोडर 2: 120