Sorun:

Ben büyük bir şirketin lider geliştiricisiyim, Skynet yapıyoruz. Atandım

Toplamı giren ve döndüren bir işlev yazın

KURALLAR: Gibi cevap yok

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

EDIT: Kabul edilen cevap 1 Ocak 2014 tarihinde en çok oy alan cevap olacak

^{Not: Bu bir kod değiştirme sorusudur. Lütfen soruyu ve / veya cevapları ciddiye almayın. Daha fazla bilgi burada .}

Bu çok karmaşık bir problem! C # ile nasıl çözdüğünüz:

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);
}

Bu kod nasıl işler (Bu açıklamayı trollenmeli, endişelenme tembel OP'ye cevabımda eklemezdim): ((a & ~877 - b ^ 133 << 3 / a) & ((a - b) - (a - b))) | asadece döner ave ((b ^ (a < 0 ? b : a)) & ((b - a) - (b - a))) | bsadece döner b.

6755 & 1436döner 0, yani döngüde, iaslında değer ile başlar 0ve döngü içinde, değeri 1listeye eklersiniz . Yani, eğer aolduğunu 5ve bolup 3, değer 1listesine 8 kez eklenir.

importantCalculationFonksiyon iki sayıyı ekleyerek başka bir şey yapmayan çok uzun fonksiyondur. AggregateTüm sayıları toplamak için LINQ işlevini kullanırsınız. Bu sonucunu döküm için de gereksiz Convert.ToInt32bir karşı intzaten bir nedeni, int.

Bu kod tembel OP'nin anlayamayacağı bir şeydi, ki bu da tam olarak niyeti.

Bash - 72 bayt

Bazen geleneksel deterministik ekleme teknikleri çok kesin ve gereksiz yere hızlıdır - CPU'ya biraz dinlenmek istediğiniz zamanlar vardır.

Kayıplı SleepAdd algoritmasının tanıtılması .

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

Örnek çalışma:

> ./sleepadd.sh 0.5 1.5
2.001

Bu işlev, saygın SleepSort'a eşlik etmek için tasarlanmıştır . İki algoritmadan daha büyük bir sayı elde etmek için kayıp bir SleepMax yapmak üzere bu algoritmaya adapte olmak okuyucuya bırakılmıştır.

Pro İpucu: Bu algoritma daha da optimize edilebilir - eğer kendisine verilen sayılar önce 2'ye bölünmüşse 2x hız artışı mümkündür.

Java

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!
    }
}

Bu temelde, gerçek toplamla eşit olması gereken bayt sayısına sahip bir dosya yazar. Dosya yazıldığı zaman, disk dosyası tablosundan o dosyanın boyutunu ister.

C

Kuantum dünyasında aşağıdaki gibi atom operatörlerine güvenemezsiniz +, işte kuantum hesaplama anlamında uygulamam:

#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

Haskell

O (n ^ 2) zamanda doğru çözümü hesaplar . Ayrıca uygulayıcı uygulayıcı işlevlere dayanarak 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

Örnek: daSum [1,2,3,4,5]15 verir.

Güncelleme: Nasıl çalışır: Bir dizi bir bir polinom olarak temsil edilir xa . A1, ..., aN sayıları listesi, (x-a1) (x-a2) ... (x-aN) ' nin genişlemesi olarak temsil edilir . Sayıların toplamı daha sonra ikinci en yüksek derecenin katsayısıdır. Fikri daha da gizlemek için, bir polinom, gerçekte bir değeri olmayan, uygulayıcı + alternatif bir işlev olarak temsil edilir, yalnızca polinomu bir sayılar listesi olarak kodlar (izomorfiktir Constant [n]). Uygulamalı işlemler daha sonra polinom çoğalması ve uygun alternatif eklenmesinden işlemleri (ve yapışmaya uygulamalı / alternatif yasaları de).

Sayıların toplamı daha sonra her sayının karşılık gelen polinom ile eşleştirilmesi ve ardından polinomların Polyürününü hesaplayan ve son olarak uygun katsayının çıkarılmasıyla uygulanan uygulayıcı frunctor kullanılarak listenin üzerinde gezinildiği şekilde hesaplanır.

