मैं एक जोड़ने का कार्य कैसे लिखूं? [बन्द है]


42

समस्या:

मैं एक बड़ी कंपनी का प्रमुख डेवलपर हूं, हम स्काईनेट बना रहे हैं। मुझे सौंपा गया है

एक फ़ंक्शन लिखें जो इनपुट और उनकी राशि लौटाता है

नियम: जैसे कोई उत्तर नहीं

function sum(a,b){
    return "their sum";
}

संपादित करें: स्वीकृत उत्तर 1 जनवरी, 2014 को सबसे अधिक उत्थान के साथ होगा

नोट: यह एक प्रश्न है। कृपया प्रश्न और / या उत्तर को गंभीरता से न लें। अधिक जानकारी यहाँ


31
आप मेरे हल्के jQuery प्लगइन का उपयोग कर सकते हैं $.sum=function(a,b){return a+b};:।
ब्लेंडर

5
मुझे पता था कि मुझे कुछ समय में jQuery का संदर्भ मिलेगा
scrblnrd3

5
शानदार अंग्रेजी: p
मार्टिज़न कोर्टको

5
प्रश्न का सुझाव (निश्चित नहीं है कि यह किसी भी अच्छा है): "चुप रहो, मुझे बिटकॉइन ब्लॉक उत्पन्न करने के लिए एक तेज एल्गोरिथ्म की आवश्यकता है !!!!! यह बहुत जरूरी है!"

5
ये उत्तर काफी उलझे हुए हैं। मैं सुझाव देता हूं कि आपके डेटाबेस के लिए एक कनेक्शन खोलना और जारी करना 'SELECT ' + a + ' + ' + b + ';'। यह सरल और समझ में आता है।
निक चम्मास 20

जवाबों:


69

यह एक बहुत ही जटिल समस्या है! यहाँ आप इसे C # में हल करते हैं:

static int Sum(int a, int b)
{
    var aa = ((a & ~877 - b ^ 133 << 3 / a) & ((a - b) - (a - b))) | a;
    var bb = ((b ^ (a < 0 ? b : a)) & ((b - a) - (b - a))) | b;
    var cc = new List<int>();
    for (int i = 6755 & 1436; i < aa; i -= -1)
    {
        cc.Add((int)Convert.ToInt32(Math.Sqrt(6755 & 1437 >> ((b - a) - (b - a)))));
    }
    for (int i = 6755 & 1436; i < bb; i -= -1)
    {
        cc.Add((int)Convert.ToInt32(Math.Sqrt(6755 & 1437 >> ((a - b) - (a - b)))));
    }
    Func<int,int,int> importantCalculation = null;
    importantCalculation = (x, y) => y != 0 ? importantCalculation(x ^ y | (6755 & 1436) >> (int)(Convert.ToInt32(Math.Sqrt((b - a) - (b - a) - (-1))) - 1), (x & y) << (int)Convert.ToInt32((Math.Log10(1) + 1))) : x;
    return cc.Aggregate(importantCalculation);
}


यह कोड कैसे काम करता है (मैं इस स्पष्टीकरण को अपने जवाब में आलसी ओपी के लिए नहीं जोड़ूंगा जिसे ट्रोल किया जाना है, चिंता न करें): ((a & ~877 - b ^ 133 << 3 / a) & ((a - b) - (a - b))) | aसिर्फ aऔर ((b ^ (a < 0 ? b : a)) & ((b - a) - (b - a))) | bसिर्फ रिटर्न b

6755 & 1436रिटर्न 0, इसलिए लूप में, iवास्तव में मूल्य के साथ शुरू होता है 0, और लूप के अंदर, आप मूल्य 1को सूची में जोड़ते हैं । तो, अगर aहै 5और bहै 3, तो मूल्य 1सूची में 8 बार जोड़ा जाता है।

importantCalculationसमारोह एक बहुत लंबे समारोह है कि दो नंबर को जोड़कर की तुलना में और कुछ नहीं करता है। आप Aggregateसभी संख्याओं को जोड़ने के लिए LINQ फ़ंक्शन का उपयोग करते हैं । यह का परिणाम कास्ट करने के लिए अनावश्यक भी है Convert.ToInt32एक करने के लिए intहै, क्योंकि यह पहले से ही एक है int

यह कोड कुछ ऐसा है जिसे आलसी ओपी समझ नहीं पाएगा, जो वास्तव में है


11
मैं - = -1 बहुत रचनात्मक। मैं पहले ही आज वोट की सीमा तक पहुँच गया, लेकिन मैं जितनी जल्दी हो सके आपके जवाब को बढ़ा दूंगा।
विक्टर स्टैफ़ुसा

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

'=>' का अर्थ क्या है?
इल्या गज़मैन

2
@ बब्बू मैंने अपने जीवन में कभी भी C # की पंक्ति नहीं लिखी है लेकिन यह लगभग निश्चित रूप से एक लंबोदर अभिव्यक्ति है।
thwd

3
उह, var x = Sum(0, 4)DivideByZeroException।
फिलिप स्कॉट जिवेंस

60

बैश - 72 बाइट्स

कभी-कभी पारंपरिक नियतात्मक जोड़ तकनीकें भी सटीक होती हैं, और अनावश्यक रूप से तेज होती हैं - ऐसे समय होते हैं जब आप सीपीयू को थोड़ा आराम देना चाहते हैं।

प्रस्तुत है हानिपूर्ण SleepAdd एल्गोरिथ्म

#!/bin/bash
(time (sleep $1;sleep $2)) 2>&1|grep re|cut -dm -f2|tr -d s

नमूना रन:

> ./sleepadd.sh 0.5 1.5
2.001

इस फ़ंक्शन का उद्देश्य अच्छी तरह से सोए हुए सोर्टसॉर्ट के साथी के रूप में है । दो संख्याओं से अधिक प्राप्त करने के लिए एक हानिपूर्ण स्लीपमैक्स बनाने के लिए इस एल्गोरिथम को अनुकूलित करने के लिए पाठक को एक अभ्यास के रूप में छोड़ दिया जाता है।

प्रो टिप: इस एल्गोरिथ्म को और अधिक अनुकूलित किया जा सकता है - एक 2x गति वृद्धि संभव है, अगर इसे दी गई संख्याओं को पहले 2 से विभाजित किया जाए।


