Il problema:

Sono lo sviluppatore principale di una grande azienda, stiamo creando Skynet. Mi è stato assegnato

Scrivi una funzione che inserisce e restituisce la loro somma

REGOLE: Nessuna risposta simile

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

EDIT: la risposta accettata sarà quella con il maggior numero di voti il ​​1 ° gennaio 2014

^{Nota: questa è una domanda di traina del codice . Si prega di non prendere sul serio la domanda e / o le risposte. Maggiori informazioni qui .}

Questo è un problema molto complesso! Ecco come risolverlo in 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);
}

Come funziona questo codice (non aggiungerei questa spiegazione nella mia risposta al PO pigro che deve essere trollato, non ti preoccupare): ((a & ~877 - b ^ 133 << 3 / a) & ((a - b) - (a - b))) | aritorna giusto ae ((b ^ (a < 0 ? b : a)) & ((b - a) - (b - a))) | britorna giusto b.

6755 & 1436ritorna 0, quindi nel ciclo, iinizia effettivamente con il valore 0e all'interno del ciclo, aggiungi il valore 1all'elenco. Quindi, se aè 5ed bè 3, il valore 1viene aggiunto 8 volte all'elenco.

La importantCalculationfunzione è una funzione molto lunga che non fa altro che sommare due numeri. Si utilizza la Aggregatefunzione LINQ per aggiungere tutti i numeri. Non è inoltre necessario eseguire il cast del risultato Convert.ToInt32in an int, perché è già un int.

Questo codice è qualcosa che l'OP pigro non capirebbe, che è esattamente l'intenzione :-)

Bash - 72 byte

A volte le tradizionali tecniche di addizione deterministica sono troppo precise e inutilmente veloci - ci sono momenti in cui si desidera riposare un po 'la CPU.

Presentazione dell'algoritmo con perdita di dati SleepAdd .

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

Esecuzione di esempio:

> ./sleepadd.sh 0.5 1.5
2.001

Questa funzione è intesa come compagna del ben considerato SleepSort . È lasciato al lettore un esercizio per adattare questo algoritmo per creare un SleepMax con perdita di dati per ottenere il maggiore di due numeri.

Suggerimento professionale: questo algoritmo può essere ulteriormente ottimizzato: è possibile aumentare di 2 volte la velocità, se i numeri ad esso assegnati sono divisi per 2 per primi.

Giava

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

Questo fondamentalmente scrive un file con il numero di byte che dovrebbe essere uguale alla somma effettiva. Quando il file viene scritto, chiede alla tabella dei file su disco la dimensione di quel file.

C

Nel mondo quantistico non puoi dipendere da operatori atomici come +, ecco la mia implementazione di addizione in termini di calcolo quantistico:

#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

Calcola la soluzione corretta in O (n ^ 2) tempo. Basato su funzioni applicative che implementano anche 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

Esempio: daSum [1,2,3,4,5]rese 15.

Aggiornamento: come funziona: un numero a è rappresentato come un polinomio xa . Un elenco di numeri a1, ..., aN viene quindi rappresentato come l'espansione di (x-a1) (x-a2) ... (x-aN) . La somma dei numeri è quindi il coefficiente del secondo grado più alto. Per oscurare ulteriormente l'idea, un polinomio è rappresentato come un applicativo + funzione alternativa che in realtà non ha un valore, codifica solo il polinomio come un elenco di numeri (da isomorfo a Constant [n]). Le operazioni applicative corrispondono quindi alla moltiplicazione polinomiale e le operazioni alternative all'addizione (e aderiscono anche alle leggi applicative / alternative ).

La somma dei numeri viene quindi calcolata come mappando ciascun numero nel polinomio corrispondente e quindi attraversando l'elenco utilizzando il Polyfrunctor applicativo, che calcola il prodotto dei polinomi e infine estraendo il coefficiente adeguato alla fine.

Vuoi aggiungere numeri ?!? Sai che questa è un'azione molto complicata? D'altra parte, tu sei lo sviluppatore principale, dovrai affrontare problemi come questo.

Questa è la soluzione più semplice che ho trovato:

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

Non cadere in preda all'operatore "+", è totalmente inefficiente. Sentiti libero di girare l'operatore "va verso" o usarlo per numeri più piccoli che diventano più grandi.

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

Caspita, questa è una domanda estremamente difficile, ma farò del mio meglio per rispondere a questa domanda.

PASSO UNO - Server TELNET

Per prima cosa dovremo ricevere l'input, ora qualsiasi programmatore pro e enterprise (come me) dovrebbe sapere che il modo migliore per ricevere l'input è impostare un server telnet !!!

Iniziamo con il server Telnet di base:

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

