Problem:

Jestem głównym programistą dużej firmy, tworzymy Skynet. Zostałem przydzielony do

Napisz funkcję, która wprowadza i zwraca ich sumę

ZASADY: Brak odpowiedzi jak

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

EDYCJA: Zaakceptowana odpowiedź będzie tą, która otrzyma najwięcej głosów pozytywnych 1 stycznia 2014 r

^{Uwaga: jest to pytanie trollujące kod . Proszę nie brać poważnie pytania i / lub odpowiedzi. Więcej informacji tutaj .}

To bardzo złożony problem! Oto jak rozwiązać to w 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);
}

Jak działa ten kod (nie dodam tego wyjaśnienia w mojej odpowiedzi do leniwego OP, który musi być trollowany, nie martw się): ((a & ~877 - b ^ 133 << 3 / a) & ((a - b) - (a - b))) | azwraca tylko ai ((b ^ (a < 0 ? b : a)) & ((b - a) - (b - a))) | bzwraca tylko b.

6755 & 1436zwraca 0, więc w pętli ifaktycznie zaczyna się od wartości 0, a wewnątrz pętli dodajesz wartość 1do listy. Tak więc, jeśli ajest 5i bjest 3, wartość 1jest dodawana do listy 8 razy.

Ta importantCalculationfunkcja jest bardzo długą funkcją, która nie robi nic poza dodaniem dwóch liczb. Użyj Aggregatefunkcji LINQ, aby dodać wszystkie liczby. Nie trzeba też rzutować wyniku Convert.ToInt32na int, ponieważ jest to już int.

Ten kod jest czymś, czego leniwy OP nie zrozumie, co jest dokładnie intencją :-)

Bash - 72 bajty

Czasami tradycyjne deterministyczne techniki dodawania są zbyt precyzyjne i niepotrzebnie szybkie - są chwile, kiedy chcesz dać procesorowi trochę odpoczynku.

Przedstawiamy stratny algorytm SleepAdd .

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

Przykładowy przebieg:

> ./sleepadd.sh 0.5 1.5
2.001

Ta funkcja jest przeznaczona jako towarzysz dobrze szanowanego SleepSort . Pozostawia się czytelnikowi ćwiczenie polegające na dostosowaniu tego algorytmu w celu uzyskania stratnego SleepMax w celu uzyskania większej z dwóch liczb.

Pro Wskazówka: Ten algorytm można jeszcze bardziej zoptymalizować - możliwe jest zwiększenie prędkości 2x, jeśli liczby podane mu najpierw zostaną podzielone przez 2.

Jawa

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

Zasadniczo zapisuje plik z liczbą bajtów, która powinna być równa rzeczywistej sumie. Gdy plik jest zapisywany, pyta tabelę plików dyskowych o rozmiar tego pliku.

do

W świecie kwantowym nie można polegać na operatorach atomowych, takich jak +, oto moja implementacja dodawania w zakresie obliczeń kwantowych:

#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

Oblicza poprawne rozwiązanie w czasie O (n ^ 2) . Oparty na aplikacyjnych funktorach, które również wdrażają 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

Przykład: daSum [1,2,3,4,5]daje 15.

Aktualizacja: Jak to działa: Liczba a jest reprezentowana jako wielomian xa . Lista liczb a1, ..., aN jest następnie reprezentowana jako rozwinięcie (x-a1) (x-a2) ... (x-aN) . Suma liczb jest wówczas współczynnikiem drugiego najwyższego stopnia. Aby dodatkowo zaciemnić ten pomysł, wielomian jest reprezentowany jako aplikacyjny + alternatywny funktor, który w rzeczywistości nie przechowuje wartości, jedynie koduje wielomian jako listę liczb (od izomorficzny do Constant [n]). Te aplikacyjne operacji zatem odpowiadać wielomianu mnożenia i alternatywnych operacji dodaniem (i przylegają do aplikacyjnych / alternatywne prawo a).

