問題：

目標は、次の数学演算子を使用せずに2つの入力数値を追加することです+,-,*,/。

また、これらの数学演算子を置き換えるように設計された組み込み関数は使用できません。

得点：

最小のコード（バイト数）が優先されます。

更新

私が見たプログラムのほとんどは、番号を含む2つの配列を連結するかfirst number、文字で構成し、文字を追加second numberしてからすべてをカウントします。

最短配列カウンター：8文字のAPL、Tobia著

最短配列連結：Doorknobによる4文字のGolfscript

最短対数ソリューション：Quincunxによる19文字のTI-89 Basic

統合ソリューション：45文字のMathematica、マイケル・スターン

クールな、私の意見では：javascriptのビット演算子、デイブ

Smalltalk、21 13

以下のすべては、正の整数でのみ機能します。深刻な問題については、他のSmalltalkの回答を参照してください。

バージョン1

大きな整数にシフトして、その高ビットインデックスを要求します（悪い、STインデックスは1ベースなので、追加の右シフトが必要です）。

(((1<<a)<<b)>>1)highBit

バージョン2

同様であり、少し短くなっています（Smalltalkの優先ルールのため、右シフトは不要です）。

1<<a<<b log:2 

バージョン3

「コレクション連結要求サイズ」テーマの別のバリエーション
。2つの数字aとbが与えられ、

((Array new:a),(Array new:b)) size

Intervalsをコレクションとして使用すると、21文字でよりメモリに優しいバージョンが得られます;-)：

((1to:a),(1to:b))size

ただし、大量の演算処理にはお勧めしません。

バージョン4

あなたの娯楽のために、時間と記憶を交換したいなら、試してください：

Time secondsToRun:[
   Delay waitForSeconds:a.
   Delay waitForSeconds:b.
]

通常は十分に正確です（ただし、保証はありません;-)））

バージョン5

ファイルに書き込み、そのサイズを尋ねる

(
    [
        't' asFilename 
            writingFileDo:[:s |
                a timesRepeat:[ 'x' printOn:s ].
                b timesRepeat:[ 'x' printOn:s ]];
            fileSize 
    ] ensure:[
        't' asFilename delete
    ]
) print

Javascript（25）

while(y)x^=y,y=(y&x^y)<<1

これは、ビット演算のみを使用して2つの変数xとyを追加し、結果をxに格納します。

これは負の数でも機能します。

C-38バイト

main(){return printf("%*c%*c",3,0,4);}

私はここで少しカンニングします、OPは数学演算子を使用しないと言いました。

*でprintf()文字を印刷するために使用されるフィールド幅を引数から取られることをフォーマット手段printf()、この場合、3および4戻り値が、printf()印刷された文字の数です。したがって' '、3のフィールド幅を持つものと4のフィールド幅を持つものを印刷すると、合計で3 + 4文字になります。

戻り値は、printf()呼び出しで追加された数値です。

Python-49バイト

変数xとに配置することで入力を想定していますy。

from math import*
print log(log((e**e**x)**e**y))

この61バイトのソリューションは完全なプログラムです。

from math import*
print log(log((e**e**input())**e**input()))

あなたがべき乗を禁止しなかったことを考慮して、私はこれを投稿しなければなりませんでした。対数のプロパティを使用して式を単純化すると、単にが得られprint input() + input()ます。

これは、負の数と浮動小数点数の両方をサポートしています。

注：ニブラーのアドバイスに従い、この答えを3つに分割しました。これがMathematicaソリューションであり、これがTI-89 Basicソリューションです。

JavaScript [25バイト]

~eval([1,~x,~y].join(''))

Mathematica、21バイト

Mathematicaでこれを行うには多くの方法があります。1つは、Accumulate関数を使用して、出力の最終番号以外のすべてをトスします。以下の他のソリューションと同様に、入力番号は変数aとにあると仮定しますb。21バイト。

Last@Accumulate@{a, b}

さらに楽しいのは、45文字ですが、数字を使用して行を定義し、その下に統合します。

Integrate[Fit[{{0, a}, {2, b}}, {x, 1}, x], {x, 0, 2}]

ボーナスとして、両方のソリューションは、ここでの他のソリューションの場合のように正の整数だけでなく、すべての複素数に対して機能します。

