以前有很多“不做__ _ __的挑战”，但我希望这是最具挑战性的挑战之一。

挑战

您将要编写一个程序，该程序从STDIN中获取两个自然数（整数> 0），并将两个数字的和输出到STDOUT。我们面临的挑战是，你必须尽可能少的使用+和-迹象可能。不允许使用任何类似求和或求反的函数。

例子

输入

123
468

输出

591

输入

702
720

输出

1422

抢七局： 如果两个程序的+和-字符数相同，则获胜者是人数/ * ( ) = . ,和0-9字符少的人。

不允许：标准加/减和增/减运算符是除+或-不允许的符号之外的语言。这意味着不允许使用空白语言。

Perl（无+/-，无平局，29个字符）

s!!xx!;s!x!$"x<>!eg;say y!!!c

另外，您可以通过向加上更多xs来使代码对两个以上的数字求和s!!xx!。

另外，这里有两个21字符的解决方案，分别带有1个和3个决胜局

say length$"x<>.$"x<>

say log exp(<>)*exp<>

注意：这些解决方案使用say自Perl 5.10.0起具有-E命令行开关或的功能use 5.010。有关适用于较早Perls的版本，请参见此答案的编辑历史记录。

没有决胜局的解决方案如何工作？

• s!!xx!是regexp替换运算符，默认情况下对$_变量进行操作，该变量用string替换空字符串xx。（通常/被用作Perl的正则表达式的分隔符，但也可以使用真正的几乎任何字符我选择，!因为它不是一个决胜）。这只是前面加上一个奇特的方式"xx"来$_-或者，因为$_开始是空的（不确定的，实际上），这实际上是一种$_ = "xx"无需使用等号（也减少了一个字符）的书写方式。

• s!x!$"x<>!eg是另一种regexp替换，这次是用expression的值替换每个xin 。（该开关指定全局替换，指定替换将作为Perl代码而不是文字字符串求值。） 是一个特殊变量，其默认值恰好是单个空格；使用它而不是保存一个字符。（任何其他已知的具有一个字符值的变量，例如或，在这里同样适用，除​​了使用会花费我一个平局。） $_$" x <>ge$"" "$&$/$/

  在<> 线路输入操作者，在标量上下文，从标准输入读取并返回它一行。在x之前，它是Perl的字符串重复操作符，而真的是该解决方案的核心是：它返回其左操作数（单个空格字符）重复其右操作数给定的次数（线我们只是作为输入读取）。

• y!!!c只是（转译）使用音译运算符对字符串中的字符进行计数的一种晦涩方式（$_默认情况下，也是）。我本来可以写的say length，但是混淆版本短了一个字符。:)

R（24个字符）

length(sequence(scan()))

这是做什么的：

• scan 从STDIN（或文件）读取输入
• sequence生成从1开始的整数序列并连接这些序列。例如，sequence(c(2, 3))得出向量1 2 1 2 3
• length 计算级联向量中的元素数

范例1：

> length(sequence(scan()))
1: 123
2: 468
3:
Read 2 items
[1] 591

范例2：

> length(sequence(scan()))
1: 702
2: 720
3:
Read 2 items
[1] 1422

d

main(){
    int a,b;
    readf("%d %d",&a,&b);
    while(b){a^=b;b=((a^b)&b)<<1;}
    write(a);
}

赢了一下

另外，编译后的代码不包含加法运算（尽管不能代表readf调用）

Python 2，43个字节

print len('%s%s'%(input()*'?',input()*'!'))

高尔夫脚本

没有+/-或决胜局：

# Twiddle some bits to get a few small integers
[]!~abs:two~abs:three!:zero~:minusone;

~[two base minusone%\two base minusone%]zip
zero:c;
{
    # Stack holds [x y] or [x] with implicit y is zero
    # Half adder using x y c: want to end up with sum on stack and carry back in c
    [~c zero]three<zero$
    ~^^\
    $~;:c;;
}%
[~c]minusone%two base

具有两个平局角色的简单得多的版本，使用与其他人相同的列表串联技巧：

~[\]{,~}%,

