व्याकुल योगों का निर्माण

Question

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

एक और आवश्यकता है: दो अलग-अलग इनपुटों के लिए कोई भी संख्या आउटपुट का हिस्सा नहीं हो सकती है ।

विवरण

• आपको कम से कम रेंज -32768 .. 32767(समावेशी) के लिए इनपुट को संभालने में सक्षम होना चाहिए ।
• यदि आपका डेटाटाइप मनमाने ढंग से पूरे नंबरों को संभाल नहीं सकता है, तो यह ठीक है लेकिन आपके एल्गोरिथ्म को सिद्धांत में बड़े और छोटे नंबरों के लिए काम करना चाहिए।

उदाहरण

प्रत्येक ब्लॉक के प्रारूप में एक सही या गलत समाधान का एक हिस्सा दिखाता है input => output।

1 => 6 -5
2 => -2 4
15 => 20 -5

Incorrect, as `-5` is used in two outputs.

-5 => -15 10
0 => 0 0
1 => 5 6
2 => -5 7

Incorrect, as `5 + 6` isn't `1`.

-1 => -1 0
0 => 6 -6
2 => 1 1

Can be correct if other outputs doesn't collide.

यह कोड गोल्फ है इसलिए सबसे छोटी प्रविष्टि जीतती है।

Comments

क्या आप -32768 .. 32767 तक इनपुट रेंज को सीमित कर सकते हैं ताकि हमें 17 बिट पूर्णांक का उपयोग न करना पड़े?

— फ़ूजएक्सएक्सएल

@FUZxxl मेरा बुरा, यही इरादा था। फिक्स्ड।

— रैंडम जूल

क्या आउटपुट एक सूची / एरे / ट्यूपल / सेट / आदि हो सकता है जिसमें दो पूर्णांक हों? (उदाहरण के लिए, f (1) => [2, -1])

— मोनोपोल

कई समाधान प्रतीत होते हैं जो मूल रूप से एक प्रतिबंधित पूर्णांक आकार पर निर्भर करते हैं - उदाहरण के लिए, इनपुट को एक बड़े सकारात्मक और एक बड़े नकारात्मक संख्या से गुणा करके। यह मुझे लगता है कि इस तरह के समाधान इस आवश्यकता को विफल कर रहे हैं कि "आपके एल्गोरिथ्म को सिद्धांत में मनमाने ढंग से बड़ी और छोटी संख्या के लिए काम करना चाहिए"। क्या मैं प्रश्न को गलत बता रहा हूँ?

— मैथमैंडन

Answer 1

पायथ, 8 बाइट्स

_J^Q3+QJ

प्रदर्शन। पायथन 2 कोड के बराबर:

Q=input()
J=Q**3
print -J
print Q+J

तो, आउटपुट का रूप है (-n**3, n+n**3)

कुछ आउटपुट:

-5 (125, -130)
-4 (64, -68)
-3 (27, -30)
-2 (8, -10)
-1 (1, -2)
 0 (0, 0)
 1 (-1, 2)
 2 (-8, 10)
 3 (-27, 30)
 4 (-64, 68)
 5 (-125, 130)

ये अलग हैं क्योंकि क्यूब्स काफी दूर तक स्थान दिया गया है कि जोड़ने nके लिए n**3अगले घन के अंतर को पार करने के लिए पर्याप्त नहीं है: n**3 < n+n**3 < (n+1)**3सकारात्मक के लिए n, और संतुलित नकारात्मक के लिए n।

Comments

आपको ,शुरुआत में इसकी आवश्यकता नहीं है , दो पंक्तियों की अनुमति दी गई प्रतीत होती है।

— माल्टीसेन

@ मैल्टीसेन मैंने इसे हटाने की कोशिश की, लेकिन केवल दूसरे नंबर के प्रिंट। हो सकता है कि Jअसाइनमेंट प्रिंटिंग को दबा दे?

— xnor

