如何编写加法函数?[关闭]


42

问题:

我是一家大公司的首席开发人员,我们正在制造天网。我已经分配给

编写一个输入并返回其总和的函数

规则: 没有类似的答案

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

编辑:接受的答案将是2014年1月1日投票最多的人

注意:这是一个询问问题。请不要认真对待问题和/或答案。更多信息在这里


31
您可以使用我的轻量级jQuery插件:$.sum=function(a,b){return a+b};
Blender 2013年

5
我知道我会在某个时候获得jQuery参考
scrblnrd3 2013年

5
精采

5
问题建议(不确定是否有什么好处):“ GUILP HALP,我需要一种快速算法来生成比特币区块!!!!!

5
这些答案相当复杂。我建议打开与数据库的连接并发出'SELECT ' + a + ' + ' + b + ';'。简单易懂。
Nick Chammas

Answers:


69

那是一个非常复杂的问题!这是在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))) | ajust返回just a((b ^ (a < 0 ? b : a)) & ((b - a) - (b - a))) | b返回just b

6755 & 1436返回0,因此在循环中i实际上以val​​ue开头0,然后在循环中将值添加1到列表中。因此,如果ais 5bis 3,则将值1添加到列表中8次。

importantCalculation函数是一个很长的函数,除了将两个数字相加外,别无其他。您使用LINQ Aggregate函数将所有数字相加。也不必将结果Convert.ToInt32转换为int,因为它已经是int

这段代码是懒惰的OP无法理解的,这正是意图:-)


11
我-= -1。非常有创意。我今天已经达到投票上限,但我会尽快支持您的回答。
Victor Stafusa 2013年

只要您坚持认为6755 & 1436未定义的行为以外的任何其他行为,尽管OP认为大多数数字似乎都有效……
Trojan

'=>'是什么意思?
伊利亚·加兹曼

2
@Babibu我一生中从未写过C#行,但这几乎可以肯定是lambda表达式。
2013年

3
哦,var x = Sum(0, 4)DivideByZeroException。
菲利普·斯科特·纪梵斯

60

重击-72字节

有时,传统的确定性加法过于精确,而且速度过快-有时您需要给CPU休息一下。

介绍有损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倍。


5
拖钓1:它可以工作,但速度很慢,使用系统计时器等待总时间。因此,较大的数字线性增加需要更长的时间。拖钓2:它甚至适用于浮点运算,但答案始终相差不大。拖钓3:免费和不必要地使用grep,cut和tr。拖钓4:任何总数超过60(秒)的操作均未正确处理。
暴动

4
@Shingetsu:什么,您是说没有人听说过mp3编解码器?:P
骚乱

7
我是说很少有人真正参加该协会。me脚虽然la脚。Vorbis大师赛。

7
+1大规模偏离主题的音频编码器大战:)
骚乱

1
我相信下面的我的Bash-Hadoop版本更加强大和可扩展!!!!!但是我必须说,我真的很喜欢您的版本,sleepadd很棒!+1
Anony-Mousse

40

爪哇

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

基本上,这将写入一个文件,其字节数应等于实际的总和。写入文件后,它会向磁盘文件表询问该文件的大小。


1
可以write还是flush扔?在我看来,您应该flush进入每个循环,并将整个内容包装在try-catch中,以便在写入失败或刷新失败时重试写入。
安东·戈洛夫

3
我建议您使用具有默认字符编码的编写器,而不要使用流。然后,在您选择的字符编码成多个字节的系统上,它可能会中断。
Buhb 2013年

33

C

在量子世界中,您不能依赖原子运算符,例如+,这是我在量子计算方面的加法实现:

#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

2
+1,尽管对于代码拖曳来说太可读了……
Marc Claesen 2014年

29

哈斯克尔

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适用的修整器遍历列表,计算多项式的乘积,最后在末尾提取适当的系数,从而计算出总和。


24

您要添加数字吗?您知道这是一个非常复杂的操作吗?好吧,另一方面,您是首席开发人员,您将不得不面对这样的问题。

这是我能找到的最简单的解决方案:

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

不要沦为运算符“ +”的猎物,这是完全无效的。随意转向“转向”运算符,或将其用于较小的数字而变得更大。


21

NODE.JS-SUMMMMYYMYYMY版/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

