Keresse meg, ha két szám viszonylag elsődleges a Java-ban

1. Áttekintés

Két egész számot adunk meg, a és b, azt mondjuk, hogy azok viszonylag prím, ha az egyetlen tényező, amely mindkettőt megosztja, 1. A kölcsönösen a prím vagy a coprime a viszonylag prímszámok szinonimája.

Ebben a gyors bemutatóban áttekintjük a probléma megoldását a Java segítségével.

2. Legnagyobb közös tényező algoritmus

Mint kiderült, ha a legnagyobb közös osztó (gcd) 2 számból áll a és b értéke 1 (azaz gcd (a, b) = 1) azután a és b viszonylag elsődlegesek. Ennek eredményeként annak megállapítása, hogy két szám viszonylag prím, egyszerűen abból áll, hogy megállapítjuk, hogy a gcd az 1.

3. Euklideszi algoritmus megvalósítása

Ebben a szakaszban az euklideszi algoritmust fogjuk használni az gcd 2 számból.

Mielőtt bemutatnánk megvalósításunkat, foglaljuk össze az algoritmust, és nézzünk meg egy gyors példát arra, hogyan alkalmazzuk az érthetőség kedvéért.

Képzeljük el, hogy két egész számunk van, a és b. Az iteratív megközelítésben először megosztunk a által b és megkapja a maradékot. Ezután hozzárendeljük a az értéke b, és hozzárendeljük b a fennmaradó érték. Ezt a folyamatot addig ismételjük, amíg b = 0. Végül, amikor elérjük ezt a pontot, visszaadjuk a a mint a gcd eredmény, és ha a = 1, azt mondhatjuk a és b viszonylag elsődlegesek.

Próbáljuk ki két egész számmal, a = 81 és b = 35.

Ebben az esetben a fennmaradó 81 és 35 (81 % 35) van 11. Tehát az első iterációs lépésben ezzel fejezzük be a = 35 és b = 11. Következésképpen egy újabb iterációt hajtunk végre.

A fennmaradó rész 35 osztva 11 van 2. Ennek eredményeként most van a = 11 (értékeket cseréltünk) és b = 2. Folytassuk.

Még egy lépés eredményez a = 2 és b = 1. Most a végéhez közeledünk.

Végül még egy ismétlés után elérjük a = 1 és b = 0. Az algoritmus visszatér 1 és arra következtethetünk 81 és 35 valóban viszonylag elsődlegesek.

3.1. Kötelező megvalósítás

Először valósítsuk meg az euklideszi algoritmus kötelező Java verzióját a fent leírtak szerint:

int iteratívGCD (int a, int b) {int tmp; míg (b! = 0) {if (a <b) {tmp = a; a = b; b = tmp; } tmp = b; b = a% b; a = tmp; } return a; } 

Mint észrevehetjük, abban az esetben, ha a kevesebb mint b, a folytatás előtt felcseréljük az értékeket. Az algoritmus leáll, amikor b értéke 0.

3.2. Rekurzív megvalósítás

Ezután nézzünk meg egy rekurzív megvalósítást. Ez valószínűleg tisztább, mivel elkerüli az explicit változóérték-csereügyleteket:

int rekurzívGCD (int a, int b) {if (b == 0) {return a; } if (a <b) {visszatér rekurzívGCD (b, a); } return recursiveGCD (b, a% b); } 

4. Használata BigIntegerVégrehajtása

De várj - nem az gcd algoritmus már megvalósult a Java-ban? Igen, ez az! A BigInteger osztály biztosítja a gcd módszer, amely az euklideszi algoritmust valósítja meg a legnagyobb közös osztó megtalálásához.

Ezzel a módszerrel könnyebben elkészíthetjük a viszonylag elsődleges algoritmust:

logikai nagyIntegerRelativePrime (int a, int b) {return BigInteger.valueOf (a) .gcd (BigInteger.valueOf (b)). egyenlő (BigInteger.ONE); } 

5. Következtetés

Ebben a gyors bemutatóban bemutattuk a megoldást arra a problémára, hogy a két megvalósítás segítségével megállapítsuk, hogy két szám viszonylag prím-e gcd algoritmus.

És mint mindig, a mintakód elérhető a GitHubon.