これまでに「Do __ without _ _」という課題が数多くありましたが、これが最も難しい課題の1つであることを願っています。

チャレンジ

STDINから2つの自然数（全数> 0）を取得し、2つの数の合計をSTDOUTに出力するプログラムを作成します。課題は、できるだけ少ない数+と-標識を使用する必要があることです。和のような関数や否定関数を使用することはできません。

例

入力

123
468

出力

591

入力

702
720

出力

1422

タイブレーカは： 2つのプログラムが同じ数のを持っている場合+や-文字、勝者が少ないと、人である/ * ( ) = . ,と0-9の文字。

許可されていない：標準の加算/減算演算子とインクリメント/デクリメント演算子が、許可されていない+または-許可されていない記号である言語。これは、言語の空白を許可しないことを意味します。

Perl（+/-、タイブレーカーなし、29文字）

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

ボーナスとして、にxsを追加することで、コードの合計を3つ以上の数字にすることができs!!xx!ます。

あるいは、ここにそれぞれ1つと3つのタイブレーカーを持つ2つの21文字のソリューションがあります

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

say log exp(<>)*exp<>

注：これらのソリューションは、sayPerl 5.10.0以降、-Eコマンドラインスイッチまたはで使用可能な関数を使用しuse 5.010ます。古いperlで動作するバージョンについては、この回答の編集履歴をご覧ください。

タイブレーカーのないソリューションはどのように機能しますか？

• s!!xx!は、デフォルトで変数を操作する正規表現置換演算子で$_、空の文字列をstringに置き換えますxx。（通常は/Perlで正規表現の区切り文字として使用されますが、実際にはほとんどの文字を使用することができます私は選んだ。!それがタイブレーカではありませんので、。）これは前に付けるだけの空想の方法です"xx"に$_-または、以来、$_未定義の空のアウトを開始し（、実際）、それ$_ = "xx"は等号を使用せずに（そして1文字も少なく）書く方法です。

• s!x!$"x<>!eg別の正規表現の置き換えで、今回は各xin $_を式の値に置き換えます$" x <>。（このgスイッチは、グローバル置換をe指定し、置換がリテラル文字列として使用される代わりにPerlコードとして評価されることを指定します。） $"は、デフォルト値がたった1つのスペースである特別な変数です。" "1文字を節約する代わりに使用します。（$&or などの1文字の値を持つことが知られている他の変数は、$/使用$/するとタイブレーカーの費用がかかることを除いて、ここでも同様に機能します。）

  スカラーコンテキストの<> 行入力演算子は、標準入力から1行を読み取り、それを返します。そのx前はPerl 文字列の繰り返し演算子であり、実際にこのソリューションの中核です：右オペランド（入力として読み取った行）で指定された回数だけ繰り返した左オペランド（単一のスペース文字）を返します。

• y!!!cこれは、文字変換演算子を使用して文字列内の文字を数える（ab）ための（あいまいな）方法$_です（デフォルトで再度）。書いたばかりかもしれませんsay lengthが、難読化されたバージョンは1文字短くなっています。:)

R（24文字）

length(sequence(scan()))

これが何をするか：

• scan STDIN（またはファイル）から入力を読み取ります
• sequence1から始まる整数シーケンスを生成し、シーケンスを連結します。たとえば、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()*'!'))

GolfScript

+/-またはタイブレーカーなし：

# 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

他の人が使用しているのと同じリスト連結のトリックを使用した、2つのタイブレーカー文字を使用したはるかに単純なバージョン：

~[\]{,~}%,

GolfScriptは)、実際には使用していないため、インクリメント演算子としての資格を失っていないと想定しています。

C（32ビットのみ）

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

ポインター演算も同様に優れています。
要件とどのように一致しますか？
* NO +または-
* NO /、=、.、0- 9
最小限の私には思えるの括弧の*のみ3組、（あなたが必要としますmain、scanf、printf）。
* 1つ*（ポインターアプローチでは必要です）。
* 4 ,（ではなく、通常の変数を定義することで1つを保存できます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

これは、全く使用しない+か、-文字、および2つだけの=タイ・ブレーカー文字の集合、結合のために必須であるのいずれかから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言語

新しいルール、新しい答え、同じ言語。への呼び出し+または-

UPDATEを使用すると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を使用しました。

コード：

⍴⊃⍪⌿⍳¨⎕⎕

右から左へ：

• 各クォートクアッド（ ⎕）は、ユーザーからの入力を要求し、評価します。
• 各演算子（ ¨）は、インデックスジェネレーター関数（ ⍳）を配列内の各項目の右側に適用します。
• これにより、結果の配列の配列が1つの配列にフラット化されます。入力配列は、縮小演算子（/）によってフラットリストに縮小されます。縮小演算子は、連結関数（,）を使用して配列を折りたたみます。この課題のために、1次元の縮小演算子（⌿）が、最初の軸に沿った連結演算子）とともに使用され⍪ます。
• リダクション演算子を使用した結果、配列は囲まれます。これは、バッグに配置するようなものです。外側に見えるのは、中身ではなくバッグです。開示オペレーター（⊃）は、囲まれた配列（バッグ）の内容を提供します。
• 最後に、shape-of関数（⍴）は配列の次元の長さを示します。この場合、1次元配列があるため、配列内のアイテムの数を取得します。これが結果です。

結果を明示的に出力する必要がある場合は、次のようにできます。

⎕←⍴⊃⍪⌿⍳¨⎕⎕

上記の対応するAPLシンボルを使用した、同等のPythonコード：

import operator

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

：、別の私は（8つの文字ではまだあるが）よりタイブレーカーを持っていることを思い付いた簡単なバージョンである-私はAPLで可能な短いバージョンがありますかどうかを知りたいのです⍴(⍳⎕),⍳⎕。

私は誰もそれを電気工学の方法で行うのを見ていませんでしたので、ここに私のルビーがあります：

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

それは少しいですが、仕事を終わらせます。2つの値はビット単位で比較され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。
• #（copy、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つのリストを1つに連結します
• 残りは明白であるべきです

K、11

{#,[!x;!y]}

Rソリューションと同じ連結トリック。右から左へ読む：2つの入力変数を列挙し、連結してからカウントします。

PowerShellの、27 42バイト、0 +-、4 1セカンダリ

^{1つと+4つのセカンダリを保存してくれたmazzyに感謝}

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

オンラインでお試しください！または3バイト余分なプリティテーブル

-または-4つのセカンダリを追加して19バイトを節約します。

32 23バイト、1 0 +-、12 5セカンダリ

^{-9バイト、mazzyのおかげ}

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

オンラインでお試しください！

引数ごとに、n配列要素（構成は[n]重要ですが、重要ではありません）をパイプラインにプッシュします。パイプラインは、括弧でグループ化されてからカウントされます。

Keg（Keg 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>

オンラインでお試しください！

この挑戦を誤解してしまったことをおologiesびしますが、05AB1Eの回答がなかったことに驚きました。この言語での最短の答えは、+または組み込みのsum関数を使用しないことです。

説明：

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

-Grimyのおかげで2バイト。

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

今回は配列の長さを使用します