Das Problem:

Ich bin der Hauptentwickler für ein großes Unternehmen, wir machen Skynet. Ich wurde zugeteilt

Schreiben Sie eine Funktion, die ihre Summe eingibt und zurückgibt

REGELN: Keine Antworten wie

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

BEARBEITEN: Die akzeptierte Antwort ist die mit den meisten positiven Stimmen am 1. Januar 2014

^{Hinweis: Dies ist eine Code-Trolling- Frage. Bitte nehmen Sie die Frage und / oder die Antworten nicht ernst. Mehr Infos hier .}

Das ist ein sehr komplexes Problem! So lösen Sie es 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);
}

Wie dieser Code funktioniert (ich würde diese Erklärung nicht in meine Antwort auf das faule OP einfügen, das überwacht werden muss, keine Sorge): ((a & ~877 - b ^ 133 << 3 / a) & ((a - b) - (a - b))) | akehrt einfach zurück aund ((b ^ (a < 0 ? b : a)) & ((b - a) - (b - a))) | bkehrt einfach zurück b.

6755 & 1436Gibt zurück 0, sodass in der Schleife itatsächlich mit dem Wert begonnen 0wird und Sie innerhalb der Schleife den Wert 1zur Liste hinzufügen . Wenn also aist 5und bist 3, wird der Wert 18 Mal zur Liste hinzugefügt.

Die importantCalculationFunktion ist eine sehr lange Funktion, die nichts anderes tut, als zwei Zahlen zu addieren. Mit der LINQ- AggregateFunktion addieren Sie alle Zahlen. Es ist auch unnötig, das Ergebnis von Convert.ToInt32auf eine zu setzen int, da es bereits eine ist int.

Dieser Code ist etwas, das der Lazy OP nicht verstehen würde, was genau die Absicht ist :-)

Bash - 72 Bytes

Manchmal sind traditionelle deterministische Additionstechniken zu präzise und unnötig schnell - manchmal möchten Sie der CPU eine kleine Pause gönnen.

Einführung des verlustbehafteten SleepAdd-Algorithmus .

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

Probelauf:

> ./sleepadd.sh 0.5 1.5
2.001

Diese Funktion ist als Begleiter des angesehenen SleepSort gedacht . Es ist eine Übung für den Leser, diesen Algorithmus anzupassen, um einen verlustbehafteten SleepMax zu erzeugen, um die größere von zwei Zahlen zu erhalten.

Pro-Tipp: Dieser Algorithmus kann weiter optimiert werden - eine zweifache Geschwindigkeitserhöhung ist möglich, wenn die ihr zugewiesenen Zahlen zuerst durch 2 geteilt werden.

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

Dies schreibt im Grunde eine Datei mit der Anzahl von Bytes, die gleich der tatsächlichen Summe sein sollte. Wenn die Datei geschrieben wird, fragt sie die Festplattendateitabelle nach der Größe dieser Datei.

C

In der Quantenwelt kann man sich nicht auf Atomoperatoren verlassen +, hier ist meine Implementierung der Addition in Bezug auf das Quantencomputing:

#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

Ermittelt die richtige Lösung in O (n ^ 2) Zeit. Basierend auf anwendbaren Funktoren , die auch implementiert werden 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

Beispiel: daSum [1,2,3,4,5]ergibt 15.

Update: So funktioniert es: Eine Zahl a wird als Polynom xa dargestellt . Eine Liste von Zahlen a1, ..., aN wird dann als die Erweiterung von (x-a1) (x-a2) ... (x-aN) dargestellt . Die Summe der Zahlen ergibt dann den zweithöchsten Koeffizienten. Um die Idee weiter zu verschleiern, wird ein Polynom als anwendbarer + alternativer Funktor dargestellt, der eigentlich keinen Wert enthält, sondern nur das Polynom als Liste von Zahlen codiert (isomorph zu Constant [n]). Die anwendbaren Operationen entsprechen dann der Polynommultiplikation und den alternativen Operationen zur Addition (und sie halten sich auch an anwendbare / alternative Gesetze).

Die Summe der Zahlen wird dann berechnet, indem jede Zahl in das entsprechende Polynom Polyabgebildet wird und dann die Liste unter Verwendung des anwendbaren Frunktors durchlaufen wird, der das Produkt der Polynome berechnet und schließlich den richtigen Koeffizienten am Ende extrahiert.

