Masalah:

Tujuan Anda adalah untuk menambahkan dua angka masukan tanpa menggunakan salah satu operator matematika berikut: +,-,*,/.

Selain itu, Anda tidak dapat menggunakan fungsi bawaan yang dirancang untuk menggantikan operator matematika tersebut.

Mencetak:

Kode terkecil (dalam jumlah byte) menang.

Memperbarui

Sebagian besar program yang saya lihat menggabungkan dua array yang berisi angka-angka mereka, atau membuat first numberkarakter, menambahkan second numberkarakter, lalu menghitung semuanya.

Penghitung array terpendek: APL dengan 8 karakter, oleh Tobia

Rangkaian array tersingkat : Golfscript dengan 4 karakter, oleh Doorknob

Solusi logaritmik terpendek: TI-89 Basic dengan 19 karakter, oleh Quincunx

Solusi integrasi: Mathematica dengan 45 karakter, oleh Michael Stern

Paling keren, menurut saya: operator bitwise dalam javascript, oleh dave

Smalltalk, 21 13

Semua yang berikut ini hanya bekerja pada bilangan bulat positif. Lihat jawaban Smalltalk lainnya untuk yang serius.

versi 1

bergeser ke bilangan bulat besar dan meminta indeks bit tinggi (buruk, pengindeksan ST berbasis 1, jadi saya perlu pergeseran kanan tambahan):

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

versi2

serupa, dan bahkan sedikit lebih pendek (karena aturan diutamakan Smalltalk, dan tidak ada pergeseran yang tepat diperlukan):

1<<a<<b log:2 

versi3

variasi lain dari tema "koleksi-menyatukan-meminta ukuran",
diberi dua angka a dan b,

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

menggunakan Interval sebagai koleksi, kami mendapatkan versi yang lebih ramah memori ;-) dalam 21 karakter:

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

tidak direkomendasikan untuk angka berat, meskipun.

versi4

Untuk hiburan Anda, jika Anda ingin menukar waktu dengan ingatan, cobalah:

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

yang biasanya cukup akurat (tetapi tidak ada jaminan ;-)))

versi5

menulis ke file dan meminta ukurannya

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

Ini menambahkan dua variabel x dan y, hanya menggunakan operasi bitwise, dan menyimpan hasilnya dalam x.

Ini bekerja dengan angka negatif juga.

C - 38 byte

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

Saya sedikit curang di sini, OP mengatakan untuk tidak menggunakan operator matematika .

The *dalam printf()format yang berarti bahwa bidang lebar digunakan untuk mencetak karakter diambil dari sebuah argumen dari printf(), dalam hal ini, 3 dan 4. Nilai kembali dari printf()adalah jumlah karakter yang dicetak. Jadi itu mencetak satu ' 'dengan lebar bidang 3, dan satu dengan lebar bidang 4, membuat total 3 + 4 karakter.

Nilai kembali adalah nomor yang ditambahkan dalam printf()panggilan.

Python - 49 byte

Mengasumsikan input oleh penempatan dalam variabel xdan y.

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

Ini 61 byte solusi adalah program penuh:

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

Mengingat Anda tidak melarang eksponensial, saya harus memposting ini. Saat Anda menyederhanakan ekspresi menggunakan properti logaritma, Anda cukup mendapatkannya print input() + input().

Ini mendukung angka negatif dan angka mengambang.

Catatan: Saya mengikuti saran gnibbler dan membagi jawaban ini menjadi tiga. Ini adalah solusi Mathematica , dan ini adalah solusi Dasar TI-89 .

JavaScript [25 byte]

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

Mathematica, 21 byte

Ada sejumlah cara untuk melakukan ini di Mathematica. Pertama, gunakan fungsi Akumulasi dan lemparkan semuanya kecuali angka terakhir pada output. Seperti dengan solusi saya yang lain di bawah ini, saya berasumsi nomor input dalam variabel adan b. 21 byte

Last@Accumulate@{a, b}

Lebih menyenangkan, meskipun 45 karakter, gunakan angka-angka untuk menentukan garis dan berintegrasi di bawahnya.

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

Sebagai bonus, kedua solusi bekerja untuk semua bilangan kompleks, bukan hanya bilangan bulat positif yang tampaknya menjadi masalah untuk beberapa solusi lain di sini.

GolfScript, 6 4 karakter / byte

Masukan dalam bentuk 10, 5(=> 15).

~,+,