ओह, हाँ, आप सही हैं, क्षमा करें।

— माल्टसेन

-pyth में unary नेगेटिव ऑपरेटर नहीं है _, इसलिए यह _J^Q3+QJअपेक्षित रूप से काम करता है।

— माल्टसेन

@ मैलेटेन वास्तव में, यह काम करता है, मुझे बस Jबाहर नहीं होना चाहिए। मुझे इस बारे में बताने के लिए धन्यवाद।

— xnor

Answer 2

स्नोमैन 0.1.0 , 101 वर्ण

}vg0aa@@*45,eQ.:?}0AaG0`NdE`;:?}1;bI%10sB%nM2np`*`%.*#NaBna!*+#@~%@0nG\]:.;:;bI~0-NdEnMtSsP" "sP.tSsP

STDIN पर इनपुट, STDOUT पर अंतरिक्ष से अलग आउटपुट।

यह उसी विधि का उपयोग करता है जैसे कि इसहाक का उत्तर।

"पठनीयता" के लिए नए संस्करण के साथ टिप्पणी संस्करण:

}vg0aa          // get input, take the first char
@@*45,eQ.       // check if it's a 45 (ASCII for -) (we also discard the 0 here)
// this is an if-else
:               // (if)
  ?}0AaG        // remove first char of input (the negative sign)
  0`NdE`        // store a -1 in variable e, set active vars to beg
;
:               // (else)
  ?}1           // store a 1 in variable e, set active vars to beg
;bI             // active variables are now guaranteed to be beg
%10sB           // parse input as number (from-base with base 10)
%nM             // multiply by either 1 or -1, as stored in var e earlier
2np`*`          // raise to the power of 2 (and discard the 2)
%.              // now we have the original number in b, its square in d, and
                //   active vars are bdg
*#NaBna!*+#     // add abs(input number) to the square (without modifying the
                //   input variable, by juggling around permavars)
@~%@0nG\]       // active vars are now abcfh, and we have (0>n) in c (where n is
                //   the input number)
:.;:;bI         // if n is negative, swap d (n^2) and g (n^2+n)
~0-NdEnM        // multiply d by -1 (d is n^2 if n is positive, n^2+n otherwise)
tSsP            // print d
" "sP           // print a space
.tSsP           // print g

PPCG पर पहले स्नोमैन समाधान पर टिप्पणी: मुझे लगता है कि मेरी भाषा को यथासंभव भ्रमित करने का मेरा डिजाइन लक्ष्य हासिल किया गया है।

यह वास्तव में बहुत छोटा हो सकता था, लेकिन मैं एक बेवकूफ हूं और स्ट्रिंग के लिए नकारात्मक संख्याओं को लागू करना भूल गया हूं -> नंबर पार्सिंग। इसलिए मुझे मैन्युअल रूप से जांचना था कि क्या -पहला चरित्र है और यदि ऐसा है तो हटा दें।

Comments

ब्रेनफक की तुलना में बेहतर है।

— चरण

शुतुरमुर्ग इस बारे में कैसा महसूस करता है? ;)

— केड

Answer 3

पायथ, 15 11 बाइट्स

4 बाइट्स @Jakube की बदौलत

*RQ,hJ.aQ_J

प्रदर्शन।

यह नक्शे निम्नानुसार हैं:

0  -> 0, 0
1  -> 2, -1
-1 -> -2, 1
2  -> 6, -4
-2 -> -6, 4

और हां, तो चालू, हमेशा से जुड़े n^2और n^2 + n, प्लस या माइनस।

Answer 4

एपीएल, 15 बाइट्स

{(-⍵*3)(⍵+⍵*3)}

यह एक अनाम मानदंड फ़ंक्शन बनाता है जो जोड़े को -n ^ 3 ( -⍵*3), n + n ^ 3 ( ⍵+⍵*3) लौटाता है ।

आप इसे ऑनलाइन आज़मा सकते हैं ।

Answer 5

अजगर - 11 10 बाइट्स

