Vấn đề:

Mục tiêu của bạn là thêm hai số đầu vào mà không sử dụng bất kỳ toán tử toán học nào sau đây : +,-,*,/.

Ngoài ra, bạn không thể sử dụng bất kỳ hàm dựng sẵn nào được thiết kế để thay thế các toán tử toán học đó.

Ghi điểm:

Mã nhỏ nhất (về số byte) thắng.

Cập nhật

Hầu hết các chương trình tôi đã thấy hoặc ghép hai mảng chứa số của chúng hoặc tạo first numberthành một ký tự, nối các second numberký tự, sau đó đếm tất cả.

Bộ đếm mảng ngắn nhất: APL với 8 ký tự, bởi Tobia

Ghép mảng ngắn nhất: Golfscript với 4 ký tự, bởi Doorknob

Giải pháp logarit ngắn nhất: TI-89 Basic với 19 ký tự, bởi Quincunx

Giải pháp tích hợp: Mathicala với 45 ký tự, bởi Michael Stern

Thú vị nhất, theo ý kiến ​​của tôi: các toán tử bitwise trong javascript, bởi dave

Smalltalk, 21 13

Tất cả những điều sau đây chỉ hoạt động trên các số nguyên dương. Xem câu trả lời khác của Smalltalk cho một câu nghiêm túc.

phiên bản 1

chuyển sang một số nguyên lớn và yêu cầu nó cho chỉ số bit cao của nó (xấu, lập chỉ mục ST là dựa trên 1, vì vậy tôi cần một sự thay đổi bên phải bổ sung):

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

phiên bản 2

tương tự, và thậm chí ngắn hơn một chút (do các quy tắc ưu tiên của Smalltalk và không cần dịch chuyển đúng):

1<<a<<b log:2 

phiên bản 3

một biến thể khác của chủ đề "kích thước yêu cầu bộ sưu tập",
cho hai số a và b,

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

sử dụng Khoảng thời gian làm bộ sưu tập, chúng tôi có được phiên bản thân thiện với bộ nhớ hơn ;-) trong 21 ký tự:

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

không khuyến khích cho crunching số nặng, mặc dù.

phiên bản4

Để giải trí, nếu bạn muốn đánh đổi thời gian cho bộ nhớ, hãy thử:

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

thường đủ chính xác (nhưng không bảo đảm ;-)))

phiên bản5

ghi vào một tập tin và yêu cầu nó cho kích thước của nó