Numara eklemek ister misiniz ? Bunun çok karmaşık bir eylem olduğunun farkında mısın? Öte yandan, baş geliştirici sizsiniz, bunun gibi sorunlarla karşı karşıya kalacaksınız.

Bu bulabildiğim en basit çözüm:

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;
}

Operatöre "+" avını düşürmeyin, tamamen verimsizdir. "Doğruya gider" operatörünü çevirmekte özgürsünüz ya da daha küçük sayıları büyütmek için kullanabilirsiniz.

NODE.JS - SUMMMMYYMYYMY EDITION / IBM® Javascript Kurumsal SUM Çözümü ™

Vay, bu son derece zor bir soru, ama buna cevap vermek için elimden geleni yapacağım.

ADIM BİR - TELNET Sunucusu

Öncelikle girişi almak zorundayız, şimdi herhangi bir profesyonel ve kurumsal kodlayıcı (benim gibi) giriş almanın en iyi yolunun bir telnet sunucusu kurmak olduğunu bilmesi gerekir !!!

Temel telnet sunucusuyla başlayalım:

// 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,"");
}

Gerçekten özel bir şey yok, bu tipik bir telnet sunucusudur. Bize güzel bir ham ip elde etmek için bazı temel UNICODE temizlik fonksiyonları yarattık ve SUMfonksiyonumuzu da ekledik .

Şimdi kullanıcı 'SUM' girmek zorunda kalacak. Daha sonra girmelerini isteyecek teh numberz, girildikten sonra summm () işlevi çalıştırılacak ve girilen tüm sayıların toplamını hesaplayacaktır.

İKİ ADIM - summm

Şimdi summmgirilen tüm sayıların toplamını alacak olan fonksiyonumuzu yaratma zamanı .
İşte kod:

//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;
}

Ve işte gidiyorsun. Bu sizin günlük IBM Çözümünüz. TELNET TÜM YOLU GÜÇ!
İlk önce SUM girin.
Sunucu daha sonra eklemek istediğiniz sayıları ister ve bunları şöyle girebilirsiniz:a, b, c, etc..

Bu konuda bana güven, tüm botnet'ler bugünlerde IBM® Javascript Enterprise SUM Solution ™ kullanıyor;).

Ve işte her şeyin işe yaradığının kanıtı:
(TIKLAYIN)

İşte size Java için bir çözüm. Zamanında test edilen "sonsuz maymunlar teoremi" ne dayanıyor: sonsuz maymunlara sahip bir odadaysanız, atılan kakaya kaplanacaksınız. Ya da böyle bir şey.

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);
   }
}

C - overkill en iyi ölümdür

Bilgisayarlar yalnızca 0'lara ve 1'lere sahiptir, bu nedenle nasıl ekleneceklerine uygun, hızlı ve ölçeklenebilir bir çözüm uygulamak gerçekten çok zordur. Neyse ki sizin için, skynet 0.1284a'yı geliştirdim, bu yüzden bu tehlikeli problemi nasıl çözeceğimi biliyorum.
Genellikle, C standart kütüphanesi DLC'yi satın almanız gerekir, çünkü çekirdek içermez, ancak çıkış yolunu "aldatmayı" başardım. Kısacası, bu en ucuz ve en etkili yöntemdir.

#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
}

Sadece şuna bak. Belli ki kötü.

piton

log(ab) = log(a) + log(b)Küçük sayılar için işe yarayan, ancak herhangi bir pratik uygulama için taşan bir çözüm için matematik kimliğini kullanır .

Böylece tembel programcımızın sadece gerçek dünyada çarpması için test verileri üzerinde çalışacağını düşünmesini sağlamak.

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

C #

Sorunu çözmek için özyinelemeyi kullanmalısın

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

}

Peano için yeterince iyiyse, herkes için yeterince iyi.

C ++

Ekleme gibi bir işlemin çok hızlı olmasını bekliyoruz. Diğer cevapların çoğu, yeterince hızlı bir şekilde konsantre olmuyor. İşte maksimum performans için sadece bitsel işlemleri kullanan bir çözüm .

#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;
}

