Su desafío es crear un programa o función que genere el GCD de sus entradas en un idioma y el LCM de sus entradas en otro. Las incorporaciones para GCD o LCM (te estoy mirando, Mathematica) están permitidas pero no son recomendables. Habrá 2 entradas, que siempre serán enteros positivos, nunca mayores de 1000.

Casos de prueba

Cada línea es un caso de prueba en el 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

Vea este pastebin para todas las entradas posibles con 0 < x, y < 31. Tenga en cuenta que las diferentes versiones de los mismos idiomas cuentan como idiomas diferentes.

Jalea / En realidad , 2 bytes

00000000: 1e 67                                            .g

Este es un hexdump (xxd) del programa enviado. No se puede probar en línea porque TIO no admite la codificación CP437. @Mego tuvo la amabilidad de verificar que esto funciona en Cygwin, que implementa CP437 según lo previsto para Actually.

Jalea: MCD

Jelly usa la página de códigos Jelly , por lo que ve los siguientes caracteres.

œg

Pruébalo en línea!

Cómo funciona

œes una ficha incompleta y por lo tanto ignorada ges el GCD incorporado.

En realidad: LCM

En realidad usa CP 437 , por lo que ve los siguientes caracteres.

▲g

Pruébalo en línea!

Cómo funciona

▲es la entrada LCM. Como g(GCD) requiere dos entradas enteras, no se ejecuta.

C / C ++, 79 78 73 bytes

¡Gracias a @ETHproductions por guardar 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 calcula el MCD: ¡ Pruébelo en línea!

C ++ calcula el LCM: ¡ Pruébelo en línea!

En C, auto e=.5declara una variable entera con la clase de almacenamiento automático (que es la predeterminada), que luego se inicializa a 0, mientras que en C ++ 11 declara un doble, que se inicializa a 0.5. Entonces el valor de la variable será verdadero en C ++ y falso en C.

La función calcula el MCD con el algoritmo de Euclides y el MCD dividiendo el producto de ayb por el MCD.

Omitir la declaración de devolución funciona al menos en GCC. La solución de 78 bytes a continuación debería funcionar con cualquier compilador:

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

Actualmente / Jelly , 3 bytes

00000000: 11 1c 67                                         ..g

Este es un hexdump (xxd) del programa enviado.

Pruébalo en línea! ¹

En realidad: MCD

En realidad usa CP 437 , por lo que ve los siguientes caracteres.

◄∟g

Pruébalo en línea!

Cómo funciona

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

Jalea: LCM

Jelly usa la página de códigos Jelly , por lo que ve los siguientes caracteres.

×÷g    

Pruébalo en línea!

Cómo funciona

×÷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 fórmula mcd (a, b) mcm (a, b) = ab se cumple porque a y b son positivos.

¹ _{TIO en realidad usa UTF-8 para En realidad. Dado que tanto los caracteres ASCII como los caracteres CP437 0x11 y 0x1c no están asignados, el programa funciona de todos modos.}

Alice y Jelly , 9 bytes

Alice calcula el LCM:

//L
oi@g

Pruébalo en línea!

Lo que parece un espacio es realmente 0x7F, el DELpersonaje de control.

Jelly calcula el MCD. Dado que Jelly usa su propia página de códigos que solo es compatible con ASCII imprimible, el salto de línea y el carácter DEL se convierten en ½y salto de línea, respectivamente:

//L½oi@
g

Pruébalo en línea!

Explicaciones

Jelly es trivial: la primera línea define un enlace auxiliar sin sentido, la segunda línea es el programa real y simplemente contiene el GCD incorporado.

Alice es un poco más complicada, pero también utiliza una función integrada:

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

Octava / MATLAB, 66 61 bytes

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

Guardado 5 bytes gracias a Foon. (x*y)^any()era, por supuesto, más corto que 1+(x*y-1)*any().

Bueno, al menos no usa el incorporado para lcm.

Explicación:

Esto usa el incorporado gcdpara calcular el divisor común más grande.

En Octave, esto se eleva al poder de 1-2*any(version==82). any(version==82)está 0en Octave, así que esto es simplemente gcd(x,y)^1. Se multiplica por (x*y)^any(version==82), o (x*y)^0 = 1.

Para MATLAB, gcdse eleva al poder de 1-2*any(version==82). any(version==82)está 1en MATLAB, así que esto es gcd(x,y)^-1. Se multiplica por (x*y)^any(version==82), o (x*y)^1 = x*y. Esto da el mínimo común múltiplo, ya que lcm(x,y) == x*y/gcd(x,y)para números positivos.

Gelatina y MATL , 6 5 bytes

ZmD
g

Este es un programa completo en cualquiera de los dos idiomas. Calcula el GCD en Jelly (¡ Pruébelo en línea! ) Y el LCM en MATL (¡ Pruébelo en línea! ). El programa MATL sale con un error (permitido por defecto) después de producir la salida correcta.

Solo se utilizan caracteres ASCII, por lo que corresponden a los mismos bytes codificados en los dos idiomas.

Explicación de GCD en gelatina

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

Explicación de LCM en 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

Evalúa a gcden Julia 0.4 (¡ Pruébelo en línea! ) Y a lcmen Julia 0.5 (¡ Pruébelo en línea! ).

Cómo funciona

En Julia 0.4, log.(1)es una forma abreviada de getfield(log,1), que devuelve la ubicación de la memoria del loggenerador, por ejemplo, el puntero Ptr{Void} @0x00007f2846cb6660. Por lo tanto, el resultado no es cero, la comparación es falsa y la expresión se evalúa como gcd.

En Julia 0.5, se introdujo una nueva sintaxis de vectorización de funciones. log.(1)ahora es una abreviatura de broadcast(log,1), que, dado 1que no es iterable, simplemente se evalúa log(1). El resultado es, por lo tanto, cero, la comparación es verdadera y la expresión se evalúa como lcm.

Octava / MATLAB, 44 42 41 bytes

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

Esto define una función anónima para GCD ( @gcd) en Octave y para LCM ( @lcm) en MATLAB.

Ejemplo en Octave (o Pruébelo en línea ):

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

Ejemplo en MATLAB:

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

JS (ES6), CGL (lenguaje de golf CGL) , 31 bytes (no competitivos)

La característica LCM de CGL se agregó después de este desafío.

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

Lo que parece un espacio es en realidad un espacio ininterrumpido, un comentario para CGL. JS calcula el GCD:

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

Y CGL calcula el 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

Pruébalo:

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