Sie möchten Zahlen hinzufügen ?!? Ihnen ist bewusst, dass dies eine sehr komplizierte Aktion ist? OK, auf der anderen Seite sind Sie der Hauptentwickler, Sie werden auf solche Probleme stoßen müssen.

Dies ist die einfachste Lösung, die ich finden konnte:

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

Fallen Sie nicht dem Operator "+" zum Opfer, es ist völlig ineffizient. Drehen Sie den Operator "Gehe zu" um oder verwenden Sie ihn für kleinere Zahlen, die größer werden.

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

Wow, das ist eine sehr schwierige Frage, aber ich werde mein Bestes geben, um dies zu beantworten.

SCHRITT 1 - TELNET Server

Zuerst müssen wir die Eingaben empfangen, jetzt sollte jeder Pro und Enterprise-Codierer (wie ich) wissen, dass der beste Weg, Eingaben zu empfangen, darin besteht, einen Telnet-Server einzurichten !!!

Beginnen wir mit dem grundlegenden Telnet-Server:

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

Es ist wirklich nichts Besonderes daran, das ist ein typischer Telnet-Server. Wir haben einige grundlegende UNICODE-Reinigungsfunktionen erstellt, um einen schönen Roh-String zu erhalten, und wir haben auch unsere SUMFunktion hinzugefügt .

Nun muss der Benutzer 'SUM' eingeben. Sie werden dann zur Eingabe aufgefordert teh numberz, sobald die summm () -Funktion ausgeführt wird, und die Summe aller eingegebenen Zahlen wird berechnet.

SCHRITT ZWEI - Zusammenfassung

Es ist jetzt Zeit, unsere summmFunktion zu erstellen , die die Summe aller eingegebenen Zahlen ergibt.
Hier ist der 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;
}

Und los geht's. Es ist Ihre alltägliche IBM Lösung. TELNET POWER DEN GANZEN WEG!
Zuerst geben Sie SUM ein.
Der Server fragt dann nach den Nummern, die Sie hinzufügen möchten, und Sie können sie als solche eingeben:a, b, c, etc..

Vertrauen Sie mir in diesem Fall, alle Botnets verwenden heutzutage IBM® Javascript Enterprise SUM Solution;).

Und hier ist der Beweis, dass alles funktioniert:
(KLICKBAR)

Hier ist eine Lösung in Java für Sie. Es basiert auf dem bewährten "Satz von unendlichen Affen": Wenn Sie sich in einem Raum mit unendlichen Affen befinden, werden Sie mit Kot überhäuft. Oder etwas ähnliches.

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 ist am besten töten

Computer haben nur Nullen und Einsen, daher ist es sehr schwierig, eine geeignete, schnelle und skalierbare Lösung für das Hinzufügen zu implementieren. Zum Glück habe ich skynet 0.1284a entwickelt, damit ich weiß, wie ich dieses gefährliche Problem lösen kann.
Normalerweise müssten Sie die C-Standardbibliothek DLC kaufen, da der Core diese nicht enthält, aber ich habe es geschafft, meinen Weg daraus zu "schummeln". Kurz gesagt, dies ist die billigste und effektivste Methode.

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

Schau es dir an. Es ist offensichtlich böse.

Python

Verwendet die mathematische Identität log(ab) = log(a) + log(b)für eine Lösung, die für kleine Zahlen funktioniert, aber für jede praktische Anwendung überläuft.

Auf diese Weise wird sichergestellt, dass unser fauler Programmierer glaubt, dass es mit Testdaten funktioniert, und dass es in der realen Welt abstürzt.

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 #

Sie sollten die Rekursion verwenden, um Ihr Problem zu lösen

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

}

Wenn es gut genug für Peano ist, ist es gut genug für alle.

C ++

Wir erwarten, dass eine Operation wie Addition sehr schnell ist. Viele der anderen Antworten konzentrieren sich einfach nicht genug auf die Geschwindigkeit. Hier ist eine Lösung, die nur bitweise Operationen verwendet , um maximale Leistung zu erzielen.

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

Meine bisher beste Lösung gibt eine ziemlich unverständliche Antwort, bis Sie ausgeführt werden aVeryLargeNumber()