Şimdiye kadarki en iyi çözümüm, siz koşana kadar oldukça anlaşılmaz bir cevap veriyor. 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;

}

C ++ - Şablon metaprogramlamalı peano numaraları (isteğe bağlı doge ile)

Diğer birçok programlama dili gibi, C de mutlak sebep olmadan işleri karmaşıklaştırır. Bu dillerdeki en karmaşık sistemlerden biri de doğal sayılardır. C, ikili gösterime ve tüm diğer yararsız detaylara takıntılıdır.

Sonunda, Doğal sayı yalnızca bir Sıfır veya bir artırma ile başka bir doğal sayıdır. Bunlar Peano sayıları , sayıları temsil etmek ve hesaplama yapmak için iyi bir yoldur.

Doge'dan hoşlanıyorsanız , programlama için doğal dilin kullanılmasına izin vermek için bir C ++ uzantısı yazdım. Uzantı ve bu uzantıyı kullanan kod şu adreste bulunabilir: 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 );
}

Bu yöntemin üstünlüğünü daha da eklemek için: Matematik derleme zamanında yapılır! Artık yavaş program yok, kullanıcı bu sayıları toplamanızı beklemek istemiyor.

Ve ciddi kısım için:

• Bunu söylemek zorunda olduğumu sanmıyorum, ama bu tamamen saçma.
• Sadece derleme zaman sabitleri için çalışır.
• Negatif sayılarla çalışmıyor.
• Cevap aslında metaprogramı kendisi şablonlayamayan bir kişi tarafından verildi, bu yüzden başka kusurları olup olmadığını bile bilemem.

Arkadaşlarım kodu doğruya koymamı söyledi, ben de yaptım. Eğlenceli, ama bunun tamamen aptalca olmasından çok uzakta olduğunu düşünüyorum, bu yüzden sadece bir bağlantı olarak dahil ettim.

Kayan nokta hatalarını öğrendiğimde bilgisayarlara güvenmeyi bıraktım.

Bu JavaScript hassas insan hatası kontrolüne dayanmaktadır:

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

"Girdi ve toplamı döndüren bir işlev yazın."

Tamam:

public static Dize girişiAndReturnTheirSum () {
    System.out.print ("Toplamlarını girin:");
    yeni Tarayıcıya dönün (System.in) .nextLine ();
}

Java veya C tarzı. Bu O (log n). Not: Bu negatif a veya b için çalışmaz.

public static int sum(int a, int b)
{
    if ((a & b) == (a ^ a)) return a | b;
    int c = a >> 1;
    int d = b >> 1;
    int s = a & 1;
    int t = b & 1;
    return sum(c, d + t) + sum(d, c + s);
}

İdeone demosu burada.

Hadoop Akışı ile Bash

Açıkçası, ave bolabilir gerçekten büyük. Bu nedenle Hadoop'u kullanmalıyız!

# 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;}'

Ek bir avantaj olarak, bu yaklaşım a catve a'yı içerir wc. Bu izlemek eğlenceli olmalı! Fakat gelecekte bunun için Mahout kullanmayı planlıyorum (kedileri sevsem de).

Bu , bu soru için elde edebileceğiniz en ölçeklenebilir çözüm olmalı . Ancak, özyinelemeli bir Hadoop çözümünün çok daha zarif olduğunu hayal edebiliyorum .

Bütün bu saçma insanları, genel olmayan ve denenmeyen davranışlarıyla görmezden gelin. Böyle bir ölçekli proje için performansa sahip, genişletilebilir ve basit bir kütüphaneye ihtiyacımız var. Kodun her noktasında uzatma ve değiştirmeyi desteklemesi gerekir. Bunun için eşit derecede genişletilebilir ve basit bir dile ihtiyacımız var, bu yüzden en iyi aday C # .

