Dreieck aus Zeichen erzeugen?

Einklappen
X
 
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

  • Dreieck aus Zeichen erzeugen?

    Hallo Zusammen,

    ich habe Anfang September meine Ausbildung zum Fachinformatiker Anwendungsentwicklung begonnen. Das ganze OHNE irgendwelche Vorkenntnise.

    Nun bringe ich mir im Moment selbst PHP/JavaScript bei.

    Zur Überprüfung des Fortschritts hat mir mein Ausbilder die Aufgabe gegeben, ein Eingabefeld zu machen, auf dem ich das Zeichen und die Anzahl der Reihen eingebe um ein Dreieck, besser eine Pyramide zu erzeugen.

    Dies ist das Eingabefeld, welches ich bisher geschrieben habe.

    Code:
    <html>
    <body>
    	<form action="pyramide.php" method="post">
    	<table>
    	<tr>
    	<td><p>alphabet:</td>
    	<td><input type="text" name="alph"></td></p>
    	</tr>
    	<tr>
    	<td><p>number:</td>
    	<td><input type="text" name="no"></td></p>
    	</tr>
    	</table>
    	<input type="submit" value="Show!" style="width:60px">
    </body>
    </html>
    Nun fehlt mir jedoch einfach der Denkansatz für ein solches Dreieck.

    Es soll in etwa so aussehen:
    Code:
           *
         *––*
       *–––––*
     *––––––––*
    Vielleicht könnt ihr mir ja ein bisschen helfen, damit ich das selbst auf die reihe bekomme!

    Grüße,

    Simon

  • #2
    1. Hör auf, Tabellen für Style zu benutzen. Fang das garnicht erst an, dir wird viel shitstorming erspart bleiben.

    2. Fehlt einiges an Angaben. Was soll "Alphabet" bedeuten? Sollen dort verschiedene Zeichen eingeben werden? Welche sollen dann wie verwendet werden?
    Was heißt die Anzahl? Anzahl von was? Breite der Pyramide? Höhe? Anzahl der "inneren" Stufen? Kantenlänge?
    This is what happens when an unstoppable force meets an immovable object.

    Kommentar


    • #3
      Tip 1: Zwei ineinander veschachtelte Schleifen
      Tip 2: Erste Schleife ist für Zeilen zuständig
      Tip 3: Zweite (innere) Schleife ist für Anzahl der Zeichen in der Zeile zuständig.

      Sind ca. 7 Zeilen simpler Code

      Kommentar


      • #4
        Da mein Ausbilder kein deutsch spricht, steht alphabet für das Zeichen/Buchstaben whatever aus dem das Dreieck entstehen soll, also z.B. "#" für ein Dreieck aus Rauten, "B" für ein Dreieck aus B's usw.

        Anzahl = Anzahl der verwendeten alphabets, d.h. 3 würde ein Dreieck aus drei z.B. Rauten erzeugen (also 2 Ebenen),
        Code:
         #
        #–#
        5 aus fünf Rauten usw...
        Code:
          #
         #–# 
        #–––#
        Dazu muss ich noch irgendwie ausschließen, dass gerade Zahlen verwendet werden.

        Edit: Danke schonmal CPCoder, ich setz mich mal dran

        Das war übrigens mein erster Versuch, jedoch soll nur der Rand durch die Zeichen dargestellt werden...

        Code:
        <html>
        <div align=center>
        <?php
        $r="#";
        
        for ($i=0; $i<=35; $i++)
        {
        	if($i>0)
        	 $r .= "###";
        	 echo $r ."<br />";
        }
        ?>
        </div>
        </html>
        Zuletzt geändert von b1p; 24.10.2012, 16:18.

        Kommentar


        • #5
          Hier mal mein Beispiel-Code dafür. Da die Information (Angebene Anzahl ist die Anzahl der Zeichen, nicht der Zeilen) fehlte, zielt mein Code bei der Übergebenen Anzahl auf die Anzahl der Zeilen ab.

          PHP-Code:
          <?php 
          $rows 
          = (isset($_POST['rows'])) ? $_POST['rows'] : 2// Wurde kein Wert angegeben, werden mind. 2 Zeilen erzeugt
          $sign = (isset($_POST['signs'])) ? $_POST['signs'] : 'X'// Wurde kein Wert angegeben, wird die Pyramide mit "X" gebaut

          $output '';
          for (
          $i 1$i <= $rows$i++) { // Schleife zur Erzeugung der Zeilen
              
          for ($k 0$k $i$k++) { // Schleife zur Erzeugung der Zeichanzahl pro Zeile
                  
          if ($k == || $k == ($i-1)) {  // Nur das Erste und Letzte Zeichen setzen
                      
          $output .= $sign;
                  } else {
                      
          $output .= '&emsp;'// Zwischenraum mit Leerzeichen in der Breite eines "m" auffüllen
                  
          }
              }
              
          $output .= '<br>'// Generierte Zeile an Output anfügen
          }

          ?>

          <html>
              <head>
                  <title>Pyramide</title>
              </head>
              <body>
                  <br><br>
                  <center>
                      <form action="pyramide.php" method="post">
                          Anzahl der Zeilen: <input type="text" name="rows" size="2"><br>
                          Darstellungszeichen: <input type="text" name="signs" size="2"><br>
                          <input type="submit" name="submit" value="Baue Pyramide ...">
                      </form>
                      <br><br>
                      Deine Pyramide:<br><br>
                      <?php echo $output?>
              </body>
          </html>

          Kommentar


          • #6
            Alles klar, dann mal ein paar Hinweise:

            1. Herausfinden, ob die Anzahl gerade oder ungerade ist. Dazu gibts keine Funktion in PHP, aber modulo sollte dich auf den richtigen Weg bringen

            2. Wie hoch wird das Dreieck sein, wenn es aus X Zeichen begrenzt werden soll? Hier ist etwas Mathematik gefragt, die aber vergleichsweise einfach durch überlegen herauszufinden ist.

            Beispiel: 3 -> 2 Zeilen, 5 -> 3, 7 -> 4, 9 -> 5... usw. führt dann zu der Formel, die dir die äußere Schleife berechnet. Tip: Teile und Herrsche, aber vergiss die Spitze nicht ;P

            3. Wie viele Zeichen müssen in eine bestimmte Zeile? Zeile 1 ist einfach, da kann nur 1 rein. Zeile 2 auch, nämlich Zeichen + Leerstelle + Zeichen. Du gehst mit jeder Zeile immer zwei Stellen zu den Rändern hin weiter.

            Damit brauchst du für jede Zeile immer zwei Stellen mehr. Simpel.

            4. Programmieren. Hier benutzt du zwei Schleifen. Die erste zählt Zeile für Zeile hoch, bis du zu der kompletten Höhe kommst, die du in [2.] berechnet hast.

            Innerhalb dieser ersten Schleife wird die zweite Schleife dann die Zeile malen. Dabei geht es immer so, dass du ein Zeichen brauchst, dann eine aus [3.] berechnete Anzahl Leerstellen, und wieder ein Zeichen.

            Probiere am Besten jetzt erstmal ein bisschen daran herum und stelle dann Fragen wenn du wirklich absolut nicht mehr weiterkommst.
            Zuletzt geändert von ApoY2k; 24.10.2012, 16:40.
            This is what happens when an unstoppable force meets an immovable object.

            Kommentar


            • #7
              Danke für die Antworten! Werde mich gleich morgen früh dran machen, jetzt dann erstmal Feierabend!

              (Zuhause derzeit kein Internet wegen Umzug...)

              Schönen Abend euch!

              Kommentar


              • #8
                Aufgabebstellung hat sich verkompliziert...

                das Dreieck in sichtbare Leerzeichen gehüllt sein, d.h.

                Code:
                ---#---
                --#-#--
                -#---#-
                #-----#
                Mir explodiert der Kopf..sollte wohl doch Systemintegration lernen

                1. habe ich durch
                PHP-Code:
                if($num%== 0//prüft ob die Zahl gerade ist
                {
                    
                $output "Please enter an odd number!";
                }
                elseif(
                $num 3//prüft ob die Anzahl der Zeichen kleiner als 3 ist.
                {
                    
                $output "A pyramide needs at least 3 signs!";

                gelöst.

                zu zweitens habe ich mir überlegt, dass die Zeilen sich aus:
                PHP-Code:
                x=1 y=1
                => (x+2) - (y+1) = Zeilenanzahl 
                wobei sich x und y mit jedem durchlauf um 2 bzw 1 erhöhen 
                [z.B. (3+2) - (1+1)] 
                ergeben.

                HILFE

                Kommentar


                • #9
                  Ist auf jeden Fall ein guter Ansatz, allerdings machst du es dir zu kompliziert. Die Höhe der Pyramide darf nur von einem einzigen Parameter abhängen; der Anzahl der Zeichen. Du musst in der Lage sein, die Frage zu beantworten:

                  Wenn ich eine beliebige, ungerade Zahl X eingebe, wieviele Zeilen wird die Pyramide haben?

                  Für diese Berechnung brauchst du keine Schleifen oder sonstiges, was du in deinem Ansatz als "Durchläufe" bezeichnest. Es reicht die Zahl X.

                  Dass das Dreieck in sichtbare Zeichen gehüllt sein muss erschwert die Aufgabe eigentlich nur geringfügig, da du die Zeichen so oder so zeichnen musst. Ob man sie nun sieht oder nicht ^^
                  Zuletzt geändert von ApoY2k; 25.10.2012, 15:00.
                  This is what happens when an unstoppable force meets an immovable object.

                  Kommentar


                  • #10
                    2. beantwortet durch

                    PHP-Code:
                    $rows round($num/2);

                    oder

                    $rows 
                    = (floor($num/2)+1
                    kopf ist dicht, ich komm nicht mehr weiter bräuchte jetzt ne stunde denkpause um das verkomplizierte wirrwarr aus mir rauszubekommen...
                    Zuletzt geändert von b1p; 25.10.2012, 15:37.

                    Kommentar


                    • #11
                      Das sieht schon besser aus Und das jetzt ohne PHP-Helferfunktionen und als mathematische Funktion und du hast mein Ergebnis Das hat auch noch den schönen Effekt, dass du Rundungsfehler nicht beachten musst, weil sie durch das -1 einfach entefernt werden ;-)

                      Code:
                      h(x) = 1 + (x-1)/2
                      Aber deins ist auch vollkommen korrekt.

                      Weiter gehts: 3. hat sich durch deine Ergänzung etwas verändert. Jede Zeile hat jetzt gleich viele Zeichen, nämlich genau soviele, wie deine Pyramide als imaginäre Grundlänge hat. Diese ergibt sich zwingend aus der Höhe und der Annahme, dass jede Stufe der Pyramide die beiden Seitenkanten um eine Stufe nach "außen" erweitert.

                      Damit ergibt sich für jede Stufe der Pyramide, dass sich die "Breite" um 2 erhöht. Hat die Pyramide die Höhe 1, ist sie auch 1 breit (#). Höhe 2 und sie ist 3 breit (#-#). Bei 3 sind es 5 (#---#) und so weiter. Es kommen also immer zwei Füllzeichen "-" hinzu.

                      Damit sollte die Berechnung der finalen Breite, also "ganz unten" relativ einfach sein.

                      Wenn du das gepackt hast, ist der Rest einfaches heruntercoden. Beginne mit der ersten Zeile am besten separat, also nicht innerhalb der Schleife. Dann ersparst du dir einige lästige If-Abfragen. Ab der zweiten Zeile kannst du dann Zeile für Zeile zeichnen.

                      Hier ist die interessanteste Frage, wie du feststellst, wann du ein Füllzeichen ("-") oder das "echte" Zeichen (#) schreiben sollst. Aber diese Erkenntnis kommt dann bestimmt von alleine
                      This is what happens when an unstoppable force meets an immovable object.

                      Kommentar


                      • #12
                        Ich hab übrigens aufgegeben hat jemand eine Lösung für mich, damit ich's vll im nachhinein kapiere?

                        Resultat: Ich hab zu Systemintegration gewechselt scheine wohl zu kompliziert zu denken, um Programmierer zu werden...

                        Kommentar


                        • #13
                          Mal ein Vorschlag:
                          PHP-Code:
                          $zeichen 7;
                          $mitte floor($zeichen 2);
                          $hoehe $zeichen $mitte;
                          $zeile str_repeat('-'$zeichen);
                          for(
                          $i=0$i<$hoehe; ++$i) {
                            
                          $neue_zeile $zeile;
                            
                          $neue_zeile[$mitte-$i] = $neue_zeile[$mitte+$i] = '#';
                            echo 
                          $neue_zeile '<br>';

                          Unkommentiert, zum selber-verstehen :-)
                          I don't believe in rebirth. Actually, I never did in my whole lives.

                          Kommentar


                          • #14
                            Siehe da, ich habs doch noch rausbekommen

                            Formular:

                            PHP-Code:
                            <html
                                <
                            head
                                    <
                            title>Pyramide</title
                                </
                            head
                                <
                            body
                                    <
                            br><br
                                    <
                            center
                                        <
                            form action="pyra.php" method="post"
                                            
                            num: <input type="text" name="num" size="2"><br
                                            
                            char: <input type="text" name="char" size="2"><br
                                            <
                            input type="submit" name="submit" value="build pyramide ..."
                                        </
                            form
                                        <
                            br><br
                                </
                            body
                            </
                            html
                            Program:

                            PHP-Code:
                            <html>
                            <center>
                            <?php
                            $num 
                            = (isset($_POST["num"])) ? $_POST["num"] : 3// kein Wert, mind. 3 Zeichen
                            $char = (isset($_POST["char"])) ? $_POST["char"] : "#"// kein Wert -> # 
                            $rows round($num/2);
                            $pos 1;

                            if(
                            $num%== 0//prüft ob die Zahl gerade ist
                            {
                                echo 
                            "Please enter an odd number!";
                            }
                            elseif(
                            $num 3//prüft ob die Anzahl der Zeichen kleiner als 3 ist.
                            {
                                echo 
                            "A pyramide needs at least 3 signs!";
                            }
                            else
                            {
                            for (
                            $k 0$k $rows$k++) //Zeilen
                                
                            {
                                for (
                            $i 1$i <= $num$i++) //Zeichenanzahl
                                    
                            {
                                    
                            $pos1 = (($num+1)/2)-$k;
                                    
                            $pos2 = (($num+1)/2)+$k;
                                
                                    if(
                            $i == $pos1 || $i == $pos2//Zeichen setzen
                                        
                            {
                                            echo 
                            "$char";
                                        }
                                    else
                                        {
                                        echo 
                            "–"//Leerzeichen setzen
                                        
                            }
                                    }
                                    echo 
                            "<br />";
                                }
                            }
                            ?>
                            </center>
                            </html>
                            Danke euch für die Tips!
                            Zuletzt geändert von b1p; 05.11.2012, 10:48.

                            Kommentar


                            • #15
                              Schade, dass du aufgibst. Ist eigentlich eine wirklich nette Aufgabe

                              Hiermal meine Lösung inklusive Kommentare. Es wäre bestimmt für manch andere Anfänger hilfreich, wenn du kurz kommentierst, woran genau du bei dem Problem (im Vergleich zur Lösung) gescheitert bist.

                              Für mich wäre es auch interessant, damit ich weiß, womit Anfänger eher Probleme haben.

                              PHP-Code:
                              <?php 

                              function replaceCharsAtRow($line$rowNum$char) {
                                  
                                  
                              // Erstmal brauchen wir die Länge der zu verarbeitenden Zeile.
                                  // Die ist zwar eigentlich immer gleich, aber damit die Funktion schön
                                  // dynamisch bleibt, sollte davon erstmal nicht ausgegangen werden
                                  
                              $length strlen($line);

                                  
                              // Nun berechnen wird, wo wir etwas ersetzen müssen, abhänging von
                                  // der Länge der Stufe. Zunächst brauchen wir den Mittelpunkt.
                                  // Da wir von einem 0-Index ausgehen, ist dieser mit der unten
                                  // stehenden Formel direkt berechnet. Nehmen wir z.B. an, dass die Zeile
                                  // 5 lang ist, so ist die "mitte" der Index "2". Also ziehen wir eins ab
                                  // und halbieren den Rest. Somit kommen wir zuverlässig auf den Mittelpunktindex
                                  
                              $positionCenter = ($length 1) / 2;
                                  
                                  
                              // Nun brauchen wir noch die Indizes der rechten und linken Ersetzungen.
                                  // Diese hängen natürlich vom Mittelpunkt ab, denn dieser "wandert" ja,
                                  // je länger die Zeile wird, immer weiter nach rechts.
                                  // Da wir den Index der aktuellen Stufe haben (rowNum), können wir
                                  // diesen relativ schön dafür benutzen, um je nach Stufe und je nach
                                  // Mittelpunkt den genauen Index zu erhalten, an dem wir links (minus)
                                  // und rechts (plus) ersetzen müssen
                                  
                              $positionLeft $positionCenter $rowNum;
                                  
                              $positionRight $positionCenter $rowNum;

                                  
                              // Wenn die aktuelle Stufe die erste ist (Index 0) müssn wir nur eine
                                  // Ersetzung durchführen, da dort ja nur ein Pyramidenzeichen vorhanden ist
                                  
                              if ($rowNum == 0) {
                                      return 
                              substr_replace($line$char$positionCenter1);
                                  } else {
                                      
                              // Sind wir aber irgendwo mitten in der Pyramide, müssen wir sowohl links
                                      // als auch rechts ersetzen
                                      
                              $tmp substr_replace($line$char$positionLeft1);
                                      return 
                              substr_replace($tmp$char$positionRight1);
                                  }
                              }

                              function 
                              pyramid($amount$filler$char) {
                                  
                                  
                              // Da wir nur mit ungeraden Anzahlen umgehen können, prüfen wir zunächst darauf
                                  // und steigen ansonsten sofort aus dem Skript aus
                                  
                              if ($amount == 0)
                                      throw new \
                              Exception("Only odd numbers of characters are supported!");
                                  
                                  
                              // Dies berechnet die Höhe der Pyramide. Diese ergibt sich aus der Überlegung,
                                  // dass auf jeder Stufe (ausgenommen der ersten) genau zwei Zeichen vorhanden sind.
                                  // Will man also die Gesamthöhe der Pyramide mit X Zeichen, braucht man mindestens
                                  // einmal X / 2 Stufen. Die + 1 bringt dann die erste Stufe mit, da diese ja nur
                                  // ein Zeichen braucht. Um Rundungsfehler (ungerade Zahlen) auszugleichen, ziehen
                                  // wir dieses eine Zeichen vorher ab.
                                  
                              $height + (($amount 1) / 2);
                                  
                                  
                              // Die Breite der Pyramide ergibt sich dann daraus, dass mit jeder neuen Stufe
                                  // (Höhe) der Pyramide, zwei neue Zeichen hinzukommen. Die - 1 zieht wieder
                                  // die erste Stufe ab, da diese ja bereits in der Höhe berechnet wurde
                                  
                              $width $height 1;

                                  
                              // Hier wird die gesamte Pyramide reingeschrieben und später zurückgegeben
                                  
                              $pyramid '';

                                  
                              // Nun erstellen wir die eigentliche Pyramide, indem alle Stufen der Pyramide
                                  // nacheinander "gebaut" werden und einzeln verarbeitet werden
                                  
                              for ($currentRow 0$currentRow $height$currentRow++) {
                                      
                                      
                              // Zunächst erstellen wir eine "leere" Zeile, die nur das Füllzeichen enthält
                                      // und zwar genau so oft, wie die Breite der Pyramide angibt
                                      
                              $currentLine str_repeat($filler$width);
                                      
                                      
                              // Nun ersetzen wir, abhänging von der aktuellen Stufe, die Pyramidenzeichen
                                      // in dieser leeren Stufe mit einer eigenen Funktion
                                      
                              $pyramid .= replaceCharsAtRow($currentLine$currentRow$char);
                                      
                                      
                              // Dann noch ein Zeilenumbruch, damit es auch eine Pyramide wird ;-)
                                      
                              $pyramid .= '<br/>';
                                  }

                                  
                              // Und zurück damit
                                  
                              return $pyramid;
                              }

                              echo 
                              pyramid(5'-''#');
                              This is what happens when an unstoppable force meets an immovable object.

                              Kommentar

                              Lädt...
                              X