Anda harus mengambil 2 input string dan output jumlah dari dua string ini tanpa mengubahnya menjadi int atau menggunakan tipe data numerik apa pun.

ex.

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

Asumsikan string tidak akan lebih besar dari 10 digit.

Ini adalah kode golf dan jawaban terpendek dalam karakter menang. Sunting jawaban di C # akan membuat saya tersenyum :).

Sunting: Konversi ke int dapat didefinisikan sebagai sesuatu yang bersifat ini

Int.TryParse, (int), Convert.ToIntDll

80836 Majelis ( 57 53 byte)

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

Ini menambahkan, digit demi digit, kanan ke kiri, tanpa mengonversi digit ascii '0'-'9'ke integer 0-9, dan meneruskan sesuai kebutuhan. Bytecode adalah kode untuk suatu fungsi, yang dapat disebut dalam C (lihat di bawah).

Bytecode di atas ditulis dengan tangan, dari majelis berikut (gaya NASM, berkomentar):

; 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

Untuk mencoba ini di C (gcc, linux, prosesor intel):

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

Ruby, 109 71

Keju Jika Anda tidak dapat membawa Mohammad ke gunung ....

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

Algoritma:

1. Bandingkan representasi string int dengan input 1 dan input 2.
2. Tambahkan int itu ke hasil per pertandingan.
3. Tambahkan dan ulangi sampai Anda melakukannya dua kali.
4. Muntah dirimu sendiri

Changelog

71 lebih pendek sebagai sebuah array.

85 menghapus deklarasi metode dan menggabungkan panggilan ke n.to_s

92 menerapkan beberapa tips

101 simpan char

102 gunakan x untuk menambah

109 komit awal

sed, 359 byte (tanpa format mewah)

Saya masih tidak yakin apakah ini adalah dup dari Tambah tanpa tambahan (atau salah satu dari 4 operator aritmatika dasar) . Sementara itu, biarkan saya mengirim jawaban saya untuk pertanyaan itu. Ini tidak akan memenangkan golf apa pun, tapi ini permulaan, dan saya pikir mudah memenuhi spesifikasi:

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

Input diambil dari STDIN dalam bentuk "x y". Itu pertama kali diubah menjadi "x: 0 :: y:". Lalu, kami menambah semua angka yang muncul setelah karakter ":", hingga kami mendapatkan "x: x: :( x + y):". Kemudian kami akhirnya kembali (x + y).

Keluaran

$ 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
$

Perhatikan bahwa ini hanya berfungsi untuk bilangan asli. Namun (setidaknya dalam teori) ini berfungsi untuk bilangan bulat besar yang sewenang-wenang. Karena kita sedang melakukan operasi kenaikan x pada y, memesan dapat membuat perbedaan besar pada kecepatan: x <y akan lebih cepat daripada x> y.

Ruby - 485 432 265

Ini tampaknya lebih dalam semangat apa yang Anda cari dalam pertanyaan.

Ini pada dasarnya memecahkan masalah bagaimana manusia akan di atas kertas - dengan "menghafal" semua hasil penambahan satu digit, menambahkan setiap kolom, dan memahami bagaimana "membawa satu" ketika diperlukan.

Ini juga menggunakan satu "tipe data numerik" (variabel i), yang dilarang oleh pertanyaan, tetapi hanya untuk pengindeksan string. Saya akan mencoba menghapus ini dan mengedit jawaban saya.

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

Agak tidak terserang:

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

EDIT: Menggunakan beberapa ide dari komentar untuk menghasilkan tabel pemetaan "hafal" bukan hanya hardcoding saja.

CJam, 95 92 80 72 70 44 karakter

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

yang diterjemahkan menjadi

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

Ini pasti bisa bermain golf banyak. Saya benar-benar tidak tahu apakah pendekatan saya optimal atau belum.