बस 10e10 से गुणा करें और -10e10 + 1 मुझे दिखाने के लिए @xnor के लिए धन्यवाद कि मैं CGसंख्या के लिए उपयोग कर सकता हूं ।

*CGQ_*tCGQ

इसे यहाँ ऑनलाइन आज़माएँ ।

Comments

आप एक उपयुक्त रूप से बड़ी संख्या बना सकते हैं CG।

— xnor

@xnor टिप्स सूची में जोड़ना।

— माल्टीसेन

Answer 6

ओ , 17 15 9 बाइट्स

O की कुछ नई विशेषताओं का उपयोग करता है।

Q3 ^ .Q + p_p

पुराना संस्करण

[मैं # .Z3 ^ * \ जेड 3 ^) _ *] ओ

Comments

मैं इन ओ जवाबों का आनंद लेना शुरू कर रहा हूं, हालांकि मैं इसे और अधिक पसंद करूंगा यदि दुभाषिया जावा में नहीं लिखा गया था ...;)

— kirbyfan64sos

@ kirbyfan64sos यह पायथ जितना छोटा नहीं है, लेकिन यह कुछ उदाहरणों में सीजेएम और गोल्फस्क्रिप्ट को हरा सकता है। यह डिफेक्टिवली एरे के साथ कुछ भी करने को हरा सकता है, क्योंकि वे बहुत शक्तिशाली हैं।

— चरण

Answer 7

अजगर 3, 29 27

संपादित करें: 2 "विवरण" बुलेट बिंदु में आवश्यकता को पूरा नहीं करता है

बोनस: यह -99998 से 99998 समावेशी के लिए काम करता है

---

lambda n:[99999*n,-99998*n]

यह एक अनाम फ़ंक्शन * बनाता है, जिसका उपयोग आप कोष्ठक में संलग्न करके और फिर तर्क को कोष्ठक में रखकर इस तरह से कर सकते हैं:

(lambda n:[99999*n,-99998*n])(arg)

* इस सुझाव के लिए @ vioz- को धन्यवाद।

---

उदाहरण इनपुट / आउटपुट:

>>> (lambda n:[99999*n,-99998*n])(1)
[99999, -99998]
>>> (lambda n:[99999*n,-99998*n])(2)
[199998, -199996]
>>> (lambda n:[99999*n,-99998*n])(0)
[0, 0]
>>> (lambda n:[99999*n,-99998*n])(-1)
[-99999, 99998]
>>> (lambda n:[99999*n,-99998*n])(-2)
[-199998, 199996]
>>> (lambda n:[99999*n,-99998*n])(65536)
[6553534464, -6553468928]

Comments

अच्छा लेख! बस इतना पता है, आप इसे हटा सकते हैं f=और इसे एक गुमनाम फ़ंक्शन के रूप में छोड़ सकते हैं , जो अभी भी एक वैध उत्तर है। फिर आप अपनी बाइट काउंट 27 :) तक ले जा सकते हैं

— केड

"... आपका एल्गोरिथ्म सिद्धांत रूप में बड़ी और छोटी संख्या के लिए काम करना चाहिए।" जाहिर है (lambda n:[99999*n,-99998*n])(99999)और (lambda n:[99999*n,-99998*n])(-99998)सिद्धांत रूप में टकराएगा (और व्यवहार में)।

— मैथमैंडन

@mathmandan आप सही हैं, मैं अपनी पोस्ट को यह स्पष्ट करने के लिए संपादित करूंगा कि यह आवश्यकताओं को पूरा नहीं करती है। मैं नया कोड लिखने और परीक्षण करने की कोशिश करूंगा लेकिन मैं अपने कंप्यूटर से मोबाइल पर हूं।

— मोनोपोल

Answer 8

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

मैंने बेशर्मी से @ xnor का तरीका कॉपी किया। शायद इससे बहुत बेहतर नहीं है।

f x=(-x^3,x^3+x)