streamalism.org

1. Introduktion

I denne vejledning skal vi udforske flere måder at udskrive en trekant på Java.

Der er naturligvis mange typer trekanter. Her, vi skal kun udforske et par af dem: rigtige og ligebenede trekanter.

2. Opbygning af en højre trekant

Den rigtige trekant er den enkleste type trekant, vi skal studere. Lad os se hurtigt på det output, vi ønsker at opnå:

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

Her bemærker vi, at trekanten er lavet af 5 rækker, der hver har et antal stjerner svarende til det aktuelle række nummer. Selvfølgelig kan denne observation generaliseres: for hver række fra 1 til N, vi er nødt til at udskrive r stjerner, hvor r er den aktuelle række og N er det samlede antal rækker.

Så lad os bygge trekanten ved hjælp af to til sløjfer:

offentlig statisk String printARightTriangle (int N) {StringBuilder result = new StringBuilder (); for (int r = 1; r <= N; r ++) {for (int j = 1; j <= r; j ++) {resultat.append ("*"); } resultat.append (System.lineSeparator ()); } returner resultat.toString (); }

3. Opbygning af en ligebenet trekant

Lad os nu se på formen af ​​en ligebenet trekant:

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

Hvad ser vi i dette tilfælde? Vi bemærker, ud over stjernerne er vi også nødt til at udskrive nogle mellemrum for hver række. Så vi skal finde ud af, hvor mange mellemrum og stjerner vi skal udskrive for hver række. Selvfølgelig afhænger antallet af mellemrum og stjerner af den aktuelle række.

Først ser vi, at vi skal udskrive 4 mellemrum til den første række, og når vi kommer ned i trekanten, har vi brug for 3 mellemrum, 2 mellemrum, 1 mellemrum og slet ingen mellemrum til den sidste række. Generelt skal vi udskrive N - r mellemrum for hver række.

For det andet, sammenlignet med det første eksempel, indser vi, at vi her har brug for et ulige antal stjerner: 1, 3, 5, 7 ...

Så, vi skal udskrive r x 2 - 1 stjerner for hver række.

3.1. Brug af indlejret til Sløjfer

Baseret på ovenstående observationer, lad os oprette vores andet eksempel:

offentlig statisk String printAnIsoscelesTriangle (int N) {StringBuilder result = new StringBuilder (); for (int r = 1; r <= N; r ++) {for (int sp = 1; sp <= N - r; sp ++) {resultat.append (""); } for (int c = 1; c <= (r * 2) - 1; c ++) {result.append ("*"); } resultat.append (System.lineSeparator ()); } returner resultat.toString (); }

3.2. Brug af en enkelt til Sløjfe

Faktisk har vi en anden måde at består kun af en enkelt til loop - det bruger Apache Commons Lang 3-biblioteket.

Vi skal bruge for-sløjfen til at gentage rækkerne i trekanten, som vi gjorde i de foregående eksempler. Derefter bruger vi StringUtils.repeat () metode for at generere de nødvendige tegn til hver række:

offentlig statisk streng printAnIsoscelesTriangleUsingStringUtils (int N) {StringBuilder result = new StringBuilder (); for (int r = 1; r <= N; r ++) {resultat.append (StringUtils.repeat ('', N - r)); result.append (StringUtils.repeat ('*', 2 * r - 1)); result.append (System.lineSeparator ()); } returner resultat.toString (); }

Eller vi kan lave et pænt trick med det understreng () metode.

Vi kan udtrække StringUtils.repeat () ovenstående metoder til at opbygge en hjælperstreng og derefter anvende String.substring () metode på det. Hjælperstrengen er en sammenkædning af det maksimale antal mellemrum og det maksimale antal stjerner, som vi har brug for for at udskrive rækkerne i trekanten.

Når vi ser på de tidligere eksempler, bemærker vi, at vi har brug for et maksimalt antal N - 1 mellemrum til første række og et maksimalt antal N x 2 - 1 stjerner til sidste række:

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

For eksempel hvornår N = 5 og r = 3, skal vi udskrive ”*****”, som er inkluderet i hjælperstreng variabel. Alt hvad vi skal gøre er at finde den rigtige formel til understreng () metode.

Lad os nu se det komplette eksempel:

offentlig statisk streng printAnIsoscelesTriangleUsingSubstring (int N) {StringBuilder result = new StringBuilder (); String helperString = StringUtils.repeat ('', N - 1) + StringUtils.repeat ('*', N * 2 - 1); for (int r = 0; r <N; r ++) {resultat.append (helperString.substring (r, N + 2 * r)); result.append (System.lineSeparator ()); } returner resultat.toString (); }

På samme måde med lidt mere arbejde kunne vi få trekanten til at udskrive på hovedet.

4. Kompleksitet

Hvis vi ser igen på det første eksempel, bemærker vi en ydre sløjfe og en indre sløjfe, der hver har et maksimum på N trin. Derfor har vi det O (N ^ 2) tidskompleksitet, hvor N er antallet af rækker i trekanten.

Det andet eksempel er ens - den eneste forskel er, at vi har to indre sløjfer, som er sekventielle og ikke øger tidskompleksiteten.

Det tredje eksempel bruger dog kun a til sløjfe med N trin. Men på hvert trin kalder vi enten StringUtils.repeat () metode eller understreng () metode på hjælperstrengen, der hver har PÅ) kompleksitet. Så den samlede tidskompleksitet forbliver den samme.

Til sidst, hvis vi taler om hjælpepladsen, kan vi hurtigt indse, at kompleksiteten i alle eksempler forbliver i StringBuilder variabel. Ved at tilføje hele trekanten til resultat variabel, kan vi ikke have mindre end O (N ^ 2) kompleksitet.

Selvfølgelig, hvis vi direkte udskrev tegnene, ville vi have konstant pladskompleksitet til de to første eksempler. Men det tredje eksempel bruger hjælpestrengen, og pladsens kompleksitet ville være PÅ).

5. Konklusion

I denne vejledning har vi lært, hvordan man udskriver to almindelige typer trekanter i Java.

Først, Vi har studeret den rigtige trekant, som er den enkleste type trekant, vi kan udskrive i Java. Derefter, vi har undersøgt to måder at opbygge en ligebenet trekant på. Den første bruger kun til sløjfer og den anden drager fordel af StringUtils.repeat () og String.substring () metode og hjælper os med at skrive mindre kode.

Endelig har vi analyseret kompleksiteten for tid og rum for hvert eksempel.

Som altid kan alle eksemplerne findes på GitHub.