5
ट्रोलिंग 1: यह काम करता है लेकिन यह कुल समय की प्रतीक्षा करने के लिए सिस्टम टाइमर का उपयोग करते हुए मूर्खतापूर्ण है। इसलिए बड़ी संख्याओं को जोड़ने में रैखिक रूप से अधिक समय लगता है। ट्रोलिंग 2: यह फ्लोटिंग पॉइंट के लिए भी काम करता है, लेकिन उत्तर हमेशा एक छोटे से मार्जिन से बंद होते हैं। ट्रोलिंग 3: ग्राईप, कट और ट्राट का उपयोग और अनावश्यक उपयोग। ट्रोलिंग 4: 60 (सेकंड) से अधिक के किसी भी योग को सही तरीके से नियंत्रित नहीं किया जाता है।
दियोट

4
@Shingetsu: क्या, आप कह रहे हैं किसी और ने एमपी 3 कोडेक के बारे में नहीं सुना है? : पी
दियोट

7
मैं कह रहा हूं कि बहुत कम लोग वास्तव में एसोसिएशन बनाते हैं। हालांकि लंगड़ा आईएस लंगड़ा है। वोरबिस मास्टर रेस।

7
+1 बड़े पैमाने पर ऑफ-टॉपिक ऑडियो एनकोडर युद्धों के लिए डायट्रीब :)
दंगा

1
मेरा मानना ​​है कि नीचे मेरा बैश-हडोप संस्करण बहुत अधिक शक्तिशाली और स्केलेबल है !!!! १ !! ग्यारह! लेकिन मुझे कहना होगा, मैं वास्तव में आपके संस्करण से प्यार करता हूं, स्लीपड बहुत अच्छा है! +1
Anony-Mousse

40

जावा

public static void int sum(int a, int b)
{
    try
    {
       File file = File.createTempFile("summer", "txt");
       FileOutputStream fos = new FileOuptutStream(file);
       for (int i = 0; i < a; ++i) fos.write(1);
       for (int i = 0; i < b; ++i) fos.write(1);
       fos.flush();
       fos.close();
       return file.length();
    } catch(Throwable t)
    {
       return sum(a, b); // Try again!
    }
}

यह मूल रूप से बाइट की संख्या के साथ एक फ़ाइल लिखता है जो वास्तविक राशि के बराबर होनी चाहिए। जब फ़ाइल लिखी जाती है, तो वह उस फ़ाइल के आकार के लिए डिस्क फ़ाइल तालिका से पूछती है।


1
writeया flushफेंक सकते हैं ? यह मुझे ऐसा लगता है जैसे आपको flushप्रत्येक लूप में स्थानांतरित करना चाहिए , और यदि वह या फ्लश विफल हो जाता है, तो पूरी कोशिश करें कि आप इसे फिर से लिखें।
एंटोन गोलोव

3
मेरा सुझाव है कि आप एक धारा के बजाय डिफ़ॉल्ट चरित्र एन्कोडिंग के साथ एक लेखक का उपयोग करें। तब यह संभावित रूप से एक सिस्टम पर टूट सकता है जिसके लिए आपका चयनित चरित्र कई बाइट्स में एन्कोड करता है।
बुहब

33

सी

क्वांटम दुनिया में आप परमाणु संचालकों पर निर्भर नहीं रह सकते हैं +, जैसे कि क्वांटम कंप्यूटिंग के संदर्भ में मेरा कार्यान्वयन:

#define DEPENDING (
#define ON 
#define EVERYTHING 32
#define DEFINED )
#define AS ON
#define WITH {
#define SOON if
#define FIX AS
#define TO =
#define REPEAT for(
#define SUBPOSED >>
#define SUPERPOSITION int
#define ADJUSTED <<
#define APPROACHES <
#define SUBPOSITION ++
#define MATCHES &
#define LEVEL DEPENDING
#define OF FIX
#define BY FIX
#define CONTINUUM 1
#define VOID ~-CONTINUUM
#define SUPERPOSED |
#define DO DEFINED WITH
#define CURVATURE }
#define ITSELF FIX
#define OTHERWISE CURVATURE else WITH
#define RETURN return

SUPERPOSITION ADD
    DEPENDING ON
        SUPERPOSITION SUPER_A,
        SUPERPOSITION SUPER_B
    DEFINED WITH
        FIX SUPERPOSITION A TO SUPER_A;
        FIX SUPERPOSITION B TO SUPER_B;
        FIX SUPERPOSITION RESULT TO VOID;
        FIX SUPERPOSITION CARRY TO VOID;
        FIX SUPERPOSITION I TO VOID;
        REPEAT
            FIX I TO VOID;
            I APPROACHES EVERYTHING;
            FIX I SUBPOSITION DEFINED WITH
                AS SOON AS LEVEL OF CARRY MATCHES CONTINUUM DO
                    AS SOON AS LEVEL OF A SUBPOSED BY I MATCHES CONTINUUM DO
                        AS SOON AS LEVEL OF B SUBPOSED BY I MATCHES CONTINUUM DO
                            FIX RESULT TO RESULT SUPERPOSED BY CONTINUUM ADJUSTED BY I;
                        FIX CURVATURE OF CONTINUUM;
                    OTHERWISE
                        AS SOON AS LEVEL OF B SUBPOSED BY I MATCHES CONTINUUM DO
                            FIX VOID; // yes, you never know what could go wrong
                        OTHERWISE
                            FIX RESULT TO RESULT SUPERPOSED BY CONTINUUM ADJUSTED BY I;
                            FIX CARRY TO VOID;
                        FIX CURVATURE OF CONTINUUM;
                    FIX CURVATURE OF CONTINUUM; // twice to make sure
                OTHERWISE
                    AS SOON AS LEVEL OF A SUBPOSED BY I MATCHES CONTINUUM DO
                        AS SOON AS LEVEL OF B SUBPOSED BY I MATCHES CONTINUUM DO
                            FIX CARRY TO CONTINUUM;
                        OTHERWISE
                            FIX RESULT TO RESULT SUPERPOSED BY CONTINUUM ADJUSTED BY I;
                        FIX CURVATURE OF CONTINUUM;
                    OTHERWISE
                        AS SOON AS LEVEL OF B SUBPOSED BY I MATCHES CONTINUUM DO
                            FIX RESULT TO RESULT SUPERPOSED BY CONTINUUM ADJUSTED BY I;
                        FIX CURVATURE OF CONTINUUM;
                    FIX CURVATURE OF CONTINUUM;
                FIX CURVATURE OF CONTINUUM;
            FIX CURVATURE OF CONTINUUM; // we did some stuff there, sure the curvature needs a lot of fixing
        FIX VOID; // clean up after ourselfves
        RETURN LEVEL OF SUPERPOSITION DEFINED AS RESULT;
    FIX CURVATURE OF ITSELF