UPDATE - sebariskan jumlah penciptaan matriks untuk menyimpan byte. Karena ini, program sekarang berjalan 10 kali lebih lambat, tetapi masih waktu yang konstan untuk segala jenis input.

Cobalah online di sini

Membaca baris yang berisi dua angka dari STDIN sebagai string dan output sebagai array karakter yang merupakan string itu sendiri.

Sebagai contoh:

123 4567

Outputnya berisi sebelumnya 0. Beritahu saya jika itu adalah masalah.

C # - 128 108 104

Terima kasih kepada Compass, BMac dan Shawn karena telah menyarankan peningkatan.

Coba pertama kali di Code Golf, dan menggunakan C # tampaknya menjadi kendala di sini ...

Dengan menggunakan .Compute()Anda dapat menggunakan nilai string dan menjumlahkannya secara langsung. Sebagai bonus, ini berfungsi untuk operator lain selain dari hanya "+".

Golf:

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

Tidak Disatukan:

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

Panggilan t("123","456");membuat Anda 579.

GNU sed, 266 byte

Menggunakan pendekatan yang berbeda dari solusi DigitalTrauma. Sebagai akibatnya, yang ini melakukan lebih buruk, menggunakan O (m + n) . Ubah kedua operan menjadi unary, concatenate, convert kembali ke desimal (semua menggunakan regex tentu saja - sed tidak memiliki konsep integer).

Sebagai bonus, program ini merangkum semua bilangan bulat alami yang diberikan pada stdin (di baris pertama), yang berarti Anda tidak dapat memberi makan apa-apa, satu angka atau sepuluh angka dan itu akan melakukan hal yang benar.

Gagasan di balik kode ini samar-samar terinspirasi oleh pengiriman lama PPCG saya, meskipun saya tidak ingat untuk pertanyaan apa itu adalah jawaban.

Ini dia, "cukup" -cetak untuk "kenyamanan" Anda, untuk meminjam ide lain dari 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#

(Untuk mendapatkan versi 266-byte, hapus tanda titik koma, spasi kosong terkemuka dan komentar terakhir, sebaiknya gunakan sed.)

Meminjam beberapa tes dari 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

Saya mengubah sedikit tes yang sangat besar karena efisiensi ruang yang sangat buruk. Karena penggunaan qhanya baris pertama yang diproses, maka whileloop dalam tes.

Java 6 (181 karakter)

Tidak mau kalah dengan cacat yang dikenal sebagai C # , Jawa dalam semua kemuliaan. Begitu banyak boilerplate! Penggunaan menyediakan argumen yang dipisahkan oleh spasi, yaitu123 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]));}}

Tidak Disatukan:

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

Dengan menggunakan mesin JavaScript yang tersedia di javax, kami dapat membuat bahasa lain melakukan pekerjaan untuk kami, dan secara teknis mengikuti aturan tidak menggunakan jenis numerik apa pun dalam bahasa asli, atau mengonversi.

Pembenaran untuk menggunakan eval

Kami belum mengonversi nilai menjadi int agar JavaScript dapat dievaluasi. Kami telah membuat String "123+456"yang bukan angka. Mesin JS mencerna rumus dan mengevaluasi String sebagai literal angka, yang bukan tipe data numerik. Logika Java cheesy! Selain itu, ini juga berfungsi untuk doublematematika.

APL (61)

Saya pikir ini termasuk dalam aturan.

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

Ini adalah fungsi yang mengambil dua argumen string, dan mengembalikan string:

      '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

Ini juga cukup cepat, ia menambahkan angka yang dibentuk oleh 999999 9dengan sendirinya dalam sekejap.

Ia menemukan indeks masing-masing karakter dalam ⎕D(yang merupakan string '0123456789'), kemudian melakukan penambahan sekolah dasar pada setiap indeks secara terpisah, membawa sesuai kebutuhan, kemudian mencari digit yang dihasilkan di ⎕D. (Saya pikir ⎕Dpencarian termasuk dalam aturan, pada dasarnya hanya melakukan 'x'-48).

