2つの文字列入力を受け取り、これらの2つの文字列の合計を、intに変換したり、数値データ型を使用したりせずに出力する必要があります。

例：

string one = "123";
string two = "456";    
string sum = "579";

文字列は10桁を超えないものとします。

これはコードゴルフであり、キャラクターの勝利における最短の答えです。C＃で回答を編集すると、笑顔になります:)。

編集：intへの変換は、このような性質のものとして定義できます

Int.TryParse、(int)、Convert.ToIntなど

80836アセンブリ（57 53バイト）

53 55 89 E5 8B 4D 0C 8B 55 10 B0 0A 30 DB 88 CF 00 C1 00 C2 49 4A 8A 01 8A 22 00 E0 00 D8 2C 30 30 DB 3C 39 7E 04 B3 01 2C 0A 88 01 88 22 38 CF 75 E2 5D 5B C3

これにより、ASCII数字'0'-'9'を整数に変換せずに、桁ごとに右から左に追加し、0-9必要に応じて引き継ぎます。バイトコードは、Cで呼び出すことができる関数のコードです（以下を参照）。

上記のバイトコードは、次のアセンブリ（NASMスタイル、コメント付き）から手動で作成されました。

; save ebx, ebp
push ebx        ; 53
push ebp        ; 55
; copy esp
mov ebp, esp    ; 8B EC
; load arguments
mov ecx, [ebp+0x0C] ; 8B 4D 0C
mov edx, [ebp+0x10] ; 8B 55 10
; initialize stuff
mov al, 10      ; B0 0A
xor bl, bl      ; 30 DB
mov bh, cl      ; 88 CF
; send edx, ecx to end of string
add cl, al     ; 00 C1
add dl, al     ; 00 C2

; decrement everything
dec ecx         ; 49
dec edx         ; 4A

; get rightmost unprocessed digit of each number
mov al, [ecx]   ; 8A 01
mov ah, [edx]   ; 8A 22

; add two ascii digits
add al, ah      ; 00 E0
; add carry if needed
add al, bl      ; 00 D8
; subtract 0x30 ('0') to get the resulting ascii digit
sub al, 0x30    ; 2C 30

; set bl to 0
xor bl, bl      ; 30 DB

; if greater than '9': must carry over to next place
cmp al, 0x39    ; 3C 39
jle $+6         ; 7E 04
; set bl to 1 if carrying over
mov bl, 1       ; B3 01
; subtract 10 from ascii digit if carrying over
sub al, 0x0A    ; 2C 0A

mov [ecx], al   ; 88 01
mov [edx], ah   ; 88 22


; check if loop has ended
cmp bh, cl      ; 38 CF
jne $-28        ; 75 E2

; restore ebx, ebp
pop ebp         ; 5D
pop ebx         ; 5B
; return
ret             ; C3

Cでこれを試すには（gcc、linux、インテルプロセッサー）：

#include <stdio.h>
#include <string.h>
#include <sys/mman.h>

int main(){
    // bytecode from earlier
    char code[] = {
        0x53, 0x55, 0x8B, 0xEC, 0x8B, 0x4D, 0x0C, 0x8B, 
        0x55, 0x10, 0x31, 0xC0, 0xB0, 0x09, 0x30, 0xDB, 
        0x01, 0xC1, 0x01, 0xC2, 0x40, 0x50, 0x8A, 0x01,
        0x8A, 0x22, 0x00, 0xE0, 0x00, 0xD8, 0x2C, 0x30,
        0x30, 0xDB, 0x3C, 0x39, 0x7E, 0x04, 0xB3, 0x01,
        0x2C, 0x0A, 0x88, 0x01, 0x88, 0x22, 0x58, 0x48,
        0x49, 0x4A, 0x85, 0xC0, 0x75, 0xDF, 0x5D, 0x5B,
        0xC3,
    };
    // allocate executable memory to a function pointer called 'add'
    void __attribute__( (__cdecl__) ) (*add)(char*,char*) = mmap(0,sizeof code,PROT_WRITE|PROT_EXEC,MAP_ANON|MAP_PRIVATE,-1,0);
    memcpy(add, code, sizeof code);

    // test inputs
    char number1[] = "0878295272", number2[] = "8184206821";

    puts(number1);
    puts(number2);

    // call the bytecode as a c function
    add(number1, number2);

    // output is in the first argument
    puts(number1);

    // release allocated memory
    munmap(add, sizeof code);

    return 0;
}

