คุณต้องรับอินพุตสตริง 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และดำเนินการตามที่จำเป็น bytecode เป็นรหัสสำหรับฟังก์ชั่นซึ่งอาจจะเรียกว่าใน 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, intel processor):

#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. เพิ่มและทำซ้ำจนกว่าคุณจะทำมันสองครั้ง
4. อาเจียนด้วยตัวเอง

การเปลี่ยนแปลง

71 สั้นกว่าเป็นอาร์เรย์

85 การลบเมธอดที่ลบออกและรวมการเรียกไปยัง n.to_s

92 ใช้เคล็ดลับบางอย่าง

101 ประหยัดถ่าน

102 ใช้ x เพื่อการเพิ่มขึ้น

กระทำครั้งแรก 109

sed, 359 ไบต์ (โดยไม่มีการจัดรูปแบบแฟนซี)

ฉันยังคงไม่แน่ใจว่านี้เป็นของ dup เพิ่มโดยไม่ต้องเติม (หรือใด ๆ ของผู้ประกอบการทางคณิตศาสตร์ขั้นพื้นฐาน 4) ในระหว่างนี้ขอข้ามคำตอบสำหรับคำถามนั้น มันจะไม่ชนะการแข่งขันกอล์ฟใด ๆ แต่เป็นการเริ่มต้นและฉันคิดว่าตรงตามข้อกำหนด:

                       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
$

โปรดทราบว่านี่ใช้งานได้กับจำนวนที่เป็นธรรมชาติเท่านั้น อย่างไรก็ตาม (ในทางทฤษฎีอย่างน้อย) มันทำงานกับจำนวนเต็มขนาดใหญ่โดยพลการ เนื่องจากเรากำลังเพิ่มการดำเนินการ x ใน y การสั่งซื้อจึงสามารถสร้างความแตกต่างให้กับความเร็วได้: x <y จะเร็วกว่า x> y

ทับทิม - 485 432 265

สิ่งนี้ดูเหมือนจะเป็นวิญญาณของสิ่งที่คุณกำลังมองหา

โดยทั่วไปแล้วมันจะแก้ปัญหาที่มนุษย์ทำบนกระดาษโดยการ "จดจำ" ผลการบวกเลขหลักเดียวทั้งหมดเพิ่มแต่ละคอลัมน์และทำความเข้าใจวิธีการ "นำหนึ่ง" เมื่อจำเป็น

สิ่งนี้ยังใช้ "ชนิดข้อมูลตัวเลข" หนึ่งตัว (ตัวแปร 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 เป็นสตริงและเอาต์พุตเป็นอาร์เรย์ของอักขระซึ่งเป็นสตริงเอง

ตัวอย่างเช่น:

123 4567

0เอาท์พุทที่มีก่อนหน้านี้ แจ้งให้เราทราบหากเป็นปัญหา

C # - 128 108 104

ขอบคุณ Compass, BMac และ Shawn สำหรับการแนะนำการปรับปรุง

ลองครั้งแรกที่ Code Golf และการใช้ C # ดูเหมือนจะเป็นแต้มต่อที่นี่ ...

โดยการใช้.Compute()คุณสามารถใช้ค่าสตริงและรวมพวกเขาโดยตรง โบนัสนี้ใช้ได้กับผู้ให้บริการรายอื่นนอกเหนือจาก "+"

แข็งแรงเล่นกอล์ฟ:

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

Ungolfed:

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) แปลงตัวถูกดำเนินการทั้งสองให้เป็นเอกภาพเรียงต่อกันแปลงกลับเป็นทศนิยม (ทั้งหมดใช้ regex แน่นอน - sed ไม่มีแนวคิดของจำนวนเต็ม)

เป็นโบนัสโปรแกรมนี้สรุปจำนวนเต็มทั้งหมดตามธรรมชาติที่กำหนดบน stdin (ในบรรทัดแรก) ซึ่งหมายความว่าคุณไม่สามารถป้อนได้เลยเลขหนึ่งหรือสิบตัวเลขและมันจะทำสิ่งที่ถูกต้องโดยไม่คำนึงถึง

แนวคิดที่อยู่เบื้องหลังรหัสนี้เป็นแรงบันดาลใจอย่างชัดเจนจากการส่ง PPCG เก่าแก่ของฉันแม้ว่าฉันจะจำไม่ได้ว่าคำถามนั้นเป็นคำตอบอะไร

นี่คือ "สวย" - พิมพ์เพื่อ "ความสะดวก" ของคุณเพื่อขอยืมแนวคิดอื่นจาก 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]));}}

Ungolfed:

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

เราไม่ได้แปลงค่าเป็น int เพื่อให้ JavaScript ทำการประเมิน เราได้สร้างสตริงที่"123+456"ไม่ใช่ตัวเลข JS Engine แยกย่อยสูตรและประเมิน String เป็นตัวอักษรตัวเลขซึ่งไม่ใช่ชนิดข้อมูลตัวเลข ตรรกะวิเศษของ Java! นอกเหนือจากนี้ยังใช้งานได้สำหรับdoubleคณิตศาสตร์

APL (61)

ฉันคิดว่าสิ่งนี้อยู่ภายในกฎ

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

นี่คือฟังก์ชั่นที่รับอาร์กิวเมนต์สตริงสองตัวและส่งคืนสตริง:

      '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: ลบออก10จากแต่ละตำแหน่งที่สูงกว่า 10
    • T←(1⌽T)+: เพิ่ม1ให้กับแต่ละตำแหน่งถัดจากแต่ละตำแหน่งที่สูงกว่า 10 Tและเก็บใน
    • T↓⍨~×⊃T: หากTเริ่มต้นด้วยศูนย์ให้ลบออก
    • ∇: ใช้ฟังก์ชั่นการพกพากับผลลัพธ์
  • ⋄⍵: มิฉะนั้นส่งคืนค่าไม่เปลี่ยนแปลง
• 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 ขยายด้วยคลาส:

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 ตัวอักษร

เนื่องจากทุกคนรู้จัก java ไม่มีภาษาที่ดีกว่าสำหรับการเล่นกอล์ฟมากกว่า 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);}}

นี่เป็นวิธีแก้ปัญหาที่ไม่ดี

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, ex: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

ปุ่มพจนานุกรมเป็นสตริงค่าพจนานุกรมรวมเฉพาะค่าคงที่จำนวนเพื่อย่อโค้ดและทำการคำนวณโดยเชื่อมสองสายเข้าด้วยกันและรับความยาวผลลัพธ์ดังนั้นฉันหวังว่ามันจะนับเป็น "ไม่แปลงให้เป็น 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นั่นเป็นเพียงรายละเอียดการใช้งานและไม่เกี่ยวข้องกับปัญหาในมือ