Penjelasan:

• ⎕D∘⍳¨⍺⍵: lihat indeks ⎕Duntuk setiap karakter di kedua string.
• ¯1+: kurangi 1dari masing-masing, karena array berbasis 1 secara default.
• ⌽↑⌽¨: membalikkan keduanya, berubah menjadi matriks (mengisi kotak kosong dengan nol), lalu balikkan matriks.
• +⌿: jumlah kolom dari matriks
• {... }: bawa:
  • ∨/T←9<Z←0,⍵: tambahkan tambahan 0di depan daftar. Cari tahu 'angka' mana yang lebih tinggi dari 9, dan simpan di T. Jika ada angka yang lebih tinggi dari 10:
    • Z-10×T: kurangi 10dari setiap posisi yang lebih tinggi dari 10,
    • T←(1⌽T)+: tambahkan 1ke setiap posisi di sebelah setiap posisi yang lebih tinggi dari 10, dan simpan di T.
    • T↓⍨~×⊃T: jika Tdimulai dengan nol, hapus,
    • ∇: terapkan fungsi carry ke hasilnya.
  • ⋄⍵: jika tidak, kembalikan nilainya tidak berubah
• 1+: tambahkan satu untuk setiap posisi (karena array 1-diindeks)
• ⎕D[... ]: gunakan hasilnya sebagai indeks ⎕D.

Perl - 136 119 115 byte

Saya belajar Perl, ini sepertinya latihan yang bagus. Tips sangat dihargai!

Jawaban murahan, untuk menghindarinya:

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

Jawaban aktual:

($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;

Terkompresi:

($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, Skor = 252

Tidak menggunakan bilangan bulat, panjang, byte, celana pendek, ganda, mengapung, atau fungsi perpustakaan bawaan untuk ditambahkan. Bungkus dengan tubuh kelas dan panggil dengan t(String1,String2). Harap pad string dengan 0 sehingga mereka memiliki panjang yang sama.

t("123","234")kembali "0357".

Golf:

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

Golf Diperluas dengan kelas:

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

Golf sebagian diperluas:

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% Diperluas:

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 Karakter

karena semua orang tahu java tidak ada bahasa yang lebih baik untuk bermain golf selain java

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

ini adalah solusi tanpa lemak

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 byte

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())

* Ini membuat beberapa asumsi:

• Kami berada di lingkungan ES6 REPL (mis. FireFox 33.1 browser console)
• Performa tidak masalah (serius, '9999999999', '9999999999' membutuhkan waktu sekitar 20 menit untuk kembali)
• Konversi dari Integer ke String diizinkan
• Input didefinisikan dalam variabel a dan b, mis:var a='123',b=321'; Diubah untuk mendapatkan input dari prompt (+11).
• Input tidak memiliki nol di depan.

Python 2.7, 196 137 karakter

versi 2 (lebih pendek dengan menginisialisasi kamus dengan kode):

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

Versi sebelumnya 1 (196 karakter):

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

misalnya

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

Kunci kamus adalah string, nilai kamus hanya menyertakan konstanta angka untuk mempersingkat kode, dan perhitungan dilakukan dengan menggabungkan dua string dan mendapatkan panjang yang dihasilkan, jadi saya harap ini dihitung sebagai "tidak mengubahnya menjadi int".

Versi aturan-cheat versi Python kecil-cetak

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

catatan:

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

Tipe z adalah tipe kustom yang saya definisikan sebagai: jelas bukan tipe numerik menurut definisi apa pun yang digunakan si penanya, tetapi berperilaku cukup dekat dengan tipe numerik untuk berguna dalam keadaan terbatas . Perilaku tipe z hanya sebagian diimplementasikan dalam sampel kode ini, dan jika juru bahasa CPython menggunakan 'int' untuk mengimplementasikan z , itu hanyalah detail implementasi dan tidak terkait dengan masalah yang dihadapi.