现在是时候创建我们的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解决方案。始终使用TELNET电源!
首先,您输入SUM。
然后,服务器将询问您要添加的号码,您可以这样输入:a, b, c, etc..

相信我,这几天所有的僵尸网络都在使用IBM®Javascript Enterprise SUM Solution™;)。

这证明一切正常:(可
求和点击)


2
您介意在屏幕截图中告诉我您正在使用什么IDE吗?Visual Studio并没有给我语法突出显示功能
Joe the Person

1
@JoethePerson:这不是一个IDE,只是一个定价过高的文本编辑器,称为“ Sublime Text”。
Apache

1
像Shiki一样,@ JoethePerson表示它的文本编辑器更加精美,并且具有免费版本,请参见此处:sublimetext.com
C1D

@Shiki,我同意你的观点,几天前我下载了LightTable,但由于我一直很忙,所以我还没有打开它。
C1D

19

这是适合您的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);
   }
}

12
替换return sum(a-number, b+number);return sum(sum(a,-number), sum(b,number));。你必须自己吃狗粮吗?
2013年

@emory:我想那行不通。
Martijn Courteaux

@MartijnCourteaux该程序有一个危险的缺陷-它是一个公然的巨魔。如果有人问什么是b+number,那么很显然,整个方法是不必要的。最好对此进行混淆。加上它会使其变慢。
2013年

@emory:好的,我测试了它,显然可以正常工作。太好了:)
马丁·考特

14

C-过度杀戮是最好的杀戮

计算机只有0和1,因此要添加一个正确,快速和可扩展的解决方案实际上非常困难。幸运的是,我开发了天网0.1284a,所以我知道如何解决这个危险的问题。
通常,您需要购买C标准库DLC,因为核心不包含它,但是我设法“欺骗”了它。简而言之,这是最便宜,最有效的方法。

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

看看吧。显然是邪恶的。


3
OP的注意事项:您可能可以避免EXDI DIMENTIONAL RIFT,但是您将不得不从事量子物理学的研究,而您并不想这样做。

14

蟒蛇

使用数学标识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

不适用于python3 @ Ubuntu
s3lph 2013年

1
@the_Seppi效果很好。只需添加from functools import reducepython3。
Bakuriu 2013年

13

C#

您应该使用递归来解决您的问题

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

}

如果对Peano足够好,那么对每个人都足够好。


2
我只是想给出这个答案。IMAO这个和sleepadd一个到目前为止是最好的答案,因为其他不必要的复杂。这些仍然是完全没有用的,但是简短而优雅。通过添加随机复杂度来使其变得毫无用处太容易了(因此很无聊)。
o0'。

1
推理是完美的!
recursion.ninja 2014年

它不应该是++a不是a++(编辑必须至少为6个字符,是否有别的东西在这个岗位,以改善?)蠢蠢蠢蠢SO
O0' 。

@Lohoris-是的,是的。已修正
Haedrian 2014年

9

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

1
拖钓1:这实际上是有效的,并且是加号的有效方法-与硬件的处理方式相差不远。但是,倒计时使用减法,因此根本不是纯粹的按位解决方案。拖钓2:要求以位为单位指定精度;不正确的精度会导致无意义的答案。拖曳3:“下至”运算符。
暴动

添加一些内联汇编器!
Kiruse

8

到目前为止,我最好的解决方案是给出一个非常难以理解的答案,直到您运行 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;

}

3
读这篇文章使我的眼睛流血。+1

它返回什么?我不太喜欢运行此程序。
Martijn Courteaux

对于那些不想运行的程序aVeryLargeNumber():它返回1。(如果OP对我执行ping操作,我将删除它。)
apnorton 2013年

7

C ++-具有模板元编程的Peano数字(具有可选的总督)

就像许多其他编程语言一样,C绝对没有理由使事情复杂化。这些语言中最复杂的系统之一是自然数。C痴迷于二进制表示形式和所有其他完全无用的细节。

最后,自然数只是零,或者是其他自然数加一。这些所谓的Peano数是表示数字和进行计算的好方法。

如果您喜欢总督,我已经写了一个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 );
}

要进一步增加此方法的优越性:数学是在编译时完成的!不再有速度慢的程序,您的用户不想等待您对这些数字求和。

