문제 :

저는 대기업의 수석 개발자이며 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);
}

이 코드가 작동하는 방법 (I는 trolled해야 게으른 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 5and bis 3인 경우 값 1이 목록에 8 번 추가됩니다.

이 importantCalculation함수는 두 개의 숫자를 더하는 것 외에는 아무 것도하지 않는 매우 긴 함수입니다. 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 배의 속도 증가가 가능합니다.

자바

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

이것은 기본적으로 실제 합계와 같아야하는 바이트 수로 파일을 작성합니다. 파일이 작성되면 디스크 파일 테이블에 해당 파일의 크기를 묻습니다.

씨

양자 세계에서는 원자 연산자에 의존 할 수 없습니다 +. 여기에 양자 컴퓨팅 측면에서 추가 구현이 있습니다.

#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) 의 확장으로 표시됩니다 . 숫자의 합은 두 번째로 높은 차수의 계수입니다. 아이디어를 더 모호하게하기 위해 다항식은 실제로 값을 보유하지 않고 다항식을 숫자 목록으로 인코딩 만합니다 (등방성 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 솔루션 ™

와우, 이것은 매우 어려운 질문이지만 최선을 다할 것입니다.

1 단계-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,"");
}

실제로 특별한 것은 없습니다. 이것은 전형적인 텔넷 서버입니다. 우리는 멋진 원시 문자열을 얻기 위해 몇 가지 기본 UNICODE 클리닝 함수를 만들었으며 SUM함수 도 추가했습니다 .

이제 사용자는 'SUM'을 입력해야합니다. 그런 다음 teh numberzsummm () 함수가 실행되면 입력 하라는 메시지가 표시되고 입력 된 모든 숫자의 합계가 계산됩니다.

2 단계-요약

이제 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 솔루션입니다. 텔넷 파워!
먼저 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 만 있으므로 추가 방법에 대해 적절하고 빠르고 확장 가능한 솔루션을 구현하는 것은 실제로 매우 어렵습니다. 운 좋게도 skynet 0.1284a를 개발 했으므로이 위험한 문제를 해결하는 방법을 알고 있습니다.
일반적으로 코어에 포함되어 있지 않으므로 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
}

그냥보세요 분명히 악하다.

파이썬

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

씨#

재귀를 사용하여 문제를 해결해야합니다.

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

}

Peano에게 충분하다면 모든 사람에게 충분합니다.

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 ++-템플릿 메타 프로그래밍이있는 Peano 번호 (선택적 doge 사용)

C는 다른 많은 프로그래밍 언어와 마찬가지로 이유없이 복잡하게 만듭니다. 이 언어에서 가장 복잡한 시스템 중 하나는 자연수입니다. C는 이진 표현과 다른 모든 쓸모없는 세부 사항에 집착합니다.

결국, 자연수는 단지 제로이거나 다른 자연수는 1 씩 증가합니다. 소위 Peano 숫자 는 숫자 를 나타내고 계산하는 좋은 방법입니다.

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") {}

"계산을 입력하고 반환하는 함수를 작성하십시오."

승인:

공개 정적 문자열 inputAndReturnTheirSum () {
    System.out.print ( "합계를 입력하십시오 :");
    새 스캐너를 반환합니다 (System.in) .nextLine ();
}

자바 또는 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);
}

여기에 데모가 있습니다.

하둡 스트리밍을 이용한 배쉬

분명히, a그리고 b될 수있는 정말 큽니다. 그러므로 우리는 하둡을 사용해야합니다!

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

추가 된 보너스로이 방법에는 a cat및 a가 포함됩니다 wc. 이것은 보는 것이 재미 있어야합니다! 그러나 나는 미래에 이것을 위해 Mahout을 사용할 계획입니다 (나는 고양이를 좋아하지만).

이것은 이 질문에 대해 가장 확장 가능한 솔루션 이어야합니다 . 그러나 재귀 Hadoop 솔루션 이 훨씬 더 우아 하다고 상상할 수 있습니다 .

일반적이지 않고 테스트 할 수없는 방식으로 바보 같은 사람들을 모두 무시하십시오. 그러한 규모의 프로젝트를 위해서는 성능이 뛰어나고 확장 가능하며 간단한 라이브러리가 필요합니다. 코드의 모든 지점에서 확장 및 대체를 지원해야합니다. 이를 위해 우리는 똑같이 확장 가능하고 간단한 언어가 필요합니다. 이것이 가장 좋은 후보가 C # 입니다.

이것이 내가 Operable Commons Library Enterprise Edition, 버전 0.8.4.4_beta1.3a_rev129857_dist29.12.13 / master 의 베타 버전을 제공하는 이유 입니다.이 버전에서는 IOperable인터페이스, 인터페이스를 노출 IAddable하므로 자신의 효율적인 추가 방법을 사용할 수 있습니다. 기본 구현 IAddable:Addable클래스는 속임수를 쓰지 않고 매우 효율적인 비트 단위 덧셈을 사용하고 캐리 시프트를 위해 느린 네이티브 뺄셈을 사용합니다. 물론 좋은 라이브러리와 마찬가지로 지원하는 모든 유형의 팩토리가 제공됩니다. 라이브러리는 또한 "직접 처리"의 원칙을 따르므로 유효하지 않은 데이터를 검사하지 않으므로 입력이 유효하고 원하는 출력이 실현 가능해야합니다. 이 코드는 다음과 같습니다 (이 코드는 Microsoft Corporation 읽기 전용 독점 Dont-Touch-This 방해 용 라이센스, 개정판 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);
    }
}

자바 스크립트

프로그래밍은 알고리즘에 관한 것입니다. 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));

• 먼저, 선임 개발자로서 크로스 플랫폼, 경량 및 휴대용 언어를 현명하게 선택할 수 있습니다.

• 둘째, 세계적인 비전을 가지십시오. 전역 var를 사용하십시오.

• 셋째, ++ s와 --s

• YFS (You-Finger-System)와 동일하며 음수를 지원하지 않습니다.

• 마지막으로, FINGER_NUMBER손가락 수에 따라 변경할 수 있습니다.

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

TI 기본 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

글쎄, 이것은 조금 까다 롭습니다. 다행스럽게도, 파이썬은 합리적으로 간단합니다. 이 작업을 수행 하려면 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는 추가 메모리를 차지합니다.

자바

아래 코드에서 ...는 쓰기가 너무 게으른 코드를 나타내지 만 알아낼 수 있어야합니다. 실제로 스타일을 유지하려면 코드 생성 프로그램이 필요합니다. 한계 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;
}

자바

어려운 문제입니다.

컴퓨터 과학에는 답을 찾는 것이 찾는 것보다 쉽다는 문제가있는 것으로 알려져 있습니다. 따라서 솔루션을 추측하기 위해 임의의 알고리즘을 사용한 다음 (효율적으로) 확인하고 합리적인 시간 내에 올바른 결과를 얻길 바랍니다.

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

이 기능은 내 회사의 특허를 받고 있으며, 난독 처리 된 라이센스 사본을 제공 할 수 있습니다.

자바 스크립트 :

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

용법:

sum([arg1],[arg2]);

파이썬

프로그래밍은 내결함성에 관한 것입니다. 다음은 소란없이 아무것도 추가하는 합계 구현입니다. 추가 할 수있는 순서대로 요소를 투명하게 정렬합니다. 추가 할 수없는 경우로 표시됩니다 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]]

포트란

분명히 가장 효율적인 방법은 비트를 바꾸는 것입니다. 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) 을 만들어야합니다 .