O problema:

Eu sou o desenvolvedor líder de uma grande empresa, estamos criando a Skynet. Fui designado para

Escreva uma função que insira e retorne sua soma

REGRAS: Nenhuma resposta como

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

EDIT: A resposta aceita será a que tiver mais votos em 1 de janeiro de 2014

^{Nota: Esta é uma pergunta de controle de código . Por favor, não leve a sério a pergunta e / ou respostas. Mais informações aqui .}

Esse é um problema muito complexo! Aqui está como você resolve isso em 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);
}

Como esse código funciona (eu não adicionaria essa explicação na minha resposta ao OP preguiçoso que precisa ser controlado, não se preocupe): ((a & ~877 - b ^ 133 << 3 / a) & ((a - b) - (a - b))) | aretorna apenas ae ((b ^ (a < 0 ? b : a)) & ((b - a) - (b - a))) | bretorna apenas b.

6755 & 1436retorna 0, portanto, no loop, ina verdade começa com valor 0e, dentro do loop, você adiciona o valor 1à lista. Portanto, se aé 5e bé 3, o valor 1é adicionado 8 vezes à lista.

A importantCalculationfunção é uma função muito longa que não faz nada além de somar dois números. Você usa a Aggregatefunção LINQ para adicionar todos os números. Também é desnecessário converter o resultado de Convert.ToInt32para an int, porque já é um int.

Esse código é algo que o OP preguiçoso não entenderia, que é exatamente a intenção :-)

Bash - 72 bytes

Às vezes, as técnicas tradicionais de adição determinística são muito precisas e desnecessariamente rápidas - há momentos em que você deseja descansar um pouco a CPU.

Apresentando o algoritmo com perda SleepAdd .

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

Exemplo de execução:

> ./sleepadd.sh 0.5 1.5
2.001

Esta função é destinada como complemento do conceituado SleepSort . É deixado como exercício para o leitor adaptar esse algoritmo para criar um SleepMax com perda e obter o maior de dois números.

Dica profissional: Esse algoritmo pode ser otimizado ainda mais - é possível um aumento de velocidade de 2x, se os números fornecidos a ele forem divididos por 2 primeiro.

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

Basicamente, isso grava um arquivo com o número de bytes que deve ser igual à soma real. Quando o arquivo é gravado, ele solicita à tabela de arquivos do disco o tamanho desse arquivo.

C

No mundo quântico, você não pode depender de operadores atômicos +, aqui está minha implementação de adição em termos de computação quântica:

#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

Calcula a solução correta em O (n ^ 2) . Baseado em functores aplicativos que também implementam 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

Exemplo: daSum [1,2,3,4,5]rendimento 15.

Atualização: Como funciona: um número a é representado como um polinômio xa . Uma lista dos números a1, ..., aN é então representada como a expansão de (x-a1) (x-a2) ... (x-aN) . A soma dos números é então o coeficiente do segundo grau mais alto. Para obscurecer ainda mais a idéia, um polinômio é representado como um aplicador + função alternativa que na verdade não possui um valor, apenas codifica o polinômio como uma lista de números (isomórfico para Constant [n]). As operações de aplicação correspondem à multiplicação polinomial e as operações alternativas à adição (e também aderem às leis alternativas / aplicáveis ).

A soma dos números é então calculada como mapeando cada número no polinômio correspondente e, em seguida, percorrendo a lista usando o Polytruncador aplicativo, que calcula o produto dos polinômios e, finalmente, extraindo o coeficiente adequado no final.

Deseja adicionar números ?!? Você está ciente de que esta é uma ação muito complicada? OK, por outro lado, você é o desenvolvedor líder, terá que enfrentar problemas como este.

Esta é a solução mais simples que eu poderia encontrar:

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

Não seja vítima do operador "+", é totalmente ineficiente. Sinta-se livre para mudar o operador "vai em direção" ou usá-lo para números menores que estão ficando maiores.

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

Uau, essa é uma pergunta extremamente difícil, mas vou tentar o meu melhor para responder a isso.

PASSO UM - Servidor TELNET

Primeiro vamos ter que receber a entrada, agora qualquer codificador profissional e corporativo (como eu) deve saber a melhor maneira de receber entrada é configurar um servidor telnet !!!

Vamos começar com o servidor telnet básico:

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