ルビー、109 71

安っぽい。あなたがモハマドを山に連れて行くことができないなら...

j=$*
r=n=d=0
(d+=x=j.count{|v|n.to_s==v}
r+=x*n
n+=1)until d>1
p r.to_s

アルゴリズム：

1. intの文字列表現を入力1および入力2と比較します。
2. マッチごとの結果にそのintを追加します。
3. インクリメントして、2回行うまで繰り返します。
4. 自分に嘔吐

変更ログ

71は配列として短くなります。

85メソッドの宣言を削除し、呼び出しを統合 n.to_s

92 いくつかのヒントを適用

101チャーを保存

102インクリメントにxを使用

109初期コミット

sed、359バイト（特別なフォーマットなし）

これが加算なしのAdd（または4つの基本的な算術演算子のいずれか）の dupであるかどうかはまだわかりません。それまでの間、その質問に対する私の回答をクロスポストします。ゴルフに勝つことはありませんが、それは始まりであり、簡単に仕様を満たしていると思います。

                       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/;
                       # # # # # # #  # # # # # # #

入力は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よりも速くなります。

ルビー-485 432 265

これはあなたが質問で探していたものの精神にもっと似ているようです。

それは基本的に人間が紙に書いた方法の問題を解決します-すべての1桁の加算結果を「記憶」し、各列を追加し、必要に応じて「1つを運ぶ」方法を理解します。

これも1つの「数値データ型」（変数i）を使用していますが、質問では禁止されていますが、これは文字列のインデックス作成にのみ使用されます。これを削除して、回答を編集します。

