Проблема:

Я провідний розробник великої компанії, ми створюємо Skynet. Мені призначено

Напишіть функцію, яка вводить і повертає їх суму

ПРАВИЛА: Немає відповідей, як

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

РЕДАКТУВАННЯ: Прийнятою відповіддю буде відповідь з найбільшою кількістю результатів 1 січня 2014 року

^{Примітка. Це запитання щодо кодування . Будь ласка, не сприймайте питання та / або відповіді серйозно. Більше інформації тут .}

Це дуже складна проблема! Ось як ви вирішите це в 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);
}

Як працює цей код (я б не додав цього пояснення у своїй відповіді на ледачий ОП, який треба пропрацювати, не хвилюйтесь): ((a & ~877 - b ^ 133 << 3 / a) & ((a - b) - (a - b))) | aповертається просто aі ((b ^ (a < 0 ? b : a)) & ((b - a) - (b - a))) | bповертається просто b.

6755 & 1436повертається 0, тому в циклі iфактично починається зі значення 0, а всередині циклу ви додаєте значення 1до списку. Отже, якщо aє 5і bє 3, значення 1додається 8 разів до списку.

importantCalculationФункція дуже довго функція , яка не робить нічого іншого , ніж складання двох чисел. Ви використовуєте LINQAggregate для складання всіх чисел. Також непотрібно передавати результат Convert.ToInt32на значення int, оскільки воно вже є int.

Цей код - це те, чого ледачий ОП не зрозумів би, що саме є наміром :-)

Bash - 72 байти

Іноді традиційні детерміновані методи додавання занадто точні та надмірно швидкі - бувають випадки, коли ви хочете трохи відпочити процесору.

Представляємо втрачений алгоритм SleepAdd .

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

Проба зразка:

> ./sleepadd.sh 0.5 1.5
2.001

Ця функція призначена як супутник добре розглянутого SleepSort . Читачеві залишається як вправа адаптувати цей алгоритм, щоб зробити втратний SleepMax, щоб отримати більше двох чисел.

Порада: Цей алгоритм можна додатково оптимізувати - можливе збільшення швидкості в 2 рази, якщо числа, що даються йому, розділяються на 2 спочатку.

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

Це в основному записує файл із кількістю байтів, яка повинна бути рівною фактичній сумі. Коли файл записаний, він запитує таблицю файлів диска про розмір цього файлу.

С

У квантовому світі ви не можете залежати від атомних операторів, наприклад +, ось моя реалізація доповнення з точки зору квантових обчислень:

#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

Хаскелл

Обчислює правильне рішення за час O (n ^ 2) . На основі прикладних функторів, які також реалізуються 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

Приклад: daSum [1,2,3,4,5]врожайність 15.

Оновлення: як це працює: Число a представлено у вигляді многочлена xa . Список чисел a1, ..., aN подається як розширення (x-a1) (x-a2) ... (x-aN) . Тоді сума чисел - коефіцієнт другого найвищого ступеня. Для подальшого затемнення ідеї поліном представлений як додатково + альтернативний функтор, який фактично не має значення, а кодує поліном як список чисел (ізоморфний Constant [n]). Тоді додаткові операції відповідають поліноміальному множенням, а альтернативним операціям додавання (і вони також дотримуються застосовних / альтернативних законів).

Потім суму чисел обчислюють як відображення кожного числа у відповідному многочлені, а потім Polyперехід списку за допомогою додаткового інструктора, який обчислює добуток поліномів, і, нарешті, витягуючи належний коефіцієнт у кінці.

Ви хочете додати числа ?!? Вам відомо, що це дуже складна дія? Гаразд, з іншого боку, ви головний розробник, вам доведеться зіткнутися з подібними проблемами.

Це найпростіше рішення, яке я міг знайти:

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

Не станьте здобиччю оператора "+", це абсолютно неефективно. Не соромтеся повертати оператор "йде в бік" або використовувати його для менших чисел, що стають більшими.

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

Вау, це надзвичайно важке запитання, але я постараюся зробити все, щоб відповісти на це.

КРОК перший - сервер TELNET

Спершу нам доведеться отримувати вхід, тепер будь-який кодер і корпоративний кодер (як я) повинен знати найкращий спосіб отримання вводу - це налаштування сервера telnet !!!

Почнемо з базового сервера 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,"");
}

Тут дійсно немає нічого особливого, це типовий сервер telnet. Ми створили основні функції очищення UNICODE, щоб отримати нам гарну сировину, а також додали своюSUM функцію.