function aVeryLargeNumber(){return Math.log(Math.log(Math.log(Math.log(Math.round((Math.log(!![].join()^{}-({}=={})|(0x00|0x11111)-(0x111111&0x10111))/Math.log(2))/(Math.tan(Math.PI/4)*Math.tan(1.48765509)))+(0xFFFF))/Math.log(2))/Math.log(2))/Math.log(2))/Math.log(2)}
function add(a,b){
    var i=aVeryLargeNumber();
    i--;
    for(;i<b;i+=aVeryLargeNumber(),a+=aVeryLargeNumber());
    return a;

}

C ++ - Peano-Nummern mit Template-Metaprogrammierung (mit optionalem Doge)

C, wie viele andere Programmiersprachen, erschweren die Dinge ohne jeden Grund. Eines der komplexesten Systeme in diesen Sprachen sind natürliche Zahlen. C ist besessen von der binären Darstellung und allen anderen völlig nutzlosen Details.

Am Ende ist die natürliche Zahl nur eine Null oder eine andere natürliche Zahl, die um eins erhöht wird. Diese sogenannten Peano-Zahlen sind eine gute Möglichkeit, Zahlen darzustellen und zu berechnen.

Wenn Sie doge mögen, habe ich eine C ++ - Erweiterung geschrieben, um die Verwendung der natürlichen Sprache für die Programmierung zu ermöglichen. Die Erweiterung und der folgende Code mit meiner Erweiterung finden Sie unter: 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 );
}

Um die Überlegenheit dieser Methode noch weiter zu steigern: Die Berechnung erfolgt zur Kompilierzeit! Keine langsamen Programme mehr, Ihr Benutzer möchte nicht darauf warten, dass Sie diese Zahlen summieren.

Und im Ernst:

• Ich glaube nicht, dass ich das sagen muss, aber das ist völlig lächerlich.
• Funktioniert nur für Kompilierzeitkonstanten.
• Funktioniert nicht mit negativen Zahlen.
• Die Antwort stammte von einer Person, die selbst keine Metaprogrammvorlagen erstellen kann, daher würde ich nicht einmal wissen, ob es andere Mängel aufweist.

Meine Freunde sagten mir, ich solle den Code doggieren, also tat ich es. Es macht Spaß, aber ich denke, es nimmt zu viel von der Tatsache ab, dass dies so dumm ist, also habe ich es nur als Link eingefügt.

Ich habe aufgehört, Computern zu vertrauen, als ich von Fließkommafehlern erfuhr.

Dieses JavaScript basiert auf einer präzisen Überprüfung menschlicher Fehler:

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

"Schreiben Sie eine Funktion, die ihre Summe eingibt und zurückgibt."

Okay:

public static String inputAndReturnTheirSum () {
    System.out.print ("Geben Sie ihre Summe ein:");
    neuen Scanner zurückgeben (System.in) .nextLine ();
}

Java oder C-Style. Dies ist O (log n). Hinweis: Dies funktioniert nicht bei negativem a oder b.

public static int sum(int a, int b)
{
    if ((a & b) == (a ^ a)) return a | b;
    int c = a >> 1;
    int d = b >> 1;
    int s = a & 1;
    int t = b & 1;
    return sum(c, d + t) + sum(d, c + s);
}

Ideone Demo hier.

Schlag mit Hadoop Streaming

Offensichtlich aund bkann sehr groß werden. Deshalb müssen wir 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;}'

Als zusätzlichen Bonus beinhaltet dieser Ansatz a catund a wc. Das sollte Spaß machen! Aber ich plane, Mahout in Zukunft dafür zu verwenden (obwohl ich Katzen mag).

Dies muss die skalierbarste Lösung für diese Frage sein. Ich kann mir jedoch vorstellen, dass eine rekursive Hadoop-Lösung viel eleganter ist.

Ignoriere all diese albernen Leute mit ihren nicht generischen und nicht testbaren Manieren. Für ein Projekt dieser Größenordnung benötigen wir eine performante, erweiterbare und einfache Bibliothek. Es muss die Erweiterung und Ersetzung an jedem Punkt des Codes unterstützen. Dafür brauchen wir eine ebenso erweiterbare und einfache Sprache, deshalb ist C # der beste Kandidat .

