Ihre Herausforderung besteht darin, ein Programm oder eine Funktion zu erstellen, die die GCD ihrer Eingaben in einer Sprache und die LCM ihrer Eingaben in einer anderen Sprache ausgibt . Builtins für GCD oder LCM (ich sehe Sie, Mathematica) sind erlaubt, aber nicht empfohlen. Es gibt 2 Eingänge, bei denen es sich immer um positive ganze Zahlen handelt, niemals mehr als 1000.

Testfälle

Jede Zeile ist ein Testfall im 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

In diesem Pastebin finden Sie alle Eingabemöglichkeiten mit 0 < x, y < 31. Beachten Sie, dass unterschiedliche Versionen derselben Sprachen als unterschiedliche Sprachen gelten.

Jelly / Eigentlich 2 Bytes

00000000: 1e 67                                            .g

Dies ist ein Hexdump (xxd) des eingereichten Programms. Es kann nicht online getestet werden, da TIO die CP437-Codierung nicht unterstützt. @Mego hat freundlicherweise überprüft, ob dies auf Cygwin funktioniert, das CP437 wie vorgesehen für Actually implementiert.

Jelly: GCD

Jelly verwendet die Jelly-Codepage , sodass die folgenden Zeichen angezeigt werden.

œg

Probieren Sie es online!

Wie es funktioniert

œist ein unvollständiges Token und wird daher ignoriert. gist der GCD eingebaut.

Eigentlich: LCM

Verwendet tatsächlich CP 437 und sieht daher die folgenden Zeichen.

▲g

Probieren Sie es online!

Wie es funktioniert

▲ist der LCM-Eingang. Da g(GCD) zwei Ganzzahleingaben erfordert , wird es nicht ausgeführt.

C / C ++, 79 78 73 Bytes

Vielen Dank an @ETHproductions für das Speichern eines Bytes!

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 berechnet die GCD: Probieren Sie es online!

C ++ berechnet die LCM: Probieren Sie es online!

In C wird auto e=.5eine Ganzzahlvariable mit der automatischen Speicherklasse deklariert (dies ist die Standardeinstellung), die dann auf 0 initialisiert wird, während in C ++ 11 ein double deklariert wird, das auf 0,5 initialisiert wird. Der Wert der Variablen ist in C ++ also wahr und in C falsch.

Die Funktion berechnet die GCD mit dem Euklid-Algorithmus und die LCM, indem sie das Produkt von a und b durch die GCD dividiert.

Das Weglassen der return-Anweisung funktioniert zumindest bei GCC. Die 78-Byte-Lösung unten sollte mit jedem Compiler funktionieren:

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

Eigentlich / Jelly , 3 Bytes

00000000: 11 1c 67                                         ..g

Dies ist ein Hexdump (xxd) des eingereichten Programms.

Probieren Sie es online! ¹

Eigentlich: GCD

Verwendet tatsächlich CP 437 und sieht daher die folgenden Zeichen.

◄∟g

Probieren Sie es online!

Wie es funktioniert

     (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 verwendet die Jelly-Codepage , sodass die folgenden Zeichen angezeigt werden.

×÷g    

Probieren Sie es online!

Wie es funktioniert

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

Anmerkung: Die Formel gcd (a, b) lcm (a, b) = ab gilt, weil a und b positiv sind.

¹ _{TIO verwendet UTF-8 für Actually. Da sowohl die ASCII-Zeichen als auch die CP437-Zeichen 0x11 und 0x1c nicht zugeordnet sind, funktioniert das Programm trotzdem.}

Alice und Jelly , 9 Bytes

Alice berechnet das LCM:

//L
oi@g

Probieren Sie es online!

Was wie ein Leerzeichen aussieht, ist wirklich 0x7Fdas DELSteuerzeichen.

Jelly berechnet die GCD. Da Jelly eine eigene Codepage verwendet, die nur mit druckbarem ASCII kompatibel ist, werden aus dem Zeilenvorschub und dem DEL-Zeichen ½jeweils Zeilenvorschub und Zeilenvorschub:

//L½oi@
g

Probieren Sie es online!

Erklärungen

Jelly ist trivial: Die erste Zeile definiert eine unsinnige Hilfsverbindung, die zweite Zeile ist das eigentliche Programm und enthält einfach die eingebaute GCD.

Alice ist ein bisschen kniffliger, nutzt aber auch ein eingebautes:

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

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

5 Bytes gespart dank Foon. (x*y)^any()war natürlich kürzer als 1+(x*y-1)*any().

Naja, zumindest nutzt es das eingebaute nicht für lcm.

Erläuterung:

Dabei wird der gcdgrößte gemeinsame Divisor mithilfe der integrierten Funktion berechnet.

In Octave wird dies zur Macht erhoben 1-2*any(version==82). any(version==82)ist 0in Oktave, so ist das einfach gcd(x,y)^1. Es wird multipliziert mit (x*y)^any(version==82)oder (x*y)^0 = 1.

Für MATLAB gcdwird die Potenz von 1-2*any(version==82). any(version==82)ist 1in MATLAB, also ist dies gcd(x,y)^-1. Es multipliziert mit (x*y)^any(version==82)oder (x*y)^1 = x*y. Dies ergibt das kleinste gemeinsame Vielfache, da lcm(x,y) == x*y/gcd(x,y)für positive Zahlen.

Jelly und MATL , 6 5 Bytes

ZmD
g

Dies ist ein vollständiges Programm in einer der beiden Sprachen. Es berechnet die GCD in Jelly ( Online testen ! ) Und die LCM in MATL ( Online testen ! ). Das MATL-Programm wird mit einem Fehler (standardmäßig zulässig) beendet, nachdem die richtige Ausgabe erstellt wurde.

Da nur ASCII-Zeichen verwendet werden, entsprechen sie denselben codierten Bytes in den beiden Sprachen.

Erklärung von GCD in Jelly

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

Erklärung von 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 Bytes

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

Evaluiert gcdin Julia 0.4 ( Online testen! ) Und lcmin Julia 0.5 ( Online testen! ).

Wie es funktioniert

In Julia 0.4 log.(1)steht eine Abkürzung für getfield(log,1), die den Speicherort des logeingebauten, zB des Zeigers zurückgibt Ptr{Void} @0x00007f2846cb6660. Das Ergebnis ist also ungleich Null, der Vergleich ist falsch und der Ausdruck ergibt gcd.

In Julia 0.5 wurde eine neue Funktionsvektorisierungssyntax eingeführt. log.(1)ist jetzt eine Abkürzung für broadcast(log,1), die - da 1nicht iterabel - einfach auswertet log(1). Das Ergebnis ist somit Null, der Vergleich ist wahr und der Ausdruck wird zu ausgewertet lcm.

Octave / MATLAB, 44 42 41 Bytes

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

Dies definiert eine anonyme Funktion für GCD ( @gcd) in Octave und für LCM ( @lcm) in MATLAB.

Beispiel in Octave (oder Online ausprobieren! ):

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

Beispiel 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 (nicht konkurrierend)

Die LCM-Funktion von CGL wurde nach dieser Herausforderung hinzugefügt.

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

Was wie ein Leerzeichen aussieht, ist eigentlich ein nicht unterbrechendes Leerzeichen, ein Kommentar für CGL. JS berechnet die GCD:

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

Und CGL berechnet das 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

Versuch es:

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