El problema:

Soy el desarrollador principal de una gran empresa, estamos haciendo Skynet. He sido asignado a

Escribe una función que ingrese y devuelva su suma

REGLAS: No hay respuestas como

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

EDITAR: La respuesta aceptada será la que tenga más votos a favor el 1 de enero de 2014

^{Nota: Esta es una pregunta de arrastre de código . No tome en serio la pregunta y / o las respuestas. Más información aquí .}

¡Ese es un problema muy complejo! Así es como lo resuelve en 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);
}

Cómo funciona este código (no agregaría esta explicación en mi respuesta al OP lento que tiene que ser controlado, no se preocupe): ((a & ~877 - b ^ 133 << 3 / a) & ((a - b) - (a - b))) | adevuelve solo ay ((b ^ (a < 0 ? b : a)) & ((b - a) - (b - a))) | bdevuelve solo b.

6755 & 1436devuelve 0, por lo que en el bucle, en irealidad comienza con el valor 0, y dentro del bucle, agrega el valor 1a la lista. Entonces, si aes 5y bes 3, el valor 1se agrega 8 veces a la lista.

La importantCalculationfunción es una función muy larga que no hace más que sumar dos números. Utiliza la Aggregatefunción LINQ para sumar todos los números. Tampoco es necesario emitir el resultado de Convert.ToInt32a int, porque ya es un int.

Este código es algo que el OP perezoso no entendería, que es exactamente la intención :-)

Bash - 72 bytes

A veces, las técnicas de adición deterministas tradicionales son demasiado precisas e innecesariamente rápidas: hay momentos en los que desea darle un descanso a la CPU.

Presentamos el algoritmo con pérdida SleepAdd .

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

Ejecución de muestra:

> ./sleepadd.sh 0.5 1.5
2.001

Esta función está pensada como un complemento para el reconocido SleepSort . Se deja como ejercicio al lector adaptar este algoritmo para hacer un SleepMax con pérdida para obtener el mayor de dos números.

Consejo profesional: este algoritmo se puede optimizar aún más: es posible un aumento de velocidad de 2x, si los números que se le asignan se dividen por 2 primero.

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

Básicamente, esto escribe un archivo con el número de bytes que debería ser igual a la suma real. Cuando se escribe el archivo, le pregunta a la tabla de archivos de disco el tamaño de ese archivo.

do

En el mundo cuántico no puede depender de operadores atómicos como +, aquí está mi implementación de la suma en términos de computación cuá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 la solución correcta en tiempo O (n ^ 2) . Basado en functores aplicativos que también implementan 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

Ejemplo: daSum [1,2,3,4,5]rinde 15.

Actualización: cómo funciona: un número a se representa como un polinomio xa . Una lista de números a1, ..., aN se representa como la expansión de (x-a1) (x-a2) ... (x-aN) . La suma de los números es entonces el coeficiente del segundo grado más alto. Para oscurecer aún más la idea, un polinomio se representa como un aplicador + un functor alternativo que en realidad no tiene un valor, solo codifica el polinomio como una lista de números (isomorfo a Constant [n]). Las operaciones aplicativas corresponden entonces a la multiplicación polinómica y las operaciones alternativas a la suma (y también se adhieren a las leyes aplicativas / alternativas ).

La suma de los números se calcula luego mapeando cada número en el polinomio correspondiente y luego atravesando la lista usando el Polyfrunctor aplicativo, que calcula el producto de los polinomios, y finalmente extrayendo el coeficiente apropiado al final.

¿Quieres agregar números ? ¿Sabes que esta es una acción muy complicada? OK, por otro lado, usted es el desarrollador principal, tendrá que enfrentar problemas como este.

Esta es la solución más simple que pude 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;
}

No caiga presa del operador "+", es totalmente ineficiente. Siéntase libre de dar la vuelta al operador "va hacia" o usarlo para números más pequeños que se hacen más grandes.

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

Wow, esta es una pregunta extremadamente difícil, pero haré todo lo posible para responderla.

PASO UNO - Servidor TELNET

Primero vamos a tener que recibir la entrada, ahora cualquier codificador profesional y empresarial (como yo) debería saber que la mejor manera de recibir la entrada es configurar un servidor telnet.

Comencemos con el 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 no tiene nada de especial, este es el típico servidor telnet. Hemos creado algunas funciones básicas de limpieza de UNICODE para obtener una buena cadena sin procesar y también hemos agregado nuestra SUMfunción.