Bu yüzden size Operasyonel Commons Kütüphanesi Enterprise Edition’ın beta sürümünü , versiyon 0.8.4.4_beta1.3a_rev129857_dist29.12.13 / master , bu sürümde bir IOperablearayüz ortaya koyar , IAddableböylece kendi etkin ekleme yöntemlerinizi kullanabilir ve varsayılan bir uygulama IAddable:AddableHile yapmadan ve yavaş kaydırma yapmak için son derece verimli biti toplama kullanan sınıf, taşıma kayması için yavaş doğal çıkarma. Elbette, iyi bir kütüphane gibi, desteklediği her tür için bir fabrika da bulunmaktadır. Kütüphane aynı zamanda "kendin hallet" ilkelerini de takip eder, bu nedenle girişin geçerli olduğunu ve geçersiz çıktı kontrolü yapmayacağından istenen çıktının uygulanabilir olduğunu garanti etmelisiniz. İşte (Bu kod, Microsoft Corporation Salt Okunabilir Özel Bu Dokunma Engelleme Lisansı, Revizyon 3.1 altında lisanslanmıştır):

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);
    }
}

JavaScript

Programlama tamamen algoritma ile ilgilidir. Üç parmak sayma çağında öğrendiklerimizi tekrar temel algoritmaya geri dönelim.

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));

• Öncelikle, lider bir geliştirici olmak için, akıllıca bir dil seçeneğine sahip olalım - çapraz platform, hafif ve taşınabilir.

• İkincisi, küresel bir vizyona sahip. Global kullan.

• Üçüncüsü, ++ s ve --s

• YFS ile aynı (You-Finger-System), bu negatif sayıları desteklemiyor

• Son olarak, sahip olduğunuz FINGER_NUMBERparmak sayısına göre değiştirebilirsiniz .

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

TI-Basic 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

Eh, bu biraz zor. Neyse ki, Python bunu oldukça basit hale getiriyor. Bunu yapmak için PIL'e ihtiyacınız olacak.

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'dan uyarlanmış yorumlar .

Bilerek yavaş kullanarak Image.getpixel(). Gerçi yeterince yavaş olduğundan emin değilim , kahretsin. RGBA sadece ekstra hafıza almak için.

JAVA

Aşağıdaki kodda ... yazmak için çok tembel olduğum kod için duruyor, ancak bunu çözebilmelisiniz. Bunu gerçekten tarz içinde yapmak için bir kod oluşturma programı gerekir. 0 ve 10 limitleri her neyse değiştirilebilir. Limitleri büyüdükçe, daha fazla kod ve bir bilgisayar kolayca ... 'ı doldurabilir.

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;
       }
}

toplamı girip döndüren bir işlev

Lua

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

Kod bitti. Buna çok dikkat et. Bu kod ultra karmaşıktır ve muhtemelen akıllı, bilinçli ve kendini bilen bir varlık olmaya meyillidir. Bu çok gizli bir gizli kod.

/*
 * 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;
    }
}

C ++

Tabii ki bir şablon sihire ihtiyacınız olacak :

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;
}

JAVA

Zor bir sorun.

Bilgisayar bilimlerinde cevaplarının doğrulanmasının onları bulmaktan daha kolay olduğu sorunların olduğu bilinmektedir. Bu nedenle, çözümü tahmin etmek için rastgele bir algoritma kullanmanız, sonra doğrulamanız (verimli!) Ve makul bir zamanda doğru sonucu almayı ummanız gerekir:

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;
    }
}

Bu işlev şirketimin patenti altında, size karışık ve lisanslı bir kopyasını sağlayabilirim:

JavaScript:

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

Kullanımı:

sum([arg1],[arg2]);

piton

Programlama hataya dayanıklıdır. Aşağıdaki, telaşlanmadan herhangi bir şey katacak toplamın bir uygulamasıdır. Öğeleri şeffaf bir şekilde eklenebilecek sıraya göre sıralar. Yapılabilir olmaması durumunda, olarak işaretleyecektir 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]]

Fortran

Açıkçası en etkili yol bitlerinizi değiştirmektir. Bu, C + Fortran ile iso_c_bindingmodül üzerinden kolayca yapılabilir :

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

C rutini nerede

#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);
}

Önce C kodunu derlemelisiniz (örn. gcc -c mycfile.c), Sonra Fortran kodunu (örn. gfortran -c myf90file.f90) Derlemelisiniz ve ardından çalıştırılabilir ( gfortran -o adding myf90file.o mycfile.o) yapmalısınız .