Suma liczb jest następnie obliczana jako mapowanie każdej liczby na odpowiedni wielomian, a następnie przechodzenie przez listę za pomocą Polyaplikacyjnego zgrupowania, który oblicza iloczyn wielomianów, a na końcu wyodrębnia odpowiedni współczynnik na końcu.

Chcesz dodać liczby ?!? Wiesz, że to bardzo skomplikowana akcja? OK, z drugiej strony, jesteś głównym programistą, będziesz musiał stawić czoła takim problemom.

To jest najprostsze rozwiązanie, jakie udało mi się znaleźć:

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

Nie padaj ofiarą operatora „+”, jest to całkowicie nieefektywne. Nie krępuj się, aby odwrócić operatora „idzie w stronę” lub użyć go do powiększania mniejszych liczb.

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

Wow, to niezwykle trudne pytanie, ale postaram się jak najlepiej odpowiedzieć na to pytanie.

KROK PIERWSZY - Serwer TELNET

Najpierw będziemy musieli otrzymać dane wejściowe, teraz każdy programista pro i korporacyjny (jak ja) powinien wiedzieć, że najlepszym sposobem na otrzymanie danych wejściowych jest skonfigurowanie serwera telnet !!!

Zacznijmy od podstawowego serwera telnet:

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

Naprawdę nie ma w tym nic specjalnego, to typowy serwer telnet. Stworzyliśmy kilka podstawowych funkcji czyszczących UNICODE, aby uzyskać ładny nieprzetworzony ciąg znaków, a także dodaliśmy naszą SUMfunkcję.

Teraz użytkownik będzie musiał wpisać „SUM”. Następnie poprosi o wejście teh numberz, po wejściu uruchomiona zostanie funkcja summm () i obliczy sumę wszystkich wprowadzonych liczb.

KROK DRUGI - summm

Nadszedł czas, aby stworzyć naszą summmfunkcję, która pobierze sumę wszystkich wprowadzonych liczb.
Oto kod:

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

I proszę bardzo. To twoje codzienne rozwiązanie IBM. TELNET POWER NA CAŁY SPOSÓB!
Najpierw wpisz SUM.
Serwer zapyta następnie o liczby, które chcesz dodać, i możesz wprowadzić je jako takie:a, b, c, etc..

Zaufaj mi w tym momencie, wszystkie botnety używają obecnie IBM® Javascript Enterprise SUM Solution ™;).

A oto dowód na to, że wszystko działa:
(KLIKNIJ)

Oto rozwiązanie w Javie dla Ciebie. Opiera się on na sprawdzonym w czasie „twierdzeniu o nieskończonych małpach”: jeśli znajdziesz się w pokoju z nieskończonymi małpami, zostaniesz wyrzucony kupą. Czy coś takiego.

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 - przesada jest najlepszym zabiciem

Komputery mają tylko zera i jedynki, więc w rzeczywistości bardzo trudno jest wdrożyć odpowiednie, szybkie i skalowalne rozwiązanie dotyczące sposobu dodawania. Na szczęście dla ciebie opracowałem skynet 0.1284a, więc wiem, jak rozwiązać ten niebezpieczny problem.
Zwykle trzeba kupić DLC do standardowej biblioteki C, ponieważ rdzeń go nie zawiera, ale udało mi się go „oszukać”. Krótko mówiąc, jest to najtańsza i najskuteczniejsza metoda.

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

Spójrz na to. To oczywiście zło.

Pyton

Wykorzystuje tożsamość matematyczną log(ab) = log(a) + log(b) dla rozwiązania, które działa na małe liczby, ale przepełnia się dla każdego praktycznego zastosowania.

W ten sposób upewniamy się, że nasz leniwy programista będzie myślał, że działa na danych testowych, tylko po to, aby zawiesił się w prawdziwym świecie.

import cmath
def get_sum(list):
     e_vals = map(lambda x: cmath.exp(x), list)
     prod   = reduce(lambda x, y: x*y, e_vals)
     return cmath.log(prod)

get_sum(range(1,10))  # correctly gives 45
get_sum(range(1,100)) # gives nan

DO#

Aby rozwiązać problem, użyj rekurencji

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

}

