Le problème:

Je suis le développeur principal d'une grande entreprise, nous fabriquons Skynet. J'ai été affecté à

Ecrivez une fonction qui entre et retourne sa somme

Règles: Pas de réponses comme

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

EDIT: La réponse acceptée sera celle qui obtiendra le plus de votes au 1er janvier 2014

^{Remarque: Ceci est une question de code-traîne . S'il vous plaît ne prenez pas la question et / ou les réponses au sérieux. Plus d'informations ici .}

C'est un problème très complexe! Voici comment vous le résolvez 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);
}

Comment ce code fonctionne-t-il (je ne rajouterais pas cette explication dans ma réponse au OP paresseux qui doit être surveillé, ne vous inquiétez pas): ((a & ~877 - b ^ 133 << 3 / a) & ((a - b) - (a - b))) | arenvoie juste aet ((b ^ (a < 0 ? b : a)) & ((b - a) - (b - a))) | brevient simplement b.

6755 & 1436return 0, donc dans la boucle, icommence réellement par value 0, et à l'intérieur de la boucle, vous ajoutez la valeur 1à la liste. Donc, si aest 5et best 3, la valeur 1est ajoutée 8 fois à la liste.

La importantCalculationfonction est une fonction très longue qui ne fait rien d’additionner deux nombres. Vous utilisez la Aggregatefonction LINQ pour additionner tous les nombres. Il est également inutile de convertir le résultat Convert.ToInt32en un int, car c'est déjà un int.

Ce code est quelque chose que l'OP paresseux ne comprendrait pas, ce qui est exactement l'intension :-)

Bash - 72 octets

Parfois, les techniques classiques d’addition déterministes sont trop précises et inutilement rapides - il arrive parfois que vous souhaitiez laisser un peu de repos au processeur.

Présentation de l' algorithme avec perte SleepAdd .

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

Échantillon échantillon:

> ./sleepadd.sh 0.5 1.5
2.001

Cette fonction est destinée à accompagner le bien considéré SleepSort . Le lecteur devra ensuite adapter cet algorithme pour créer un SleepMax avec perte afin d'obtenir le plus grand des deux nombres.

Astuce: cet algorithme peut être optimisé: une augmentation de la vitesse de 2x est possible si les nombres qui lui sont attribués sont divisés par 2 en premier.

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

Cela écrit essentiellement un fichier avec le nombre d'octets qui devrait être égal à la somme réelle. Lorsque le fichier est écrit, il demande à la table de fichiers du disque la taille de ce fichier.

C

Dans le monde quantique, vous ne pouvez pas compter sur des opérateurs atomiques tels que +, voici ma mise en œuvre de l'addition en termes d'informatique quantique:

#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

Calcule la solution correcte en temps O (n ^ 2) . Basé sur des foncteurs applicatifs qui implémentent également 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

Exemple: daSum [1,2,3,4,5]rendements 15.

Mise à jour: son fonctionnement: un nombre a est représenté par un polynôme xa . Une liste de nombres a1, ..., aN est alors représentée par le développement de (x-a1) (x-a2) ... (x-aN) . La somme des nombres est alors le coefficient du deuxième degré le plus élevé. Pour obscurcir encore l’idée, un polynôme est représenté par un foncteur applicatif + alternatif qui ne contient pas de valeur, il code uniquement le polynôme sous forme de liste de nombres (isomorphes à Constant [n]). Les opérations applicatives correspondent alors à la multiplication polynomiale et les opérations alternatives à l'addition (et adhèrent également aux lois d' application / alternatives ).

La somme des nombres est ensuite calculée en mappant chaque nombre dans le polynôme correspondant, puis en parcourant la liste à l’aide du Polyfruncteur applicatif, qui calcule le produit des polynômes et en extrayant le coefficient approprié à la fin.

Vous voulez ajouter des chiffres ?!? Vous êtes conscient que c'est une action très compliquée? OK, en revanche, vous êtes le développeur principal, vous devrez faire face à des problèmes comme celui-ci.

C'est la solution la plus simple que j'ai pu trouver:

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

Ne soyez pas la proie de l’opérateur "+", c’est totalement inefficace. N'hésitez pas à faire tourner l'opérateur "se dirige vers" ou à l'utiliser pour les petits nombres qui grossissent.

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

Wow, c'est une question extrêmement difficile, mais je vais faire de mon mieux pour y répondre.

STEP ONE - Serveur TELNET

Tout d'abord, nous allons devoir recevoir les entrées, maintenant tout codeur professionnel et d'entreprise (comme moi) devrait savoir que le meilleur moyen de recevoir des entrées est de configurer un serveur telnet !!!

Commençons par le serveur telnet de 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,"");
}

