बिना जोड़ के (या 4 मूल अंकगणित संचालकों में से कोई भी)

40

संकट:

आपका लक्ष्य निम्नलिखित गणित ऑपरेटरों में से किसी का उपयोग किए बिना दो इनपुट नंबर जोड़ना है +,-,*,/:।

इसके अतिरिक्त, आप उन गणित ऑपरेटरों को बदलने के लिए डिज़ाइन किए गए किसी भी फ़ंक्शन का उपयोग नहीं कर सकते हैं।

स्कोरिंग:

सबसे छोटा कोड (बाइट्स की संख्या में) जीतता है।

अद्यतन करें

मैंने जितने भी कार्यक्रम देखे हैं, उनमें से दो संख्याओं को समाहित करते हुए, या संख्याओं को बनाते first numberहुए, पात्रों को जोड़ते second numberहैं, फिर सभी को गिनते हैं।

सबसे छोटा सरणी काउंटर: 8 चर्ज के साथ एपीएल, टोबिया द्वारा

सबसे कम सरणी संयोजन: डॉर्कनोब द्वारा 4 वर्णों वाला गोल्फस्क्रिप्ट

लघु लघुगणक समाधान: TI-89 मूल 19 वर्णों के साथ, Quincunx द्वारा

एकीकरण समाधान: माइकल स्टर्न द्वारा ४५ चरों वाला गणितज्ञ

सबसे अच्छे, मेरी राय में: जावास्क्रिप्ट में बिटवाइज़ ऑपरेटर्स, डेव द्वारा

code-golf  restricted-source 
— चिकित्सक
स्रोत
क्या इसमें झांकियां होंगी?
— इस्माईल मिगुएल
7
क्या इसके नकारात्मक अंक होंगे? (वर्तमान में, सब जवाब मान लेते हैं कि नंबर, सकारात्मक होंगे तो आप शायद उस परिवर्तन नहीं होना चाहिए)
— दरवाज़े
4
गणितीय समाधान के बारे में क्या? आप उन लोगों को सूचीबद्ध करना भूल गए! यह एकीकृत करता है, और यह लघुगणक के साथ खेलता है
— जस्टिन
3
आपने लंबे समाधानों में से एक को क्यों स्वीकार किया? क्या यह इसलिए है क्योंकि यह ऋणात्मक संख्याओं को स्वीकार करता है जबकि सबसे छोटा समाधान ( यह और यह ) नहीं है? यदि ऐसा है, तो मेरा उत्तर नकारात्मक संख्याओं का समर्थन करता है (यह फ्लोटिंग पॉइंट का भी समर्थन करता है) और इस से छोटा है। आपने इस प्रश्न को कोड-गोल्फ के रूप में टैग किया है , इस प्रकार आप सबसे छोटे समाधान को स्वीकार करने के लिए बाध्य हैं।
— जस्टिन
2
"संख्या" को परिभाषित करें। कोई पूर्णांक? गैर-नकारात्मक पूर्णांक? क्या उन्हें बेस -10 होना चाहिए?
— SuperJedi224

जवाबों:

2

लघुतल, २१ १३

निम्नलिखित में से सभी केवल सकारात्मक पूर्णांक पर काम करते हैं। एक गंभीर के लिए अन्य स्मॉलटाक उत्तर देखें ।

संस्करण 1

एक बड़े पूर्णांक में शिफ्ट करना और इसके उच्च बिट इंडेक्स के लिए पूछना (खराब, एसटी इंडेक्सिंग 1-आधारित है, इसलिए मुझे एक अतिरिक्त राइट शिफ्ट की आवश्यकता है):

(((1<<a)<<b)>>1)highBit

संस्करण 2

इसी तरह, और यहां तक ​​कि थोड़ा छोटा (स्मालटाक पूर्ववर्ती नियमों के कारण, और कोई सही बदलाव की आवश्यकता नहीं):

1<<a<<b log:2

version3

"संग्रह-कंक्रीटिंग-पूछ आकार" थीम का एक और रूपांतर,
दो संख्याओं ए और बी दिया गया,

((Array new:a),(Array new:b)) size

संग्रह के रूप में अंतराल का उपयोग करते हुए, हम एक और अधिक स्मृति के अनुकूल संस्करण प्राप्त करते हैं; 21 वर्णों में ;-)

((1to:a),(1to:b))size

भारी संख्या में crunching के लिए अनुशंसित नहीं है, हालांकि।

version4

अपने मनोरंजन के लिए, यदि आप स्मृति के लिए समय निकालना चाहते हैं, तो प्रयास करें:

Time secondsToRun:[
   Delay waitForSeconds:a.
   Delay waitForSeconds:b.
]

जो आमतौर पर पर्याप्त सटीक होता है (लेकिन कोई गारंटी नहीं; ;-))

