問題：

私は大企業の主任開発者で、Skynetを作っています。に割り当てられました

合計を入力して返す関数を作成する

ルール： 答えはありません

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

編集：受け入れられた答えは、2014年1月1日に最も賛成票を投じる

^{注：これはコードトローリングの質問です。質問や回答を真剣に受け取らないでください。詳細はこちら。}

それは非常に複雑な問題です！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);
}

このコードがどのように機能するか（制御する必要のある遅延OPの答えにこの説明を追加しません。心配しないでください）：を((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実際にはvalue 0で始まり、ループ内で1はリストに値を追加します。したがって、ais 5およびbisの3場合、値1はリストに8回追加されます。

このimportantCalculation関数は非常に長い関数であり、2つの数値を加算するだけです。LINQ Aggregate関数を使用して、すべての数値を合計します。これは、その結果をキャストすることも不要だConvert.ToInt32しint、それはすでにあるので、int。

このコードは、遅延OPが理解できないものであり、まさに意図です:-)

バッシュ-72バイト

時々、伝統的な決定的加算技術は、あまりにも正確で、不必要に高速です-CPUに少し休息を与えたい場合があります。

非可逆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

この関数は、よく知られているSleepSortの仲間として意図されています。このアルゴリズムを適応させて損失のあるSleepMaxを作成し、2つの数値のうち大きい方を取得することは、読者の課題です。

プロのヒント：このアルゴリズムはさらに最適化できます-与えられた数値を最初に2で割ると、2倍の速度向上が可能です。

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

これは基本的に、実際の合計と同じバイト数のファイルを書き込みます。ファイルが書き込まれると、ディスクファイルテーブルにそのファイルのサイズを要求します。

C

量子の世界では+、のような原子演算子に依存することはできません。ここに、量子コンピューティングの観点からの加算の実装を示します。

#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

ハスケル

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を生成します。

更新：仕組み：数値aは多項式xaとして表されます。数値a1、...、aNのリストは、（x-a1）（x-a2）...（x-aN）の展開として表されます。数値の合計は、2番目に高い次数の係数になります。アイデアをさらにわかりにくくするために、多項式は、実際には値を保持せず、多項式を数値のリストとして符号化するだけの、アプリカティブ+オルタナティブファンクタとして表されます（に同型Constant [n]）。応用的操作は、次いで、多項式乗算とに対応する別の添加操作（およびその接着する応用的/代替法も同様）。

次に、各数値を対応する多項式にマッピングし、その後Poly、多項式の積を計算するアプリカティブフルンクターを使用してリストを走査し、最後に適切な係数を抽出することで、数値の合計が計算されます。

数字を追加しますか？！？これは非常に複雑なアクションであることをご存知ですか？わかりました、一方で、あなたは主任開発者です、あなたはこのような問題に直面しなければなりません。

これは私が見つけることができる最も簡単な解決策です：

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

演算子「+」の餌食にならないでください。完全に非効率的です。「進む」演算子を自由に変えたり、小さい数字が大きくなる場合に使用してください。

NODE.JS-SUMMMMYYMYYMY EDITION /IBM®Javascript Enterprise SUM Solution™

うわー、これは非常に難しい質問ですが、私はこれに答えるために最善を尽くします。

ステップ1-TELNETサーバー

最初に入力を受信する必要がありますが、今ではプロやエンタープライズのコーダー（私のような）はtelnetサーバーをセットアップすることが入力を受信する最良の方法を知っているはずです!!!

基本的な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,"");
}

特別なことは何もありません。これは典型的なtelnetサーバーです。生の文字列を取得するための基本的なUNICODEクリーニング関数を作成し、SUM関数も追加しました。

これで、ユーザーは「SUM」を入力する必要があります。次に、入力を促すメッセージが表示され、入力されるとteh numberzsummm（）関数が実行され、入力されたすべての数値の合計が計算されます。

ステップ2-summm

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

そしてそこに行きます。その毎日のIBMソリューション。TELNETのすべての方法
最初にSUMを入力します。
サーバーは、追加したい番号を要求し、そのように入力できます。a, b, c, etc..

これを信じてください、すべてのボットネットは最近IBM®Javascript Enterprise SUM Solution™を使用しています;）。

そして、ここにすべてが機能している証拠があります：（
クリック可能）

Javaのソリューションを紹介します。実績のある「無限サルの定理」に依存しています。無限サルの部屋にいる場合は、スローされたうんちで覆われてしまいます。またはそのようなもの。

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-オーバーキルはベストキルです

コンピューターには0と1しかありません。そのため、追加する方法に対して適切で高速でスケーラブルなソリューションを実装することは実際には非常に困難です。幸いなことに、私はスカイネット0.1284aを開発したので、この危険な問題を解決する方法を知っています。
通常、コアにはC標準ライブラリDLCが含まれていないため、C標準ライブラリDLCを購入する必要がありますが、どうにかして「チート」しました。要するに、これは最も安価で最も効果的な方法です。

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

見てください。それは明らかに悪です。

Python

数値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

C＃

再帰を使用して問題を解決する必要があります

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

}

ペアノにとって十分であれば、誰にとっても十分です。

C ++

加算のような操作は非常に高速であると予想されます。他の答えの多くは、単に速度に十分に集中していません。最大のパフォーマンスを得るためにビット演算のみを使用するソリューションを次に示します。

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

これまでの私の最善の解決策は、実行するまでかなり分かりにくい答えを与えます 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 ++-テンプレートメタプログラミングを使用したペアノ数（オプションのdogeを使用）

