Tantangan Anda adalah membuat program atau fungsi yang menampilkan GCD inputnya dalam satu bahasa dan LCM inputnya dalam bahasa lain. Builtins untuk GCD atau LCM (Saya melihat Anda, Mathematica) diizinkan tetapi tidak dianjurkan. Akan ada 2 input, yang akan selalu menjadi bilangan bulat positif, tidak pernah lebih besar dari 1000.

Uji Kasus

Setiap baris adalah satu test case dalam format x y => GCD(x,y) LCM(x,y):

1 1 => 1 1
1 2 => 1 2
4 1 => 1 4
3 4 => 1 12
7 5 => 1 35
18 15 => 3 90
23 23 => 23 23
999 1000 => 1 999000
1000 999 => 1 999000
1000 1000 => 1000 1000

Lihat pastebin ini untuk semua input yang mungkin dengan 0 < x, y < 31. Perhatikan bahwa versi berbeda dari bahasa yang sama dihitung sebagai bahasa yang berbeda.

Jelly / Sebenarnya , 2 byte

00000000: 1e 67                                            .g

Ini adalah hexdump (xxd) dari program yang dikirimkan. Itu tidak dapat diuji secara online karena TIO tidak mendukung pengkodean CP437. @Mego cukup berbaik hati untuk memverifikasi bahwa ini berfungsi di Cygwin, yang mengimplementasikan CP437 sebagaimana dimaksudkan untuk Sebenarnya.

Jelly: GCD

Jelly menggunakan halaman kode Jelly , sehingga ia melihat karakter berikut.

œg

Cobalah online!

Bagaimana itu bekerja

œadalah token yang tidak lengkap dan karenanya diabaikan. gadalah GCD bawaan.

Sebenarnya: LCM

Sebenarnya menggunakan CP 437 , jadi itu melihat karakter berikut.

▲g

Cobalah online!

Bagaimana itu bekerja

▲adalah input LCM. Karena g(GCD) memerlukan dua input integer, itu tidak dijalankan.

C / C ++, 79 78 73 byte

Terima kasih kepada @ETHproductions untuk menghemat satu byte!

int f(int a,int b){int c,d=a*b;for(;a;b=c)c=a,a=b%a;auto e=.5;c=e?d/b:b;}

C menghitung GCD: Coba online!

C ++ menghitung LCM: Coba online!

Dalam C, auto e=.5mendeklarasikan variabel integer dengan kelas penyimpanan otomatis (yang merupakan default), yang kemudian diinisialisasi ke 0, sedangkan dalam C ++ 11 menyatakan ganda, yang diinisialisasi ke 0,5. Jadi nilai variabel akan benar dalam C ++ dan falsy dalam C.

Fungsi menghitung GCD dengan algoritma Euclid, dan LCM dengan membagi produk a dan b oleh GCD.

Menghilangkan pernyataan pengembalian paling tidak berfungsi pada GCC. Solusi 78 byte di bawah ini harus bekerja dengan kompiler apa pun:

int f(int a,int b){int c,d=a*b;for(;a;b=c)c=a,a=b%a;auto e=.5;return e?d/b:b;}

Sebenarnya / Jelly , 3 byte

00000000: 11 1c 67                                         ..g

Ini adalah hexdump (xxd) dari program yang dikirimkan.

Cobalah online! ¹

Sebenarnya: GCD

Sebenarnya menggunakan CP 437 , jadi itu melihat karakter berikut.

◄∟g

Cobalah online!

Bagaimana itu bekerja

     (implicit) Read a and b from STDIN and push them on the stack.
◄    Unassigned. Does nothing.
 ∟   Unassigned. Does nothing.
  g  Pop a and b and push gcd(a,b).
     (implicit) Write the result to STDOUT.

Jelly: LCM

Jelly menggunakan halaman kode Jelly , sehingga ia melihat karakter berikut.

×÷g    

Cobalah online!

Bagaimana itu bekerja

×÷g  Main link. Left argument: a. Right argument: b

×      Multiply; yield ab.
  g    GCD; yield gcd(a,b).
 ÷     Division; yield ab/gcd(a,b) = lcm(a,b).

Catatan: Rumus gcd (a, b) lcm (a, b) = ab tahan karena a dan b positif.

¹ _{TIO sebenarnya menggunakan UTF-8 untuk Actually. Karena karakter ASCII dan CP437 karakter 0x11 dan 0x1c tidak ditetapkan, program tetap bekerja.}

Alice dan Jelly , 9 byte

Alice menghitung LCM:

//L
oi@g

Cobalah online!

Terlihat seperti apa ruang benar-benar 0x7F, yang DELkarakter kontrol.

Jelly menghitung GCD. Karena Jelly menggunakan halaman kode sendiri yang hanya kompatibel dengan ASCII yang dapat dicetak, karakter linefeed dan DEL berubah menjadi ½dan linefeed, masing-masing:

//L½oi@
g

Cobalah online!

Penjelasan

Jelly itu sepele: baris pertama mendefinisikan tautan pembantu yang tidak masuk akal, baris kedua adalah program aktual dan hanya berisi GCD bawaan.

Alice sedikit lebih rumit, tetapi juga menggunakan built-in:

/   Reflect to SE. Switch to Ordinal.
    While in Ordinal mode, the IP bounces diagonally up and down through the grid.