version5

किसी फ़ाइल पर लिखें और उसके आकार के लिए पूछें

(
    [
        't' asFilename 
            writingFileDo:[:s |
                a timesRepeat:[ 'x' printOn:s ].
                b timesRepeat:[ 'x' printOn:s ]];
            fileSize 
    ] ensure:[
        't' asFilename delete
    ]
) print
— blabla999
स्रोत
45

जावास्क्रिप्ट (25)

while(y)x^=y,y=(y&x^y)<<1

यह दो चर x और y को जोड़ता है, केवल बिटवाइज़ संचालन का उपयोग करता है, और x में परिणाम संग्रहीत करता है।

यह नकारात्मक संख्याओं के साथ भी काम करता है।

— डेव
स्रोत
1
@ यदि आप थोड़ी देर के लिए स्विच कर रहे हैं, तो आप दो और चार्ट बचा सकते हैं while(y)x^=y,y=(y&x^y)<<1!
— डोम हेस्टिंग्स
1
— फ्रेंक डेर्नोनकोर्ट
3
@ user3125280, समस्या "अतिरिक्त किए बिना जोड़ नहीं है" (जो थोड़ा बकवास है), बल्कि "मूल गणित संचालकों के बिना इसके अलावा नहीं है"
— ब्रायन एस
8
@ user3125280, मुझे क्षमा करें, लेकिन मेरी टिप्पणी से आपके द्वारा व्याख्या की गई कोई अशिष्टता नहीं थी। मुझे लगता है कि आपके पास बहुत से लोगों को खोजने में एक कठिन समय होगा जो सहमत हैं कि XOR को "मूल अंकगणित" की श्रेणी में PLUS के साथ समूहीकृत किया जाना चाहिए। यहां तक ​​कि सहमत लोगों को खोजने से परे, ओपी स्पष्ट रूप से कहता है कि ऑपरेटरों को क्या अनुमति नहीं है, और XOR उनमें से एक नहीं है। एर्गो, यह एक वैध जवाब है।
— ब्रायन एस
3
for(;y;y=(y&x^y)<<1)x^=yहै 1 बाइट छोटा :)
— विलियम बारबोसा
22

सी - 38 बाइट्स

main(){return printf("%*c%*c",3,0,4);}

मैं यहां थोड़ा धोखा देता हूं, ओपी ने कहा कि किसी भी गणित ऑपरेटर का उपयोग न करें ।

*में printf()प्रारूप का मतलब है कि क्षेत्र चौड़ाई चरित्र मुद्रित करने के लिए प्रयोग किया जाता का एक तर्क से लिया जाता है printf(), इस मामले में, 3 और 4 के रिटर्न मान printf()मुद्रित अक्षरों की संख्या है। तो यह ' '3 की फ़ील्ड-चौड़ाई के साथ एक प्रिंट कर रहा है , और 4 की फ़ील्ड-चौड़ाई के साथ एक, कुल 3 + 4 वर्ण बनाता है।

वापसी मूल्य printf()कॉल में जोड़ा संख्या है ।

— syb0rg
स्रोत
3
आपको 3 और 4 पैरामीटर बनाने चाहिए, और फ़ंक्शन की आवश्यकता नहीं है main। इसके अलावा, अगर आप परवाह नहीं है कि तुम क्या प्रिंट, आप एक जगह ले सकता है ' 'के साथ 0और दूसरा छोड़ देते हैं।
— बदसूरत
17

पायथन - 49 बाइट्स

चर में प्लेसमेंट द्वारा इनपुट मानते हुए xऔर y।

from math import*
print log(log((e**e**x)**e**y))

यह 61 बाइट समाधान एक पूर्ण कार्यक्रम है:

from math import*
print log(log((e**e**input())**e**input()))

यह देखते हुए कि आपने घातांक पर प्रतिबंध नहीं लगाया, मुझे यह पोस्ट करना पड़ा। जब आप लघुगणक के गुणों का उपयोग करके अभिव्यक्ति को सरल करते हैं, तो आप बस प्राप्त करते हैं print input() + input()।

यह नकारात्मक और फ्लोटिंग पॉइंट दोनों संख्याओं का समर्थन करता है।

नोट: मैंने gnibbler की सलाह का पालन ​​किया और इस उत्तर को तीन में विभाजित किया। यह गणितज्ञ समाधान है , और यह TI-89 मूल समाधान है ।

