Seu desafio é criar um programa ou função que produza o GCD de suas entradas em um idioma e o LCM de suas entradas em outro. Builtins para GCD ou LCM (estou olhando para você, Mathematica) são permitidos, mas não incentivados. Haverá 2 entradas, que sempre serão números inteiros positivos, nunca maiores que 1000.

Casos de teste

Cada linha é um caso de teste no 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

Veja esta pasta para todas as entradas possíveis com 0 < x, y < 31. Observe que versões diferentes dos mesmos idiomas contam como idiomas diferentes.

Gelatina / Na verdade , 2 bytes

00000000: 1e 67                                            .g

Este é um hexdump (xxd) do programa enviado. Não pode ser testado online porque o TIO não suporta a codificação CP437. A @Mego teve a gentileza de verificar se isso funciona no Cygwin, que implementa o CP437 como pretendido na verdade.

Geléia: GCD

Jelly usa a página de código Jelly , para ver os seguintes caracteres.

œg

Experimente online!

Como funciona

œé um token incompleto e, portanto, ignorado. gé o GCD embutido.

Na verdade: LCM

Na verdade, usa o CP 437 , para ver os seguintes caracteres.

▲g

Experimente online!

Como funciona

▲é a entrada LCM. Como g(GCD) requer duas entradas inteiras, ele não é executado.

C / C ++, 79 78 73 bytes

Agradecemos a @ETHproductions por salvar um 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 o GCD: Experimente online!

C ++ calcula o LCM: Experimente online!

Em C, auto e=.5declara uma variável inteira com a classe de armazenamento automático (que é o padrão), que é inicializada como 0, enquanto que em C ++ 11 declara um duplo, inicializado como 0,5. Portanto, o valor da variável será verdadeiro em C ++ e falso em C.

A função calcula o GCD com o algoritmo de Euclid e o LCM dividindo o produto de aeb pelo GCD.

A omissão da declaração de retorno funciona pelo menos no GCC. A solução de 78 bytes abaixo deve funcionar com qualquer 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;}

Na verdade / geléia , 3 bytes

00000000: 11 1c 67                                         ..g

Este é um hexdump (xxd) do programa enviado.

Experimente online! ¹

Na verdade: GCD

Na verdade, usa o CP 437 , para ver os seguintes caracteres.

◄∟g

Experimente online!

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

Geléia: LCM

Jelly usa a página de código Jelly , para ver os seguintes caracteres.

×÷g    

Experimente online!

Como 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: A fórmula GCD (a, b) lcm (a, b) = ab segura porque um e b são positivos.

^{1 O} _{TIO realmente usa UTF-8 para Na verdade. Como os caracteres ASCII e CP437 0x11 e 0x1c não estão atribuídos, o programa funciona mesmo assim.}

Alice e Jelly , 9 bytes

Alice calcula o LCM:

//L
oi@g

Experimente online!

O que parece um espaço é realmente 0x7Fo DELpersonagem de controle.

Jelly calcula o GCD. Como o Jelly usa sua própria página de códigos, compatível apenas com ASCII imprimível, o avanço de linha e o caractere DEL se transformam em ½avanço de linha, respectivamente:

//L½oi@
g

Experimente online!

Explicações

A geléia é trivial: a primeira linha define um link auxiliar sem sentido, a segunda linha é o programa real e simplesmente contém o GCD embutido.

Alice é um pouco mais complicada, mas também usa um 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.

Oitava / MATLAB, 66 61 bytes

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

Economizou 5 bytes graças a Foon. (x*y)^any()era obviamente mais curto que 1+(x*y-1)*any().

Bem, pelo menos ele não usa o built-in para lcm.

Explicação:

Isso usa o builtin gcdpara calcular o maior divisor comum.

Na oitava, isso é levado ao poder de 1-2*any(version==82). any(version==82)está 0na oitava, então isso é simples gcd(x,y)^1. É multiplicado por (x*y)^any(version==82), ou (x*y)^0 = 1.

Para o MATLAB, gcdé elevado ao poder de 1-2*any(version==82). any(version==82)está 1no MATLAB, então está gcd(x,y)^-1. É multiplicado por (x*y)^any(version==82), ou (x*y)^1 = x*y. Isso fornece o menor múltiplo comum, já que lcm(x,y) == x*y/gcd(x,y)para números positivos.

Geléia e MATL , 6 5 bytes

ZmD
g

Este é um programa completo em um dos dois idiomas. Ele calcula o GCD no Jelly ( Experimente online! ) E o LCM no MATL ( Experimente online! ). O programa MATL sai com um erro (permitido por padrão) após produzir a saída correta.

Somente caracteres ASCII são usados ​​e, portanto, correspondem aos mesmos bytes codificados nos dois idiomas.

Explicação do GCD em Jelly

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

Explicação do LCM no 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

Avalia gcdem Julia 0.4 ( Experimente online! ) E lcmem Julia 0.5 ( Experimente online! ).

Como funciona

Em Julia 0.4, log.(1)é uma abreviação de getfield(log,1), que retorna a localização da memória do logbuiltin, por exemplo, o ponteiro Ptr{Void} @0x00007f2846cb6660. O resultado é, portanto, diferente de zero, a comparação é falsa e a expressão é avaliada como gcd.

Na Julia 0.5, uma nova sintaxe de vetorização de função foi introduzida. log.(1)agora é uma abreviação para broadcast(log,1), que - como 1não é iterável - simplesmente avalia log(1). O resultado é, portanto, zero, a comparação é verdadeira e a expressão é avaliada como lcm.

Oitava / MATLAB, 44 42 41 bytes

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

Isso define uma função anônima para GCD ( @gcd) na oitava e para LCM ( @lcm) no MATLAB.

Exemplo no Octave (ou Experimente online! ):

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

Exemplo no MATLAB:

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

JS (ES6), CGL (linguagem de golfe CGL) , 31 bytes (não concorrente)

O recurso LCM do CGL foi adicionado após esse desafio.

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

O que parece um espaço é, na verdade, um espaço sem quebra, um comentário para o CGL. JS calcula o GCD:

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

E o CGL calcula o 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

Experimente:

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