我假设GolfScript不具有)作为增量运算符的资格，因为我实际上并未使用它。

C（仅32位）

int main(int ac, char *av) {
    scanf("%d\n%d", &ac, &av);
    return printf("%d\n", &av[ac]);
}

指针算法也一样。
它如何符合要求？
*无+或-
*号/，=，.，0- 9
*仅3对括号的，这似乎是我最小的（你需要main，scanf，printf）。
*一个*（指针方法需要它）。
*四,（可以通过定义普通变量来节省一个，而不是ac,av）

C ++ 0 +/-，3个决胜局

#include <vector>
#include <iostream>

#define WAX (
#define WANE )
#define SPOT .

int main WAX WANE {
    unsigned x;
    unsigned y;
    std::cin >> x >> y;
    std::vector<int> v WAX x WANE;
    std::vector<int> u WAX y WANE;
    for WAX auto n : u WANE {
        v SPOT push_back WAX n WANE;
    }
    std::cout << v SPOT size WAX WANE;
}

Haskell，0 + 2

import Monad
main = join $ fmap print $ fmap length $ fmap f $ fmap lines getContents
f x = join $ flip replicate [] `fmap` fmap read x

这不使用+或-字符，并且=在决胜局字符集中仅使用两个，其中一个对于绑定是必需的main。通过连接适当长度的列表来完成总和。

编辑这是在规则更改为禁止之前发布的sum...

R语言：没有呼叫+或-...还有9个抢七局字符！

sum(as.numeric(readLines(n=2)))

例：

> sum(as.numeric(readLines(n=2)))
123
456
[1] 579

的[1] 579答案是579（的[1]是跟踪你都在结果矢量，其中自R中的所有值都是矢量-在这种情况下长度为1）

请注意，R +像大多数语言一样具有运算符-碰巧它也sum具有一堆矢量。

在这种情况下，readLines返回长度为2的字符串向量。然后将其强制为数字（双精度）并将其求和...

只是为了展示R的其他功能：

> 11:20 # Generate a sequence
 [1] 11 12 13 14 15 16 17 18 19 20

> sum(1:10, 101:110, pi)
[1] 1113.142

R语言

新规则，新答案，相同语言。没有电话到+或-

更新使用scan，它将下降到11个决胜局字符（总共27个字符）。

as.numeric(scan())%*%c(1,1)

原文：13个决胜局角色！

as.numeric(readLines(n=2)) %*% c(1,1)

例：

> as.numeric(readLines(n=2)) %*% c(1,1)
123
456
     [,1]
[1,]  579

这次通过矩阵乘法获得了结果。答案显示为1x1矩阵。

Haskell，0 +/ -，6 2决胜局（=）

（不使用字符串/列表串联技巧）

main = interact f
f x = show $ log $ product $ map exp $ map read $ lines x

Javascript，56

p=prompt;alert(Array(~~p()).concat(Array(~~p())).length)

感谢~~提示中的@JiminP！我要去最少的字节，所以在p = prompt上节省了1个字节；仍然值得。我了解您关于抢七局字符的说法，但是老实说，您不是宁愿最少的字节数：-p

版本69

i=parseInt;p=prompt;alert(Array(i(p())).concat(Array(i(p()))).length)

感谢@Ilmari和@JiminP的一些反馈，我将原来的解决方案减少了13个字节。

原来是82

i=parseInt;p=prompt;a=Array(i(p()));a.push.apply(a, Array(i(p())));alert(a.length)

C