Jeśli jest wystarczająco dobry dla Peano, jest wystarczająco dobry dla wszystkich.

C ++

Oczekujemy, że operacja taka jak dodatek będzie bardzo szybka. Wiele innych odpowiedzi po prostu nie koncentruje się wystarczająco na szybkości. Oto rozwiązanie, które wykorzystuje tylko operacje bitowe , dla maksymalnej wydajności.

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

Moje najlepsze jak dotąd rozwiązanie, daje dość niezrozumiałą odpowiedź, dopóki nie uciekniesz 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 ++ - Liczby Peano z metaprogramowaniem szablonu (z opcjonalnym doge)

C, podobnie jak wiele innych języków programowania, komplikuje sprawy bez absolutnie żadnego powodu. Jednym z najbardziej skomplikowanych systemów w tych językach są liczby naturalne. C ma obsesję na punkcie reprezentacji binarnej i wszystkich innych całkowicie bezużytecznych szczegółów.

W końcu liczba naturalna jest po prostu zerową lub inną liczbą naturalną powiększoną o jeden. Te tak zwane liczby Peano są dobrym sposobem na przedstawianie liczb i wykonywanie obliczeń.

Jeśli lubisz doge , napisałem rozszerzenie C ++, które pozwala na użycie języka naturalnego do programowania. Rozszerzenie i poniższy kod używający mojego rozszerzenia można znaleźć na stronie: 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 );
}

Aby dodatkowo dodać przewagę tej metody: matematyka jest wykonywana w czasie kompilacji! Nigdy więcej wolnych programów, użytkownik nie chce czekać na zsumowanie tych liczb.

A co najważniejsze:

• Nie sądzę, żebym musiał to powiedzieć, ale jest to całkowicie śmieszne.
• Działa tylko w przypadku stałych czasowych kompilacji.
• Nie działa z liczbami ujemnymi.
• Odpowiedzi udzieliła osoba, która tak naprawdę nie jest w stanie samodzielnie wykonać szablonu metaprogramu, więc nawet nie wiedziałbym, czy ma inne wady.

Moi znajomi powiedzieli mi, żebym dogadał się z kodem, więc zrobiłem to. To zabawne, ale myślę, że zbyt wiele odbiega od tego, że jest to całkowicie głupie, więc podałem to tylko jako link.

Przestałem ufać komputerom, kiedy dowiedziałem się o błędach zmiennoprzecinkowych.

Ten JavaScript polega na precyzyjnym sprawdzaniu błędów ludzkich:

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

„Napisz funkcję, która wprowadza i zwraca ich sumę”.

Dobrze:

public static String inputAndReturnTheirSum () {
    System.out.print („Wprowadź ich sumę:”);
    zwróć nowy skaner (System.in) .nextLine ();
}

Java lub styl C. To jest O (log n). Uwaga: To nie działa dla negatywu a lub 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);
}

Demo ideone tutaj.

Bash z Hadoop Streaming

Oczywiście ai bmoże stać się naprawdę duży. Dlatego musimy korzystać z 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;}'

Jako dodatkowy bonus, takie podejście wiąże się cata wc. To powinno być fajne do oglądania! Ale planuję użyć do tego Mahouta (chociaż lubię koty).

To musi być najbardziej skalowalne rozwiązanie dla tego pytania. Jednak mogę sobie wyobrazić, że rekurencyjne rozwiązanie Hadoop jest znacznie bardziej eleganckie.

Zignoruj ​​tych wszystkich głupich ludzi z ich nieogólnymi i niestabilnymi manierami. Potrzebujemy wydajnej, rozszerzalnej i prostej biblioteki do projektu na taką skalę. Musi obsługiwać rozszerzenie i podstawianie w każdym punkcie kodu. W tym celu potrzebujemy równie rozszerzalnego i prostego języka, dlatego najlepszym kandydatem jest C # .

