Opprette en trekant med for loops i Java

1. Introduksjon

I denne opplæringen skal vi utforske flere måter å skrive ut en trekant på Java.

Det er naturligvis mange typer trekanter. Her, vi skal bare utforske et par av dem: rette og likebenede trekanter.

2. Å bygge en høyre trekant

Den rette trekanten er den enkleste typen trekant vi skal studere. La oss se raskt på utdataene vi ønsker å oppnå:

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

Her merker vi at trekanten er laget av 5 rader, som hver har et antall stjerner som er lik det nåværende radnummeret. Selvfølgelig kan denne observasjonen generaliseres: for hver rad fra 1 til N, vi må skrive ut r stjerner, hvor r er gjeldende rad og N er totalt antall rader.

Så la oss bygge trekanten med to til sløyfer:

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

3. Å bygge et likestilt trekant

La oss nå ta en titt på formen av en likestilt trekant:

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

Hva ser vi i dette tilfellet? Vi merker at, i tillegg til stjernene, må vi også skrive ut noen mellomrom for hver rad. Så vi må finne ut hvor mange mellomrom og stjerner vi må skrive ut for hver rad. Antall mellomrom og stjerner avhenger selvfølgelig av gjeldende rad.

Først ser vi at vi trenger å skrive ut 4 mellomrom for første rad, og når vi kommer ned i trekanten, trenger vi 3 mellomrom, 2 mellomrom, 1 mellomrom og ingen mellomrom i det hele tatt for siste rad. Generelt må vi skrive ut N - r mellomrom for hver rad.

For det andre, sammenlignet med det første eksemplet, innser vi at her trenger vi et oddetall antall stjerner: 1, 3, 5, 7 ...

Så, vi trenger å skrive ut r x 2 - 1 stjerner for hver rad.

3.1. Bruker nestet til Sløyfer

Basert på observasjonene ovenfor, la oss lage vårt andre 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 ++) {result.append (""); } for (int c = 1; c <= (r * 2) - 1; c ++) {result.append ("*"); } result.append (System.lineSeparator ()); } returner resultat.toString (); }

3.2. Bruke en singel til Løkke

Egentlig har vi en annen måte det består bare av en singel til loop - den bruker Apache Commons Lang 3-biblioteket.

Vi skal bruke for-løkken til å gjenta over radene i trekanten som vi gjorde i de foregående eksemplene. Så bruker vi StringUtils.repeat () metode for å generere de nødvendige tegnene for hver rad:

offentlig statisk strengutskriftAnIsoscelesTriangleUsingStringUtils (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 gjøre et pent triks med de substring () metode.

Vi kan trekke ut StringUtils.repeat () metodene ovenfor for å bygge en hjelperstreng og deretter bruke String.substring () metode på den. Hjelperstrengen er en sammenkobling av maksimalt antall mellomrom og maksimalt antall stjerner vi trenger for å skrive ut radene i trekanten.

Ser vi på de forrige eksemplene, merker vi at vi trenger maksimalt antall N - 1 mellomrom for første rad og maksimalt antall N x 2 - 1 stjerner for siste rad:

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

For eksempel når N = 5 og r = 3, må vi skrive ut "*****", som er inkludert i helperString variabel. Alt vi trenger å gjøre er å finne den rette formelen for substring () metode.

La oss nå se hele eksemplet:

offentlig statisk strengutskriftAnIsoscelesTriangleUsingSubstring (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åte, med litt mer arbeid, kunne vi få trekanten til å skrive ut opp ned.

4. Kompleksitet

Hvis vi tar en titt på det første eksemplet igjen, merker vi en ytre sløyfe og en indre sløyfe som hver har maksimalt N trinn. Derfor har vi O (N ^ 2) tidskompleksitet, hvor N er antall rader i trekanten.

Det andre eksemplet er likt - den eneste forskjellen er at vi har to indre sløyfer, som er sekvensielle og ikke øker tidskompleksiteten.

Det tredje eksemplet bruker imidlertid bare a til løkke med N trinn. Men på hvert trinn kaller vi enten StringUtils.repeat () metoden eller substring () metode på hjelperstrengen, som hver har PÅ) kompleksitet. Så den totale tidskompleksiteten forblir den samme.

Til slutt, hvis vi snakker om hjelpeplassen, kan vi raskt innse at for alle eksempler forblir kompleksiteten i StringBuilder variabel. Ved å legge hele trekanten til resultat variabel, kan vi ikke ha mindre enn O (N ^ 2) kompleksitet.

Selvfølgelig, hvis vi direkte skrev ut tegnene, ville vi ha konstant plasskompleksitet for de to første eksemplene. Men det tredje eksemplet bruker hjelperstrengen, og romkompleksiteten vil være PÅ).

5. Konklusjon

I denne veiledningen har vi lært hvordan du skriver ut to vanlige typer trekanter i Java.

Først, Vi har studert riktig trekant, som er den enkleste typen trekant vi kan skrive ut på Java. Deretter, vi har utforsket to måter å bygge en likestilt trekant på. Den første bruker bare til sløyfer og den andre utnytter StringUtils.repeat () og String.substring () metode og hjelper oss med å skrive mindre kode.

Til slutt har vi analysert tid og romkompleksitet for hvert eksempel.

Som alltid kan alle eksemplene bli funnet på GitHub.


$config[zx-auto] not found$config[zx-overlay] not found