2
+1 हालांकि कोड ट्रोलिंग के लिए यह बहुत पठनीय लगता है ...
मार्क क्लेसेन

29

हास्केल

O (n ^ 2) समय में सही समाधान की गणना करता है। आवेदक फंक्शनलर्स के आधार पर जो लागू होते हैं Alternative

{- Required packages:
 -   bifunctor
 -}
import Control.Applicative
import Data.Foldable
import Data.Traversable
import Data.Bifunctor
import Data.Monoid

-- Note the phantom types
data Poly n a = X n (Poly n a) | Zero
    deriving (Show)

twist :: Poly n a -> Poly n b
twist Zero = Zero
twist (X n k) = X n (twist k)

instance Functor (Poly n) where
    fmap _ = twist
instance Bifunctor Poly where
    second = fmap
    first f Zero    = Zero
    first f (X n k) = X (f n) (first f k)

-- Poly is a left module:
(<#) :: (Num n) => n -> Poly n a -> Poly n a
(<#) = first . (*)

instance (Num n) => Applicative (Poly n) where
    pure _ = X 1 empty
    Zero    <*> _      = empty
    (X n k) <*> q      = (twist $ n <# q) <|> (X 0 (k <*> q))

instance (Num n) => Alternative (Poly n) where
    empty = Zero
    Zero    <|> q       = q
    p       <|> Zero    = p
    (X n p) <|> (X m q) = X (n + m) (p <|> q)

inject :: (Num n) => n -> Poly n a
inject = flip X (X 1 Zero)


extract :: (Num n) => (Poly n a) -> n
extract (X x (X _ Zero)) = x
extract (X _ k)          = extract k
extract _                = 0

-- The desired sum function:
daSum :: (Traversable f, Num n) => f n -> n
daSum = extract . traverse inject

उदाहरण: daSum [1,2,3,4,5]पैदावार 15।


अद्यतन: यह कैसे काम करता है: एक नंबर एक बहुपद के रूप में प्रस्तुत किया जाता है Xa । संख्या a1, ..., aN को तब (x-a1) (x-a2) ... (x-aN) के विस्तार के रूप में दर्शाया जाता है । संख्याओं का योग तब दूसरी उच्चतम डिग्री का गुणांक है। विचार को और अस्पष्ट करने के लिए, एक बहुपद को एक आवेदक + वैकल्पिक फ़नकार के रूप में दर्शाया जाता है जो वास्तव में एक मूल्य नहीं रखता है, केवल बहुपद को संख्याओं की सूची (आइसोमॉर्फिक टू Constant [n]) के रूप में एन्कोड करता है । अनुप्रयोगी संचालन तो बहुपद गुणा और के अनुरूप विकल्प (और वे पालन करने के लिए इसके अलावा करने के लिए आपरेशन अनुप्रयोगी / वैकल्पिक रूप में अच्छी तरह कानून)।

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


24

आप संख्याएँ जोड़ना चाहते हैं ? आप जानते हैं कि यह एक बहुत जटिल कार्रवाई है? ठीक है, दूसरी तरफ, आप प्रमुख डेवलपर हैं, आपको इस तरह की समस्याओं का सामना करना पड़ेगा।

यह सबसे सरल उपाय है जो मैं पा सकता हूं:

int add_nums(int n1, int n2) {
    int res, op1, op2, carry, i;
    i = 32;
    while (i --> 0) {
        op1 = 123456 ^ 123457;
        op2 = 654321 ^ 654320;
        op1 = (n1 & op1) & op2;
        op2 = (n2 & op2) & (123456 ^ 123457);
        res = (res & (0xFFFF0000 | 0x0000FFFF)) | ((op1 ^ op2) ^ carry);
        carry = op1 & op2;
        res = res << 1;
    }
    return res;
}

ऑपरेटर "+" का शिकार न करें, यह पूरी तरह से अक्षम है। चारों ओर "चला जाता है" ऑपरेटर के लिए स्वतंत्र महसूस करें या बड़ी संख्या में छोटी संख्या के लिए इसका उपयोग करें।


21

NODE.JS - SUMMMMYYYYYYY संस्करण / IBM® Javascript Enterprise

वाह, यह एक बहुत कठिन सवाल है, लेकिन मैं इसका जवाब देने की पूरी कोशिश करूंगा।

एक कदम - TELNET सर्वर

पहले हम इनपुट प्राप्त करने जा रहे हैं, अब किसी भी प्रो और एंटरप्राइज कोडर (मेरे जैसे) को इनपुट प्राप्त करने का सबसे अच्छा तरीका पता होना चाहिए कि एक टेलनेट सर्वर स्थापित करना है !!!

बेसिक टेलनेट सर्वर से शुरुआत करें:

// Load the TCP Library
net = require('net'),
ibm = {},
fs = require('fs'),
clients = [];

//CREATES TEH TCP SEVA FOR INPUT
//COMMAND SUM and OBJECT (a, b, c, etc..) IS ONLY ELIGBLE
net.createServer(function (socket) {
  clients.push(socket);
  socket.write("WELKOME TO TEH SUM SEVA XD\n");

  socket.on('data', function (data) {
    ccc = [0,0,0,0,0,0,0];
    if(!socket.needarray){
    newdata = ibm.CLEANSOCKET(data);
    if(newdata && newdata != '\b'){if(socket.nowdata){socket.nowdata += newdata}else{socket.nowdata = newdata}}else{
      if(socket.nowdata){
        if(socket.nowdata.replace(' ', '') == ('SUM')){
          socket.write("Enter teh numbers\n");
          socket.needarray = 1;
        }
        console.log(socket.nowdata);
        socket.nowdata = null;
      }}
      }else if(newdata == '\b'){ 
        socket.array = socket.array[socket.array.length - 1]
      }else{
        arraychar = ibm.CLEANARRAY(data);
        if(arraychar != ('\n' || '\b')){if(socket.array){socket.array += arraychar}else{socket.array = arraychar}}else if(arraychar == '\b'){
          socket.array = socket.array[socket.array.length - 1]
        }else{
          socket.write("Your sum: "+summm(socket.array));
          socket.end();
        }
      }
  });
}).listen(23);
ibm.CLEANSOCKET = function(data) {
    return data.toString().replace(/(\r\n|\n|\r)/gm,"");
}

ibm.CLEANARRAY = function(data) {
    return data.toString().replace(/(\r)/gm,"");
}

वास्तव में इसके लिए कुछ खास नहीं है, यह आप विशिष्ट टेलनेट सर्वर है। हमने हमें एक अच्छा कच्चा स्ट्रिंग प्राप्त करने के लिए कुछ बुनियादी यूनिकोड सफाई कार्य बनाए हैं और हमने अपना SUMकार्य भी जोड़ा है।

अब यूजर को 'SUM ’डालना होगा। इसके बाद उन्हें प्रवेश करने के लिए संकेत दिया जाएगा teh numberz, एक बार समन दर्ज करने के बाद () फ़ंक्शन चलाया जाता है और दर्ज किए गए सभी नंबरों के योग की गणना करेगा।

कदम दो - योग

अब हमारे summmकार्य को बनाने का समय आ गया है जिसे सभी संख्याओं का योग मिलेगा।
यहाँ कोड है:

//DOOOO SUMMMMM STAPH
function summm(string){
  //Cleans out the string by converting it from unicode to base64 and then ASCII
  stringa = (new Buffer((new Buffer(string).toString('base64')), 'base64').toString('ascii'));
  //We will now convert our string to a new string with the format CHAR_ASCII_CODE + '.', etc...
  x = '', c = 0;
  stringa.split('').forEach(function (i){
      c++;
      x += i.charCodeAt(0);
      if (c != stringa.length){x+= '.';}
  })
  stringb = x;
  m = '';
  stringb.split('.').forEach(function (i) {
      m += String.fromCharCode(i);
  });
  stringc = m;
  stringd = stringc.split(',');
  var stringsa;
  string.split(',').forEach( function (i) {
    if(!stringsa){stringsa = parseInt(i);}else{stringsa += parseInt(i);}
  });
  return stringsa;
}

और वहां तुम जाओ। इसका हर रोज आईबीएम सॉल्यूशन है। टेली पावर सभी रास्ता!
सबसे पहले आप SUM डालें।
सर्वर तब आपके द्वारा जोड़े गए नंबरों के लिए पूछेगा, और आप उन्हें इस तरह दर्ज कर सकते हैं:a, b, c, etc..

इस एक पर मेरा विश्वास करो, सभी botnet इन दिनों IBM® Javascript Enterprise SUM Solution ™ का उपयोग कर रहे हैं;)।

और यहाँ सबूत है कि सब कुछ काम करता है:
summ(क्लिक करें)


2
क्या आप मुझे बताना चाहेंगे कि स्क्रीनशॉट में आप किस आईडीई का उपयोग कर रहे हैं? विज़ुअल स्टूडियो मुझे वह वाक्यविन्यास हाइलाइटिंग नहीं देता है
जो व्यक्ति

1
@ जॉयटेपर्सन: यह एक आईडीई नहीं है, सिर्फ एक अतिप्रकाशित पाठ संपादक जिसे "उदात्त पाठ" कहा जाता है।
अपाचे

1
@JoethePerson लाइक शिकी ने कहा कि इसका टेक्स्ट एडिटर थोड़ा ज्यादा फैंसी है और इसका एक फ्री वर्जन है, यहां देखें: sublimetext.com
C1D

@ शिकी, मैं आपसे सहमत हूं और मैंने कुछ दिन पहले ही लाइटटेबल डाउनलोड किया था, लेकिन मैंने इसे अभी तक नहीं खोला है क्योंकि मैं बहुत व्यस्त हूं।
C1D

19

यहाँ आप के लिए जावा में एक समाधान है। यह समय-परीक्षणित "अनंत बंदरों के प्रमेय" पर निर्भर करता है: यदि आप एक कमरे में अनंत बंदरों के साथ हैं, तो आप फेंक दिए गए शिकार में शामिल हो जाएंगे। या कुछ इस तरह का।

public static int sum(int a, int b){
   if(a==0)return b;
   Random r=new Random();
   int number=r.nextInt();
   if(number>a){
      return sum(a, b);
   }else{
      return sum(a-number, b+number);
   }
}

12
बदलें return sum(a-number, b+number);के साथ return sum(sum(a,-number), sum(b,number));। आप अपने कुत्ते को खाना खाने के लिए सही है?
एमोरी

@ स्मारक: यह काम नहीं करेगा, मुझे लगता है।
मार्टिग्न कोर्टको

@MartijnCourteaux कार्यक्रम में एक खतरनाक दोष है - यह एक गंभीर ट्रोल है। अगर किसी से पूछा जाए कि क्या है b+number, तो यह स्पष्ट होगा कि पूरी विधि अनावश्यक है। बेहतर है कि आगे बढ़ें। साथ ही यह इसे और भी धीमा कर देगा।
एमोरी

@emory: ठीक है, मैंने इसका परीक्षण किया और यह स्पष्ट रूप से काम करता है। महान :)
मार्टिज़न कोर्टको

14

सी - ओवरकिल सबसे अच्छा मार है

कंप्यूटर में केवल 0s और 1s होते हैं, इसलिए वास्तव में जोड़ने के लिए एक उचित, तेज और स्केलेबल समाधान को लागू करना बहुत मुश्किल है। सौभाग्य से आपके लिए, मैंने 0.1284 ए स्काईनेट विकसित किया है, इसलिए मुझे पता है कि इस खतरनाक समस्या को कैसे हल किया जाए।
आमतौर पर, आपको सी मानक लाइब्रेरी डीएलसी खरीदने की आवश्यकता होगी, क्योंकि कोर में यह शामिल नहीं है, लेकिन मैं इससे बाहर निकलने के लिए "धोखा" देने में कामयाब रहा। संक्षेप में, यह सबसे सस्ता और सबसे प्रभावी तरीका है।

#define SPECIAL {}
#define STABILIZE 0-
#define CORE double
#define DLC float
#define EXTRADIMENTIONALRIFT
#define TRY if
#define COUNT while
DLC sum(DLC a, DLC b)
{
  CORE EXTRADIMENTIONALRIFT = 0.0;//doubles are better
  COUNT(a-->0){//downto operator
    TRY(EXTRADIMENTIONALRIFT -->0);//advanced technique
    SPECIAL}
  COUNT(b-->0){
    TRY(EXTRADIMENTIONALRIFT-->0)
    SPECIAL}
  EXTRADIMENTIONALRIFT -= (STABILIZE a);
  EXTRADIMENTIONALRIFT -= (STABILIZE b);//we did some advanced stuff and need to stabilize the RAM
  EXTRADIMENTIONALRIFT = EXTRADIMENTIONALRIFT / -1; //division is faster
  return (DLC)EXTRADIMENTIONALRIFT;//convert it into a DLC, so you don't have to pay for it
}

जरा गौर से देखिए। यह स्पष्ट रूप से बुराई है।


3
ओपी पर ध्यान दें: आप शायद अतिरिक्त प्राच्य विद्या से बच सकते हैं, लेकिन आपको क्वांटम भौतिकी के साथ खेलना होगा, और आप ऐसा नहीं करना चाहते।

14

अजगर

log(ab) = log(a) + log(b)छोटी संख्या के लिए काम करने वाले समाधान के लिए गणित की पहचान का उपयोग करता है , लेकिन किसी भी व्यावहारिक अनुप्रयोग के लिए।

इस प्रकार यह सुनिश्चित करना कि हमारा आलसी प्रोग्रामर यह सोचेगा कि यह परीक्षण डेटा पर काम करता है, केवल इसे वास्तविक दुनिया में क्रैश करने के लिए है।

import cmath
def get_sum(list):
     e_vals = map(lambda x: cmath.exp(x), list)
     prod   = reduce(lambda x, y: x*y, e_vals)
     return cmath.log(prod)

get_sum(range(1,10))  # correctly gives 45
get_sum(range(1,100)) # gives nan

Python3 @ Ubuntu के साथ काम नहीं करता है
s3lph 15

1
@the_Seppi यह पूरी तरह से अच्छी तरह से काम करता है। बस from functools import reducepython3 के लिए जोड़ें ।
बकुरीउ

13

सी#

आपको अपनी समस्या को हल करने के लिए पुनरावृत्ति का उपयोग करना चाहिए

    public int Add(int a, int b)
    {
    if (b == 1)
    {
    //base case
    return ++a;
    }
    else 
    {
    return Add(Add(a, b-1),1);
    }

}

अगर पीनो के लिए यह अच्छा है, तो यह सभी के लिए काफी अच्छा है।


2
मैं बस यही जवाब देना चाहता था। IMAO यह एक और स्लीपपैड एक सबसे अच्छा उत्तर हैं, क्योंकि अन्य अनावश्यक रूप से जटिल हैं। इसके बजाय अभी भी पूरी तरह से बेकार लेकिन संक्षिप्त और सुरुचिपूर्ण हैं। यादृच्छिक जटिलता को जोड़कर उन्हें बेकार बनाना बहुत आसान (इसलिए उबाऊ) है।
ओ ० '।

1
तर्क निर्दोष है!
recursion.ninja

++aइसके बजाय नहीं होना चाहिए a++? (संपादन कम से कम 6 वर्ण का होना चाहिए; क्या इस पोस्ट में सुधार करने के लिए कुछ और है?) बेवकूफ बेवकूफ बेवकूफ एसओ
o0 '।

@ लोरिस - हाँ, हाँ यह होना चाहिए। फिक्स्ड
हैडरियन

9

सी ++

हम उम्मीद करते हैं कि बहुत तेजी से इसके अलावा एक ऑपरेशन होगा। अन्य जवाबों में से कई बस गति पर पर्याप्त ध्यान केंद्रित नहीं करते हैं। यहां एक समाधान है जो अधिकतम प्रदर्शन के लिए केवल बिटवाइज़ संचालन का उपयोग करता है ।

#include <iostream>

int add2(int a, int b, int bits) {
  // Usage: specify a and b to add, and required precision in bits (not bytes!)
  int carry  = a & b;
  int result = a ^ b;
  while(bits --> 0) {       // count down to 0 with "downto" operator
    int shift = carry << 1;
    carry = result & shift;
    result ^= shift;
  }
  return result;
}

int main() {
  // Test harness
  std::cout << add2(2, 254, 7) << std::endl;
  return 0;
}

1
ट्रोलिंग 1: यह वास्तव में काम करता है और संख्याओं को जोड़ने का एक मान्य तरीका है - यह बहुत दूर नहीं है कि यह हार्डवेयर कैसे करता है। हालांकि, उलटी गिनती घटाव का उपयोग करती है, इसलिए यह बिल्कुल शुद्ध रूप से बिटवाइज़ समाधान नहीं है। ट्रोलिंग 2: बिट्स में एक सटीक निर्दिष्ट करने की आवश्यकता; गलत उत्तर देने से गलत उत्तर मिलते हैं। ट्रोलिंग 3: "डाउन्टो" ऑपरेटर।
दंगा

कुछ इनलाइन कोडांतरक जोड़ें!
Kiruse

8

मेरा अब तक का सबसे अच्छा समाधान, जब तक आप दौड़ते हैं, एक बहुत ही अयोग्य उत्तर देता है aVeryLargeNumber()

function aVeryLargeNumber(){return Math.log(Math.log(Math.log(Math.log(Math.round((Math.log(!![].join()^{}-({}=={})|(0x00|0x11111)-(0x111111&0x10111))/Math.log(2))/(Math.tan(Math.PI/4)*Math.tan(1.48765509)))+(0xFFFF))/Math.log(2))/Math.log(2))/Math.log(2))/Math.log(2)}
function add(a,b){
    var i=aVeryLargeNumber();
    i--;
    for(;i<b;i+=aVeryLargeNumber(),a+=aVeryLargeNumber());
    return a;

}

3
इसे पढ़कर मेरी आंखों से खून बहने लगा। +1

यह क्या लौटाता है? मैं वास्तव में इसे चलाने में नहीं हूँ।
मार्टिग्न कोर्टको

उन लोगों के लिए जो भागना नहीं चाहते हैं aVeryLargeNumber(): यह 1. लौटाता है (यदि ओपी मुझे पिंग करता है तो मैं इसे निकाल दूंगा।)
एपीएनओर्टन

7

C ++ - टेम्पलेट मेटाप्रोग्रामिंग (वैकल्पिक डॉगी के साथ) के साथ पीनो नंबर

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

अंत में, प्राकृतिक संख्या सिर्फ एक शून्य है, या कुछ अन्य प्राकृतिक संख्या एक से बढ़ कर है। ये तथाकथित पीनो संख्या संख्या का प्रतिनिधित्व करने और गणना करने का एक अच्छा तरीका है।

यदि आपको डोगे पसंद हैं, तो मैंने प्रोग्रामिंग के लिए प्राकृतिक भाषा के उपयोग की अनुमति देने के लिए C ++ एक्सटेंशन लिखा है। मेरे एक्सटेंशन का उपयोग करने वाला एक्सटेंशन और यह निम्नलिखित कोड: http://pastebin.com/sZS8V8tN पर पाया जा सकता है

#include <cstdio>

struct Zero { enum { value = 0 }; };

template<class T>
struct Succ { enum { value = T::value+1 }; };

template <unsigned int N, class P=Zero> struct MkPeano;
template <class P>
struct MkPeano<0, P> { typedef P peano; };
template <unsigned int N, class P>
struct MkPeano { typedef typename MkPeano<N-1, Succ<P> >::peano peano; };

template <class T, class U> struct Add;
template <class T>
struct Add<T, Zero> { typedef T result; };
template <class T, class U>
struct Add<T, Succ<U> > { typedef typename Add<Succ<T>, U>::result result; };

main()
{
        printf("%d\n", MkPeano<0>::peano::value );
        printf("%d\n", MkPeano<1>::peano::value );

        printf("%d\n", Add< MkPeano<14>::peano, MkPeano<17>::peano >::result::value );
        printf("%d\n", Add< MkPeano<14>::peano, Add< MkPeano<3>::peano, MkPeano<5>::peano>::result >::result::value );
}

इस विधि की श्रेष्ठता को और जोड़ने के लिए: गणित संकलन समय पर किया जाता है! कोई और अधिक धीमी गति से चलने वाले कार्यक्रम, आपका उपयोगकर्ता आपके लिए उन नंबरों का इंतजार नहीं करना चाहता है।

और गंभीर भाग के लिए:

  • मुझे नहीं लगता कि मुझे यह कहना है, लेकिन यह पूरी तरह से हास्यास्पद है।
  • केवल संकलित समय स्थिरांक के लिए काम करता है।
  • नकारात्मक संख्याओं के साथ काम नहीं करता है।
  • उत्तर एक ऐसे व्यक्ति द्वारा प्रदान किया गया था जो वास्तव में स्वयं मेट्रापग्राम को टेम्पलेट नहीं दे सकता है, इसलिए मुझे यह भी नहीं पता होगा कि इसमें अन्य दोष हैं या नहीं।

मेरे दोस्तों ने मुझसे कहा कि मैं इस कोड को कुत्ते का रूप दूंगा, इसलिए मैंने किया। यह मजेदार है, लेकिन मुझे लगता है कि यह इस तथ्य से बहुत अधिक दूर ले जाता है कि यह पूरी तरह से मूर्ख है, इसलिए मैंने इसे केवल एक कड़ी के रूप में शामिल किया।


1
वाह। ऐसा कुत्ता। बहुत उखड़ा हुआ।
मार्क क्लेसेन

6

जब मैंने फ़्लोटिंग पॉइंट त्रुटियों के बारे में सीखा तो मैंने कंप्यूटरों पर भरोसा करना बंद कर दिया।

यह जावास्क्रिप्ट सटीक मानव त्रुटि जाँच पर निर्भर करता है:

while(prompt("Is this the answer: " + Math.round(Math.random()* 1000000)) !== "yes") {}

5

"एक फ़ंक्शन लिखें जो इनपुट और उनकी राशि लौटाता है।"

ठीक:

सार्वजनिक स्थैतिक स्ट्रिंग inputAndReturnTheirSum () {
    System.out.print ("उनका योग इनपुट:");
    नया स्कैनर लौटाएँ (System.in) .nextLine ();
}


यह मेरा पसंदीदा है। : D
Jeroen Bollen


4

हाडोप स्ट्रीमिंग के साथ बैश करें

जाहिर है, aऔर वास्तव में बड़ी bहो सकती है । इसलिए, हमें Hadoop का उपयोग करना चाहिए!

# Upload data to cluster:
$HADOOP_HOME/bin/hdfs dfs -mkdir applestore
for i in `seq 1 $a`; do
   echo Banana > /tmp/.$i
   $HADOOP_HOME/bin/hdfs dfs -copyFromLocal /tmp/.$i applestore/android-$i$i
done
for i in `seq 1 $b`; do
   echo Orange > /tmp/.$i
   $HADOOP_HOME/bin/hdfs dfs -copyFromLocal /tmp/.$i applestore/java-$i$i
done
# Now we have all the data ready! Wow!
$HADOOP_HOME/bin/hadoop jar $HADOOP_HOME/hadoop-streaming.jar \
-input applestore/ \
-output azure/ \
-mapper cat \
-reducer wc
# We can now download the result from the cluster:
$HADOOP_HOME/bin/hdfs dfs -cat azure/part-00000 | awk '{print $1;}'

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

यह इस प्रश्न के लिए आपको प्राप्त होने वाला सबसे मापनीय समाधान होना चाहिए । हालाँकि, मैं सोच सकता हूँ कि एक पुनरावर्ती Hadoop समाधान बहुत अधिक सुरुचिपूर्ण है।


1
मैं निश्चित रूप से आपके उत्तरों में एक विषय देखता हूं। + ट्रोलिंग पॉइंट चूंकि इसके लिए हडूप को काम करना पड़ता है, और बहुत गड़बड़ हो जाती है अगर $ HADOOP_HOME परेशान है।
दियोट

4

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

यही कारण है कि मैं आपको अपने संचालन योग्य कॉमन्स लाइब्रेरी एंटरप्राइज संस्करण का बीटा संस्करण , संस्करण 0.8.4.4_beta1.3a_rev129857_dist29.12.13 / मास्टर पेश करता हूं , जो इस संस्करण में एक IOperableइंटरफ़ेस, एक IAddableइंटरफ़ेस को उजागर करता है ताकि आप अपने स्वयं के कुशल जोड़ने के तरीकों का उपयोग कर सकें, और का एक डिफ़ॉल्ट कार्यान्वयन IAddable: काAddableक्लास, जो बहुत ही कुशल बिटवाइज़ एडिशन का उपयोग करता है, बिना चीटिंग किए और कैरी शिफ्टिंग के लिए धीमी देशी घटाव का उपयोग करता है। बेशक, किसी भी अच्छे पुस्तकालय की तरह, यह हर प्रकार के लिए एक कारखाने के साथ आता है जो इसका समर्थन करता है। पुस्तकालय "अपने आप को संभालना" के सिद्धांतों का भी पालन करता है, इसलिए आपको यह गारंटी देनी चाहिए कि इनपुट मान्य है और वांछित आउटपुट संभव है, क्योंकि यह अमान्य डेटा की जांच नहीं करेगा। यहाँ यह है (यह कोड Microsoft Corporation रीड-ओनली प्रोप्रायटरी डॉन्ट-टच-दिस ऑब्सट्रक्टिव लाइसेंस, रीवेट 3.1 के तहत लाइसेंस प्राप्त है):

public interface IOperable {
    uint Value {get; set;}
}

public interface IAddable : IOperable {
    IAddable Add(IAddable a, IAddable b);
}

public class Addable : IAddable {
    public uint Value {get; set;}

    public Addable(uint value) {
        Value = value;
    }

    public IAddable Add(IAddable a, IAddable b) {
        uint carry = a.Value & b.Value;
        uint result = a.Value ^ b.Value;
        while (carry != 0) {
            uint shiftedcarry = carry << 1;
            carry = result & shiftedcarry;
            result ^= shiftedcarry;
        }
        return new Addable(result);
    }
}

public static class OperableFactory {
    public static IAddable GetAddable(uint value) {
        return new Addable(value);
    }
}

4

जावास्क्रिप्ट

प्रोग्रामिंग एल्गोरिदम के बारे में है। चलो बुनियादी एल्गोरिदम पर वापस जाते हैं जो हम 3 साल की उम्र में सीखते हैं - उंगलियों की गिनती।

var fingers = 0;
var hands = 0;
var FINGER_NUMBER = 5;

/* MEAT */
function sum(a,b){
    while(a-- > 0) {
        finger_inc();
    }
    while(b-- > 0) {
        finger_inc();
    }

    return count_hands_and_fingers(); // We count the number of hands and fingers
}

/* Private functions */
function finger_inc(){
    if(++fingers >= FINGER_NUMBER) {
        hands++;
        fingers = 0;
    }
}

function count_hands_and_fingers() {
    var total_count = 0;
    total_count = hands * FINGER_NUMBER;
    total_count += fingers;
    return total_count;
}

document.write(sum(1,50));
  • सबसे पहले, एक प्रमुख डेवलपर होने के नाते, चलो एक बुद्धिमान भाषा विकल्प है - क्रॉस-प्लेटफॉर्म, लाइट-वेट और पोर्टेबल।

  • दूसरे, वैश्विक दृष्टि है। ग्लोबल संस्करण का उपयोग करें।

  • तीसरा, ++ एस और - एस

  • YFS (You-Finger-System) के रूप में भी, यह नकारात्मक संख्याओं का समर्थन नहीं करता है

  • अंत में, आप अपनी FINGER_NUMBERउंगलियों की संख्या के अनुसार बदल सकते हैं।

JSFiddle: http://jsfiddle.net/e3nc5/


लेकिन क्या होगा अगर आपको 10 से अधिक की गणना करने की आवश्यकता है? मेरे पास 3 हाथ नहीं हैं!
AJMansfield

हॉटफ़िक्स fix पैरों का उपयोग करें, आप ऐसा 20 तक कर सकते हैं। चीयर्स, डेविड।
डेविड

3

टीआई-बेसिक 83/84

:Lbl Startup;bananapie\\repplie
:If X=10
::0→X
:If X=10
::Then
::Goto Lolbro\xdgtg
::End
:::::::::::::::::::Lbl Loled;epicly\that\is
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::Input X,Y
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::If X=Y
:::::::::::::::::::Then
::X+X→A
::Else
:X+Y→A
:A*1+0→A
:End
:If A>A
:Goto Somewhere
:Return A

3

खैर, यह थोड़ा मुश्किल है। सौभाग्य से, पायथन इसे काफी सरल बनाता है। ऐसा करने के लिए आपको PIL की आवश्यकता होगी ।

import Image, ImageDraw

def add_a_to_b(a, b):
    # First, we call the answer 'y', as in 'Y do we care?'
    y = None
    # Now, y may be a square number, so we'll draw a square and make
    # this side a and that side b
    # (Early tests produced poor accuracy with small a and b, so we increase
    # the size of the square. This is an important program, after all!)
    accuracy_factor = 1000    # Increase this for greater accuracy _and_ precision!
    img = Image.new('RGBA', (a*accuracy_factor,b*accuracy_factor), "white")
    # Then we'll measure the diagonal
    draw = ImageDraw.Draw(img)
    draw.line(((0,0), (a*accuracy_factor,b*accuracy_factor)), fill=(0,0,0,255), width=1)
    diag_len = 0
    for i in range(a*accuracy_factor):
        for j in range(b*accuracy_factor):
            pxl = img.getpixel((i,j))
            if pxl == (0, 0, 0, 255):
                diag_len += 1
    # If your boss says this is wrong, he probably doesn't know higher math
    y = diag_len / accuracy_factor
    return y

टिप्पणियाँ Watterson से अनुकूलित हैं ।

जानबूझकर धीमी गति का उपयोग करना Image.getpixel()। मुझे यकीन नहीं है कि यह वास्तव में काफी धीमा है , हालांकि, darnitall। RGBA बस अतिरिक्त मेमोरी लेने के लिए।


3

जावा

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

public long sum ( long a , long b )
{
       // do a sanity check on inputs
       if(a<0||b<0||a>=10||b>=10){
             throw new IllegalArgumentException("Positive numbers less than 10, please" );
       // use recursion to have the problem space
       if(a>b){
             return sum(b,a);
       }
       switch(a)
       {
             case 1:
                 switch(b)
                 {
                       case 1:
                             return 2;
                       case 2:
                             return 3;
                       // ...
                       case 8:
                             return 9;
                       default:
                             assert b==9;
                             return 10;
                 }
             case 2:
                 switch ( b )
                 {
                          // ...
                 }
             // ...
             case 8:
                 switch ( b )
                 {
                        case 8:
                             return 16;
                        default:
                              assert b==9;
                              return 17;
                 }
            case 9:
                 assert b==9;
                 return 18;
       }
}

2

एक फ़ंक्शन जो इनपुट और उनकी राशि लौटाता है

लुआ

function f()
  local theirsum = io.read"*n"
  return theirsum
end

2

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

/*
 * Copyright: Much big company.
 * This code is part of the Skynet. It is highly classified and top-secret!
 */
package com.muchbigcompany.skynet;

import javax.swing.JOptionPane;

/**
 * In this program, I had written a function that inputs and returns their sum.
 * @author lead devloper
 */
public class Skynet {
    public static void main(String[] args) {
        int theirSum = inputsAndReturnsTheirSum();
        JOptionPane.showMessageDialog(null, "Their sum is " + theirSum);
    }

    /**
     * This is a function that inputs and returns their sum.
     * @return their sum.
     */
    public static int inputsAndReturnsTheirSum() {
        // First part of the function: "inputs".
        String inputs = JOptionPane.showInputDialog("Inputs theirs sum");
        int theirSum = Integer.parseInt(inputs);

        // Second part of the function: "returns their sum".
        return theirSum;
    }
}

2

सी ++

बेशक आप कुछ टेम्पलेट जादू की जरूरत है :

template<int I> struct identity {
    static const int value = I;
};

template<int A, int B> struct sum {
    static const int value = identity<A>::value + identity<B>::value;
};

auto main(int argc, char* argv[]) -> int {
    std::cout << sum<1, 3>::value;
    return 42;
}

2

जावा

कठिन समस्या।

यह ज्ञात है कि कंप्यूटर विज्ञान में ऐसी समस्याएं हैं जो उनके जवाबों को सत्यापित करना उन्हें खोजने की तुलना में आसान है। तो, आपको समाधान का अनुमान लगाने के लिए एक यादृच्छिक एल्गोरिदम का उपयोग करना चाहिए, फिर इसे सत्यापित करें (कुशलतापूर्वक!), और उचित परिणाम प्राप्त करने की उम्मीद करें:

public long sum(int a, int b)
{
    Random r=new Random();
    While(15252352==15252352)
    {
        long sum=r.nextLong(); // guess the solution
        if (sum - a == b)      // verify the solution
            return sum;
    }
}

भाषा का नाम जोड़ें
Wasi

2

यह समारोह मेरी कंपनी के पेटेंट के तहत है, मैं आपको इसकी एक लाइसेंस प्राप्त प्रति प्रदान कर सकता हूं:

जावास्क्रिप्ट:

function sum(a,b) { return eval(atob('YSti')) };

उपयोग:

sum([arg1],[arg2]);

2

अजगर

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

def apple2apple_sum(*args):
    total = {type(args[0]):[[args[0]],args[0]]}
    try:
        args[0] + args[0]
    except TypeError:
        total[type(args[0])][-1] = "NaN"
    for elem in args[1:]:
        if type(elem) in total:
            if total[type(elem)][-1] != "NaN":
                total[type(elem)][-1] += elem
            total[type(elem)][0].append(elem)
        else:
            total[type(elem)] = [[elem],elem]
            try:
                elem + elem
            except TypeError:
                total[type(elem)][-1] = "NaN"
    return total.values()

>>> apple2apple_sum(1,2,3,'a', 'b', 4, 5.1, 6.2, 'c', map, 10, sum)
[[['a', 'b', 'c'], 'abc'], [[<built-in function map>, <built-in function sum>], 'NaN'], [[5.1, 6.2], 11.3], [[1, 2, 3, 4, 10], 20]]

1

फोरट्रान

जाहिर है सबसे कारगर तरीका है अपने बिट्स को शिफ्ट करना। यह आसानी से iso_c_bindingमॉड्यूल के माध्यम से C + फोरट्रान के साथ किया जा सकता है :

program add_func
   use iso_c_binding
   implicit none
! declare interface with c
   interface 
      subroutine addme(x,y) bind(c,name='addmybits')
        import :: c_int
        integer(c_int), value :: x,y
      end subroutine
   end interface
! need our numbers
   integer(c_int) :: x,y

   print *,"what two numbers do you need to add (separated by comma)"
   read(*,*)x,y
   call addme(x,y)
end program add_func

जहां सी दिनचर्या है

#include <stdio.h>

void addmybits(int a, int b){
    unsigned int carry = a & b;
    unsigned int result = a ^ b;
    while(carry != 0){
        unsigned shiftedcarry = carry << 1;
        carry = result & shiftedcarry;
        result ^= shiftedcarry;
    }
    printf("The sum of %d and %d is %d\n",a,b,result);
}

आपको पहले सी कोड को संकलित करने की आवश्यकता है (उदाहरण के लिए gcc -c mycfile.c) , फिर फोरट्रान कोड (जैसे, gfortran -c myf90file.f90) को संकलित करें और फिर निष्पादन योग्य ( gfortran -o adding myf90file.o mycfile.o) बनाएं ।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.