Cは、他の多くのプログラミング言語と同様、物事を複雑にします。これらの言語で最も複雑なシステムの1つは自然数です。Cは、バイナリ表現と他のすべての完全に役に立たない詳細に取りつかれています。

最終的に、自然数はゼロ、または1ずつ増加する他の自然数です。これらのいわゆるペアノ数は、数を表現して計算を行うための良い方法です。

dogeが好きなら、プログラミングに自然言語を使用できるようにする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 );
}

この方法の優位性をさらに追加するには：計算はコンパイル時に行われます！これ以上遅いプログラムはありません。ユーザーはあなたがそれらの数値を合計するのを待ちたくありません。

そして重大な部分について：

• 私はこれを言う必要はないと思いますが、これは完全にばかげています。
• コンパイル時定数に対してのみ機能します。
• 負の数では機能しません。
• 答えは実際に自分でメタプログラムをテンプレート化できない人によって提供されたので、他の欠陥があるかどうかさえ知りません。

友人からコードを証明するように言われたので、私はそうしました。それは楽しいですが、これはまったくばかげているという事実からあまりにも多くを奪うと思うので、リンクとしてのみ含めました。

浮動小数点エラーについて知ったとき、コンピューターを信頼しなくなりました。

このJavaScriptは、正確なヒューマンエラーチェックに依存しています。

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

「合計を入力して返す関数を作成します。」

OK：

public static String inputAndReturnTheirSum（）{
    System.out.print（ "それらの合計を入力："）;
    return new Scanner（System.in）.nextLine（）;
}

JavaまたはCスタイル。これはO（log n）です。注：これは、負のaまたはbでは機能しません。

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

Ideoneデモはこちら。

HadoopストリーミングでのBash

明らかに、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。これは見るのが楽しいはずです！しかし、今後はこれにMahoutを使用する予定です（ただし猫は好きですが）。

これは、この質問に対して得られる最もスケーラブルなソリューションでなければなりません。ただし、再帰的なHadoopソリューションのほうがはるかにエレガントだと想像できます。

それらの愚かな人々を、彼らの非一般的でテスト不可能な態度で無視してください。このような規模のプロジェクトには、パフォーマンスが高く、拡張可能でシンプルなライブラリが必要です。コードのすべてのポイントで拡張と置換をサポートする必要があります。そのためには、等しく拡張可能でシンプルな言語が必要です。だからこそ、最高の候補はC＃です。

私はあなたに私のベータ版の提供理由です動作可能コモンズ図書館のEnterprise Edition、バージョン0.8.4.4_beta1.3a_rev129857_dist29.12.13 /マスターこのバージョンで公開し、IOperableインターフェースを、IAddableインターフェースはあなたが、あなた自身の効率的な追加のメソッドを使用できるようにし、のデフォルト実装IAddable：Addableこのクラスは、非常に効率的なビット単位の加算を使用します。不正な実行や、キャリーシフトの低速なネイティブ減算は使用しません。もちろん、優れたライブラリと同様に、サポートするすべてのタイプのファクトリーが付属しています。ライブラリは「自分で処理する」という原則にも従っているため、無効なデータをチェックしないため、入力が有効であり、目的の出力が実行可能であることを保証する必要があります。これは次のとおりです（このコードは、Microsoft Corporation読み取り専用のDont-Touch-This Obstructive License、Revision 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);
    }
}

JavaScript

プログラミングはすべてアルゴリズムです。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));

• まず、リード開発者であるため、賢明な言語を選択しましょう-クロスプラットフォーム、軽量、ポータブル。

• 第二に、グローバルなビジョンを持っています。グローバル変数を使用

• 第三に、++ sおよび--s

• YFS（You-Finger-System）と同じ、これは負の数をサポートしません

• 最後に、FINGER_NUMBER持っている指の数に応じて変更できます。

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

まあ、これは少しトリッキーです。幸いなことに、Pythonはそれをかなり簡単にします。これを正しく行うには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。

JAVA

以下のコードでは、...私が書くのが面倒だったコードを表しますが、理解できるはずです。これを本当にスタイリッシュに行うには、コード生成プログラムが必要です。制限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;
       }
}

合計を入力して返す関数

ルア

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

コードが完成しました。それには非常に注意してください。このコードは非常に複雑であり、おそらくインテリジェントな意識と自己認識の存在になる傾向があります。それは高度に分類された極秘コードです。

/*
 * 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 ++

もちろん、いくつかのテンプレートマジックが必要になります。

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

難しい問題。

コンピュータサイエンスでは、答えを見つけるよりも答えを確認する方が簡単であるという問題があることが知られています。そのため、解を推測するためにランダムアルゴリズムを使用し、それを（効率的に！）検証し、妥当な時間で適切な結果を得ることができます。

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

この機能は私の会社の特許の下にあります、私はあなたにそれの難読化されたライセンスされたコピーを提供できます：

Javascript：

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

使用法：

sum([arg1],[arg2]);

Python

プログラミングはフォールトトレラントです。以下は、混乱することなく何かを追加するsumの実装です。追加可能な順序で要素を透過的にソートします。追加できない場合は、フラグを立て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

明らかに最も効率的な方法は、ビットをシフトすることです。これは、iso_c_bindingモジュールを介してC + Fortranで簡単に実行できます。

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ルーチンは

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

最初にCコードをコンパイルする必要があり（たとえば、gcc -c mycfile.c）、Fortranコードをコンパイルする必要があります（たとえば、gfortran -c myf90file.f90）、実行可能ファイルを作成します（gfortran -o adding myf90file.o mycfile.o）。