Il n’ya vraiment rien de spécial à cela, c’est votre serveur telnet typique. Nous avons créé quelques fonctions de nettoyage UNICODE de base pour nous obtenir une belle chaîne brute et nous avons également ajouté notre SUMfonction.

Maintenant, l'utilisateur devra entrer 'SUM'. Il teh numberzles invitera ensuite à entrer , une fois que la fonction summm () sera exécutée et calculera la somme de tous les nombres entrés.

ÉTAPE DEUX - summm

Il est maintenant temps de créer notre summmfonction qui obtiendra la somme de tous les nombres entrés.
Voici le code:

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

Et voilà. C'est votre solution IBM quotidienne. TELNET POWER TOUJOURS!
D'abord, vous entrez SUM.
Le serveur vous demandera alors les numéros que vous souhaitez ajouter, et vous pouvez les entrer tels quels:a, b, c, etc..

Croyez-moi, tous les réseaux de zombies utilisent actuellement IBM® Javascript Enterprise SUM Solution;).

Et voici la preuve que tout fonctionne:
(CLIQUABLE)

Voici une solution en Java pour vous. Il repose sur le "théorème infini des singes", qui a fait ses preuves: si vous êtes dans une pièce avec des singes infinis, vous serez couvert de foutaises. Ou quelque chose comme ça.

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 - l'overkill est le meilleur tuer

Les ordinateurs ne comportent que des 0 et des 1, il est donc très difficile de mettre en œuvre une solution appropriée, rapide et évolutive. Heureusement pour vous, j’ai développé skynet 0.1284a, je sais donc comment résoudre ce problème périlleux.
Habituellement, vous devez acheter le DLC de la bibliothèque standard C, car le noyau ne le contient pas, mais j'ai réussi à "tricher" pour m'en sortir. En bref, c'est la méthode la moins chère et la plus 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
}

Il suffit de regarder. C'est évidemment mal.

Python

Utilise l'identité mathématique log(ab) = log(a) + log(b)pour une solution qui fonctionne pour de petits nombres, mais déborde pour toute application pratique.

Nous nous assurons ainsi que notre programmeur paresseux pensera que cela fonctionne sur des données de test, mais que cela se bloque dans le monde réel.

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 #

Vous devriez utiliser la récursivité pour résoudre votre problème

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

}

Si c'est bon pour Peano, c'est bon pour tout le monde.

C ++

Nous nous attendons à ce qu'une opération comme addition soit très rapide. Beaucoup d'autres réponses ne se concentrent tout simplement pas assez sur la vitesse. Voici une solution qui utilise uniquement des opérations au niveau des bits , pour des performances maximales.

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

Ma meilleure solution à ce jour, donne une réponse assez incompréhensible jusqu'à ce que vous couriez 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 ++ - Numéros Peano avec métaprogrammation de modèle (avec doge optionnel)

C, comme beaucoup d'autres langages de programmation, complique les choses sans aucune raison. Les nombres naturels sont l’un des systèmes les plus complexes dans ces langues. C est obsédé par la représentation binaire et tous les autres détails complètement inutiles.

En fin de compte, le nombre naturel est juste un zéro, ou un autre nombre naturel incrémenté de un. Ces soi-disant nombres Peano sont un bon moyen de représenter des nombres et d'effectuer des calculs.

Si vous aimez doge, j’ai écrit une extension C ++ pour permettre l’utilisation du langage naturel pour la programmation. L'extension et le code suivant utilisant mon extension peuvent être trouvés à l' adresse suivante : 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 );
}

Pour ajouter plus loin la supériorité de cette méthode: Le calcul est fait à la compilation! Plus de programmes lents, votre utilisateur ne veut pas attendre que vous additionniez ces chiffres.

Et pour la partie sérieuse:

• Je ne pense pas avoir à le dire, mais c'est complètement ridicule.
• Ne fonctionne que pour les constantes de temps de compilation.
• Ne fonctionne pas avec des nombres négatifs.
• La réponse a été fournie par une personne qui ne peut pas réellement créer elle-même un métaprogramme de gabarit, de sorte que je ne saurais même pas si elle présente d'autres défauts.

Mes amis m'ont dit de dogifier le code, alors je l'ai fait. C'est amusant, mais je pense que cela en enlève trop au fait que c'est totalement stupide, alors je ne l'ai inclus que comme lien.

J'ai arrêté de faire confiance aux ordinateurs lorsque j'ai appris l'existence d'erreurs en virgule flottante.

Ce JavaScript repose sur une vérification d'erreur humaine précise:

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

"Écris une fonction qui entre et retourne sa somme."

D'accord:

public static String inputAndReturnTheirSum () {
    System.out.print ("Entrez leur somme:");
    renvoyer le nouveau Scanner (System.in) .nextLine ();
}