GolfScript、6 4文字/バイト

10, 5（=> 15）の形式で入力します。

~,+,

+配列の連結ではなく、またあります。

仕組みは,、数字が（0,1,...,n-2,n-1）である長さの配列を作成するために使用されることです。これは両方の数値に対して行われ、配列は連結されます。,結果の配列の長さを見つけるために、別の目的で再び使用されます。

さて、ここにトリックがあります。これは、入力形式を乱用するため、本当に気に入っています。配列を入力しているように見えますが、実際には、入力はGolfScriptコードとして実行され,ているため、最初の操作は既に完了しています。（古い6文字バージョンは~,\,+,input format 10 5で、\,（swap-array）を削除することで2文字を削除しました）。

古いバージョン（12）：

関数を作成しますf。

{n*\n*+,}:f;

*そして+、それぞれの算術関数、文字列の繰り返しと連結されません。

説明：n1文字のストリング（改行）を作成します。その後、これが何a度も繰り返され、同じことがで行われbます。文字列は連結,され、文字列の長さに使用されます。

C、29 27バイト

ポインター演算の使用：

f(x,y)char*x;{return&x[y];}

x はポインタとして定義されますが、呼び出し元は整数を渡す必要があります。

匿名ユーザーは次のように提案しました-27バイトですが、パラメーターは整数です：

f(x,y){return&x[(char*)y];}

Brainf * ck、9 36

,>,[-<+>]

++[->,[->>[>]+[<]<]<]>>>[<[->+<]>>]<

これは単純な追加を使用せずに機能します。通過して1の証跡を作成し、それらをカウントアップします

注：+と-は単に1つの増分であり、brainf * ckでそれらがなければ何もできません。それらは実際には加算/減算ではないので、これはまだ重要だと思います。

J（6）

succ関数を使用できないとは言わなかった：