— जस्टिन
स्रोत
मैं जावास्क्रिप्ट के साथ ऐसा ही कुछ करने की कोशिश कर रहा था, लेकिन यह भूल गया कि क्या फार्मूला था क्योंकि यह पिछली बार से कुछ साल पहले मैंने इसे देखा था और इसे खोजने के लिए इंटरनेट पर खोज कर रहा था।
— विक्टर स्टाफ़ुसा
4
@ विक्टर मैंने खुद ही फॉर्मूला बनाया। मुझे गणित बहुत स्पष्ट रूप से याद है।
— जस्टिन
1
आपका गणितज्ञ बहुत करीब है, आपको सिर्फ अंतर्निहित प्रतीकों को भुनाने की जरूरत है। लॉग करें [लॉग [(ई ^ ई ^ एक्स) ^ (ई ^ वाई)] काम करता है (23 अक्षर, या 22 यदि आप बाहरी फ़ंक्शन रैपिंग के लिए @ नोटेशन का उपयोग करते हैं)।
— माइकल स्टर्न
"अगर मुझे चर x और y में प्लेसमेंट द्वारा इनपुट ग्रहण करने की अनुमति है .." मुझे लगता है कि आप कर सकते हैं - दूसरे भी ऐसा करते हैं।
— ब्लाबला 999
@ मिचेल्टरस्टर्न: आप कोष्ठकों को चारों ओर छोड़ कर दो और पात्रों को बचा सकते हैं E^y। का उपयोग कर Log[Log[(E^E^x)^E^y]]ठीक काम करने लगता है।
— एलेक्सवचन
14

जावास्क्रिप्ट [25 बाइट्स]

~eval([1,~x,~y].join(''))
— एंड्रयू टेम्पलटन
स्रोत
1
आपका उत्तर बुरा (और नीचा-आकर्षित) लगता है, लेकिन यह वास्तव में एक अच्छा जवाब है। कृपया इसे हटाए जाने के लिए इसे हटा दें और किसी पाठ के साथ इसे समझाते हुए इसे फिर से लिखें। मैं आपके नए उत्तर को बढ़ाऊंगा।
— विक्टर स्टैफ़ुसा
1
अब यह वास्तव में अच्छा लग रहा है, मुझे यह पसंद है। निश्चित रूप से अधिक upvotes के लायक है।
— VisioN
13

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

गणितज्ञों में ऐसा करने के कई तरीके हैं। एक, Accumulate फ़ंक्शन का उपयोग करें और आउटपुट में सब कुछ लेकिन अंतिम संख्या को टॉस करें। नीचे मेरे अन्य समाधान के साथ, मुझे लगता है कि इनपुट संख्याएं चर में हैं aऔर b। 21 बाइट्स।

Last@Accumulate@{a, b}

अधिक मजेदार, हालांकि यह 45 वर्णों का है, एक पंक्ति को परिभाषित करने और इसके तहत एकीकृत करने के लिए संख्याओं का उपयोग करें।

Integrate[Fit[{{0, a}, {2, b}}, {x, 1}, x], {x, 0, 2}]

एक बोनस के रूप में, दोनों समाधान सभी जटिल संख्याओं के लिए काम करते हैं, न कि केवल सकारात्मक पूर्णांक के रूप में, कुछ अन्य समाधानों के लिए यहां मामला लगता है।

— माइकल स्टर्न
स्रोत
2
मैं एकीकरण प्यार करता हूँ! (हालांकि, सख्ती से यह कुछ कहते हैं)। +1
— blabla999
1 समाधान अमान्य है। चुनौती के लेखक का हवाला देते हुए: "इसके अतिरिक्त, आप किसी भी अंतर्निहित कार्यों का उपयोग नहीं कर सकते हैं जो उन गणित ऑपरेटरों को बदलने के लिए डिज़ाइन किए गए हैं।" मैंने इसका हल दिया था function _(){return array_sum(func_get_args());}:। मुझे इसे नीचे ले जाना पड़ा क्योंकि मैं इसे "ठीक" करने के लिए एक छोटा रास्ता नहीं खोज सका।
— इस्माईल मिगुएल
@ इस्माइल मिगुएल Accumulate [] को प्लस को बदलने के लिए डिज़ाइन नहीं किया गया है। यह अपने आउटपुट के बीच संख्याओं की सूची का योग देता है, और मैं इसका लाभ उठाता हूं।
— माइकल स्टर्न
लेकिन यह उस सूची में सभी तत्वों का योग बनाता है, है ना? यदि ऐसा होता है, तो मेरी राय में, यह array_sum()php के उपयोग के रूप में अमान्य है , जो एक ही सटीक काम करता है।
— इस्माइल मिगुएल
3
@ इस्माईल मिगुएल वहाँ एक मैथेमेटिका फ़ंक्शन मौजूद है जो एक सरणी, कुल [] कहा जाता है। मैं मानता हूं कि यह उस फ़ंक्शन का उपयोग करने के लिए निर्दिष्ट नियमों के विरुद्ध होगा, लेकिन मैंने ऐसा नहीं किया। Accumulate [{a, b}] का आउटपुट a + b नहीं है।
— माइकल स्टर्न
12

GolfScript, 6 4 अक्षर / बाइट्स

10, 5(=> 15) के रूप में इनपुट ।

~,+,

+सरणी संयोजन, नहीं है।

यह कैसे काम करता है ,इसका उपयोग उस लंबाई की एक सरणी बनाने के लिए किया जाता है जो संख्या ( 0,1,...,n-2,n-1) है। यह दोनों संख्याओं के लिए किया जाता है, फिर सरणियों को समतल किया जाता है। ,परिणामी सरणी की लंबाई का पता लगाने के लिए एक अलग उद्देश्य के लिए फिर से उपयोग किया जाता है।

अब, यहाँ चाल है । मुझे वास्तव में यह पसंद है क्योंकि यह इनपुट प्रारूप का दुरुपयोग करता है। ऐसा लगता है कि यह केवल एक सरणी इनपुट कर रहा है, लेकिन वास्तव में, चूंकि इनपुट को गोल्फस्क्रिप्ट कोड के रूप में निष्पादित किया जा रहा है, इसलिए पहले ,से ही मेरे लिए किया गया है! (पुराना 6-वर्ण संस्करण ~,\,+,इनपुट प्रारूप के साथ था 10 5, जिसे मैंने \,(स्वैप-एरे) को समाप्त करके 2 चार्ट्स को बंद कर दिया था ।

पुराना संस्करण (12) :

एक फ़ंक्शन बनाता है f।

{n*\n*+,}:f;

*और +स्ट्रिंग पुनरावृत्ति और संयोजन क्रमशः, नहीं अंकगणितीय कार्य हैं।

स्पष्टीकरण: nएक-वर्ण स्ट्रिंग (एक नई रेखा) बनाता है। यह तब दोहराया जाता aहै, फिर वही काम किया जाता है b। तारों को समतल ,किया जाता है , और फिर स्ट्रिंग की लंबाई के लिए उपयोग किया जाता है।

— Doorknob
स्रोत
क्या यह नकारात्मक संख्याओं के लिए भी काम करता है?
— माइकल स्टर्न
@MichaelStern नहीं, लेकिन यह सवाल में उल्लेख नहीं किया गया था। हम्म, मैंने एक टिप्पणी जोड़ी है। अधिकांश (वास्तव में, सभी ) अन्य उत्तर भी सकारात्मक मानते हैं।
— दरवाज़े
मेरा गणितज्ञ समाधान देखें। सही भाषा में, नकारात्मक संख्याओं के लिए समाधान संभव है।
— माइकल स्टर्न
सभी स्थानों की इस साइट पर @MichaelStern LOL @ "सही भाषा" ...
— टोबिया
10

सी, 29 27 बाइट्स

सूचक अंकगणितीय का उपयोग करना:

f(x,y)char*x;{return&x[y];}

x एक पॉइंटर के रूप में परिभाषित किया गया है, लेकिन कॉल करने वाले को पूर्णांक पास करना चाहिए।

एक अनाम उपयोगकर्ता ने निम्नलिखित सुझाव दिया - 27 बाइट्स भी, लेकिन पैरामीटर पूर्णांक हैं:

f(x,y){return&x[(char*)y];}
— ugoren
स्रोत
पहला रूप शायद बुरी तरह से टूट जाता है अगर दो- intएस पास करने पर अब सामान्य सिस्टम में जहां int32 बिट्स हैं, और पॉइंटर्स में 64 बिट्स हैं। दूसरा उस समस्या से बचता है।
— hvd
@hvd, दोनों काम करते हैं, कम से कम लिनक्स 64 बिट पर। पूर्णांक मापदंडों को मशीन रजिस्टर आकार में वैसे भी बढ़ाया जाता है।
— बदसूरत
आह, काफी निष्पक्ष, सहमत हुए कि यह सामान्य मामला होगा। फिर से टिप्पणी करूंगा यदि मुझे एक ठोस उदाहरण मिल सकता है जो काम नहीं करता है, हालांकि। :)
— hvd
8

ब्रेनफ * ck, 9 36

,>,[-<+>]


++[->,[->>[>]+[<]<]<]>>>[<[->+<]>>]<

यह सरल जोड़ का उपयोग किए बिना काम करता है; यह 1 के निशान को पार करता है और फिर उन्हें गिनता है

नोट: केवल +और -केवल वेतन वृद्धि हैं और उनके बिना brainf * ck में कुछ भी नहीं किया जा सकता है। वे वास्तव में जोड़ / घटाव नहीं हैं इसलिए मेरा मानना ​​है कि यह अभी भी मायने रखता है।

— ASKASK
स्रोत
-1। यह सरल जोड़ है। यदि आपने कुछ ऐसा किया है जो जोड़, गुणा, आदि नहीं है, तो यह मायने रखता है, लेकिन जैसा है, यह गिनती नहीं करता है।
— जस्टिन
@Quincunx मैंने इसे ठीक किया; मैंने इसे लोगों के निशान के माध्यम से छोड़ दिया और फिर से गुजर रहा था और 'निशान' उठा रहा था
— ASKASK
3
उलट। अच्छी नौकरी।
— जस्टिन
6

जे (6)

आपने यह नहीं कहा कि हम सक्सेस फंक्शन का इस्तेमाल नहीं कर सकते:

>:@[&0

उपयोग:

   9>:@[&0(8)
17

यह सिर्फ >:8 पर 9 पुनरावृत्ति करता है ।

सूची समवर्ती दृष्टिकोण काम करता है, भी #@,&(#&0):। और - मुझे पता है कि यह नियमों के खिलाफ है - मैं इस जवाब को सबसे अधिक जे-ईश समाधान के बिना जाने नहीं दे सकता: *&.^(घातांक के तहत गुणा)।

— जेम्स वुड
स्रोत
5

पोस्टस्क्रिप्ट, 41

हम 41 बाइट्स के साथ फ़ंक्शन को परिभाषित करते हैं:

/a{0 moveto 0 rmoveto currentpoint pop}def

तो हम इसे कहते हैं जैसे:

gs -q -dBATCH -c '/a{0 moveto 0 rmoveto currentpoint pop}def' -c '10 15 a ='

जो देता है

25.0

यह आसानी से अधिकांश प्रतियोगियों के विपरीत, नकारात्मक और तैरता संभालता है :-)

— user2846289
स्रोत
4

स्मॉलटाक (अब गंभीरता से), 123 118 105 (*)

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

दो आधे-योजक के संयोजन से, और समानांतर में शब्दों के सभी बिट्स करते हुए, हम प्राप्त करते हैं (इनपुट्स ए, बी; आउटपुट एस में) रीडिंग संस्करण:

  s := a bitXor: b.            
  c := (a & b)<<1.             

  [c ~= 0] whileTrue:[        
     cn := s & c.
     s := s bitXor: c.
     c := cn<<1.
     c := c & 16rFFFFFFFF.
     s := s & 16rFFFFFFFF.
  ].
  s

लूप प्रचार प्रसार के लिए है। मास्क यह सुनिश्चित करते हैं कि हस्ताक्षर किए गए पूर्णांक संभाले हुए हैं (उनके बिना, केवल अहस्ताक्षरित संख्याएँ हैं)। वे शब्द की लंबाई को भी परिभाषित करते हैं, ऊपर 32 बिट ऑपरेशन के लिए। यदि आप 68bit जोड़ पसंद करते हैं, तो 16rFFFFFFFFFFFFFFFFFF में बदलें।

गोल्फ संस्करण (123 वर्ण) (मीटर में पुन: उपयोग करके लंबे मास्क से बचा जाता है):

[:a :b||s c n m|s:=a bitXor:b.c:=(a&b)<<1.[c~=0]whileTrue:[n:=s&c.s:=s bitXor:c.c:=n<<1.c:=c&m:=16rFFFFFFFF.s:=s&m].s]

(*) 16rFFFFFFFF के बजाय -1 का उपयोग करके, हम बेहतर गोल्फ कर सकते हैं, लेकिन कोड अब मनमाने ढंग से सटीक संख्याओं के लिए काम नहीं करता है, केवल मशीन-वर्ड आकार के स्मॉलइन्जर्स के लिए (बड़ेIntegers के लिए प्रतिनिधित्व मानक मानक में परिभाषित नहीं है):

[:a :b||s c n|s:=a bitXor:b.c:=(a&b)<<1.[c~=0]whileTrue:[n:=s&c.s:=s bitXor:c.c:=n<<1.c:=c&-1.s:=s&-1].s]

यह कोड का आकार 105 वर्णों तक लाता है।

— blabla999
स्रोत
यह कोड-गोल्फ है, इसलिए अपना उत्तर गोल्फ दें।
— विक्टर स्टैफुसा
1
जीतने का कोई मौका नहीं, लेकिन मैं इसे आपके लिए
— करूंगा
स्मॉलटाक का उत्तर देखकर अच्छा लगा!
— टूथब्रश
4

एपीएल, 8 और 12

यहाँ कुछ भी नया नहीं है, सरणी गिनती संस्करण:

{≢∊⍳¨⍺⍵}

और लॉग ○ लॉग संस्करण:

{⍟⍟(**⍺)**⍵}

मुझे लगा कि वे एपीएल में मस्त लग रहे हैं!

{≢     }       count
  ∊            all the elements in
   ⍳¨          the (two) sequences of naturals from 1 up to
     ⍺⍵        both arguments

 

{⍟⍟        }   the double logarithm of
   (**⍺)       the double exponential of ⍺
        *      raised to
         *⍵    the exponential of ⍵
— Tobia
स्रोत
2
निष्पक्ष होने के लिए, एपीएल में सब कुछ अच्छा लगता है।
— माइकल स्टर्न
आप 5 के लिए पहले एक ≢∘∊⍳¨
— टैसिट
@ Adám हां, लेकिन मुझे टासिट फ़ंक्शंस पसंद नहीं हैं और मुझे उन्हें पढ़ना मुश्किल लगता है।
— टोबिया
@ टोबिया शायद आप उन्हें पसंद नहीं करते क्योंकि आपको उन्हें पढ़ना मुश्किल लगता है? मैं उस पर एक कार्यशाला चला रहा हूँ ... क्या आपने इस पर मेरा पाठ देखा है ?
— एडम जूल
@ नमस्कार, धन्यवाद! इसकी जांच कराएंगे।
— तोबिया
4

सेड, 359 बाइट्स (फैंटेसी फॉर्मेटिंग के बिना)

देर से जवाब के लिए क्षमा करें, और शायद अब तक का सबसे लंबा जवाब है। लेकिन मैं देखना चाहता था कि क्या यह सेड के साथ संभव है:

                       s/([^ ]+) ([^ ]+)/\1:0::\2:/
                       :d /^([^:]+):\1::([^:]+):/tx
                       s/(:[^:]*)9([_:])/\1_\2/g;td
s/(:[^:]*)8(_*:)/\19\2/g;s/(:[^:]*)7(_*:)/\18\2/g;s/(:[^:]*)6(_*:)/\17\2/g
s/(:[^:]*)5(_*:)/\16\2/g;s/(:[^:]*)4(_*:)/\15\2/g;s/(:[^:]*)3(_*:)/\14\2/g
s/(:[^:]*)2(_*:)/\13\2/g;s/(:[^:]*)1(_*:)/\12\2/g;s/(:[^:]*)0(_*:)/\11\2/g
                       s/:(_+:)/:1\1/g; y/_/0/; # #
                       bd;  :x  s/.*::([^:]+):/\1/;
                       # # # # # # #  # # # # # # #

यह https://codegolf.stackexchange.com/a/38087/11259 के समान है , जो केवल एक स्ट्रिंग में संख्या बढ़ाते हैं। लेकिन इसके बजाय यह एक लूप में वृद्धि संचालन करता है।

इनपुट "x y" के रूप में STDIN से लिया गया है। यह पहली बार "x: 0 :: y:" में बदल गया है। फिर हम ":" वर्णों के बाद आने वाले सभी संख्याओं को बढ़ाते हैं, जब तक कि हमें "x: x: :( x + y):" नहीं मिल जाता। फिर हम अंत में लौटते हैं (x + y)।

उत्पादन

$ printf "%s\n" "0 0" "0 1" "1 0" "9 999" "999 9" "12345 67890" "123 1000000000000000000000"  | sed -rf add.sed
0
1
1
1008
1008
80235
1000000000000000000123
$

ध्यान दें कि यह केवल प्राकृतिक संख्याओं के लिए काम करता है। हालांकि (सिद्धांत में कम से कम) यह मनमाने ढंग से बड़े पूर्णांकों के लिए काम करता है। क्योंकि हम y पर x इंक्रीमेंट ऑपरेशन कर रहे हैं, इसलिए ऑर्डर करने से स्पीड पर बड़ा फर्क पड़ सकता है: x <y x> y से तेज होगा।

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

पानी का छींटा , 18 बाइट्स

time -f%e sleep $@

जीएनयू समय 1.7 या उच्चतर की आवश्यकता है। आउटपुट STDERR को है।

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

ध्यान दें कि यह बी ऐश में काम नहीं करेगा , क्योंकि इसका बिल्ट टाइम कमांड GNU टाइम से अलग है।

एक अतिरिक्त बाइट की कीमत पर, बश के \timeबजाय timeबाहरी कमांड का उपयोग करने के लिए मजबूर किया जा सकता है ।

— डेनिस
स्रोत
यदि इनपुट में से एक नकारात्मक है तो क्या होगा?
— माइकल स्टर्न
4
यह विफल रहा। ठीक वैसे ही जैसे बाकी सभी जवाब।
— डेनिस
5
Drats! मुझे आशा है कि प्रश्न पूछे जाने से पहले इसने परिणाम दिया।
— तोबिया
3
हाँ। मैं इस उम्मीद में भी था कि रैंडम डालने से sleep -3मैं अपने कार्यक्रमों को गति दे सकूं। क्या लेट-डाउन है।
— अल्फ
1
@userunknown \timeको बैश में भी काम करना चाहिए।
— डेनिस
3

जावास्क्रिप्ट (67)

शायद बहुत बेहतर है

a=Array;p=Number;r=prompt;alert(a(p(r())).concat(a(p(r()))).length)
— माइकल एम।
स्रोत
आपको यह जानने के बिना निश्चित जवाब नहीं देना चाहिए कि उसे तैरने की जरूरत है या नहीं। और यह NaN की संभाल नहीं करेगा। लेकिन इसका काफी अच्छा कोड है!
— इस्माईल मिगुएल
मुझे लगता है कि सभी joinsअनावश्यक हैं। Arrayनिर्माता की एक सरणी में आता है undefineds: है, जो गिना जा सकता हैa=Array;p=parseInt;r=prompt;alert(a(p(r())).concat(a(p(r()))).length)
— बेन रैह
@BenReich, आप सही कह रहे हैं, धन्यवाद
— माइकल एम।
@ मिचेल इसके अलावा, Numberकंस्ट्रक्टर 2 पात्रों को बचाता हैparseInt
— बेन रीच
@ मिचेल इसके अलावा, यदि आप हटाते हैं alert, तो आउटपुट अभी भी कंसोल पर जाएगा, लेकिन यह उत्तर को थोड़ा कम मजेदार बनाता है। आप promptचेतावनी के बजाय चर का पुन: उपयोग कर सकते हैं , (निर्माणकर्ता तर्क के साथ संकेत देता है)। वैसे भी, अच्छा जवाब!
— बेन रीच
3

रूबी, 18 वर्ण 

a.times{b=b.next}

और दो और वर्बोज़ वेरिएंट, 29 वर्ण 

[*1..a].concat([*1..b]).size

एक और संस्करण, 32 वर्ण 

(''.rjust(a)<<''.rjust(b)).size
— निक ओ ललाई
स्रोत
3

मक्खी कोड पीढ़ी पर सी # -

हाँ, वहाँ वास्तव में एक जोड़ है, लेकिन + ऑपरेटर नहीं है और एक फ्रेमवर्क फ़ंक्शन भी नहीं है जो जोड़ रहा है, इसके बजाय हम मक्खी पर एक विधि उत्पन्न करते हैं जो जोड़ते हैं।

public static int Add(int i1, int i2)
{
    var dm = new DynamicMethod("add", typeof(int), new[] { typeof(int), typeof(int) });
    var ilg = dm.GetILGenerator();
    ilg.Emit(OpCodes.Ldarg_0);
    ilg.Emit(OpCodes.Ldarg_1);
    ilg.Emit(OpCodes.Add);
    ilg.Emit(OpCodes.Ret);
    var del = (Func<int, int, int>)dm.CreateDelegate(typeof(Func<int, int, int>));
    return del(i1, i2);
}
— fejesjoco
स्रोत
2

आर 36

function(x,y)length(rep(1:2,c(x,y)))

जहाँ दो लोगों द्वारा पीछा किया गया repएक वेक्टर बनाता है ।xy

— flodel
स्रोत
2
आप एक ऐसा कार्यक्रम बना सकते हैं, जो थोड़ा छोटा हो:length(rep(1:2,scan()))
— मैकलिन्स
2

टीआई बेसिक 89 - 19 बाइट्स

इसे अपने TI-89 (होम स्क्रीन या प्रोग्रामिंग ऐप) में चलाएं:

ln(ln((e^e^x)^e^y))

यह इस समाधान कीx+y तरह, गणना करने के लिए लॉग नियमों का उपयोग करता है । एक बोनस के रूप में, यह दशमलव और पूर्णांक संख्याओं के लिए काम करता है। यह सभी वास्तविक संख्याओं के लिए काम करता है। यदि लघुगणक नियम अभी भी जटिल घातांक के साथ मान्य हैं, तो यह जटिल संख्याओं के लिए भी काम करता है। हालाँकि, जब मैं जटिल घातांक डालने की कोशिश करता हूँ तो मेरा कैलकुलेटर कबाड़ निकाल देता है।

— जस्टिन
स्रोत
3
lnटीआई बेसिक में 1 बाइट नहीं है ? इसके अलावा, आप समापन कोष्ठकों को गिरा सकते हैं, इसे 15 बाइट्स तक ला सकते हैं।
— atı 9uʎs
2

मुझे गणितज्ञ संकेतन पढ़ाने के लिए माइकल स्टर्न का धन्यवाद ।

गणितज्ञ - 21 20 बाइट्स

Log@Log[(E^E^x)^E^y]

यह इस समाधान के समान दृष्टिकोण का उपयोग करता है , लेकिन इसे छोटा बनाने के लिए यह गणितज्ञ में है। नकारात्मक और में चल बिन्दु संख्या के साथ-साथ पूर्णांकों के लिए यह काम करता है xऔर y।

लॉग नियम पैदावार का उपयोग करके अभिव्यक्ति को सरल बनाना x+y, लेकिन यह मान्य है क्योंकि यह घातांक का उपयोग करता है, 4 मूल ऑपरेटरों में से एक नहीं।

— जस्टिन
स्रोत
क्या आप सुनिश्चित हैं कि यह जटिल संख्याओं के लिए काम करता है?
— माइकल स्टर्न
2

सी # - स्ट्रिंग अंकगणित

हम दोनों संख्याओं को स्ट्रिंग में परिवर्तित करते हैं, स्ट्रिंग कटिंग (कैरी और सब कुछ, जो आप जानते हैं) के साथ जोड़ते हैं, फिर पूर्णांक में वापस करते हैं। 0..200 में i1, i2 के साथ परीक्षण, एक आकर्षण की तरह काम करता है। इस एक में एक अतिरिक्त खोजें!

public static int Add(int i1, int i2)
{
    var s1 = new string(i1.ToString().Reverse().ToArray());
    var s2 = new string(i2.ToString().Reverse().ToArray());
    var nums = "01234567890123456789";
    var c = '0';
    var ret = new StringBuilder();
    while (s1.Length > 0 || s2.Length > 0 || c != '0')
    {
        var c1 = s1.Length > 0 ? s1[0] : '0';
        var c2 = s2.Length > 0 ? s2[0] : '0';
        var s = nums;
        s = s.Substring(int.Parse(c1.ToString()));
        s = s.Substring(int.Parse(c2.ToString()));
        s = s.Substring(int.Parse(c.ToString()));
        ret.Append(s[0]);
        if (s1.Length > 0)
            s1 = s1.Substring(1);
        if (s2.Length > 0)
            s2 = s2.Substring(1);
        c = s.Length <= 10 ? '1' : '0';
    }
    return int.Parse(new string(ret.ToString().ToCharArray().Reverse().ToArray()));
}
— fejesjoco
स्रोत
2

एपीएल: २

1⊥

यह संख्याओं को आधार 1 से परिवर्तित करता है, इसलिए (n * 1 ^ 1) + (m * 1 ^ 2) जो कि बिल्कुल n + m है।

TryApl.org पर कोशिश की जा सकती है

— मोरिस ज़ुक्का
स्रोत
2

TI-BASIC, 10

जोड़ता है XऔरY

ln(ln(e^(e^(X))^e^(Y
— Timtech
स्रोत
1
आप निश्चित रूप से जानते हैं कि समाधानों की नकल कैसे करें: codegolf.stackexchange.com/a/21033/9498
— जस्टिन
सबसे पहले, यह काम नहीं करता है क्योंकि यह लॉग का उपयोग करता है (ln के बजाय (दूसरा, यह वास्तव में दस बाइट्स है) अगर फॉर्म में लिखा है ln (ln (e ^ (e ^ (X)) ^ e ^ (Y।
— lirtosiast)
2

के, 2 बाइट्स

#&

उपयोग उदाहरण:

  #&7 212
219

&एक इनपुट सूची में संख्याओं के लिए "जहां" ऑपरेटर (मोनैडिक ) लागू करें (संभवतः इनपुट प्रारूप के साथ स्वतंत्रता ले रहा है)। यह एक सूची का उत्पादन करेगा जिसमें शून्य की पहली संख्या होगी और उसके बाद दूसरी संख्या होगी:

  &3 2
0 0 0 1 1

आम तौर पर इस ऑपरेटर का उपयोग एक "इकट्ठा" के रूप में एक बूलियन सूची के गैर-एज़ेरो तत्वों के सूचकांकों का निर्माण करने के लिए किया जाता है, लेकिन सामान्यीकृत रूप कभी-कभी काम में आता है।

फिर बस उस सूची (मानद #) की गिनती करें ।

यदि इनपुट आवश्यकताओं की मेरी व्याख्या अस्वीकार्य है, तो निम्नलिखित थोड़ा लंबा समाधान एक ही चाल है:

{#&x,y}
— JohnE
स्रोत
2

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

AQW!qG0=k.&GH=HxGH=k.<k1=Gk)H

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

मेरा पहला सबमिशन यहाँ!

यह संकलन:

assign('Q',eval_input())     # Q
assign('[G,H]',Q)            #A
while Pnot(equal(G,0)):      #  W!qG0
  assign('k',bitand(G,H))    #       =k.&GH
  assign('H',index(G,H))     #             =HxGH  (index in this case is XOR)
  assign('k',leftshift(k,1)) #                  =k.<k1
  assign('G',k)              #                        =Gk)
imp_print(H)                 #                            H
— bengdahl
स्रोत
1
साइट पर आपका स्वागत है!
— गेहूं जादूगर
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.