Тепер користувачеві доведеться ввести "SUM". Потім вони запропонують їм ввести teh numberz, як тільки введена функція summm () буде запущена, і обчислить суму всіх введених чисел.

КРОК ДВА - сумм

Настав час створити нашу summmфункцію, яка отримає суму всіх введених чисел.
Ось код:

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

І ось ти йдеш. Це ваше щоденне рішення IBM. ТЕЛЕТНА ВЛАДА ВСІХ ШЛЯХІВ!
Спочатку ви вводите СУМ.
Потім сервер запитає числа, які ви хочете додати, і ви можете ввести їх як такі:a, b, c, etc..

Повірте мені в цьому, всі ботнети користуються IBM® Javascript Enterprise SUM Solution ™ сьогодні IBM).

І ось доказ того, що все працює:
(КЛІЧНО)

Ось рішення на Java для вас. Він спирається на перевірену часом "нескінченну теорему мавп": якщо ви знаходитесь в кімнаті з нескінченними мавпами, ви опинитеся вкриті кинутим ковпаком. Або щось подібне.

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 - перевиконання найкраще вбити

Комп'ютери мають лише 0 і 1, тому реалізувати правильне, швидке та масштабоване рішення щодо того, як додати, насправді дуже важко. На щастя для вас, я розробив skynet 0.1284a, тому знаю, як вирішити цю небезпечну проблему.
Зазвичай вам потрібно буде придбати стандартну бібліотеку DLC бібліотеки C, оскільки ядро ​​її не містить, але мені вдалося "обдурити" свій вихід з неї. Словом, це найдешевший і найефективніший метод.

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

Просто подивіться на це. Це очевидно зло.

Пітон

Використовує математичну ідентичність log(ab) = log(a) + log(b)для рішення, яке працює для невеликої кількості, але переповнює будь-яке практичне застосування.

Таким чином, гарантуючи, що наш ледачий програміст подумає, що це працює над тестовими даними, лише для того, щоб вони зазнали краху в реальному світі.

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 #

Ви повинні використовувати рекурсію для вирішення своєї проблеми

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

}

Якщо його достатньо для Peano, то його достатньо для всіх.

C ++

Ми очікуємо, що така операція, як додавання, буде дуже швидкою. Багато інших відповідей просто недостатньо зосереджені на швидкості. Ось рішення, яке використовує лише побітові операції для досягнення максимальної продуктивності.

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

Моє найкраще рішення поки що дає досить незрозумілу відповідь, поки ти не біжиш 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 ++ - номери фортепіано з метапрограмуванням шаблонів (з додатковою дожею)

C, як і багато інших мов програмування, ускладнює речі абсолютно без причин. Однією з найбільш складних систем цих мов є натуральні числа. C одержимий бінарним поданням і всіма іншими абсолютно марними деталями.

Зрештою, натуральне число - це просто Нуль або якесь інше природне число, збільшене на одиницю. Ці так звані номери Peano - хороший спосіб представити числа і зробити обчислення.

Якщо вам подобається doge, я написав розширення C ++, щоб дозволити використовувати природну мову для програмування. Розширення та цей наступний код із використанням мого розширення можна знайти за адресою: 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 );
}

Щоб додатково додати перевагу цього методу: Математика робиться під час компіляції! Більше повільних програм немає, користувач не хоче чекати, коли ви підсумуєте ці цифри.

І для серйозної частини:

• Я не думаю, що я повинен це говорити, але це абсолютно смішно.
• Працює лише для констант часу компіляції.
• Не працює з від’ємними числами.
• Відповідь надавав людина, яка насправді не може сама метапрограма шаблону, тому я навіть не знаю, чи є у неї інші недоліки.

Мої друзі сказали мені догіфікувати код, так я і зробив. Це весело, але я думаю, що це забирає занадто багато того, що це абсолютно глупо, як є, тому я включив це лише як посилання.

Я перестав довіряти комп’ютерам, коли дізнався про помилки з плаваючою комою.

Цей JavaScript покладається на точну перевірку помилок людини:

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

"Написати функцію, яка вводить і повертає їх суму."

Гаразд:

загальнодоступний статичний рядок inputAndReturnTheirSum () {
    System.out.print ("Введіть їх суму:");
    повернути новий сканер (System.in) .nextLine ();
}

Java або C-стиль. Це O (log n). Примітка. Це не працює для мінус a або 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);
}

Демонстраційна демонстрація тут.

Баш з Hadoop Streaming