Ahora el usuario deberá ingresar 'SUMA'. Luego les pedirá que ingresen teh numberz, una vez ingresada la función summm () se ejecuta y calculará la suma de todos los números ingresados.

PASO DOS - summm

Ahora es el momento de crear nuestra summmfunción que obtendrá la suma de todos los números ingresados.
Aquí está el 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;
}

Y ahi tienes. Es su solución diaria de IBM. ¡TELNET POWER TODO EL CAMINO!
Primero ingresas SUM.
El servidor le pedirá los números que desea agregar, y puede ingresarlos como tales:a, b, c, etc..

Confíe en mí en este caso, todas las botnets están utilizando IBM® Javascript Enterprise SUM Solution ™ en estos días;).

Y aquí hay pruebas de que todo funciona:
(CLICABLE)

Aquí hay una solución en Java para ti. Se basa en el "teorema de los monos infinitos" probado en el tiempo: si estás en una habitación con monos infinitos, terminarás cubierto de popó. O algo así.

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 es mejor matar

Las computadoras solo tienen 0s y 1s, por lo que en realidad es muy difícil implementar una solución adecuada, rápida y escalable sobre cómo agregar. Por suerte para ti, desarrollé skynet 0.1284a, así que sé cómo resolver este peligroso problema.
Por lo general, necesitaría comprar el DLC de la biblioteca estándar de C, ya que el núcleo no lo contiene, pero me las arreglé para "engañarme". En resumen, este es el método más barato y más efectivo.

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

Solo míralo. Obviamente es malvado.

Pitón

Utiliza la identidad matemática log(ab) = log(a) + log(b)para una solución que funciona para números pequeños, pero se desborda para cualquier aplicación práctica.

De este modo, nos aseguramos de que nuestro programador vago piense que funciona en datos de prueba, solo para que se bloquee en el 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

DO#

Debes usar la recursividad para resolver tu problema

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

}

Si es lo suficientemente bueno para Peano, es lo suficientemente bueno para todos.

C ++

Esperamos que una operación como la adición sea muy rápida. Muchas de las otras respuestas simplemente no se concentran lo suficiente en la velocidad. Aquí hay una solución que usa solo operaciones bit a bit para obtener el máximo rendimiento.

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

Mi mejor solución hasta ahora, da una respuesta bastante incomprensible hasta que corres 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 ++ - Números de Peano con metaprogramación de plantilla (con doge opcional)

C, como muchos otros lenguajes de programación, complican las cosas sin ninguna razón. Uno de los sistemas más complejos en estos idiomas son los números naturales. C está obsesionado con la representación binaria y todos los demás detalles completamente inútiles.

Al final, el número natural es solo un cero, o algún otro número natural incrementado en uno. Estos llamados números de Peano son una buena manera de representar números y hacer cálculos.

Si te gusta Doge , he escrito una extensión de C ++ para permitir el uso del lenguaje natural para la programación. La extensión y el siguiente código usando mi extensión se pueden encontrar en: 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 agregar aún más la superioridad de este método: ¡Las matemáticas se realizan en tiempo de compilación! No más programas lentos, su usuario no quiere esperar a que sume esos números.

Y para la parte seria:

• No creo que tenga que decir esto, pero esto es completamente ridículo.
• Funciona solo para constantes de tiempo de compilación.
• No funciona con números negativos.
• La respuesta fue proporcionada por una persona que en realidad no puede metaprogramar la plantilla, por lo que ni siquiera sabría si tiene otros defectos.

Mis amigos me dijeron que dogificara el código, así que lo hice. Es divertido, pero creo que le quita demasiado al hecho de que esto es totalmente estúpido, así que solo lo incluí como enlace.

Dejé de confiar en las computadoras cuando me enteré de los errores de coma flotante.

Este JavaScript se basa en la comprobación precisa de errores humanos:

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

"Escriba una función que ingrese y devuelva su suma".

Okay:

Cadena estática pública inputAndReturnTheirSum () {
    System.out.print ("Ingrese su suma:");
    return new Scanner (System.in) .nextLine ();
}

Java o estilo C. Esto es O (log n). Nota: Esto no funciona para a o b negativo.

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

Demostración de Ideone aquí.

Bash con Hadoop Streaming