Realmente não há nada de especial nisso, este é o seu servidor telnet típico. Criamos algumas funções básicas de limpeza UNICODE para obter uma boa sequência bruta e também adicionamos nossa SUMfunção.

Agora o usuário precisará digitar 'SUM'. Em seguida, solicitará que eles entrem teh numberz, uma vez inserida a função summm (), é executada e calculará a soma de todos os números inseridos.

PASSO DOIS - summm

Agora é hora de criar nossa summmfunção, que receberá a soma de todos os números inseridos.
Aqui está o código:

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

E lá vai você. É a sua solução IBM todos os dias. TELNET POWER TODO O CAMINHO!
Primeiro você insere SUM.
O servidor solicitará os números que você gostaria de adicionar e você poderá inseri-los da seguinte forma:a, b, c, etc..

Confie em mim, neste caso, todas as redes de bots estão usando o IBM® Javascript Enterprise SUM Solution ™ hoje em dia;).

E aqui está a prova de que tudo funciona:
(CLICÁVEL)

Aqui está uma solução em Java para você. Ele se baseia no "teorema dos macacos infinitos", testado pelo tempo: se você estiver em uma sala com macacos infinitos, acabará coberto de cocô jogado. Ou algo assim.

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 - exagero é melhor matar

Os computadores têm apenas 0s e 1s; portanto, é realmente muito difícil implementar uma solução adequada, rápida e escalável para adicionar. Felizmente para você, desenvolvi o skynet 0.1284a, para saber como resolver esse problema perigoso.
Normalmente, você precisa comprar o DLC da biblioteca padrão C, pois o núcleo não o contém, mas eu consegui "desviar" o caminho para fora dele. Em suma, este é o método mais barato e mais eficaz.

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

Apenas olhe para isso. É obviamente mau.

Python

Usa a identidade matemática log(ab) = log(a) + log(b)para uma solução que funciona para números pequenos, mas que excede o limite para qualquer aplicativo prático.

Assim, assegurando que nosso programador preguiçoso pense que funciona nos dados de teste, apenas para travá-lo no mundo real.

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 #

Você deve usar a recursão para resolver seu problema

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

}

Se é bom o suficiente para Peano, é bom o suficiente para todos.

C ++

Esperamos que uma operação como a adição seja muito rápida. Muitas das outras respostas simplesmente não se concentram o suficiente na velocidade. Aqui está uma solução que usa apenas operações bit a bit , para desempenho máximo.

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

Minha melhor solução até agora, fornece uma resposta bastante incompreensível até você executar 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;

}

Números Peano com metaprogramação de modelo (com doge opcional)

C, como muitas outras linguagens de programação, complicam as coisas sem nenhuma razão. Um dos sistemas mais complexos nesses idiomas são os números naturais. C é obcecado com a representação binária e todos os outros detalhes completamente inúteis.

No final, o número natural é apenas um zero, ou algum outro número natural incrementado por um. Esses chamados números Peano são uma boa maneira de representar números e fazer cálculos.

Se você gosta de doge , escrevi uma extensão C ++ para permitir o uso de linguagem natural para programação. A extensão e este código a seguir usando minha extensão podem ser encontrados em: 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 );
}

Para adicionar ainda mais a superioridade desse método: A matemática é feita em tempo de compilação! Não há mais programas lentos, seu usuário não deseja esperar a soma desses números.

E para a parte séria:

• Eu não acho que tenho que dizer isso, mas isso é completamente ridículo.
• Funciona apenas para constantes de tempo de compilação.
• Não funciona com números negativos.
• A resposta foi fornecida por uma pessoa que realmente não pode modelar o metaprograma, então eu nem saberia se ele tem outras falhas.

Meus amigos me disseram para dogificar o código, então eu fiz. É divertido, mas acho que isso afasta demais o fato de que isso é totalmente estúpido, então eu o incluí apenas como um link.

Parei de confiar nos computadores quando aprendi sobre erros de ponto flutuante.

Este JavaScript baseia-se na verificação precisa de erros humanos:

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

"Escreva uma função que insira e retorne sua soma."

Está bem:

public static String inputAndReturnTheirSum () {
    System.out.print ("Insira sua soma:");
    retornar novo Scanner (System.in) .nextLine ();
}

Java ou estilo C. Este é O (log n). Nota: Isso não funciona para negativos a ou 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 demo aqui.

Bash com Hadoop Streaming