Non c'è davvero niente di speciale, questo è il tipico server Telnet. Abbiamo creato alcune funzioni di pulizia UNICODE di base per darci una bella stringa grezza e abbiamo anche aggiunto la nostra SUMfunzione.

Ora l'utente dovrà inserire 'SUM'. Richiederà quindi loro di entrare teh numberz, una volta inserita la funzione summm () viene eseguita e calcolerà la somma di tutti i numeri inseriti.

PASSO DUE: riepilogo

Ora è il momento di creare la nostra summmfunzione che otterrà la somma di tutti i numeri immessi.
Ecco il codice:

//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 il gioco è fatto. È la tua soluzione IBM di tutti i giorni. TELNET POWER TUTTO IL MODO!
Per prima cosa inserisci SUM.
Il server chiederà quindi i numeri che desideri aggiungere e puoi inserirli come tali:a, b, c, etc..

Fidati di me su questo, tutte le botnet utilizzano IBM® Javascript Enterprise SUM Solution ™ in questi giorni;).

E qui è la prova che tutto funziona:
(CLICCABILE)

Ecco una soluzione in Java per te. Si basa sul "teorema delle scimmie infinite" testato nel tempo: se ti trovi in ​​una stanza con infinite scimmie, finirai coperto dalla cacca gettata. O qualcosa di simile.

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 è la migliore uccisione

I computer hanno solo 0 e 1, quindi in realtà è molto difficile implementare una soluzione adeguata, veloce e scalabile su come aggiungere. Fortunatamente per te, ho sviluppato skynet 0.1284a, quindi so come risolvere questo pericoloso problema.
Di solito, dovresti acquistare il DLC della libreria standard C, poiché il core non lo contiene, ma sono riuscito a "barare" la mia via d'uscita. In breve, questo è il metodo più economico ed efficace.

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

Basta guardarlo. È ovviamente malvagio.

Pitone

Utilizza l'identità matematica log(ab) = log(a) + log(b)per una soluzione che funziona per piccoli numeri, ma trabocca per qualsiasi applicazione pratica.

In questo modo assicuriamo che il nostro programmatore pigro penserà che funzioni sui dati di test, solo per farlo precipitare nel mondo reale.

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 #

È necessario utilizzare la ricorsione per risolvere il problema

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

}

Se è abbastanza buono per Peano, è abbastanza buono per tutti.

C ++

Ci aspettiamo che un'operazione come l'aggiunta sia molto veloce. Molte delle altre risposte semplicemente non si concentrano abbastanza sulla velocità. Ecco una soluzione che utilizza solo operazioni bit per bit , per le massime prestazioni.

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

La mia migliore soluzione finora, dà una risposta piuttosto incomprensibile fino a quando non corri 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 ++ - Numeri di Peano con metaprogrammazione di modelli (con doge opzionale)

C, come molti altri linguaggi di programmazione complicano le cose senza alcun motivo. Uno dei sistemi più complessi in queste lingue sono i numeri naturali. C è ossessionato dalla rappresentazione binaria e da tutti gli altri dettagli completamente inutili.

Alla fine, il numero naturale è solo uno zero o qualche altro numero naturale incrementato di uno. Questi cosiddetti numeri di Peano sono un bel modo per rappresentare i numeri e fare calcoli.

Se ti piace il doge, ho scritto un'estensione C ++ per consentire l'uso del linguaggio naturale per la programmazione. L'estensione e il seguente codice che utilizza la mia estensione sono disponibili all'indirizzo: 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 );
}

Per aggiungere ulteriormente la superiorità di questo metodo: la matematica viene eseguita in fase di compilazione! Niente più programmi lenti, il tuo utente non vuole aspettare che tu sommi quei numeri.

E per la parte seria:

• Non credo di doverlo dire, ma è completamente ridicolo.
• Funziona solo per le costanti di tempo di compilazione.
• Non funziona con numeri negativi.
• La risposta è stata fornita da una persona che in realtà non è in grado di creare un metaprogramma da solo, quindi non saprei nemmeno se ha altri difetti.

I miei amici mi hanno detto di dogificare il codice, così l'ho fatto. È divertente, ma penso che si allontani troppo dal fatto che questo è totalmente stupido così com'è, quindi l'ho incluso solo come link.

Ho smesso di fidarmi dei computer quando ho appreso degli errori in virgola mobile.

Questo JavaScript si basa su un preciso controllo degli errori umani:

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

"Scrivi una funzione che inserisce e restituisce la loro somma."

Ok:

public static String inputAndReturnTheirSum () {
    System.out.print ("Inserisci la loro somma:");
    restituisce il nuovo scanner (System.in) .nextLine ();
}

Stile Java o C. Questo è O (log n). Nota: questo non funziona con a o b negativi.

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

Demo di Ideone qui.

Bash con Hadoop Streaming

Ovviamente, ae bpuò diventare davvero grande. Pertanto, dobbiamo usare 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;}'