i   Read all input as a single string.
L   Compute the shortest common superstring of an empty string and the input. That
    is simply the input itself, so this does nothing.
    After two more bounces, the IP hits the top right corner and turns
    around, continuing to bounce up and down while moving west.
L   Still does nothing.
i   Try to read more input, but this simply pushes an empty string.
/   Reflect to W. Switch to Cardinal.
    The IP wraps to the last column.
L   Implicitly discard the empty string and convert the input to two integers.
    Compute their LCM.
/   Reflect to NW. Switch to Ordinal.
    The IP immediately reflects off the top boundary to move SW instead.
o   Implicitly convert the LCM to a string and print it.
    Reflect off the bottom left corner and move back NE.
/   Reflect to S. Switch to Cardinal.
i   Try to read a byte, but we're at EOF, so this pushes -1 instead. Irrelevant.
    The IP wraps back to the first line.
/   Reflect to NE. Switch to Ordinal.
    The IP immediately reflects off the top boundary to move SE instead.
@   Terminate the program.

Oktaf / MATLAB, 66 61 byte

@(x,y)gcd(x,y)^(1-2*any(version==82))*(x*y)^any(version==82))

Disimpan 5 byte berkat Foon. (x*y)^any()tentu saja lebih pendek dari 1+(x*y-1)*any().

Yah, setidaknya itu tidak menggunakan builtin untuk lcm.

Penjelasan:

Ini menggunakan builtin gcduntuk menghitung pembagi umum terbesar.

Dalam Oktaf, ini dinaikkan ke kekuatan 1-2*any(version==82). any(version==82)ada 0di Octave, jadi ini sederhana gcd(x,y)^1. Ini dikalikan dengan (x*y)^any(version==82), atau (x*y)^0 = 1.

Untuk MATLAB, gcddinaikkan ke kekuatan 1-2*any(version==82). any(version==82)ada 1di MATLAB, jadi ini gcd(x,y)^-1. Ini dikalikan dengan (x*y)^any(version==82), atau (x*y)^1 = x*y. Ini memberi Least multiple umum, karena lcm(x,y) == x*y/gcd(x,y)untuk angka positif.

Jelly dan MATL , 6 5 byte

ZmD
g

Ini adalah program lengkap dalam salah satu dari dua bahasa. Ini menghitung GCD di Jelly ( Coba online! ) Dan LCM di MATL ( Coba online! ). Program MATL keluar dengan kesalahan (diizinkan secara default) setelah menghasilkan output yang benar.

Hanya karakter ASCII yang digunakan, sehingga sesuai dengan byte yang disandikan dalam dua bahasa.

Penjelasan GCD dalam Jelly

ZmD    Unused link
g      Main link (gets called automatically). Builtin GCD function (g)

Penjelasan LCM di MATL

ZmD    Compute LCM (builtin function Zm) and display immediately (D)
g      Tries to implicitly take input to do something with it (depending
       on the type of the input). Since there is no input, it errors out

Julia 0.4 / Julia 0.5 , 18 bytes

log.(1)==0?lcm:gcd

Mengevaluasi gcddalam Julia 0.4 ( Coba online! ) Dan ke lcmdalam Julia 0.5 ( Coba online! ).

Bagaimana itu bekerja

Dalam Julia 0.4, log.(1)adalah singkatan untuk getfield(log,1), yang mengembalikan lokasi memori logbuiltin, misalnya, pointer Ptr{Void} @0x00007f2846cb6660. Hasilnya adalah bukan nol, perbandingannya salah, dan ekspresi dievaluasi gcd.

Dalam Julia 0.5, sintaksis vektorisasi fungsi baru diperkenalkan. log.(1)sekarang merupakan singkatan broadcast(log,1), yang - karena 1tidak dapat diubah - hanya mengevaluasi log(1). Hasilnya adalah nol, perbandingannya benar, dan ekspresi dievaluasi lcm.

Oktaf / MATLAB, 44 42 41 byte

eval(['@' 'lcm'-[5 0 9]*all(version-82)])

Ini mendefinisikan fungsi anonim untuk GCD ( @gcd) di Oktaf, dan untuk LCM ( @lcm) di MATLAB.

Contoh dalam Oktaf (atau Coba online! ):

>> eval(['@' 'lcm'-[5 0 9]*all(version-82)])
warning: implicit conversion from numeric to char
ans = @gcd
>> ans(12,16)
ans =  4

Contoh dalam MATLAB:

>> eval(['@' 'lcm'-[5 0 9]*all(version-82)])
ans =
    @lcm
>> ans(12,16)
ans =
    48

JS (ES6), CGL (CGL Golfing Language) , 31 byte (tidak bersaing)

Fitur LCM dari CGL ditambahkan setelah tantangan ini.

 g=(a,b)=>b?g(b,a%b):a
//-LⓍ

Apa yang tampak seperti spasi sebenarnya adalah ruang yang tidak melanggar, komentar untuk CGL. JS menghitung GCD:

g=(a,b)=>b?g(b,a%b):a

Dan CGL menghitung LCM:

//  does nothing
- decrements the current stack number, resulting in it pointing to input
L computes the LCM of the first and second stack items and pushes it to the stack
Ⓧ prints out the last stack item

Cobalah:

Snippetify( g=(a,b)=>b?g(b,a%b):a
//-LⓍ
);

<script src="https://programmer5000.com/snippetify.min.js"></script>
<input type = "number">
<input type = "number">