对于重要的部分:

  • 我认为我不必这么说,但这完全是荒谬的。
  • 仅适用于编译时间常数。
  • 不适用于负数。
  • 答案是由一个实际上无法自己模板元程序的人提供的,所以我什至不知道它是否还有其他缺陷。

我的朋友告诉我要验证代码,所以我做到了。这很有趣,但是我认为这完全是愚蠢的,因此,我仅将其作为链接包含在内,这与事实相去甚远。


1
哇。这样的总督。非常赞。
马克·克莱森

6

当我了解浮点错误时,我不再信任计算机。

此JavaScript依靠精确的人为错误检查:

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

5

“编写一个输入并返回其总和的函数。”

好:

公共静态字符串inputAndReturnTheirSum(){
    System.out.print(“输入其总和:”);
    返回新的Scanner(System.in).nextLine();
}


这是我最喜欢的。:D
Jeroen Bollen 2014年

4

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

Ideone演示在这里。


4

Bash与Hadoop流

显然,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;}'

另外,此方法还涉及a cat和a wc。看着这应该很有趣!但是我计划将来将Mahout用于此用途(尽管我喜欢猫)。

这必须是您针对此问题获得的最具扩展性的解决方案。但是,我可以想象到,递归Hadoop解决方案要优雅得多。


1
我肯定在您的答案中看到了一个主题。+曳引点,因为这需要hadoop才能工作,并且如果未设置$ HADOOP_HOME,则会非常混乱地失败。
暴动

4

忽略所有那些愚蠢的人,他们的举止都是非常规和不可测的。对于这种规模的项目,我们需要高性能,可扩展且简单的库。它必须在代码的每个点都支持扩展和替换。为此,我们需要同样可扩展且简单的语言,这就是为什么最佳候选者是C#的原因

这就是为什么我向您介绍我的Operable Commons Library Enterprise Edition的Beta版本,版本0.8.4.4_beta1.3a_rev129857_dist29.12.13 / master,在此版本中,它公开了一个IOperable接口,一个IAddable接口,以便您可以使用自己的有效添加方法,以及默认实现IAddableAddable类,使用非常有效的按位加法,而不作弊,并使用慢速本机减法进行进位移位。当然,就像任何好的库一样,它也为每种支持的类型提供了一个工厂。该库还遵循“自己处理”的原则,因此,您必须保证输入是有效的,并且所需的输出是可行的,因为它不会检查无效数据。就是这样(此代码已获得Microsoft Corporation只读专有的Dont-Touch-此阻塞性许可证,修订版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);
    }
}

4

的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));
  • 首先,作为首席开发人员,让我们有一个明智的语言选择-跨平台,轻巧和可移植。

  • 其次,要有全球视野。使用全局变量。

  • 第三,++和--s

  • 与YFS(You-Finger-System)相同,不支持负数

  • 最后,您可以FINGER_NUMBER根据手指的数量进行更改。

JSFiddle:http : //jsfiddle.net/e3nc5/


但是,如果您需要数超过10,该怎么办?我没有三只手!
AJMansfield 2014年

修补程序:用脚最多可以做20个。
大卫

3

TI基本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

3

好吧,这有点棘手。幸运的是,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

评论摘自Watterson

故意使用慢Image.getpixel()。我不确定darnitall 实际上是否足够慢。RGBA只是占用额外的内存。


3

爪哇

在下面的代码中,...代表我懒得编写的代码,但是您应该可以弄清楚。要真正做到这一点,就需要一个代码生成程序。限制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;
       }
}

2

输入并返回总和的函数

a

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

2

代码完成。对此要非常小心。该代码非常复杂,很可能会成为有智能意识和自我意识的人。这是高度机密的绝密代码。

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

2

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

2

爪哇

难题。

众所周知,在计算机科学中,存在的问题是验证答案要比找到答案容易。因此,您应该使用随机算法来猜测解决方案,然后(有效地!)对其进行验证,并希望在合理的时间内获得正确的结果:

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

添加语言名称
Wasi 2013年

2

此功能已获得我公司的专利保护,我可以为您提供模糊的许可副本:

Javascript:

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

用法:

sum([arg1],[arg2]);

2

蟒蛇

编程是关于容错的。以下是sum的实现,它将不加麻烦地添加任何内容。它将按照可以添加的顺序对元素进行透明排序。如果它不是可加的,它将标记为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]]

1

Fortran

显然,最有效的方法是移位您的位。这可以通过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)。

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.