Obviamente, ay bpuede llegar a ser realmente grande. Por lo tanto, debemos usar 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 una ventaja adicional, este enfoque involucra a caty a wc. ¡Esto debería ser divertido de ver! Pero planeo usar Mahout para esto en el futuro (aunque me gustan los gatos).

Esta debe ser la solución más escalable que obtenga para esta pregunta. Sin embargo, puedo imaginar que una solución recursiva de Hadoop es mucho más elegante.

Ignora a todas esas personas tontas con sus modales no genéricos e incontestables. Necesitamos una biblioteca performante, extensible y simple para un proyecto de tal escala. Debe admitir extensión y sustitución en cada punto del código. Para eso, necesitamos un lenguaje igualmente extensible y simple, por eso el mejor candidato es C # .

Es por eso que le presento la versión beta de mi Operable Commons Library Enterprise Edition, versión 0.8.4.4_beta1.3a_rev129857_dist29.12.13 / master , que en esta versión expone una IOperableinterfaz, una IAddableinterfaz para que pueda usar sus propios métodos de adición eficientes, y una implementación predeterminada de IAddable: elAddableclase, que utiliza una suma bit a bit extremadamente eficiente, sin trampas y utilizando la sustracción nativa lenta para el desplazamiento de carga. Por supuesto, como cualquier buena biblioteca, viene con una fábrica para cada tipo que admite. La biblioteca también sigue los principios de "manejarlo usted mismo", por lo que debe garantizar que la entrada sea válida y que la salida deseada sea factible, ya que no buscará datos no válidos. Aquí está (Este código está bajo la licencia de propiedad intelectual de solo lectura de Microsoft Corporation Dont-Touch-This Obstructive License, Revisión 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

La programación tiene que ver con el algoritmo. Volvamos al algoritmo básico lo que aprendemos a la edad de 3 años: contar 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));

• En primer lugar, como desarrollador principal, tengamos una elección sabia de idioma: multiplataforma, liviana y portátil.

• En segundo lugar, tener una visión global. Use Global var.

• En tercer lugar, ++ s y --s

• Igual que YFS (You-Finger-System), esto no admite números negativos

• Finalmente, puede modificar FINGER_NUMBERsegún la cantidad de dedos que tenga.

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

Bueno, este es un poco complicado. Afortunadamente, Python lo hace razonablemente sencillo. Necesitarás PIL para hacer esto bien.

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

Comentarios adaptados de Watterson .

Intencionalmente usando el lento Image.getpixel(). Sin embargo, no estoy seguro de que sea lo suficientemente lento . RGBA solo para ocupar memoria extra.

JAVA

En el código a continuación, ... representa el código que era demasiado vago para escribir pero que debería poder resolver. Para hacer esto realmente con estilo, se requeriría un programa de generación de código. Los límites 0 y 10 podrían cambiarse a lo que sea. Cuanto más grandes sean los límites, más código y una computadora podría completar fácilmente el ... 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;
       }
}

una función que ingresa y devuelve su suma

Lua

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

El código está hecho. Ten mucho cuidado con eso. Este código es ultracomplejo y probablemente es propenso a convertirse en un ser inteligente consciente y consciente de sí mismo. Es un código altamente secreto altamente clasificado.

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

Por supuesto, necesitarás un poco de plantilla mágica :

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

Se sabe que en informática existen problemas que verifican sus respuestas es más fácil que encontrarlas. Por lo tanto, debe usar un algoritmo aleatorio para adivinar la solución, luego verificarla (de manera eficiente) y esperar obtener el resultado correcto en un tiempo razonable:

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 función está patentada por mi empresa, puedo proporcionarle una copia con licencia ofuscada:

Javascript:

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

Uso:

sum([arg1],[arg2]);

Pitón

La programación es tolerante a fallas. La siguiente es una implementación de suma que agregará cualquier cosa sin preocuparse. Clasificará los elementos de forma transparente en el orden que se pueden agregar. En caso de que no se pueda agregar, lo marcará 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, la forma más eficiente es cambiar sus bits. Esto se puede hacer fácilmente con C + Fortran a través del 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

donde está la rutina 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);
}

Primero debe compilar el código C (p. Ej. gcc -c mycfile.c) , Luego compilar el código Fortran (p. Ej. gfortran -c myf90file.f90) Y luego hacer el ejecutable ( gfortran -o adding myf90file.o mycfile.o).