Gyakorlati alapok
Hatványozódjunk...
A 4 elemi művelet alapszintű leprogramozása után nézzünk egy kissé bonyolultabb matematikát, bár látni fogjuk, hogy a matematikai alapelv valójában nem az: a hatványozásról és a gyökvonásról van szó.
A matematikai apparátus viszonylag egyszerű: hatványozásról beszélünk, ha számot mindig önmagával szorozzuk meg, például:
2 * 2 * 2 * 2 = 16
A fenti példában láthatjuk, hogy a 2 számot négyszer (4x) szoroztuk meg, a végeredmény 16 lesz. Egy másik példa:
3 * 3 * 3 = 27
A fenti 2 műveletet így is ki tudjuk fejezni...
24 = 16 és 33 = 27
...ahol az alapszám az alap, a felsőindex pedig a kitevő.
alapkitevő
Voltaképpen a hatványozás egyszerű esetének tekinthető a négyzetre emelés, ahol a kitevő mindig 2 (hatványozási sorrendben a 2. hatvány), azaz:
22 = 4 (mert 2 * 2 = 4)
32 = 9 (mert 3 * 3 = 9)
A művelet Java-implementációja sokféle lehet az egyszerűtől kezdve egészen a beépített-előregyártott függvényig.
public class Main {
public static void main(String[] args) {
int alap = 2;
int eredmeny = alap * alap * alap *
alap;
System.out.println(eredmeny);
}
}
Végeredmény:
16
A fenti kód valójában még nem hatványozás, hanem csak a matematikai kiindulópont.
A kitevő jelenléte azt sejteti, hogy ciklikus iterálást (for ciklus) kell alkalmaznunk, még pedig mindig a kitevő mértékéig (for (int i = 1; i <= kitevo; i++));
public class Main {
public static void main(String[] args) {
int alap = 2;
int kitevo = 4;
int eredmeny = 1;
for (int i = 1; i <= kitevo; i++){
eredmeny *=
alap;
}
System.out.println(eredmeny);
}
}
Végeredmény:
16
Fontos észrevennünk, hogy az eredményt 1-el, nem pedig 0-val inicializáltuk (int eredmeny = 1;), mert ebben az esetben a 0-val szorzás mindig 0 lenne, így a végeredmény is.
Nézzük meg ugyanezt hátultesztelő ciklussal is (ez a kód kissé döcögős, mert a for ciklus tökéletesen elég az optimális megvalósításhoz):
public class Main {
public static void main(String[] args) {
int alap = 2;
int kitevo = 1;
int eredmeny = 1;
do{
eredmeny *= alap;
kitevo++;
}while(kitevo <= 4);
System.out.println(eredmeny);
}
}
Végeredmény:
16
Természetesen a Java-nyelv roppant széleskörű, előre megkomponált függvénykönyvtárakkal rendelkezik, ebből következően a számítási kódot sem nekünk kell leprogramozni, "csupán" megtalálni a megfelelő függvényt hozzá és bekonfigurálni (beállítani). Ehhez importálnunk kell a matematikai csomagot (import java.math.*;), amelyből most a Math.pow(alap, kitevo) függvény kell nekünk:
import java.math.*;
public class Main {
public static void main(String[] args) {
int alap = 2;
int kitevo = 4;
double eredmeny = 0;
eredmeny = Math.pow(alap, kitevo);
System.out.println(eredmeny);
}
}
Végeredmény:
16.0
Mivel a pow() függvény double típusú visszatérési értéket ad, ezért az eredményt (eredmeny) szintén double típusúvá kéne átalakítani. Persze kasztolhatjuk is, ezúttal lefelé ((int) Math.pow(alap, kitevo)), ám ezzel sok esetben adatvesztést kockáztatunk:
import java.math.*;
public class Main {
public static void main(String[] args) {
int alap = 2;
int kitevo = 4;
int eredmeny = 0;
eredmeny = (int) Math.pow(alap, kitevo);
System.out.println(eredmeny);
}
}
Végeredmény:
16.0
Most érdekességképpen nézzük meg a 2 hatványait 16. hatványig:
import java.math.*;
public class Main {
public static void main(String[] args) {
int alap = 2;
double eredmeny = 1;
for(int kitevo = 0; kitevo <= 16; kitevo++){
eredmeny =
Math.pow(alap, kitevo);
System.out.println(kitevo + ". hatvány: " + eredmeny);
}
}
}
Végeredmény:
0. hatvány: 1.0
1. hatvány: 2.0
2. hatvány: 4.0
3. hatvány: 8.0
4. hatvány: 16.0
5. hatvány: 32.0
6. hatvány: 64.0
7. hatvány: 128.0
8. hatvány: 256.0
9. hatvány: 512.0
10. hatvány: 1024.0
11. hatvány: 2048.0
12. hatvány: 4096.0
13. hatvány: 8192.0
14. hatvány: 16384.0
15. hatvány: 32768.0
16. hatvány: 65536.0
Az oktatás során felmerült a kód "régimódi", azaz szorzásos-összegzéses megoldása is (eredmeny *= alap). Nézzük meg for ciklusos és do-while ciklusos implementációját:
public class Main {
public static void main(String[] args) {
int alap = 2;
int eredmeny = 1;
for(int kitevo = 0; kitevo <= 16; kitevo++){
System.out.println(kitevo + ". hatvány: "
+ eredmeny);
eredmeny *= alap;
}
}
}
Végeredmény:
0. hatvány: 1
1. hatvány: 2
2. hatvány: 4
3. hatvány: 8
4. hatvány: 16
5. hatvány: 32
6. hatvány: 64
7. hatvány: 128
8. hatvány: 256
9. hatvány: 512
10. hatvány: 1024
11. hatvány: 2048
12. hatvány: 4096
13. hatvány: 8192
14. hatvány: 16384
15. hatvány: 32768
16. hatvány: 65536
public class Main {
public static void main(String[] args) {
int alap = 2;
int kitevo = 0;
int eredmeny = 1;
do {
System.out.println(kitevo + ".
hatvány: " + eredmeny);
eredmeny *= alap;
kitevo++;
} while (kitevo <= 16);
}
}
Végeredmény:
0. hatvány: 1
1. hatvány: 2
2. hatvány: 4
3. hatvány: 8
4. hatvány: 16
5. hatvány: 32
6. hatvány: 64
7. hatvány: 128
8. hatvány: 256
9. hatvány: 512
10. hatvány: 1024
11. hatvány: 2048
12. hatvány: 4096
13. hatvány: 8192
14. hatvány: 16384
15. hatvány: 32768
16. hatvány: 65536
Házi feladat - Írjunk programot, ami bekér egy egész számot és kiírja az első annyi darab négyzetszámot!
A megoldás fejezete a képre kattintva érhető el.
Pénzes László