>:@[&0

使用法：

   9>:@[&0(8)
17

>:on 8を9回繰り返します。

リスト連結アプローチも機能します#@,&(#&0)。そして-私はそれが規則に反していることを知っています-私はほとんどのJっぽい解決策なしではこの答えを手放すことはできません：（*&.^べき乗の下での乗算）。

追記、41

次のように、41バイト長の式で関数を定義します。

/a{0 moveto 0 rmoveto currentpoint pop}def

次に、たとえば次のように呼び出します。

gs -q -dBATCH -c '/a{0 moveto 0 rmoveto currentpoint pop}def' -c '10 15 a ='

それは与える

25.0

ほとんどの競合他社とは異なり、ネガとフロートを簡単に処理できます:-)

bash、20文字

(seq 10;seq 4)|wc -l

Smalltalk（現在深刻）、123 118 105（*）

2回答えてすみませんが、これは真剣な答えで、もう1つはユーモアに近いものでした。以下は、すべてのマシンで（ハードウェアで）この瞬間に実際に実行されます。奇妙なことに、他の誰にも思いつかなかった...

2つの半加算器を組み合わせて、単語のすべてのビットを並列に実行することで、（入力a、b、sの出力）読み取り可能なバージョンを取得します。

  s := a bitXor: b.            
  c := (a & b)<<1.             

  [c ~= 0] whileTrue:[        
     cn := s & c.
     s := s bitXor: c.
     c := cn<<1.
     c := c & 16rFFFFFFFF.
     s := s & 16rFFFFFFFF.
  ].
  s           

ループはキャリー伝播用です。マスクは、符号付き整数が処理されるようにします（マスクなしでは、符号なしの数値のみが可能です）。これらは、語長も定義します。上記は32ビット操作の場合です。68ビットの追加を希望する場合は、16rFFFFFFFFFFFFFFFFFに変更します。

ゴルフバージョン（123文字）（mで再利用することで長いマスクを回避）：

[:a :b||s c n m|s:=a bitXor:b.c:=(a&b)<<1.[c~=0]whileTrue:[n:=s&c.s:=s bitXor:c.c:=n<<1.c:=c&m:=16rFFFFFFFF.s:=s&m].s]

（*）16rFFFFFFFFの代わりに-1を使用することで、ゴルフをより良くすることができますが、コードは任意の精度の数値では機能せず、機械語サイズのsmallIntegerのみで機能します（largeIntegerの表現はAnsi標準では定義されていません）：

[:a :b||s c n|s:=a bitXor:b.c:=(a&b)<<1.[c~=0]whileTrue:[n:=s&c.s:=s bitXor:c.c:=n<<1.c:=c&-1.s:=s&-1].s]

これにより、コードサイズが105文字になります。

APL、8および12

ここでは新しいことはありません。配列カウントバージョン：

{≢∊⍳¨⍺⍵}

およびログ○ログバージョン：

{⍟⍟(**⍺)**⍵}

APLではかっこいいと思っただけです！

{≢     }       count
  ∊            all the elements in
   ⍳¨          the (two) sequences of naturals from 1 up to
     ⍺⍵        both arguments

{⍟⍟        }   the double logarithm of
   (**⍺)       the double exponential of ⍺
        *      raised to
         *⍵    the exponential of ⍵

sed、359バイト（派手なフォーマットなし）

回答が遅れて申し訳ありませんが、おそらくここで最も長い回答です。しかし、私はこれがsedで可能かどうかを見たかったです：

                       s/([^ ]+) ([^ ]+)/\1:0::\2:/
                       :d /^([^:]+):\1::([^:]+):/tx
                       s/(:[^:]*)9([_:])/\1_\2/g;td
s/(:[^:]*)8(_*:)/\19\2/g;s/(:[^:]*)7(_*:)/\18\2/g;s/(:[^:]*)6(_*:)/\17\2/g
s/(:[^:]*)5(_*:)/\16\2/g;s/(:[^:]*)4(_*:)/\15\2/g;s/(:[^:]*)3(_*:)/\14\2/g
s/(:[^:]*)2(_*:)/\13\2/g;s/(:[^:]*)1(_*:)/\12\2/g;s/(:[^:]*)0(_*:)/\11\2/g
                       s/:(_+:)/:1\1/g; y/_/0/; # #
                       bd;  :x  s/.*::([^:]+):/\1/;
                       # # # # # # #  # # # # # # #

これはhttps://codegolf.stackexchange.com/a/38087/11259に似ており、単に文字列の数字をインクリメントします。しかし、代わりにループでインクリメント操作を行います。

入力は、STDINから「x y」の形式で取得されます。最初に「x：0 :: y：」に変換されます。次に、「：」文字の後に続くすべての数字を「x：x：:( x + y）：」になるまでインクリメントします。その後、最終的に（x + y）を返します。

出力

$ printf "%s\n" "0 0" "0 1" "1 0" "9 999" "999 9" "12345 67890" "123 1000000000000000000000"  | sed -rf add.sed
0
1
1
1008
1008
80235
1000000000000000000123
$

これは自然数に対してのみ機能することに注意してください。ただし、（少なくとも理論的には）任意の大きな整数に対して機能します。yに対してxの増分演算を行っているため、順序付けによって速度に大きな違いが生じる可能性があります。x<yはx> yよりも高速です。

ダッシュ、18バイト

time -f%e sleep $@

GNU time 1.7以降が必要です。出力はSTDERRになります。

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

組み込みのtimeコマンドはGNU timeとは異なるため、これはB ashでは機能しないことに注意してください。

1バイトの追加コストで、Bashに外部コマンドを使用させる\time代わりに使用できますtime。

Javascript（67）

おそらくはるかに優れている

a=Array;p=Number;r=prompt;alert(a(p(r())).concat(a(p(r()))).length)

ルビー、18文字

a.times{b=b.next}

さらに2つの冗長なバリアント、29文字

[*1..a].concat([*1..b]).size

別のバージョン、32文字

(''.rjust(a)<<''.rjust(b)).size

C＃-オンザフライのコード生成

ええ、実際にはそこに追加がありますが、+演算子はなく、追加を行うフレームワーク関数もありません。代わりに、追加を行うメソッドをその場で生成します。

public static int Add(int i1, int i2)
{
    var dm = new DynamicMethod("add", typeof(int), new[] { typeof(int), typeof(int) });
    var ilg = dm.GetILGenerator();
    ilg.Emit(OpCodes.Ldarg_0);
    ilg.Emit(OpCodes.Ldarg_1);
    ilg.Emit(OpCodes.Add);
    ilg.Emit(OpCodes.Ret);
    var del = (Func<int, int, int>)dm.CreateDelegate(typeof(Func<int, int, int>));
    return del(i1, i2);
}

ルビー39

f=->a,b{[*1..a].concat([*1..b]).length}

R 36

function(x,y)length(rep(1:2,c(x,y)))

ここでrep、x1の後にy2が続くベクトルを作成します。

TI Basic 89-19バイト

TI-89（ホーム画面またはプログラミングアプリ）でこれを実行します。

ln(ln((e^e^x)^e^y))

これはx+y、このソリューションのように、ログルールを使用して計算します。おまけとして、10進数と整数で機能します。すべての実数で機能します。対数ルールがまだ複素指数で有効な場合、これは複素数でも機能します。ただし、複雑な指数を挿入しようとすると、計算機がジャンクを吐き出します。

Mathematica表記法を教えてくれたMichael Sternに感謝します。

Mathematica- 21 20バイト

Log@Log[(E^E^x)^E^y]

これはこのソリューションと同じアプローチを使用しますが、Mathematicaで短くすることです。これは、xおよびの整数と同様に、負および浮動小数点数に対して機能しますy。

ログルールを使用して式を簡略化するx+yとが得られますが、4つの基本演算子の1つではなく、べき乗を使用するため、これは有効です。

C＃-文字列演算

両方の数値を文字列に変換し、文字列の切断（キャリーとすべて、ご存じのとおり）を追加してから、解析して整数に戻します。0..200のi1、i2でテストされ、魅力のように動作します。これで追加を見つけてください！

public static int Add(int i1, int i2)
{
    var s1 = new string(i1.ToString().Reverse().ToArray());
    var s2 = new string(i2.ToString().Reverse().ToArray());
    var nums = "01234567890123456789";
    var c = '0';
    var ret = new StringBuilder();
    while (s1.Length > 0 || s2.Length > 0 || c != '0')
    {
        var c1 = s1.Length > 0 ? s1[0] : '0';
        var c2 = s2.Length > 0 ? s2[0] : '0';
        var s = nums;
        s = s.Substring(int.Parse(c1.ToString()));
        s = s.Substring(int.Parse(c2.ToString()));
        s = s.Substring(int.Parse(c.ToString()));
        ret.Append(s[0]);
        if (s1.Length > 0)
            s1 = s1.Substring(1);
        if (s2.Length > 0)
            s2 = s2.Substring(1);
        c = s.Length <= 10 ? '1' : '0';
    }
    return int.Parse(new string(ret.ToString().ToCharArray().Reverse().ToArray()));
}

C（79）

void main(){int a,b;scanf("%d%d",&a,&b);printf("%d",printf("%*c%*c",a,0,b,0));}

Python-22文字

len(range(x)+range(y))

APL：2

1⊥

これは、基数1からの数値を変換するため、（n * 1 ^ 1）+（m * 1 ^ 2）は正確にn + mです。

TryApl.orgで試すことができます

TI-BASIC、10

追加しX、Y

ln(ln(e^(e^(X))^e^(Y

K、2バイト

#&

使用例：

  #&7 212
219

「where」演算子（単項式&）を入力リスト内の数値に適用します（入力フォーマットで自由度を取ります）。これにより、最初の数のゼロとそれに続く2番目の数の1を含むリストが生成されます。

  &3 2
0 0 0 1 1

通常、この演算子は、ブールリストの非ゼロ要素のインデックスのリストを作成するための「収集」として使用されますが、一般化された形式がときどき役立ちます。

次に、そのリストのカウント（単項#）を取得します。

入力要件の解釈が受け入れられない場合、次のわずかに長い解決策でも同じトリックを行います。

{#&x,y}

Pyth、29バイト

AQW!qG0=k.&GH=HxGH=k.<k1=Gk)H

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

ここに私の最初の提出！

これは次のようにコンパイルされます。

assign('Q',eval_input())     # Q
assign('[G,H]',Q)            #A
while Pnot(equal(G,0)):      #  W!qG0
  assign('k',bitand(G,H))    #       =k.&GH
  assign('H',index(G,H))     #             =HxGH  (index in this case is XOR)
  assign('k',leftshift(k,1)) #                  =k.<k1
  assign('G',k)              #                        =Gk)
imp_print(H)                 #                            H