Aus diesem Grund präsentiere ich Ihnen die Beta-Version meiner Operable Commons Library Enterprise Edition, Version 0.8.4.4_beta1.3a_rev129857_dist29.12.13 / master , die in dieser Version eine IOperableSchnittstelle bereitstellt, eine IAddableSchnittstelle, sodass Sie Ihre eigenen effizienten Additionsmethoden verwenden können, und eine Standardimplementierung vonIAddable : theAddableKlasse, die eine äußerst effiziente bitweise Addition verwendet, ohne zu schummeln und die langsame native Subtraktion zum Verschieben des Übertrags verwendet. Natürlich enthält es, wie jede gute Bibliothek, eine Factory für jeden unterstützten Typ. Die Bibliothek folgt auch den Grundsätzen der "Selbstverwaltung". Sie müssen also sicherstellen, dass die Eingabe gültig und die gewünschte Ausgabe möglich ist, da sie nicht auf ungültige Daten überprüft. Hier ist es (Dieser Code ist lizenziert unter der schreibgeschützten Dont-Touch-This Obstructive License, Revision 3.1 der Microsoft Corporation):

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

Beim Programmieren dreht sich alles um Algorithmen. Kehren wir zum grundlegenden Algorithmus zurück, den wir im Alter von drei Fingern lernen.

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

• Als führender Entwickler müssen wir zunächst eine kluge Sprachauswahl treffen - plattformübergreifend, leicht und portabel.

• Zweitens haben Sie eine globale Vision. Verwenden Sie Global var.

• Drittens ++ s und --s

• Genau wie YFS (You-Finger-System) unterstützt dies keine negativen Zahlen

• Schließlich können Sie FINGER_NUMBERentsprechend der Anzahl der Finger ändern , die Sie haben.

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

Nun, das ist ein bisschen knifflig. Glücklicherweise macht es Python einigermaßen einfach. Sie benötigen PIL , um dies richtig zu machen.

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

Kommentare von Watterson angepasst .

Absichtlich das langsame verwenden Image.getpixel(). Ich bin mir nicht sicher, ob es langsam genug ist, verdammt. RGBA, nur um zusätzlichen Speicher zu belegen.

JAVA

Im folgenden Code steht ... für Code, für den ich zu faul war, um ihn zu schreiben, aber Sie sollten es herausfinden können. Um dies wirklich mit Stil zu tun, wäre ein Code-Generierungsprogramm erforderlich. Die Grenzen 0 und 10 können beliebig geändert werden. Je größer die Grenzwerte, desto mehr Code und ein Computer könnten die ... s leicht ausfüllen.

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

eine Funktion, die ihre Summe eingibt und zurückgibt

Lua

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

Der Code ist fertig. Sei sehr vorsichtig damit. Dieser Code ist äußerst komplex und neigt wahrscheinlich dazu, ein intelligentes bewusstes und selbstbewusstes Wesen zu werden. Es ist hoch eingestufter streng geheimer Code.

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

Natürlich brauchen Sie Template-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

Schweres Problem.

Es ist bekannt, dass es in der Informatik Probleme gibt, deren Antworten zu überprüfen, anstatt sie zu finden. Verwenden Sie daher einen Zufallsalgorithmus, um die Lösung zu erraten, und überprüfen Sie sie (effizient!). Hoffen Sie, dass Sie in angemessener Zeit das richtige Ergebnis erzielen:

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

Diese Funktion steht unter dem Patent meiner Firma. Ich kann Ihnen eine verschleierte lizenzierte Kopie davon zur Verfügung stellen:

Javascript:

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

Verwendungszweck:

sum([arg1],[arg2]);

Python

Die Programmierung ist fehlertolerant. Das Folgende ist eine Implementierung der Summe, die alles hinzufügt, ohne sich aufzuregen. Die Elemente werden transparent in der Reihenfolge sortiert, in der sie hinzugefügt werden können. Falls es nicht addierbar ist, wird es als gekennzeichnet 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

Offensichtlich ist der effizienteste Weg, um Ihre Bits zu verschieben. Dies kann mit C + Fortran einfach über das iso_c_bindingModul erfolgen:

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

wo die C-Routine ist

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

Sie müssen zuerst den C-Code kompilieren (z. B. gcc -c mycfile.c), dann den Fortran-Code kompilieren (z. B. gfortran -c myf90file.f90) und dann die ausführbare Datei erstellen ( gfortran -o adding myf90file.o mycfile.o).