Проблема:

Я ведущий разработчик для большой компании, мы делаем 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);
}

Как работает этот код (я бы не добавил это объяснение в своем ответе на ленивый OP, который нужно проверять, не волнуйтесь): ((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Функция очень долго функция , которая не делает ничего другого , чем сложение двух чисел. Вы используете Aggregateфункцию LINQ, чтобы сложить все числа. Также нет необходимости приводить результат Convert.ToInt32к int, потому что он уже есть int.

Этот код - то, что ленивый ОП не поймет, что и есть намерение :-)

Баш - 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 с потерями, чтобы получить большее из двух чисел.

Pro Совет: этот алгоритм может быть дополнительно оптимизирован - возможно увеличение скорости в 2 раза, если заданные числа сначала делятся на 2.

Джава

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

Haskell

Вычисляет правильное решение за 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 - SUMMMMYYMYYMY EDITION / IBM® Javascript Enterprise SUM Solution ™

Вау, это чрезвычайно сложный вопрос, но я постараюсь ответить на него.

ШАГ ПЕРВЫЙ - TELNET Server

Сначала мы должны получить входные данные, теперь любой профессиональный и корпоративный кодер (например, я) должен знать, что лучший способ получить входные данные - это настроить сервер 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функцию.

Теперь пользователю нужно будет ввести «СУММА». После этого будет предложено ввести их 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 ™ в эти дни;).

И вот доказательство того, что все работает:
(CLICKABLE)

Вот решение для 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, поэтому на самом деле очень сложно реализовать правильное, быстрое и масштабируемое решение для добавления. К счастью для вас, я разработал скайнет 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);
    }

}

Если это достаточно хорошо для Пеано, это достаточно хорошо для всех.

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 ++ - числа Пеано с шаблонным метапрограммированием (с необязательным doge)

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

В конце Натуральное число - это просто Ноль или другое натуральное число, увеличенное на единицу. Эти так называемые числа Пеано являются хорошим способом представления чисел и выполнения расчетов.

Если вам нравится 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") {}

«Напишите функцию, которая вводит и возвращает их сумму».

Хорошо:

public static String inputAndReturnTheirSum () {
    System.out.print («Введите их сумму:»);
    вернуть новый сканер (System.in) .nextLine ();
}

Java или C-стиль. Это O (log n). Примечание: это не работает для отрицательных а или б.

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

Идеальная демонстрация здесь.

Bash с 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. Это должно быть весело смотреть! Но я планирую использовать Mahout для этого в будущем (хотя я люблю кошек).

Это должно быть самое масштабируемое решение, которое вы получите для этого вопроса. Тем не менее, я могу представить, что рекурсивное решение Hadoop намного элегантнее.

Проигнорируйте всех тех глупых людей с их неуниверсальными и непроверяемыми манерами. Нам нужна мощная, расширяемая и простая библиотека для проекта такого масштаба. Он должен поддерживать расширение и подстановку в каждой точке кода. Для этого нам нужен одинаково расширяемый и простой язык, поэтому лучшим кандидатом является C # .

Вот почему я представляю вам бета-версию моего Operable Commons Library Enterprise Edition, версия 0.8.4.4_beta1.3a_rev129857_dist29.12.13 / master , которая в этой версии предоставляет IOperableинтерфейс, IAddableинтерфейс, чтобы вы могли использовать свои собственные эффективные методы добавления, и реализация по умолчанию IAddable:Addableкласс, который использует чрезвычайно эффективное побитовое сложение, без мошенничества и используя медленное собственное вычитание для переноса переноса. Конечно, как и любая хорошая библиотека, она поставляется с фабрикой для каждого поддерживаемого типа. Библиотека также следует принципам «сделай сам», поэтому вы должны гарантировать, что ввод действителен и что желаемый вывод возможен, так как он не будет проверять недействительные данные. Вот оно (этот код лицензирован по проприетарной Dont-Touch-This Obstructive лицензии Microsoft Corporation, редакция 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 только для того, чтобы занять дополнительную память.

ДЖАВА

В приведенном ниже коде ... обозначает код, который мне было лень писать, но вы должны быть в состоянии разобраться. Чтобы действительно сделать это в стиле, потребуется программа генерации кода. Пределы 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;
       }
}

функция, которая вводит и возвращает их сумму

Lua

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

ДЖАВА

Сложная проблема.

Известно, что в информатике существуют проблемы, которые позволяют проверить их ответы легче, чем найти их. Таким образом, вы должны использовать случайный алгоритм для угадывания решения, затем проверить его (эффективно!) И надеяться получить правильный результат в разумные сроки:

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

где рутина 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);
}

Вы должны сначала скомпилировать код C (например, gcc -c mycfile.c), затем скомпилировать код Fortran (например, gfortran -c myf90file.f90), а затем сделать исполняемый файл ( gfortran -o adding myf90file.o mycfile.o).