Come bonus aggiuntivo, questo approccio prevede a cate a wc. Questo dovrebbe essere divertente da guardare! Ma ho intenzione di usare Mahout per questo in futuro (anche se mi piacciono i gatti).

Questa deve essere la soluzione più scalabile che ottieni per questa domanda. Tuttavia, posso immaginare che una soluzione ricorsiva di Hadoop sia molto più elegante.

Ignora tutte quelle persone sciocche con i loro modi non generici e non verificabili. Abbiamo bisogno di una libreria performante, estensibile e semplice per un progetto di tale portata. Deve supportare l'estensione e la sostituzione in ogni punto del codice. Per questo, abbiamo bisogno di un linguaggio altrettanto estensibile e semplice, ecco perché il miglior candidato è C # .

Questo è il motivo per cui ti presento la versione beta della mia Operable Commons Library Enterprise Edition, versione 0.8.4.4_beta1.3a_rev129857_dist29.12.13 / master , che in questa versione espone IOperableun'interfaccia, IAddableun'interfaccia in modo da poter utilizzare i tuoi metodi di aggiunta efficienti e un'implementazione predefinita di IAddable: ilAddableclasse, che utilizza un'aggiunta bit per bit estremamente efficiente, senza barare e utilizzando la sottrazione nativa lenta per il trasferimento di spostamento. Naturalmente, come ogni buona biblioteca, viene fornito con una fabbrica per ogni tipo che supporta. La libreria segue anche i principi di "gestisci te stesso", quindi devi garantire che l'input sia valido e che l'output desiderato sia fattibile, dal momento che non verificherà la presenza di dati non validi. Eccolo qui (Questo codice è concesso in licenza in base alla sola licenza ostruttiva Dont-Touch-This-Obstructive di Microsoft Corporation, Revisione 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 programmazione riguarda esclusivamente l'algoritmo. Torniamo all'algoritmo di base che cosa impariamo all'età di 3 anni - il conteggio delle dita.

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

• In primo luogo, essendo uno sviluppatore principale, abbiamo una scelta linguistica saggia: multipiattaforma, leggera e portatile.

• In secondo luogo, avere una visione globale. Usa var globale.

• In terzo luogo, ++ s e --s

• Come YFS (You-Finger-System), questo non supporta numeri negativi

• Infine, puoi modificare in FINGER_NUMBERbase al numero di dita che hai.

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

Bene, questo è un po 'complicato. Fortunatamente, Python lo rende ragionevolmente semplice. Avrai bisogno di PIL per farlo bene.

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

Commenti adattati da Watterson .

Uso intenzionale del lento Image.getpixel(). Non sono sicuro che sia abbastanza lento , malgrado tutto, maledetto. RGBA solo per occupare memoria aggiuntiva.

GIAVA

Nel codice qui sotto, ... sta per codice che ero troppo pigro per scrivere ma dovresti essere in grado di capire. Per farlo davvero con stile, richiederebbe un programma di generazione del codice. I limiti 0 e 10 potrebbero essere cambiati in qualunque cosa. Maggiore è il limite, più codice e un computer potrebbero facilmente compilare i ... 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 funzione che immette e restituisce la loro somma

Lua

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

Il codice è terminato. Stai molto attento a questo. Questo codice è ultra-complesso ed è probabilmente incline a diventare un essere cosciente e autocosciente intelligente. È un codice top-secret altamente classificato.

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

Ovviamente avrai bisogno di un po 'di magia modello :

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

GIAVA

Problema difficile.

È noto che nell'informatica ci sono problemi per cui verificare le loro risposte è più facile che trovarle. Quindi, dovresti usare un algoritmo casuale per indovinare la soluzione, quindi verificarla (in modo efficiente!) E sperare di ottenere il risultato giusto in tempi ragionevoli:

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

Questa funzione è sotto brevetto della mia azienda, posso fornirti una copia con licenza offuscata:

Javascript:

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

Uso:

sum([arg1],[arg2]);

Pitone

La programmazione riguarda la tolleranza agli errori. Quella che segue è un'implementazione della somma che aggiungerà qualsiasi cosa senza complicazioni. Ordinerà in modo trasparente gli elementi nell'ordine che può essere aggiunto. Nel caso in cui non sia aggiungibile, lo contrassegnerà come 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

Ovviamente il modo più efficiente è quello di spostare i tuoi bit. Questo può essere fatto facilmente con C + Fortran tramite il iso_c_bindingmodulo:

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

dove si trova la routine 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);
}

È necessario compilare prima il codice C (ad esempio, gcc -c mycfile.c) quindi compilare il codice Fortran (ad esempio, gfortran -c myf90file.f90) e quindi rendere eseguibile ( gfortran -o adding myf90file.o mycfile.o).