Очевидно, aі bможе стати справді великим. Тому ми повинні використовувати 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;}'

Як додатковий бонус, такий підхід передбачає а catі а wc. На це слід було б весело спостерігати! Але я планую використовувати Махуут для цього в майбутньому (хоча мені подобаються коти).

Це має бути найбільш масштабним рішенням, яке ви отримаєте з цього питання. Однак я можу уявити, що рекурсивне рішення Hadoop набагато елегантніше.

Ігноруйте всіх тих нерозумних людей з їхніми загальними та неприборканими манерами. Для проекту такого масштабу нам потрібна виконавська, розширювана та проста бібліотека. Він повинен підтримувати розширення та заміщення в кожній точці коду. Для цього нам потрібна однаково розширювана та проста мова, тому найкращим кандидатом є C # .

Ось чому я представляю вам бета-версію мого Operable Commons Library Enterprise Edition, версія 0.8.4.4_beta1.3a_rev129857_dist29.12.13 / master , яка в цій версії розкриває IOperableінтерфейс, IAddableінтерфейс, щоб ви могли використовувати власні ефективні методи додавання та реалізація за замовчуванням IAddable:Addableклас, який використовує надзвичайно ефективне побітове додавання, без обману та використання повільного рідного віднімання для перенесення перенесення. Звичайно, як і будь-яка хороша бібліотека, вона має фабрику для кожного типу, який вона підтримує. Бібліотека також дотримується принципів "впорайтеся самі", тому ви повинні гарантувати, що введення є дійсним і що бажаний вихід є здійсненним, оскільки він не перевірятиме на наявність недійсних даних. Ось він (Цей код ліцензований відповідно до власницької корпорації Майкрософт для читання лише для читання, ця обмежувальна ліцензія, редакція 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

Програмування - все про алгоритм. Повернемося до основного алгоритму, що ми вивчаємо у віці 3 років - підрахунок пальців.

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

• По-перше, будучи провідним розробником, давайте мудрий вибір мови - крос-платформний, легкий і портативний.

• По-друге, мати глобальне бачення. Використовуйте Global var.

• По-третє, ++ s і --s

• Як і YFS (You-Finger-System), це не підтримує негативні числа

• Нарешті, ви можете змінити FINGER_NUMBER залежно від кількості ваших пальців.

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

Ну, це трохи хитро. На щастя, Python робить це досить просто. Для цього вам знадобиться PIL .

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

Коментарі адаптовані з Уоттерсона .

Навмисне використання повільного Image.getpixel(). Я не впевнений, що насправді це досить повільно , дармо. RGBA просто, щоб зайняти додаткову пам'ять.

JAVA

У наведеному нижче коді ... стоїть код, який мені було лінь писати, але ви повинні мати можливість з'ясувати. Щоб дійсно зробити це в стилі, знадобиться програма генерації коду. Межі 0 і 10 можна змінити на будь-які. Чим більше обмеження, тим більше код і комп'ютер може легко заповнити ... 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;
       }
}

функція, яка вводить і повертає їх суму

Луа

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

Код зроблено. Будьте дуже обережні з цього приводу. Цей код є надскладним і, ймовірно, схильний стати розумною свідомою і усвідомленою істотою. Це високо секретний код.

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

Звичайно, вам знадобиться магія шаблону :

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

Важка проблема.

Відомо, що в інформатиці є проблеми, що перевірити їх відповіді простіше, ніж їх знайти. Отже, ви повинні використовувати випадковий алгоритм для відгадування рішення, а потім перевірити його (ефективно!) Та сподіватися отримати правильний результат у розумний час:

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

Ця функція є патентом моєї компанії, я можу надати вам приховану ліцензовану її копію:

Javascript:

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

Використання:

sum([arg1],[arg2]);

Пітон

Програмування стосується помилок. Далі йде реалізація суми, яка додасть що-небудь, не метушившись. Це буде прозоро сортувати елементи в порядку, який можна додати. У випадку, якщо його не можна рекламувати, він позначить його як 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]]

Фортран

Очевидно, що найефективніший спосіб - це змістити свої біти. Це легко зробити за допомогою C + Fortran через iso_c_bindingмодуль:

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

де є звичайна програма С

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

Спочатку потрібно скомпілювати код C (наприклад, gcc -c mycfile.c), потім скомпілювати код Fortran (наприклад, gfortran -c myf90file.f90), а потім зробити виконуваний файл ( gfortran -o adding myf90file.o mycfile.o).