Ini +adalah rangkaian array, bukan tambahan.

Cara kerjanya adalah yang ,digunakan untuk membuat array dengan panjang angka tersebut ( 0,1,...,n-2,n-1). Ini dilakukan untuk kedua angka, maka array digabungkan. ,digunakan lagi untuk tujuan yang berbeda, untuk menemukan panjang array yang dihasilkan.

Sekarang, inilah triknya . Saya sangat suka yang ini karena menyalahgunakan format input. Ini terlihat seperti itu hanya memasukkan array, tapi benar-benar, karena input sedang dijalankan sebagai kode GolfScript, yang pertama ,sudah dilakukan untuk saya! (Versi 6-karakter lama ~,\,+,dengan format input 10 5, yang saya mencukur 2 karakter dengan menghilangkan \,(swap-array)).

Versi lama (12) :

Menciptakan suatu fungsi f.

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

Masing *-masing +adalah pengulangan dan penggabungan string, bukan fungsi aritmatika.

Penjelasan: nmembuat string satu karakter (baris baru). Ini kemudian berulang akali, maka hal yang sama dilakukan dengan b. String digabungkan, dan kemudian ,digunakan untuk panjang string.

C, 29 27 Bytes

Menggunakan pointer aritmatika:

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

x didefinisikan sebagai pointer, tetapi pemanggil harus melewati bilangan bulat.

Seorang pengguna anonim menyarankan yang berikut - juga 27 byte, tetapi parameternya adalah bilangan bulat:

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

Brainf * ck, 9 36

,>,[-<+>]

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

Ini berfungsi tanpa menggunakan penambahan sederhana; melewati dan meletakkan jejak 1 dan kemudian menghitungnya

Catatan: The +dan -hanyalah peningkatan tunggal dan tidak ada yang dapat dilakukan di brainf * ck tanpa mereka. Mereka tidak benar-benar penambahan / pengurangan jadi saya percaya ini masih diperhitungkan.

J (6)

Anda tidak mengatakan kami tidak dapat menggunakan fungsi succ:

>:@[&0

Pemakaian:

   9>:@[&0(8)
17

Itu hanya 9 pengulangan >:pada 8.

Pendekatan daftar Rangkaian bekerja, juga: #@,&(#&0). Dan - saya tahu itu melanggar aturan - saya tidak bisa membiarkan jawaban ini pergi tanpa solusi J-ish yang paling: *&.^(perkalian di bawah eksponensial).

Catatan tambahan, 41

Kami mendefinisikan fungsi dengan ekspresi 41 byte sepanjang:

/a{0 moveto 0 rmoveto currentpoint pop}def

Kemudian kita menyebutnya sebagai:

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

Pemberian yang mana

25.0

Ini dengan mudah menangani hal negatif dan mengapung, tidak seperti kebanyakan pesaing :-)

bash, 20 karakter

(seq 10;seq 4)|wc -l

Smalltalk (sekarang serius), 123 118 105 (*)

Maaf telah menjawab dua kali, tetapi anggap ini jawaban yang serius, sementara yang lain lebih seperti humor. Berikut ini sebenarnya dieksekusi tepat pada saat ini di semua mesin kami (dalam perangkat keras, meskipun). Aneh bahwa itu datang ke pikiran orang lain ...

Dengan menggabungkan dua setengah-adders, dan melakukan semua bit dari kata-kata secara paralel, kita mendapatkan (input a, b; output dalam s) versi yang dapat dibaca:

  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           

Loop untuk propagasi carry. Topeng memastikan bahwa bilangan bulat yang ditandatangani ditangani (tanpa mereka, hanya nomor yang tidak ditandatangani yang mungkin). Mereka juga menentukan panjang kata, di atas adalah untuk operasi 32bit. Jika Anda lebih suka penambahan 68bit, ubah ke 16rFFFFFFFFFFFFFFFFFFF.

versi golf (123 karakter) (menghindari topeng panjang dengan menggunakan kembali dalam 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]

(*) Dengan menggunakan -1 alih-alih 16rFFFFFFFFFF, kita dapat bermain golf lebih baik, tetapi kode tidak lagi berfungsi untuk angka presisi yang berubah-ubah, hanya untukIntegers berukuran kecil dengan kata mesin (representasi untuk bigIntegers tidak didefinisikan dalam standar 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]

ini membawa ukuran kode ke 105 karakter.

APL, 8 dan 12

Tidak ada yang baru di sini, versi penghitungan array:

{≢∊⍳¨⍺⍵}

dan versi log ○ log:

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

Saya hanya berpikir mereka terlihat keren di 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 (tanpa format mewah)

Maaf untuk jawaban yang terlambat, dan mungkin jawaban terlama di sini sejauh ini. Tapi saya ingin melihat apakah ini mungkin dengan 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/;
                       # # # # # # #  # # # # # # #

Ini mirip dengan https://codegolf.stackexchange.com/a/38087/11259 , yang hanya menambah angka dalam sebuah string. Tetapi sebaliknya ia melakukan operasi kenaikan dalam satu lingkaran.

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, pemesanan dapat membuat perbedaan besar pada kecepatan: x <y akan lebih cepat daripada x> y.

Dash , 18 byte

time -f%e sleep $@

Membutuhkan waktu GNU 1,7 atau lebih tinggi. Outputnya ke STDERR.

Cobalah online!

Perhatikan bahwa ini tidak akan berfungsi dalam B ash, karena perintah waktu bawaannya berbeda dari waktu GNU.

Dengan biaya satu byte tambahan, \timedapat digunakan alih-alih timememaksa Bash untuk menggunakan perintah eksternal.

Javascript (67)

Mungkin ada yang jauh lebih baik

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

Ruby, 18 karakter

a.times{b=b.next}

Dan dua varian verbose lagi, 29 karakter

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

Versi lain, 32 karakter

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

C # - pada pembuatan kode fly

Ya, sebenarnya ada tambahan di sana, tetapi bukan operator + dan bahkan tidak ada fungsi framework yang menambahkan, sebaliknya kita menghasilkan metode on the fly yang melakukan penambahan.

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

di mana repmembangun vektor xyang diikuti oleh ydua-dua.

TI Basic 89 - 19 byte

Jalankan ini di TI-89 Anda (Layar awal atau aplikasi pemrograman):

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

Ini menggunakan aturan log untuk menghitung x+y, seperti dalam solusi ini . Sebagai bonus, ini berfungsi untuk angka desimal dan bilangan bulat. Ini bekerja untuk semua bilangan real. Jika aturan logaritma masih valid dengan eksponen kompleks, maka ini berfungsi untuk bilangan kompleks juga. Namun, kalkulator saya mengeluarkan sampah ketika saya mencoba memasukkan eksponen yang kompleks.

Terimakasih untuk Michael Stern karena mengajari saya notasi Mathematica .

Mathematica - 21 20 byte

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

Ini menggunakan pendekatan yang sama dengan solusi ini , tetapi ada di Mathematica untuk membuatnya lebih pendek. Ini berfungsi untuk angka titik negatif dan mengambang serta bilangan bulat di xdan y.

Menyederhanakan ekspresi menggunakan hasil aturan log x+y, tapi ini valid karena menggunakan eksponensial, bukan salah satu dari 4 operator dasar.

C # - string aritmatika

Kami mengonversi kedua angka menjadi string, melakukan penambahan dengan memotong string (dengan carry dan semuanya, Anda tahu), lalu mengurai kembali ke integer. Diuji dengan i1, i2 di 0..200, bekerja seperti pesona. Temukan tambahan di sini!

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

Python - 22 karakter

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

APL: 2

1⊥

Ini mengubah angka-angka dari basis 1, jadi (n * 1 ^ 1) + (m * 1 ^ 2) yang persis n + m.

Dapat dicoba di TryApl.org

TI-BASIC, 10

Tambah XdanY

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

K, 2 byte

#&

Contoh penggunaan:

  #&7 212
219

Terapkan operator "di mana" (monadik &) ke angka-angka dalam daftar input (mungkin mengambil kebebasan dengan format input). Ini akan menghasilkan daftar yang berisi angka nol pertama diikuti oleh angka kedua:

  &3 2
0 0 0 1 1

Biasanya operator ini digunakan sebagai "kumpul" untuk menghasilkan daftar indeks elemen bukan-nol dari daftar boolean, tetapi bentuk umum kadang-kadang berguna.

Maka cukup ambil hitungan daftar itu (monadik #).

Jika interpretasi saya terhadap persyaratan input tidak dapat diterima, solusi yang sedikit lebih lama berikut melakukan trik yang sama:

{#&x,y}

Pyth , 29 byte

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

Cobalah online!

Kiriman pertama saya di sini!

Ini mengkompilasi ke:

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