La tua sfida è creare un programma o una funzione che emetta il GCD dei suoi input in una lingua e il LCM dei suoi input in un'altra. I builtin per GCD o LCM (ti sto guardando, Mathematica) sono ammessi ma non incoraggiati. Ci saranno 2 ingressi, che saranno sempre numeri interi positivi, mai superiori a 1000.

Casi test

Ogni riga è un caso di test nel formato 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

Vedi questo pastebin per tutti i possibili input con 0 < x, y < 31. Si noti che versioni diverse delle stesse lingue contano come lingue diverse.

Gelatina / In realtà , 2 byte

00000000: 1e 67                                            .g

Questo è un hexdump (xxd) del programma inviato. Non può essere testato online perché TIO non supporta la codifica CP437. @Mego è stato così gentile da verificare che questo funzioni su Cygwin, che implementa CP437 come previsto per Actually.

Gelatina: GCD

Jelly utilizza la tabella codici Jelly , quindi vede i seguenti caratteri.

œg

Provalo online!

Come funziona

œè un token incompleto e quindi ignorato. gè il GCD integrato.

In realtà: LCM

Attualmente utilizza CP 437 , quindi vede i seguenti caratteri.

▲g

Provalo online!

Come funziona

▲è l'ingresso LCM. Poiché g(GCD) richiede due ingressi interi, non viene eseguito.

C / C ++, 79 78 73 byte

Grazie a @ETHproductions per aver salvato un 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 calcola il GCD: provalo online!

C ++ calcola l'LCM: provalo online!

In C, auto e=.5dichiara una variabile intera con la classe di memorizzazione automatica (che è l'impostazione predefinita), che viene quindi inizializzata su 0, mentre in C ++ 11 dichiara un doppio, che viene inizializzato su 0,5. Quindi il valore della variabile sarà veritiero in C ++ e falso in C.

La funzione calcola il GCD con l'algoritmo di Euclide e il LCM dividendo il prodotto di aeb dal GCD.

L'omissione della dichiarazione di ritorno funziona almeno su GCC. La seguente soluzione da 78 byte dovrebbe funzionare con qualsiasi compilatore:

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

In realtà / Jelly , 3 byte

00000000: 11 1c 67                                         ..g

Questo è un hexdump (xxd) del programma inviato.

Provalo online! ¹

In realtà: GCD

Attualmente utilizza CP 437 , quindi vede i seguenti caratteri.

◄∟g

Provalo online!

Come funziona

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

Gelatina: LCM

Jelly utilizza la tabella codici Jelly , quindi vede i seguenti caratteri.

×÷g    

Provalo online!

Come funziona

×÷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).

Nota: La formula MCD (a, b) mcm (a, b) = ab tiene perché un e b sono positivi.

¹ _{TIO attualmente utilizza UTF-8 per attualmente. Poiché sia ​​i caratteri ASCII che i caratteri CP437 0x11 e 0x1c non sono assegnati, il programma funziona comunque.}

Alice e Jelly , 9 byte

Alice calcola l'LCM:

//L
oi@g

Provalo online!

Quello che sembra uno spazio è davvero 0x7F, il DELpersonaggio di controllo.

Jelly calcola il GCD. Poiché Jelly utilizza una propria codepage che è compatibile solo con ASCII stampabile, il linefeed e il carattere DEL si trasformano rispettivamente in ½linefeed:

//L½oi@
g

Provalo online!

spiegazioni

Jelly è banale: la prima riga definisce un collegamento di supporto privo di senso, la seconda riga è il programma reale e contiene semplicemente il GCD incorporato.

Alice è un po 'più complicata, ma utilizza anche un 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.

Octave / MATLAB, 66 61 byte

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

5 byte salvati grazie a Foon. (x*y)^any()era ovviamente più breve di 1+(x*y-1)*any().

Beh, almeno non usa il builtin per lcm.

Spiegazione:

Questo utilizza il builtin gcdper calcolare il massimo comune divisore.

In Octave, questo è elevato al potere di 1-2*any(version==82). any(version==82)è 0in Octave, quindi questo è semplicemente gcd(x,y)^1. È moltiplicato per (x*y)^any(version==82), o (x*y)^0 = 1.

Per MATLAB, gcdè elevato al potere di 1-2*any(version==82). any(version==82)è 1in MATLAB, quindi questo è gcd(x,y)^-1. Si è moltiplicato per (x*y)^any(version==82), o (x*y)^1 = x*y. Questo dà il minimo comune multiplo, poiché lcm(x,y) == x*y/gcd(x,y)per i numeri positivi.

Jelly e MATL , 6 5 byte

ZmD
g

Questo è un programma completo in una delle due lingue. Calcola il GCD in Jelly ( provalo online! ) E l'LCM in MATL ( provalo online! ). Il programma MATL si chiude con un errore (consentito per impostazione predefinita) dopo aver prodotto l'output corretto.

Vengono utilizzati solo caratteri ASCII, quindi corrispondono agli stessi byte codificati nelle due lingue.

Spiegazione di GCD in Jelly

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

Spiegazione di LCM in 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 byte

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

Valuta gcdin Julia 0.4 ( Provalo online! ) E lcmin Julia 0.5 ( Provalo online! ).

Come funziona

In Julia 0.4, log.(1)è una scorciatoia per getfield(log,1), che restituisce la posizione di memoria dell'integrato log, ad esempio il puntatore Ptr{Void} @0x00007f2846cb6660. Il risultato è quindi diverso da zero, il confronto è falso e l'espressione valuta gcd.

In Julia 0.5, è stata introdotta una nuova sintassi di vettorializzazione delle funzioni. log.(1)è ora una scorciatoia per broadcast(log,1), che - poiché 1non è iterabile - valuta semplicemente log(1). Il risultato è quindi zero, il confronto è vero e l'espressione valuta lcm.

Octave / MATLAB, 44 42 41 byte

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

Ciò definisce una funzione anonima per GCD ( @gcd) in Octave e per LCM ( @lcm) in MATLAB.

Esempio in Octave (o provalo online! ):

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

Esempio in MATLAB:

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

JS (ES6), CGL (CGL Golfing Language) , 31 byte (non concorrenti)

La funzione LCM di CGL è stata aggiunta dopo questa sfida.

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

Quello che sembra uno spazio è in realtà uno spazio non-break, un commento per CGL. JS calcola il GCD:

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

E CGL calcola l'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

Provalo:

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