Bạn phải lấy 2 chuỗi đầu vào và xuất tổng của hai chuỗi này mà không chuyển đổi chúng thành int hoặc sử dụng bất kỳ loại dữ liệu số nào.

Ví dụ.

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

Giả sử các chuỗi sẽ không lớn hơn 10 chữ số.

Đây là mã golf và câu trả lời ngắn nhất trong các nhân vật chiến thắng. Một chỉnh sửa cho câu trả lời trong C # sẽ khiến tôi mỉm cười :).

Chỉnh sửa: Chuyển đổi sang int có thể được định nghĩa là bất cứ điều gì có tính chất này

Int.TryParse, (int), Convert.ToIntVv

80836 hội ( 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

Điều này thêm, chữ số theo chữ số, từ phải sang trái, mà không chuyển đổi chữ số ascii '0'-'9'sang số nguyên 0-9và mang theo khi cần thiết. Mã byte là mã cho một hàm, có thể được gọi trong C (xem bên dưới).

Mã byte trên được viết bằng tay, từ cụm sau (kiểu NASM, đã nhận xét):

; 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

Để thử điều này trong C (gcc, linux, bộ xử lý 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

Phô mai. Nếu bạn không thể mang Mohammad lên núi ....

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

Thuật toán:

1. So sánh biểu diễn chuỗi của int với đầu vào 1 và đầu vào 2.
2. Thêm int đó vào kết quả mỗi trận đấu.
3. Tăng và lặp lại cho đến khi bạn thực hiện hai lần.
4. Nôn về chính mình

Thay đổi

71 ngắn hơn như một mảng.

85 loại bỏ khai báo phương thức và hợp nhất các cuộc gọi đến n.to_s

92 áp dụng một số mẹo

101 lưu một char

102 sử dụng x để tăng

109 cam kết ban đầu

sed, 359 byte (không có định dạng ưa thích)

Tôi vẫn không chắc đây có phải là bản sao của Add mà không cần thêm hay không (hoặc bất kỳ trong số 4 toán tử số học cơ bản) . Trong khi đó, hãy để tôi đăng bài trả lời cho câu hỏi đó. Nó sẽ không chiến thắng bất kỳ môn đánh gôn nào, nhưng đó là một khởi đầu và tôi nghĩ dễ dàng đáp ứng thông số kỹ thuật:

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

Đầu vào được lấy từ STDIN dưới dạng "x y". Đó là lần đầu tiên được chuyển đổi thành "x: 0 :: y:". Sau đó, chúng tôi tăng tất cả các số đến sau ký tự ":", cho đến khi chúng tôi nhận được "x: x: :( x + y):". Cuối cùng chúng tôi trở lại (x + y).

Đầu ra

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

Lưu ý rằng điều này chỉ hoạt động cho các số tự nhiên. Tuy nhiên (về lý thuyết ít nhất) nó hoạt động cho các số nguyên lớn tùy ý. Vì chúng tôi đang thực hiện các thao tác tăng x trên y, nên việc đặt hàng có thể tạo ra sự khác biệt lớn về tốc độ: x <y sẽ nhanh hơn x> y.

Hồng ngọc - 485 432 265

Điều này dường như nhiều hơn trong tinh thần của những gì bạn đang tìm kiếm trong câu hỏi.

Về cơ bản, nó giải quyết vấn đề con người sẽ làm thế nào trên giấy - bằng cách "ghi nhớ" tất cả các kết quả bổ sung một chữ số, thêm từng cột và hiểu cách "mang theo" khi cần thiết.

Điều này cũng sử dụng một "kiểu dữ liệu số" (biến i), bị cấm bởi câu hỏi, nhưng nó chỉ dành cho lập chỉ mục chuỗi. Tôi sẽ thử loại bỏ điều này và chỉnh sửa câu trả lời của tô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

Hơi vô dụng:

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: Đã sử dụng một số ý tưởng từ các bình luận để tạo bảng ánh xạ "ghi nhớ" thay vì chỉ mã hóa nó.

CJam, 95 92 80 72 70 44 ký tự

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

dịch ra

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

Điều này chắc chắn có thể được chơi golf rất nhiều. Tôi thực sự không biết cách tiếp cận của tôi là tối ưu hay chưa.

CẬP NHẬT - Nội tuyến tạo ma trận tổng để lưu byte. Do đó, chương trình này chạy chậm hơn 10 lần, nhưng vẫn là thời gian không đổi cho bất kỳ loại đầu vào nào.

Dùng thử trực tuyến tại đây

Đọc dòng chứa hai số từ STDIN dưới dạng chuỗi và xuất ra dưới dạng một mảng các ký tự là một chuỗi.

Ví dụ:

123 4567

Đầu ra chứa trước 0. Hãy cho tôi biết nếu đó là một vấn đề.

C # - 128 108 104

Cảm ơn La bàn, BMac và Shawn đã đề xuất cải tiến.

Lần thử đầu tiên tại Code Golf và sử dụng C # dường như là một bất lợi ở đây ...

Bằng cách sử dụng, .Compute()bạn có thể sử dụng các giá trị chuỗi và tính tổng chúng trực tiếp. Là một phần thưởng, điều này hoạt động cho các nhà khai thác khác ngoài "+".

Chơi gôn

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

Ung dung:

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

Gọi điện thoại t("123","456");giúp bạn 579.

GNU sed, 266 byte

Sử dụng một cách tiếp cận khác với giải pháp của DigitalTrauma. Như một hiệu ứng, cái này thực hiện thậm chí còn kém hơn, sử dụng O (m + n) . Chuyển đổi cả hai toán hạng thành unary, concatenate, chuyển đổi trở lại thập phân (tất cả đều sử dụng regex của khóa học sed sed không có khái niệm về một số nguyên).

Như một phần thưởng, chương trình này tổng hợp tất cả các số nguyên tự nhiên được cung cấp trên stdin (trong dòng đầu tiên), có nghĩa là bạn không thể cung cấp cho nó bất cứ thứ gì, một số hoặc mười số và nó sẽ làm đúng mọi thứ.

Ý tưởng đằng sau mã này được lấy cảm hứng mơ hồ từ bản đệ trình sed PPCG cũ của tôi, mặc dù tôi không nhớ câu hỏi đó là câu trả lời.

Ở đây, "khá" được in để "thuận tiện" cho bạn, để mượn một ý tưởng khác từ 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#

(Để có được phiên bản 266 byte, hãy xóa dấu chấm phẩy, khoảng trắng hàng đầu và nhận xét cuối cùng, tốt nhất là sử dụng sed.)

Mượn một số bài kiểm tra từ 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

Tôi đã điều chỉnh các bài kiểm tra thực sự lớn một chút vì hiệu quả không gian (trong) khủng khiếp. Do chỉ sử dụng qdòng đầu tiên được xử lý, do đó whilevòng lặp trong thử nghiệm.

Java 6 (181 ký tự)

Không chịu thua kém bởi handicap được gọi là C # , Java trong tất cả vinh quang của nó. Quá nhiều nồi hơi! Cách sử dụng đang cung cấp các đối số được phân tách bằng khoảng trắng, nghĩa là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]));}}

Ung dung:

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

Bằng cách sử dụng công cụ JavaScript có sẵn javax, chúng tôi có thể khiến một ngôn ngữ khác thực hiện công việc cho chúng tôi và về mặt kỹ thuật tuân theo quy tắc không sử dụng bất kỳ loại số nào trong ngôn ngữ bản địa hoặc chuyển đổi.

Biện minh cho việc sử dụng eval

Chúng tôi chưa chuyển đổi các giá trị thành int cho JavaScript thành eval. Chúng tôi đã tạo một Chuỗi "123+456"không phải là số. Công cụ JS tiêu hóa công thức và đánh giá Chuỗi dưới dạng chữ số, không phải là kiểu dữ liệu số. Logic cheesy Java! Như một bên, điều này cũng làm việc cho doubletoán học.

APL (61)

Tôi nghĩ rằng điều này nằm trong các quy tắc.

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

Đây là một hàm có hai đối số chuỗi và trả về một chuỗi:

      '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

Nó cũng khá nhanh, nó bổ sung số được hình thành bởi 999999 9giây ngay lập tức.

Nó tìm thấy chỉ mục của từng ký tự ⎕D(là chuỗi '0123456789'), sau đó thực hiện bổ sung trường học trên từng chỉ số một cách riêng biệt, mang theo khi cần thiết, sau đó tìm kiếm các chữ số kết quả ⎕D. (Tôi nghĩ rằng việc ⎕Dtra cứu nằm trong các quy tắc, về cơ bản nó chỉ đang làm'x'-48 ).

Giải trình:

• ⎕D∘⍳¨⍺⍵: tra cứu các chỉ số ⎕Dcho mỗi ký tự trong cả hai chuỗi.
• ¯1+: trừ đi 1từng phần, bởi vì các mảng được dựa trên 1 theo mặc định.
• ⌽↑⌽¨: đảo ngược cả hai, biến thành ma trận (điền vào các ô vuông trống bằng 0), sau đó đảo ngược ma trận.
• +⌿: tổng các cột của ma trận
• {... }: mang qua:
  • ∨/T←9<Z←0,⍵: thêm một phần phụ 0trước danh sách. Tìm ra 'chữ số' nào cao hơn 9 và lưu nó vàoT . Nếu bất kỳ chữ số nào cao hơn 10:
    • Z-10×T: trừ 10từ mỗi vị trí cao hơn 10,
    • T←(1⌽T)+: thêm 1vào từng vị trí bên cạnh mỗi vị trí cao hơn 10 và lưu trữ trong T.
    • T↓⍨~×⊃T: nếu Tbắt đầu bằng 0, hãy xóa nó,
    • ∇: áp dụng hàm carry cho kết quả.
  • ⋄⍵: nếu không, trả về giá trị không đổi
• 1+: thêm một vào mỗi vị trí (vì mảng được lập chỉ mục 1)
• ⎕D[... ]: sử dụng kết quả như các chỉ số vào ⎕D.

Perl - 136 119 115 byte

Tôi đang học Perl, điều này có vẻ như là thực hành tốt. Lời khuyên được đánh giá cao!

Câu trả lời phô mai, để có được điều đó ra khỏi đường đi:

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

Câu trả lời thực tế:

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

Không nén

($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, Điểm = 252

Sử dụng không có số nguyên, độ dài, byte, quần short, đôi, float hoặc bất kỳ chức năng thư viện tích hợp nào để thêm. Bọc trong một cơ thể lớp và gọi với t(String1,String2). Vui lòng đệm các chuỗi có 0 để chúng có độ dài bằng nhau.

t("123","234")trả lại "0357".

Chơi gôn

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 Mở rộng với lớp:

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

Mở rộng một phần golf:

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

Mở rộng 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 ký tự

như mọi người đều biết java, không có ngôn ngữ nào tốt hơn để chơi gôn hơn 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);}}