Java ou C-style. C'est O (log n). Remarque: cela ne fonctionne pas pour le négatif 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);
}

Idée démo ici.

Bash avec Hadoop en streaming

Évidemment, aet bpeut devenir vraiment grand. Par conséquent, nous devons utiliser 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;}'

En prime, cette approche implique a catet a wc. Cela devrait être amusant à regarder! Mais je prévois d’utiliser Mahout pour cela à l’avenir (même si j’aime les chats).

Ce doit être la solution la plus évolutive que vous obteniez pour cette question. Cependant, je peux imaginer qu'une solution Hadoop récursive est beaucoup plus élégante.

Ignorez tous ces gens stupides avec leurs manières non génériques et indestructibles. Nous avons besoin d'une bibliothèque performante, extensible et simple pour un projet d'une telle envergure. Il doit prendre en charge l’extension et la substitution à chaque endroit du code. Pour cela, nous avons besoin d’un langage également extensible et simple, c’est pourquoi le meilleur candidat est le C # .

C’est la raison pour laquelle je vous présente la version bêta de ma version 0.8.4.4_beta1.3a_rev129857_dist29.12.13 / master de Operable Commons Library Enterprise Edition, qui expose à cette version une IOperableinterface, une IAddableinterface vous permettant d’utiliser vos propres méthodes d’ajout efficaces, et une implémentation par défaut de IAddable:Addableclass, qui utilise l'addition binaire extrêmement efficace, sans tricherie et en utilisant la soustraction native lente pour le report de report. Bien entendu, comme toute bonne bibliothèque, elle est livrée avec une usine pour chaque type prise en charge. La bibliothèque suit également les principes de "manipulez-la vous-même", vous devez donc vous assurer que l'entrée est valide et que la sortie souhaitée est réalisable, car elle ne vérifiera pas les données non valides. La voici (ce code est sous licence de la licence propriétaire Dont-Touch-This Obstructive de Microsoft Corporation en lecture seule, révision 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 programmation est tout au sujet de l'algorithme. Retournons à l'algorithme de base de ce que nous apprenons à l'âge de 3 ans - compter les doigts.

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

• Premièrement, en tant que développeur principal, choisissons un langage judicieux: multiplate-forme, légère et portable.

• Deuxièmement, avoir une vision globale. Utilisez Global var.

• Troisièmement, ++ s et --s

• Comme YFS (You-Finger-System), cela ne supporte pas les nombres négatifs

• Enfin, vous pouvez modifier en FINGER_NUMBERfonction du nombre de doigts que vous avez.

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

Eh bien, celui-ci est un peu délicat. Heureusement, Python rend les choses relativement simples. Vous aurez besoin de PIL pour faire cela correctement.

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

Commentaires adaptés de Watterson .

Utiliser intentionnellement le lent Image.getpixel(). Je ne suis pas sûr que ce soit assez lent , darnitall. RGBA juste pour prendre de la mémoire supplémentaire.

JAVA

Dans le code ci-dessous, ... remplace un code que j'étais trop paresseux pour écrire, mais vous devriez être capable de le comprendre. Pour le faire avec style, il faudrait un programme de génération de code. Les limites 0 et 10 peuvent être changées en n'importe quoi. Plus les limites sont grandes, plus il y a de code et un ordinateur pourrait facilement remplir le ... 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;
       }
}

une fonction qui entre et retourne leur somme

Lua

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

Le code est terminé. Soyez très prudent à ce sujet. Ce code est ultra-complexe et a probablement tendance à devenir un être intelligent et conscient. C'est un code top secret hautement classifié.

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

Bien sûr, vous aurez besoin de modèles de magie :

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

Problème difficile.

On sait qu'en informatique, il est plus facile de vérifier leurs réponses que de les trouver. Vous devez donc utiliser un algorithme aléatoire pour deviner la solution, puis la vérifier (efficacement!) Et espérer obtenir le bon résultat dans un délai raisonnable:

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

Cette fonction est sous brevet de mon entreprise, je peux vous en fournir une copie sous licence obfusquée:

Javascript:

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

Usage:

sum([arg1],[arg2]);

Python

La programmation concerne la tolérance aux pannes. Ce qui suit est une implémentation de sum qui ajoutera n'importe quoi sans se faire chier. Il va trier de manière transparente les éléments dans l'ordre qui peut être ajouté. Dans le cas où ce n’est pas possible, il le marquera comme 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

De toute évidence, le moyen le plus efficace est de déplacer vos bits. Cela peut être facilement fait avec C + Fortran via le iso_c_bindingmodule:

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

où est 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);
}

Vous devez d'abord compiler le code C (par exemple gcc -c mycfile.c), puis le code Fortran (par exemple gfortran -c myf90file.f90), puis créer l'exécutable ( gfortran -o adding myf90file.o mycfile.o).