Votre défi consiste à créer un programme ou une fonction qui génère le GCD de ses entrées dans une langue et le LCM de ses entrées dans une autre. Les builtins pour GCD ou LCM (je vous regarde, Mathematica) sont autorisés mais pas encouragés. Il y aura 2 entrées, qui seront toujours des entiers positifs, jamais supérieurs à 1000.

Cas de test

Chaque ligne est un cas de test au 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

Voir cette boîte à pâte pour toutes les entrées possibles avec 0 < x, y < 31. Notez que différentes versions des mêmes langues comptent comme des langues différentes.

Gelée / En fait , 2 octets

00000000: 1e 67                                            .g

Il s'agit d'un hexdump (xxd) du programme soumis. Il ne peut pas être testé en ligne car TIO ne prend pas en charge le codage CP437. @Mego a eu la gentillesse de vérifier que cela fonctionne sur Cygwin, qui implémente CP437 comme prévu pour Actually.

Gelée: GCD

Jelly utilise la page de codes Jelly , donc il voit les caractères suivants.

œg

Essayez-le en ligne!

Comment ça marche

œest un jeton incomplet et donc ignoré. gest le GCD intégré.

En fait: LCM

Utilise en fait le CP 437 , il voit donc les caractères suivants.

▲g

Essayez-le en ligne!

Comment ça marche

▲est l'entrée LCM. Puisque g(GCD) nécessite deux entrées entières, il n'est pas exécuté.

C / C ++, 79 78 73 octets

Merci à @ETHproductions pour avoir sauvé un octet!

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 calcule le GCD: Essayez-le en ligne!

C ++ calcule le LCM: essayez-le en ligne!

En C, auto e=.5déclare une variable entière avec la classe de stockage automatique (qui est la valeur par défaut), qui est ensuite initialisée à 0, tandis qu'en C ++ 11, elle déclare un double, qui est initialisé à 0,5. Ainsi, la valeur de la variable sera véridique en C ++ et fausse en C.

La fonction calcule le GCD avec l'algorithme d'Euclide et le LCM en divisant le produit de a et b par le GCD.

L'omission de la déclaration de retour fonctionne au moins sur GCC. La solution de 78 octets ci-dessous devrait fonctionner avec n'importe quel compilateur:

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

En fait / Jelly , 3 octets

00000000: 11 1c 67                                         ..g

Il s'agit d'un hexdump (xxd) du programme soumis.

Essayez-le en ligne! ¹

En fait: GCD

Utilise en fait le CP 437 , il voit donc les caractères suivants.

◄∟g

Essayez-le en ligne!

Comment ça marche

     (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ée: LCM

Jelly utilise la page de codes Jelly , donc il voit les caractères suivants.

×÷g    

Essayez-le en ligne!

Comment ça marche

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

Remarque: La formule gcd (a, b) lcm (a, b) = ab est valable car a et b sont positifs.

¹ _{TIO utilise réellement UTF-8 pour Actually. Étant donné que les caractères ASCII et les caractères CP437 0x11 et 0x1c ne sont pas attribués, le programme fonctionne néanmoins.}

Alice et Jelly , 9 octets

Alice calcule le LCM:

//L
oi@g

Essayez-le en ligne!

Ce qui ressemble à un espace, c'est vraiment 0x7Fle DELpersonnage de contrôle.

Jelly calcule le GCD. Étant donné que Jelly utilise sa propre page de codes qui n'est compatible qu'avec l'ASCII imprimable, les caractères de saut de ligne et DEL se transforment respectivement en ½saut de ligne:

//L½oi@
g

Essayez-le en ligne!

Explications

Jelly est trivial: la première ligne définit un lien auxiliaire absurde, la deuxième ligne est le programme réel et contient simplement le GCD intégré.

Alice est un peu plus délicate, mais elle utilise également une fonction intégrée:

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

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

Enregistré 5 octets grâce à Foon. (x*y)^any()était bien sûr plus court que 1+(x*y-1)*any().

Eh bien, au moins, il n'utilise pas la fonction intégrée pour lcm.

Explication:

Celui-ci utilise la fonction intégrée gcdpour calculer le plus grand diviseur commun.

Dans Octave, cela est élevé au pouvoir de 1-2*any(version==82). any(version==82)est 0à Octave, c'est tout simplement gcd(x,y)^1. Il est multiplié par (x*y)^any(version==82)ou (x*y)^0 = 1.

Pour MATLAB, gcdest élevé au pouvoir de 1-2*any(version==82). any(version==82)est 1dans MATLAB, c'est donc gcd(x,y)^-1. Il s'est multiplié par (x*y)^any(version==82)ou (x*y)^1 = x*y. Cela donne le plus petit multiple commun, car lcm(x,y) == x*y/gcd(x,y)pour les nombres positifs.

Gelée et MATL , 6 5 octets

ZmD
g

Il s'agit d'un programme complet dans l'une des deux langues. Il calcule le GCD dans Jelly ( Essayez-le en ligne! ) Et le LCM dans MATL ( Essayez-le en ligne! ). Le programme MATL se termine avec une erreur (autorisée par défaut) après avoir produit la sortie correcte.

Seuls les caractères ASCII sont utilisés, ils correspondent donc aux mêmes octets codés dans les deux langues.

Explication de GCD dans Jelly

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

Explication de LCM dans 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 octets

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

Évalue à gcddans Julia 0.4 ( Essayez-le en ligne! ) Et à lcmdans Julia 0.5 ( Essayez-le en ligne! ).

Comment ça marche

Dans Julia 0.4, log.(1)est un raccourci pour getfield(log,1), qui renvoie l'emplacement de mémoire de la commande logintégrée, par exemple, le pointeur Ptr{Void} @0x00007f2846cb6660. Le résultat est donc non nul, la comparaison est fausse et l'expression est évaluée à gcd.

Dans Julia 0.5, une nouvelle syntaxe de vectorisation de fonctions a été introduite. log.(1)est maintenant un raccourci pour broadcast(log,1), qui - puisqu'il 1n'est pas itérable - évalue simplement log(1). Le résultat est donc nul, la comparaison est vraie et l'expression est évaluée à lcm.

Octave / MATLAB, 44 42 41 octets

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

Ceci définit une fonction anonyme pour GCD ( @gcd) dans Octave et pour LCM ( @lcm) dans MATLAB.

Exemple dans Octave (ou essayez-le en ligne! ):

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

Exemple dans MATLAB:

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

JS (ES6), CGL (CGL Golfing Language) , 31 octets (hors compétition)

La fonction LCM de CGL a été ajoutée après ce défi.

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

Ce qui ressemble à un espace est en fait un espace insécable, un commentaire pour CGL. JS calcule le GCD:

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

Et CGL calcule le 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

Essaye le:

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