Obviamente, ae bpode se tornar realmente grande. Portanto, devemos usar o 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;}'

Como um bônus adicional, essa abordagem envolve ae cata wc. Isso deve ser divertido de assistir! Mas pretendo usar o Mahout para isso no futuro (embora eu goste de gatos).

Essa deve ser a solução mais escalável que você obtém para esta pergunta. No entanto, posso imaginar que uma solução recursiva do Hadoop seja muito mais elegante.

Ignore todas essas pessoas tolas com suas maneiras não genéricas e não testáveis. Precisamos de uma biblioteca de alto desempenho, extensível e simples para um projeto dessa escala. Ele deve suportar extensão e substituição em todos os pontos do código. Para isso, precisamos de uma linguagem igualmente extensível e simples, por isso o melhor candidato é o C # .

É por isso que apresento a versão beta do meu Operable Commons Library Enterprise Edition, versão 0.8.4.4_beta1.3a_rev129857_dist29.12.13 / master , que nesta versão expõe uma IOperableinterface, umaIAddable interface para que você possa usar seus próprios métodos de adição eficientes e uma implementação padrão de IAddable: oAddableclasse, que usa adição bit a bit extremamente eficiente, sem trapaça e usando a subtração nativa lenta para a mudança de transporte. Obviamente, como qualquer boa biblioteca, ela vem com uma fábrica para todos os tipos que suporta. A biblioteca também segue os princípios de "manipule você mesmo", portanto, você deve garantir que a entrada seja válida e que a saída desejada seja viável, pois não verificará dados inválidos. Aqui está (este código está licenciado sob a licença proprietária somente para leitura e leitura não autorizada da Microsoft Corporation, revisão 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

A programação é toda sobre algoritmo. Vamos voltar ao algoritmo básico, o que aprendemos com a contagem de três dedos.

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

• Em primeiro lugar, como desenvolvedor líder, vamos ter uma escolha sábia de idioma - multiplataforma, leve e portátil.

• Em segundo lugar, tenha uma visão global. Use Var. Global

• Terceiro, ++ se - s

• Igual ao YFS (sistema de dedos), isso não suporta números negativos

• Finalmente, você pode alterar de FINGER_NUMBERacordo com o número de dedos que possui.

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

Bem, este é um pouco complicado. Felizmente, o Python o torna razoavelmente direto. Você precisará do PIL para fazer isso corretamente.

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

Comentários adaptados de Watterson .

Intencionalmente usando o lento Image.getpixel(). Não tenho certeza se é realmente lento o suficiente , no máximo. RGBA apenas para ocupar memória extra.

JAVA

No código abaixo, ... representa o código que eu estava com preguiça de escrever, mas você deve ser capaz de descobrir. Para realmente fazer isso com estilo, seria necessário um programa de geração de código. Os limites 0 e 10 podem ser alterados para qualquer que seja. Quanto maiores os limites, mais código e um computador poderia facilmente preencher os ... s.

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

uma função que insere e retorna sua soma

Lua

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

O código está pronto. Tenha muito cuidado com isso. Este código é ultra complexo e provavelmente está propenso a se tornar um ser consciente e autoconsciente. É um código altamente secreto altamente classificado.

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

Claro que você precisará de alguma mágica de modelo :

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

Problema difícil.

Sabe-se que na ciência da computação há problemas que verificar suas respostas é mais fácil do que encontrá-las. Portanto, você deve usar um algoritmo aleatório para adivinhar a solução, depois verificar (com eficiência!) E esperar obter o resultado certo em tempo razoável:

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

Esta função está sob patente da minha empresa, posso fornecer uma cópia licenciada ofuscada:

Javascript:

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

Uso:

sum([arg1],[arg2]);

Python

A programação é tolerante a falhas. A seguir, uma implementação da soma que adicionará qualquer coisa sem exageros. Ele classificará os elementos de forma transparente na ordem em que podem ser adicionados. Caso não seja possível adicionar, ele será sinalizado como 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

Obviamente, a maneira mais eficiente é mudar seus bits. Isso pode ser feito facilmente com o C + Fortran através do iso_c_bindingmódulo:

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

onde a rotina 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);
}

Você precisa compilar o código C primeiro (por exemplo, gcc -c mycfile.c) e depois compilar o código Fortran (por exemplo gfortran -c myf90file.f90) e depois tornar o executável ( gfortran -o adding myf90file.o mycfile.o).