(
    [
        '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

Điều này thêm hai biến x và y, chỉ sử dụng các phép toán bit và lưu kết quả trong x.

Điều này làm việc với các số âm, quá.

C - 38 byte

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

Tôi gian lận một chút ở đây, OP nói không sử dụng bất kỳ toán tử toán học nào .

Các *trong printf()định dạng phương tiện mà các lĩnh vực rộng dùng để in các nhân vật được lấy từ một cuộc tranh cãi của printf(), trong trường hợp này, 3 và 4. Giá trị trả về của printf()là số ký tự in. Vì vậy, nó in một ' 'với chiều rộng trường là 3 và một với chiều rộng trường là 4, tạo tổng cộng 3 + 4 ký tự.

Giá trị trả về là các số được thêm vào trong printf()cuộc gọi.

Python - 49 byte

Giả sử đầu vào theo vị trí trong các biến xvà y.

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

Đây byte 61 giải pháp là một chương trình đầy đủ:

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

Xem xét rằng bạn đã không cấm lũy thừa, tôi đã phải đăng bài này. Khi bạn đơn giản hóa biểu thức bằng các thuộc tính của logarit, bạn chỉ cần lấy print input() + input().

Điều này hỗ trợ cả số âm và dấu phẩy động.

Lưu ý: Tôi đã làm theo lời khuyên của gnibbler và chia câu trả lời này thành ba. Đây là giải pháp Mathicala và đây là giải pháp TI-89 Basic .

JavaScript [25 byte]

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

Toán học, 21 byte

Có một số cách để làm điều này trong Mathematica. Một, sử dụng chức năng Tích lũy và ném mọi thứ trừ số cuối cùng trong đầu ra. Như với giải pháp khác của tôi dưới đây, tôi giả sử các số đầu vào nằm trong các biến avà b. 21 byte.

Last@Accumulate@{a, b}

Thú vị hơn, mặc dù có 45 ký tự, sử dụng các số để xác định một dòng và tích hợp bên dưới nó.

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

Như một phần thưởng, cả hai giải pháp đều hoạt động cho tất cả các số phức, không chỉ các số nguyên dương mà dường như là trường hợp đối với một số giải pháp khác ở đây.

GolfScript, 6 4 ký tự / byte

Nhập vào dưới dạng 10, 5(=> 15).

~,+,

Đây +là mảng nối, không bổ sung.

Cách thức hoạt động của nó là ,được sử dụng để tạo một mảng có độ dài mà số đó là ( 0,1,...,n-2,n-1). Điều này được thực hiện cho cả hai số, sau đó các mảng được nối. ,được sử dụng lại cho một mục đích khác, để tìm độ dài của mảng kết quả.

Bây giờ, đây là mẹo . Tôi thực sự thích cái này vì nó lạm dụng định dạng đầu vào. Có vẻ như nó chỉ nhập một mảng, nhưng thực sự, vì đầu vào đang được thực thi dưới dạng mã GolfScript, lần đầu tiên ,đã được thực hiện cho tôi! (Phiên bản 6 ký tự cũ là ~,\,+,với định dạng đầu vào 10 5, tôi đã loại bỏ 2 ký tự bằng cách loại bỏ \,(mảng trao đổi)).

Phiên bản cũ (12) :

Tạo một chức năng f.

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

Các *và +là chuỗi lặp lại và nối tương ứng, không phải là hàm số học.

Giải thích: ntạo chuỗi một ký tự (một dòng mới). Điều này sau đó được lặp đi lặp lại nhiều alần, sau đó điều tương tự được thực hiện với b. Các chuỗi được nối, và sau đó ,được sử dụng cho chiều dài chuỗi.

C, 29 27 byte

Sử dụng số học con trỏ:

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

x được định nghĩa là một con trỏ, nhưng người gọi sẽ truyền một số nguyên.

Một người dùng ẩn danh đã đề xuất các mục sau - cũng là 27 byte, nhưng các tham số là số nguyên:

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

Brainf * ck, 9 36

,>,[-<+>]

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

Điều này hoạt động mà không sử dụng bổ sung đơn giản; nó đi qua và đặt dấu vết của 1 giây và sau đó đếm chúng

Lưu ý: Việc +và -chỉ đơn thuần là gia số đơn lẻ và không có gì có thể được thực hiện trong brainf * ck mà không có chúng. Chúng không thực sự cộng / trừ nên tôi tin rằng điều này vẫn còn có giá trị.

J (6)

Bạn đã không nói rằng chúng tôi không thể sử dụng chức năng succ:

>:@[&0

Sử dụng:

   9>:@[&0(8)
17

Nó chỉ thực hiện 9 lần lặp lại >:trên 8.

Cách tiếp cận danh sách nối cũng hoạt động : #@,&(#&0). Và - tôi biết điều đó trái với quy tắc - Tôi không thể để câu trả lời này mà không có giải pháp J-ish nhất: *&.^(phép nhân theo cấp số nhân).

Bản tin, 41

Chúng tôi xác định hàm với biểu thức 41 byte dài như sau:

/a{0 moveto 0 rmoveto currentpoint pop}def

Sau đó, chúng tôi gọi nó là:

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

Mà cho

25.0

Nó dễ dàng xử lý các tiêu cực và nổi, không giống như hầu hết các đối thủ cạnh tranh :-)

bash, 20 ký tự

(seq 10;seq 4)|wc -l

Smalltalk (nghiêm túc), 123 118 105 (*)

Xin lỗi vì đã trả lời hai lần, nhưng hãy coi đây là một câu trả lời nghiêm túc, trong khi câu hỏi còn lại giống như sự hài hước. Điều sau đây thực sự được thực hiện ngay tại thời điểm này trong tất cả các máy của chúng tôi (mặc dù về phần cứng). Kỳ lạ là nó không xuất hiện trong tâm trí của ai khác ...

Bằng cách kết hợp hai nửa bổ trợ và thực hiện song song tất cả các bit của các từ, chúng tôi nhận được (đầu vào a, b; đầu ra trong s) phiên bản có thể đọc được:

  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           

Các vòng lặp là để truyền mang. Các mặt nạ đảm bảo rằng các số nguyên đã ký được xử lý (không có chúng, chỉ có số không dấu là sở hữu). Họ cũng xác định độ dài từ, ở trên là cho hoạt động 32 bit. Nếu bạn thích bổ sung 68 bit, hãy đổi thành 16rFFFFFFFFFFFFFFF.

phiên bản golf (123 ký tự) (tránh mặt nạ dài bằng cách sử dụng lại trong 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]

(*) Bằng cách sử dụng -1 thay vì 16rFFFFFFFF, chúng ta có thể chơi golf tốt hơn, nhưng mã không còn hoạt động đối với các số chính xác tùy ý, chỉ dành cho smallIntegers có kích thước từ máy (đại diện cho LargeIntegers không được xác định trong tiêu chuẩn 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]

điều này mang lại kích thước mã xuống 105 ký tự.

APL, 8 và 12

Không có gì mới ở đây, phiên bản đếm mảng:

{≢∊⍳¨⍺⍵}

và phiên bản nhật ký log:

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

Tôi chỉ nghĩ rằng họ trông thật tuyệt trong 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 byte (không có định dạng ưa thích)

Xin lỗi vì câu trả lời muộn, và có lẽ là câu trả lời dài nhất ở đây cho đến nay. Nhưng tôi muốn xem nếu điều này là có thể với 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/;
                       # # # # # # #  # # # # # # #

Điều này tương tự với https://codegolf.stackexchange.com/a/38087/11259 , chỉ đơn giản là tăng số trong một chuỗi. Nhưng thay vào đó, nó thực hiện các hoạt động gia tăng trong một vòng lặp.

Đầ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):". Sau đó, chúng tôi cuối cùng đã 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.

Dấu gạch ngang , 18 byte

time -f%e sleep $@

Yêu cầu thời gian GNU 1.7 trở lên. Đầu ra là STDERR.

Hãy thử trực tuyến!

Lưu ý rằng điều này sẽ không hoạt động trong tro B , vì lệnh thời gian dựng sẵn của nó khác với thời gian GNU.

Với chi phí của một byte bổ sung, \timecó thể được sử dụng thay vì timebuộc Bash sử dụng lệnh bên ngoài.

Javascript (67)

Có lẽ tốt hơn nhiều

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

Ruby, 18 ký tự

a.times{b=b.next}

Và hai biến thể dài dòng hơn, 29 ký tự

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

Một phiên bản khác, 32 ký tự

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

C # - trên thế hệ mã bay

Vâng, thực sự có một bổ sung trong đó, nhưng không phải là toán tử + và thậm chí không phải là một hàm khung có thêm, thay vào đó chúng ta tạo ra một phương thức nhanh chóng để thêm vào.

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

Ruby 39

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

R 36

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

trong đó repxây dựng một vectơ của xnhững người theo sau bởi ytwos.

TI Basic 89 - 19 byte

Chạy cái này trong TI-89 (Màn hình chính hoặc ứng dụng lập trình):

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

Điều này sử dụng các quy tắc nhật ký để tính toán x+y, giống như trong giải pháp này . Là một phần thưởng, nó hoạt động cho số thập phân và số nguyên. Nó hoạt động cho tất cả các số thực. Nếu quy tắc logarit vẫn còn hiệu lực với số mũ phức tạp, thì điều này cũng hoạt động với số phức. Tuy nhiên, máy tính của tôi phun ra rác khi tôi cố gắng chèn các số mũ phức tạp.

Cảm ơn Michael Stern đã dạy tôi ký hiệu Mathicala .

Toán học - 21 20 byte

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

Điều này sử dụng cách tiếp cận tương tự như giải pháp này , nhưng nó nằm trong Mathicala để làm cho nó ngắn hơn. Điều này hoạt động cho số âm và dấu phẩy động cũng như số nguyên trong xvà y.

Đơn giản hóa biểu thức bằng cách sử dụng quy tắc log mang lại x+y, nhưng điều này là hợp lệ vì nó sử dụng lũy ​​thừa, không phải là một trong 4 toán tử cơ bản.

C # - chuỗi số

Chúng tôi chuyển đổi cả hai số thành chuỗi, thực hiện bổ sung với cắt chuỗi (với carry và mọi thứ, bạn biết), sau đó phân tích lại thành số nguyên. Đã thử nghiệm với i1, i2 trong 0..200, hoạt động như một lá bùa. Tìm một bổ sung trong cái này!

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

Con trăn - 22 ký tự

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

APL: 2

1⊥

Điều này chuyển đổi các số từ cơ sở 1, vì vậy (n * 1 ^ 1) + (m * 1 ^ 2) chính xác là n + m.

Có thể dùng thử trên TryApl.org

TI-CƠ BẢN, 10

Thêm XvàY

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

K, 2 byte

#&

Ví dụ sử dụng:

  #&7 212
219

Áp dụng toán tử "where" (monadic &) cho các số trong danh sách đầu vào (có thể lấy tự do với định dạng đầu vào). Điều này sẽ tạo ra một danh sách chứa số 0 đầu tiên theo sau là số thứ hai:

  &3 2
0 0 0 1 1

Thông thường toán tử này được sử dụng như một "tập hợp" để tạo ra một danh sách các chỉ số của các phần tử khác không trong danh sách boolean, nhưng dạng tổng quát đôi khi có ích.

Sau đó, chỉ cần lấy số lượng của danh sách đó (monadic #).

Nếu giải thích của tôi về các yêu cầu đầu vào là không thể chấp nhận được, thì giải pháp dài hơn một chút sau đây cũng thực hiện thủ thuật tương tự:

{#&x,y}

Bình thường , 29 byte

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

Hãy thử trực tuyến!

Trình đầu tiên của tôi ở đây!

Điều này biên dịch thành:

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