b[500];i;j;main(){scanf("%d%d",&i,&j);printf("%d\n",sprintf(b,"%*s%*s",i,"",j,""));

APL（无+/-，无平局，8或10个字符）

该条目类似于将输入生成的序列连接起来并找到长度的其他条目...但是它在APL中，即使对于像这样的小问题，也可能会造成混淆。我使用了Dyalog APL，它提供了免费的教育许可证。

码：

⍴⊃⍪⌿⍳¨⎕⎕

从右到左：

• 每个引用四进制（⎕）请求用户输入并进行评估。
• 每个运算符（¨）将索引生成器函数（ ⍳）应用于右侧数组中的每个项目。
• 这将数组的结果数组展平为一个数组。归约运算符（/）将输入数组归约为一个平面列表，后者使用串联函数（,）折叠该数组。为了解决这一难题，使用了一维归约运算符（⌿）和沿着第一轴（⍪）的串联运算符。
• 由于使用了归约运算符，数组被封闭了，就像将其放在包中一样。我们在外面看到的只是一个袋子，而不是里面的东西。公开运算符（⊃）向我们提供了封闭数组（袋子）的内容。
• 最后，shape-of函数（⍴）提供了数组维的长度。在这种情况下，我们有一个一维数组，因此我们获得了数组中的项数，这就是我们的结果。

如果我们需要显式输出结果，可以这样进行：

⎕←⍴⊃⍪⌿⍳¨⎕⎕

可比较的Python代码，上面带有相应的APL符号：

import operator

⎕←     ⍴    ⌿        ⍪                 ¨              ⍳                ⎕        ⎕         ⊃
print (len (reduce (operator.__add__, [map (lambda n: range (1, n+1), [input(), input()])][0])))

我想知道APL中是否可能有一个较短的版本-我想出的另一个更简单的版本有更多的决胜局（尽管仍然是8个字符）是：⍴(⍳⎕),⍳⎕。

我没有看到有人用电气工程的方式来做的，所以这是我的看法（用红宝石表示）：

def please_sum(a, b)
    return (a&b !=0)? please_sum( ((a&b)<<1) , a^b ):a^b
end

这有点难看，但可以完成工作。将这两个值按位进行比较AND。如果它们没有任何共同点，则在下一个二进制列中没有“进位”，因此可以通过按位将XOR它们加法完成。如果有进位，则必须将进位添加到按位XOR。这是我用来确保我的数字逻辑不会太生锈的一个红宝石脚本：

100.times do
    a=rand 10
    b=rand 10
    c=please_sum(a,b)
    puts "#{a}+#{b}=#{c}"
    end

干杯!

种子，3904 3846 11字节，0 +/-，10个决胜局

4 141745954

壳牌52

read a
read b
(seq 1 $a;seq 1 $b)|wc|awk '{print$1}'

这与我针对另一个问题给出的答案基本相同。

C

a,b;A(int a,int b){return a&b?A(a^b,(a&b)<<1):a^b;}
main(){scanf("%d%d",&a,&b);printf("%d\n",A(a,b));}

C＃

这绝不是最短的：

private static int getIntFromBitArray(BitArray bitArray)
{
    int[] array = new int[1];
    bitArray.CopyTo(array, 0);
    return array[0];
}

private static BitArray getBitArrayFromInt32(Int32 a)
{
    byte[] bytes = BitConverter.GetBytes(a);
    return new BitArray(bytes);
}

static void Main(string[] args)
{
    BitArray first = getBitArrayFromInt32(int.Parse(Console.ReadLine()));
    BitArray second = getBitArrayFromInt32(int.Parse(Console.ReadLine()));
    BitArray result = new BitArray(32);

    bool carry = false;
    for (int i = 0; i < result.Length; i++)
    {
        if (first[i] && second[i] && carry)
        {
            result[i] = true;
        }
        else if (first[i] && second[i])
        {
            result[i] = false;
            carry = true;
        }
        else if (carry && (first[i] || second[i]))
        {
            result[i] = false;
            carry = true;
        }
        else
        {
            result[i] = carry || first[i] || second[i];
            carry = false;
        }
    }
    Console.WriteLine(getIntFromBitArray(result));
}

J，15个 7字符，1个平局手，程序不完整

这是我的J尝试。它不是一个完整的程序，因为我还没有弄清楚如何编写一个程序。只需将这一行放在脚本中即可获得p可用于添加任意数量的数字的函数。它是单声道，并带有要添加的数字列表（例如p 1 2 3 4）：

p=:#@#~

这个想法很简单。该函数以默认的无意义样式编写。这是一个明确的定义：

p=:3 :'##~y'

从右到左阅读。在默认版本中，@组成功能的各个部分。（如数学[[f∘g）（x）= f（g（x）]中的）））

• y是的参数p。
• ~使动词反身。对于某些动词m，m~ a等于a m a。
• #（复制a#b）：中的每个元素都会a被复制i一次，其中i的元素与的当前元素位于相同的索引a处b。因此，#~复制一个项目n n时间。
• #（count，#b）：计算中的元素数b。

结论：J比Perl糟糕，可读性差（这使其更加糟糕）

编辑

• 15-> 7使用#代替i.。是的 字符少于golfscript。

更多程序

这个查询输入，但是它仍然不是一个完整的程序：（13个字符，3个断路器）

##~".1!:1<#a:

Javascript（17个决胜局字符）

eval('걢갽거걲걯걭거건갨걡갽거걲걯걭거건갨걹갽걦걵걮걣건걩걯걮갨걡갩걻걣갽걮걥걷갠걕걩걮건갸걁걲걲걡걹갨걡갩갻걦걯걲갨걩갠걩걮갠걣갩걩걦갨걩갽갽걾걾걩갩걸갮거걵걳걨갨갱갩걽갬걸갽걛걝갩갩갻걹갨걡갩갻걹갨걢갩갻걡걬걥걲건갨걸갮걬걥걮걧건걨갩갻'['split']('')['map'](function(_){return String['fromCharCode'](_['charCodeAt'](~~[])^0xac00)})['join'](''))

：P（“混淆”以减少平局字符的数量。内部为 b=prompt(a=prompt(y=function(a){c=new Uint8Array(a);for(i in c)if(i==~~i)x.push(1)},x=[]));y(a);y(b);alert(x.length); 。）

C＃，

程序工作在1行上；多行分开，以避免水平滚动。

using C=System.Console;
class A{
static void Main(){
int a,b,x,y;
a=int.Parse(C.ReadLine());
b=int.Parse(C.ReadLine());
do{x=a&b;y=a^b;a=x<<1;b=y;}while(x>0);
C.WriteLine(y);
}}

Clojure（44个字符）

(pr(#(count(concat(%)(%)))#(repeat(read)0)))

编辑：修复了在STDOUT上打印而不仅仅是返回总和的问题。

斯卡拉

• 得分：
  • +-：0
  • （）。：5 + 5 + 3 = 13

码：

(List.fill (readInt) (1) ::: List.fill (readInt) (2)).size

• List.fill（4）（7）产生List（7、7、7、7）
• a ::: b将2个列表连接成一个
• 其余的应该很明显

K，11

{#,[!x;!y]}

与R解决方案相同的串联技巧。从右到左阅读：枚举两个输入变量，并置然后计数。

PowerShell中，27 42个字节，0 +-，4 1副

^{感谢mazzy保存了a +和4个次级}

$args|%{[int[]]$_*$_}|measure|select count

在线尝试！或Pretty Table额外的3个字节

-或者-添加四个辅助节点以节省19个字节：

32 23个字节，1 0 +-，12个 5次级

^{-9个字节，感谢mazzy}

($args|%{,$_*$_}).count

在线尝试！

对于每个参数，我们将n数组元素（由组成，[n]但不重要）推入管道，并由括号将其分组然后计数。

小桶（小桶Wiki上的SBCS）

基本上是R答案的端口。

¿¿Ï_"Ï_!.

说明

¿¿#        Take 2 integer inputs
  Ï_"Ï_#   Generate 2 arrays the length of the integer inputs
       !.# Output the length of the stack

05AB1E，2 4字节，0 +/-

F>

在线尝试！

如果我误解了这个挑战，我深表歉意，但是我很惊讶没有05AB1E的答案。我能用这种语言给出的最短答案不使用+或内置的sum函数。

说明：

 F   #Loop A many times
  >  #Increment B
     #(Implicit output)

-2字节感谢Grimy。

Python 3

无需依赖其他函数中的隐藏求和。

h=input;x,y=int(h()),int(h())
while y:c=x&y;x^=y;y=c<<1
print(x)

在线尝试！

d

main(){
    int a,b;
    readf("%d %d",&a,&b);
    write((new int[a]~new int[b]).length);
}

这次使用数组长度