def s p
(y=(?0..?9).to_a).product(y).map{|x|/#{x.join}/}.zip((?0..'18').to_a.each_cons(10).to_a.flatten).each{|k,v|return v if k=~p.sort.join}
end
a,b=$*.map{|n|n.rjust(10,?0).reverse}
r=?0
c=''
(0..9).each{|i|d=s [a[i],b[i]]
c=s([d[-1],r])+c
r=d[-2]||?0}
puts r+c

やや手に負えない：

def s p
  y = (?0..?9).to_a
  y.product(y).map{ |x|
    /#{x.join}/
  }.zip(
    (?0..'18').to_a.each_cons(10).to_a.flatten
  ).each{ |k,v|
    return v if k =~ p.sort.join
  }
end

a,b=$*.map{ |n| n.rjust(10,?0).reverse }

r = ?0
c = ''

(0..9).each { |i|
  d = s [ a[i], b[i] ]
  c = s([ d[-1], r ]) + c
  r = d[-2] || '0'
}

puts r+c

編集：ハードコーディングするのではなく、コメントからいくつかのアイデアを使用して、「記憶された」マッピングテーブルを生成しました。

CJam、95 92 80 72 70 44文字

"Ǻᨌ⹝瀶噄頼୅籌◳ॶ騥箄덮庸匕帯標ឭ⹞➻䗧㩱砡࣍㤬醻孹꽬"2G#b127b:c~

これは

lW%'0A*+S/zW%{{A,__m*{_1b\saa*~}%\{_saa*~}%+\aa/,(s_,({(@+\}*}%_Wf<s}g

これは間違いなくたくさんゴルフすることができます。私のアプローチが最適かどうかはまだわかりません。

UPDATE-合計行列の作成をインライン化してバイトを節約します。このため、プログラムの実行速度は10倍遅くなりますが、あらゆる種類の入力に対して一定の時間がかかります。

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

STDINから2つの数値を含む行を文字列として読み取り、文字列そのものである文字の配列として出力します。

例えば：

123 4567

出力には、先行するが含まれます0。それが問題であるかどうか私に知らせてください。

C＃-128 108 104

改善を提案してくれたCompass、BMac、Shawnに感謝します。

最初にコードゴルフを試してみてください、そしてC＃を使用することはここでハンディキャップのようです...

使用すると.Compute()、あなたは、文字列値を使用して直接それらを合計することができます。おまけとして、これは「+」だけでなく他の演算子でも機能します。

ゴルフ：

static void t(string a,string b){System.Console.Write(new System.Data.DataTable().Compute(a+"+"+b,""));}

非ゴルフ：

static void t(string a, string b)
{
    System.Console.Write(new System.Data.DataTable().Compute(a+"+"+b,""));
}

電話をt("123","456");かけると579になります。

GNU sed、266バイト

DigitalTraumaのソリューションとは異なるアプローチを使用します。効果として、これはO（m + n）を使用してさらにパフォーマンスが低下します。両方のオペランドを単項に変換し、連結し、10進数に戻します（もちろん、すべて正規表現を使用しています。sedには概念がありません。整数のがあり）。

おまけとして、このプログラムはstdin（最初の行）に指定されたすべての自然整数を合計します。つまり、何も、1つの数値または10つの数値を与えることができ、それは関係なく正しいことを行います。

このコードの背後にあるアイデアは、私が提出した古いPPCG sedの提出に漠然と触発されていますが、それがどのような質問に対する答えであるかは覚えていません。

ここに、DigitalTraumaから別のアイデアを借りるために、「便利」のために「かなり」印刷されています。：D

                s/9/x8/g;
                s/8/x7/g;
                s/7/x6/g;
                s/6/x5/g;
                s/5/x4/g;
                s/4/x3/g;
  s/3/x2/g;s/2/x1/g;s/1/x0/g;s/0\b//g;;
  :l;s/x0/0xxxxxxxxxx/;/x0/bl;s/[^x]//g
  s/^$/0/;:m;s/x{10}/!/g;s/!\b/&0/;;;;;
  s/0x/1/;s/1x/2/;s/2x/3/;s/3x/4/;;;;;;
  s/4x/5/;s/5x/6/;s/6x/7/;s/7x/8/;;;;;;
                s/8x/9/;;
                s/!/x/g;;
                /x{10}/bm
                /x/!q;;;;
                s/^/0/;bm
                #sum.sed#

（266バイトのバージョンを取得するには、末尾のセミコロン、先頭の空白、最後のコメントを削除し、できればsedを使用します。）

DigitalTraumaからいくつかのテストを借用する：

% printf "%s\n" "0 0" "0 1" "1 0" "9 999" "999 9" "12345 6789" "123 100" | while read l; do sed -rf /tmp/sum.sed <<<"$l"; done 
0
1
1
1008
1008
19134
223

非常に大きなスペース（非）効率のため、非常に大きなテストを少し調整しました。q最初の行のみが使用されるためwhile、テストのループが処理されます。

Java 6（181文字）

C＃として知られるハンディキャップ、Javaの栄光に負けないでください。定型文が多すぎます。使用法は、スペースで区切られた引数を提供しています。123 456

import javax.script.*;class T {public static void main(String[] a) throws Exception {System.out.print(new ScriptEngineManager().getEngineByName("JavaScript").eval(a[0]+"+"+a[1]));}}

非ゴルフ：

import javax.script.*;

class T {
    public static void main(String[] a) throws Exception {
        System.out.print(new ScriptEngineManager()
                .getEngineByName("JavaScript").eval(a[0] + "+" + a[1]));
    }
}

で利用可能なJavaScriptエンジンを使用する javaxことで、別の言語に代わって機能させ、技術的には母国語で数値型を使用しない、または変換するというルールに従うことができます。

使用の理由 eval

JavaScriptをevalにするには、値をintに変換していません。"123+456"数値ではない文字列を作成しました。JS Engineは数式をダイジェストし、文字列を数値データ型ではない数値リテラルとして評価します。Java安っぽいロジック！余談ですが、これはdouble数学にも有効です。

APL（61）

これはルールに当てはまると思います。

{⎕D[1+{∨/T←9<Z←0,⍵:∇T↓⍨~×⊃T←(1⌽T)+Z-10×T⋄⍵}+⌿⌽↑⌽¨¯1+⎕D∘⍳¨⍺⍵]}

これは、2つの文字列引数を取り、文字列を返す関数です。

      '123'{⎕D[1+{∨/T←9<Z←0,⍵:∇T↓⍨~×⊃T←(1⌽T)+Z-10×T⋄⍵}+⌿⌽↑⌽¨¯1+⎕D∘⍳¨⍺⍵]}'456'
579
      ⍝ show dimensions (if it was a number, this would give the empty list)
      ⍴'123'{⎕D[1+{∨/T←9<Z←0,⍵:∇T↓⍨~×⊃T←(1⌽T)+Z-10×T⋄⍵}+⌿⌽↑⌽¨¯1+⎕D∘⍳¨⍺⍵]}'456'
3

それもかなり高速で、999999 9秒で形成される数を瞬時に追加します。

で各文字のインデックス⎕D（文字列 '0123456789'）を見つけ、必要に応じて各インデックスに小学校の追加を個別に実行し、結果の数字をで検索し⎕Dます。（⎕Dルックアップはルールの範囲内に収まると思います'x'-48。基本的には単に実行しているだけです）。

説明：

• ⎕D∘⍳¨⍺⍵：⎕D両方の文字列の各文字のインデックスを調べます。
• ¯1+：1配列はデフォルトで1ベースであるため、それぞれから減算します。
• ⌽↑⌽¨：両方を逆にし、行列に変換し（空の正方形をゼロで埋めます）、行列を逆にします。
• +⌿：行列の列を合計する
• {...}：キャリーオーバー：
  • ∨/T←9<Z←0,⍵：0リストの前に追加します。9より大きい「桁」を見つけ、これを次の場所に保存しますTます。10より大きい数字がある場合：
    • Z-10×T：1010より大きい各位置から差し引く
    • T←(1⌽T)+：110より大きい各位置の隣の各位置に追加し、に保存しTます。
    • T↓⍨~×⊃T：Tゼロで始まる場合は削除します。
    • ∇：結果にキャリー関数を適用します。
  • ⋄⍵：それ以外の場合は、値を変更せずに返します
• 1+：各位置に1を追加します（配列には1インデックスが付けられているため）
• ⎕D[... ]：結果をへのインデックスとして使用し⎕Dます。

Perl- 136 119 115バイト

私はPerlを学んでいますが、これは良い習慣のように思えました。ヒントは大歓迎です！

それを邪魔にならないようにするための安っぽい答え：

print$ARGV[0]+$ARGV[1]; #Adding strings

実際の答え：

($x,$y)=@ARGV;while($x.$y.$s){$s-=48-ord$&if$x=~s/.$//;$s-=48-ord$&if$y=~s/.$//;$r=chr($s%10+48).$r;$s=$s>9;}print$r;

非圧縮：

($x,$y)=@ARGV;
while($x.$y.$s){
$s-=48-ord$&if$x=~s/.$//;
$s-=48-ord$&if$y=~s/.$//;
$r=chr($s%10+48).$r;
$s=$s>9;
}
print$r;

Java 7、スコア= 252

追加に整数、長整数、バイト、短整数、倍精度浮動小数点数、または組み込みライブラリ関数を使用しません。クラス本体で囲み、で呼び出しますt(String1,String2)。文字列の長さが等しくなるように、0でパディングしてください。

t("123","234")を返します"0357"。

ゴルフ：

char c,d,e,f,g,k;String t(String a,String b){g++;char[]h=a.toCharArray(),i=b.toCharArray(),j=new char[h.length + 1];for(d=(char)h.length;d>f;)j[--d+1]=(c=(e=(char)(h[d]+i[d]-'0'+c))>'9'?g:f)==g?(char)(e-'\n'):e;j[0]=(char)('0'+c);return new String(j);}

Golfed Expanded with class：

public class T{

    public static void main(String[] args){
        System.out.println(new T().t(args[0],args[1]));
    }

    char c,d,e,f,g,k;
    String t(String a,String b){
        g++;
        char[]h=a.toCharArray(),i=b.toCharArray(),j=new char[h.length + 1];
        for(d=(char)h.length;d>f;)
            j[--d+1]=(c=(e=(char)(h[d]+i[d]-'0'+c))>'9'?g:f)==g?(char)(e-'\n'):e;
        j[0]=(char)('0'+c);
        return new String(j);
    }
}

部分的にゴルフを拡張：

public class TrickSum{

    public static void main(String[] args){
        System.out.println(new TrickSum().trickSum(args[0], args[1]));
    }

    char carry, i, aSum,nullChar,oneChar;
    public String trickSum(String a, String b){
        oneChar++;
        char[] number1 = toCharArray(a), number2 = toCharArray(b), sum = new char[number1.length + 1];
        for (i = (char) number1.length; i > nullChar;)
            sum[--i + 1] = (carry = (aSum = (char) (number1[i] + number2[i] - '0' + carry)) > '9' ? oneChar : nullChar) == oneChar ? (char) (aSum - '\n') : aSum;
        sum[0] = (char)('0' + carry);
        return new String(sum);
    }

    char[] toCharArray(String string){
        return string.toCharArray();
    }
}

100％エキスパンド：

public class TrickSum{

    public static void main(String[] args){
        System.out.println(trickSum(args[0], args[1]));
    }

    public static String trickSum(String a, String b){
        char[] number1 = a.toCharArray();
        char[] number2 = b.toCharArray();
        char[] sum = new char[number1.length + 1];
        char carry = '\u0000';
        for (char i = (char)(number1.length - 1); i != '\uFFFF'; i--){
            char aSum = (char) (number1[i] + number2[i] - '0' + carry);
            carry = aSum > '9' ? '\u0001' : '\u0000';
            aSum = (carry == '\u0001') ? (char) (aSum - '\n') : aSum;
            sum[i + 1] = aSum;
        }
        sum[0] = (char)('0' + carry);
        return new String(sum);
    }
}

Java-257文字

誰もがジャワを知っているので、ジャワほどゴルフに適した言語はありません

    class A{public static void main(String[]s){char[]a=s[0].toCharArray();char[]b=s[1].toCharArray();int c=a.length;int d=b.length;int e=0;String f="";for(int i=0;i<Math.max(c,d);i++){f=f+(((i<c?a[i]-48:0)+(i<d?b[i]-48:0)+e)%10);e/=10;}System.out.println(f);}}

これはゴルフのソリューションです

public static void main(String[] args) {
        char[] aa = args[0].toCharArray();
        char[] bb = args[1].toCharArray();
        int aal = aa.length;
        int bbl = bb.length;

        int reminder = 0;
        String result ="";
        for(int i=0;i<Math.max(aal,bbl);i++){
            result=result+(((i<aal?aa[i]-48:0)+(i<bbl?bb[i]-48:0)+reminder)%10);
            reminder/=10;
        }
        System.out.println(result);
    }

Haskell- 98 94バイト

main=do
 a<-getLine
 b<-getLine
 let c d=last$takeWhile(\e->d/=(show$e-1))[0..]
 print$c a+c b

JavaScript（ES6）、55 66 59 *

 f=x=>{for(i=0;i+[]!=x;i++);return i};f((p=prompt)())+f(p())

*これにはいくつかの前提があります：

• ES6 REPL環境にいる（例：FireFox 33.1ブラウザーコンソール）
• パフォーマンスは問題ではありません（真剣に、「9999999999」、「9999999999」が戻るまでに約20分かかりました）
• 整数から文字列への変換が許可されています
• 入力は変数aとbで定義されます。例： var a='123',b=321'; プロンプトから入力を取得するように変更されました（+11）。
• 入力には先行ゼロがありません。

Python 2.7、196 137文字

バージョン2（辞書をコードで初期化することにより短縮）：

n={}
for i in range(10):n[`i`]=i*' '
def q(a,b):f=lambda x:''.join([10**p*n[s] for p,s in enumerate(reversed(x))]);return len(f(a)+f(b))

以前のバージョン1（196文字）：

def q(a,b):n,f={0:'','1':' ','2':'  ','3':'   ','4':4*' ','5':5*' ','6':6*' ','7':7*' ','8':8*' ','9':9*' '}, lambda x:''.join(
    [10**p*n[s] for p,s in enumerate(reversed(x))]);return len(f(a)+f(b))

例えば

>>> print q('123','111')
234

ディクショナリキーは文字列で、ディクショナリ値にはコードを短縮するための数値定数のみが含まれ、計算は2つの文字列を連結して結果の長さを取得することで行われるため、「intに変換しない」と見なされることを期待しています。

Pythonの小柄なルールチートバージョン

class z(int):0
def s(a,b): return z(a)+z(b)

注意：

>>> type(z('4'))
<class '__main__.z'>

タイプzは、私が次のように定義するカスタムタイプです。質問者が使用する定義による数値タイプではありませんが、限られた状況で役立つように数値タイプに十分近い動作をします。タイプzの動作はこのコードサンプルで部分的にのみ実装されており、CPythonインタープリターが 'int'を使用してzを実装する場合、これは単なる実装の詳細であり、当面の問題とは関係ありません。