đây là giải pháp vô căn cứ

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

* Điều này làm cho một vài giả định:

• Chúng tôi đang ở trong môi trường REPL ES6 (ví dụ: bảng điều khiển trình duyệt FireFox 33.1)
• Hiệu suất không thành vấn đề (nghiêm túc, '9999999999', '9999999999' mất khoảng 20 phút để trở về)
• Chuyển đổi từ Integer sang String được cho phép
• Đầu vào được xác định trong các biến a và b, ví dụ:var a='123',b=321'; Thay đổi để nhận đầu vào từ dấu nhắc (+11).
• Đầu vào không có số 0 đứng đầu.

Python 2.7, 196 137 ký tự

phiên bản 2 (ngắn hơn bằng cách khởi tạo từ điển bằng mã):

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

Phiên bản trước 1 (196 ký tự):

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

ví dụ

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

Các khóa từ điển là các chuỗi, các giá trị từ điển chỉ bao gồm các hằng số để rút ngắn mã và việc tính toán được thực hiện bằng cách nối hai chuỗi và lấy độ dài kết quả, vì vậy tôi hy vọng nó được tính là "không chuyển đổi chúng thành ints".

Python phiên bản quy tắc-in nhỏ

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

Ghi chú:

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

Loại z là loại tùy chỉnh tôi xác định là: chắc chắn không phải là loại số theo bất kỳ định nghĩa nào mà người hỏi sử dụng, nhưng hành xử đủ gần với loại số sẽ hữu ích trong các trường hợp hạn chế . Các hành vi loại z chỉ được triển khai một phần trong mẫu mã này và nếu trình thông dịch CPython sử dụng 'int' để triển khai z , thì đó chỉ là một chi tiết triển khai và không liên quan đến vấn đề.