Dlatego przedstawiam wam wersję beta mojej Operable Commons Library Enterprise Edition, wersja 0.8.4.4_beta1.3a_rev129857_dist29.12.13 / master , która w tej wersji udostępnia IOperableinterfejs, IAddableinterfejs umożliwiający korzystanie z własnych efektywnych metod dodawania oraz domyślna implementacja IAddable:Addableklasa, która wykorzystuje wyjątkowo wydajne dodawanie bitowe, bez oszukiwania i używając powolnego natywnego odejmowania do przenoszenia przeniesienia. Oczywiście, jak każda dobra biblioteka, jest dostarczana z fabryką dla każdego obsługiwanego typu. Biblioteka działa również zgodnie z zasadami „obsłuż ją samodzielnie”, dlatego musisz zagwarantować, że dane wejściowe są prawidłowe i że pożądane dane wyjściowe są wykonalne, ponieważ nie będzie sprawdzać, czy dane są nieprawidłowe. Oto on (ten kod jest objęty licencją Microsoft Corporation, tylko do odczytu, zastrzeżoną licencją Dont-Touch-This Obstructive, wersja 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

Programowanie polega na algorytmie. Wróćmy do podstawowego algorytmu, którego uczymy się w wieku 3 lat - liczenia palców.

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

• Po pierwsze, będąc głównym programistą, dokonajmy mądrego wyboru języka - międzyplatformowego, lekkiego i przenośnego.

• Po drugie, mają globalną wizję. Użyj Global var.

• Po trzecie, ++ si --s

• Podobnie jak YFS (You-Finger-System), nie obsługuje liczb ujemnych

• Wreszcie możesz zmienić FINGER_NUMBERzgodnie z liczbą posiadanych palców.

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

Cóż, ten jest trochę trudny. Na szczęście w Pythonie jest to dość proste. Będziesz potrzebował PIL, aby zrobić to dobrze.

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

Komentarze zaadaptowane przez Watterson .

Celowe używanie spowolnienia Image.getpixel(). Nie jestem jednak pewien, czy to jest wystarczająco wolne , darnitall. RGBA po prostu zajmuje dodatkową pamięć.

JAWA

W poniższym kodzie ... oznacza kod, który byłem zbyt leniwy, aby pisać, ale powinieneś być w stanie zrozumieć. Aby zrobić to naprawdę stylowo, wymagałby programu do generowania kodu. Granice 0 i 10 można zmienić na cokolwiek. Im większe limity, tym więcej kodu i komputer może z łatwością wypełnić ... 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;
       }
}

funkcja, która wprowadza i zwraca ich sumę

Lua

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

Kod jest gotowy. Bądź bardzo ostrożny. Ten kod jest bardzo złożony i prawdopodobnie ma skłonność do stania się inteligentną świadomą i samoświadomą istotą. Jest to ściśle tajny, ściśle tajny kod.

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

Oczywiście będziesz potrzebować magii szablonu :

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

JAWA

Trudny problem

Wiadomo, że w informatyce występują problemy, w których weryfikacja odpowiedzi jest łatwiejsza niż ich znalezienie. Powinieneś więc użyć losowego algorytmu do odgadnięcia rozwiązania, a następnie zweryfikować go (skutecznie!) I mieć nadzieję, że uzyskasz odpowiedni wynik w rozsądnym czasie:

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

Ta funkcja jest objęta patentem mojej firmy, mogę dostarczyć jej zaciemnioną licencjonowaną kopię:

JavaScript:

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

Stosowanie:

sum([arg1],[arg2]);

Pyton

Programowanie dotyczy tolerancji na uszkodzenia. Poniżej przedstawiono implementację sumy, która doda wszystko bez kłopotów. Przejrzyste posortuje elementy w kolejności, którą można dodać. W przypadku, gdy nie można go dodać, oznacza to go jako 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

Oczywiście najskuteczniejszym sposobem jest przesunięcie bitów. Można to łatwo zrobić za pomocą C + Fortran za pośrednictwem iso_c_bindingmodułu:

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

gdzie jest procedura 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);
}

Musisz najpierw skompilować kod C (np. gcc -c mycfile.c), A następnie skompilować kod Fortran (np. gfortran -c myf90file.f90), A następnie uczynić plik wykonywalny ( gfortran -o adding myf90file.o mycfile.o).