streamalism.org

1. Bemutatkozás

Ebben az oktatóanyagban egy háromszög Java-ban történő kinyomtatásának számos módját vizsgáljuk meg.

Természetesen sokféle háromszög létezik. Itt, csak néhányat fogunk felfedezni: derékszögű és egyenlő szárú háromszögeket.

2. Jobb háromszög építése

A derékszögű háromszög a legegyszerűbb típusú háromszög, amelyet tanulmányozni fogunk. Nézzük meg gyorsan a kimenetet, amelyet el akarunk szerezni:

* ** *** **** *****

Itt észrevesszük, hogy a háromszög 5 sorból áll, amelyek mindegyikének csillagszáma megegyezik az aktuális sorszámmal. Természetesen ez a megfigyelés általánosítható: minden sorhoz 1-től N, ki kell nyomtatnunk r csillagok, hol r az aktuális sor és N a sorok teljes száma.

Tehát építsük fel a háromszöget kettővel mert hurkok:

public static String printARightTriangle (int N) {StringBuilder eredmény = új StringBuilder (); for (int r = 1; r <= N; r ++) {for (int j = 1; j <= r; j ++) {eredmény.függelék ("*"); } result.append (System.lineSeparator ()); } return result.toString (); }

3. Egy egyenlő szárú háromszög építése

Vessünk egy pillantást egy egyenlő szárú háromszög formájára:

 * *** ***** ******* *********

Mit látunk ebben az esetben? Észrevesszük, hogy a csillagokon kívül néhány sort is ki kell nyomtatnunk. Tehát ki kell találnunk, hogy hány sort és csillagot kell kinyomtatnunk az egyes sorokhoz. Természetesen a szóközök és a csillagok száma az aktuális sortól függ.

Először azt látjuk, hogy az első sorhoz 4 szóközt kell kinyomtatnunk, és ahogy a háromszögben lefelé haladunk, 3 szóközre, 2 szóközre, 1 szóközre és az utolsó sorra egyáltalán nincs szükség szóközre. Általánosítva nyomtatnunk kell N - r szóközök minden sorhoz.

Másodszor, összehasonlítva az első példával, rájövünk, hogy itt páratlan számú csillagra van szükségünk: 1, 3, 5, 7 ...

Így, nyomtatnunk kell r x 2 - 1 csillagok minden sorhoz.

3.1. A Nested használatával mert Hurkok

A fenti megfigyelések alapján készítsük el a második példánkat:

public static String printAnIsoscelesTriangle (int N) {StringBuilder eredmény = új StringBuilder (); for (int r = 1; r <= N; r ++) {for (int sp = 1; sp <= N - r; sp ++) {eredmény.összead (""); } for (int c = 1; c <= (r * 2) - 1; c ++) {result.append ("*"); } result.append (System.lineSeparator ()); } return result.toString (); }

3.2. Single használata mert Hurok

Valójában van egy másik módunk is erre csak egyetlenből áll mert loop - az Apache Commons Lang 3 könyvtárat használja.

A for ciklust fogjuk használni a háromszög sorainak ismétléséhez, ahogy az előző példákban tettük. Akkor használjuk a StringUtils.repeat () módszer az egyes sorokhoz szükséges karakterek előállításához:

public static String printAnIsoscelesTriangleUsingStringUtils (int N) {StringBuilder eredmény = új StringBuilder (); for (int r = 1; r <= N; r ++) {result.append (StringUtils.repeat ('', N - r)); result.append (StringUtils.repeat ('*', 2 * r - 1)); result.append (System.lineSeparator ()); } return result.toString (); }

Vagy csinálhatunk egy ügyes trükköt a szubsztring () módszer.

Kivonhatjuk a StringUtils.repeat () a fenti módszerekkel egy segítő karakterlánc felépítéséhez, majd a String.substring () módszer rajta. A segítő húr a maximális szóköz és a csillagok maximális számának összefűzése, amelyre a háromszög sorainak kinyomtatásához szükségünk van.

Az előző példákat tekintve észrevesszük, hogy maximális számra van szükségünk N - 1 szóközök az első sorhoz és a maximális számú N x 2 - 1 csillag az utolsó sorban:

String helperString = StringUtils.repeat ('', N - 1) + StringUtils.repeat ('*', N * 2 - 1); // N = 10 esetén helperString = "*********"

Például mikor N = 5 és r = 3, ki kell nyomtatnunk a „*****” szót, amelyet a helperString változó. Csak annyit kell tennünk, hogy megtaláljuk a megfelelő képletet szubsztring () módszer.

Most nézzük meg a teljes példát:

public static String printAnIsoscelesTriangleUsingSubstring (int N) {StringBuilder eredmény = új StringBuilder (); String helperString = StringUtils.repeat ('', N - 1) + StringUtils.repeat ('*', N * 2 - 1); for (int r = 0; r <N; r ++) {result.append (helperString.substring (r, N + 2 * r)); result.append (System.lineSeparator ()); } return result.toString (); }

Hasonlóképpen, egy kicsit több munkával a háromszöget fejjel lefelé nyomtathatjuk.

4. Komplexitás

Ha ismét megnézzük az első példát, akkor észlelünk egy külső és egy belső hurkot, amelyek mindegyike maximum N lépések. Ezért van O (N ^ 2) az idő összetettsége, ahol N a háromszög sorainak száma.

A második példa hasonló - az egyetlen különbség az, hogy két belső hurok van, amelyek egymás után következnek, és nem növelik az idő bonyolultságát.

A harmadik példa azonban csak a mert hurok a N lépések. De minden lépésnél felhívjuk akár a StringUtils.repeat () módszer vagy az szubsztring () módszer a segítő húron, mindegyiknek megvan TOVÁBB) bonyolultság. Tehát az idő bonyolultsága nem változik.

Végül, ha a kiegészítő térről beszélünk, gyorsan rájöhetünk, hogy az összes példa esetében a bonyolultság StringBuilder változó. Hozzáadva a teljes háromszöget a eredmény változó, nem lehet kevesebb, mint O (N ^ 2) bonyolultság.

Természetesen, ha közvetlenül kinyomtatjuk a karaktereket, akkor az első két példa számára állandó térbonyolultságot mutatunk. De a harmadik példa a segítő karakterláncot használja, és a tér bonyolultsága az lenne TOVÁBB).

5. Következtetés

Ebben az oktatóanyagban megtanultuk, hogyan lehet két általános háromszöget nyomtatni a Java-ban.

Első, tanulmányoztuk a derékszögű háromszöget, amely a Java-ban nyomtatható legegyszerűbb háromszögtípus. Azután, egy egyenlő szárú háromszög felépítésének két módját tártuk fel. Az első csak mert hurkok és a másik kihasználja a StringUtils.repeat () és a String.substring () módszer, és segít kevesebb kódot írni.

Végül elemeztük az idő és a tér összetettségét az egyes példáknál.

Mint mindig, az összes példa megtalálható a GitHubon.