Du verwendest einen veralteten Browser. Es ist möglich, dass diese oder andere Websites nicht korrekt angezeigt werden. Du solltest ein Upgrade durchführen oder ein alternativer Browser verwenden.
Hey Leute Ich würde gerne so eine Pyramide wie im Anhang programmieren, sodass der Nutzer eingeben kann aus wie vielen Blöcken das 'Fundament' besteht und der Farbverlauf soll auch so sein wie gezeigt ((new Color(255, 0, 0)Farbe vom untersten Block) und ((new Color(255, 220, 220)Farbe vom obersten Block) die Blöcke sollen 'GRects' aus dem ACM paket sein. Vielen Dank schonmal!
Dann fange doch einfach mal an Code zu schreiben.
Fange damit an zuerst einen Stein zu zeichen, dann zwei nebeneinander.
Danach eine Pyramide aus 3 Steinen.
Wenn das funktioniert sollte es ein leichtes eine größere zu Zeichnen.
Wenn du eine konkrete Frage hast helfen wir dir gerne weiter.
Mein Problem ist ja dass der Nutzer eingeben soll wie viele Steine das Fundament hat und demnach die pyramide ausgegeben werden soll. Eine pyramide zu zeichnen bekomme ich auch hin. Also das ist die Aufgabenstellung:
This assignment would have been way cooler if we actually used Scheme as our programming language of choice, but alas... Java it is. Anyway, your assignment is to write a program Pyramid that extends GraphicsProgram. The program is supposed to draw a pyramid with rectangles, as such:
Before drawing the pyramid, it should ask the user for the number of bricks in the bottom layer. Also, as you can see in the picture, each layer of bricks should have a different colour. The bottom layer uses plain red (new Color(255, 0, 0)), while the top layer uses a very bright red (new Color(255, 220, 220)). The layers in between should smoothly interpolate from plain red to very bright red.
import java.awt.Color;
import acm.graphics.GRect;
import acm.program.GraphicsProgram;
public class Pyramid extends GraphicsProgram {
public void run() {
int n = readInt("Enter the number of bricks in the bottom layer: ");
int i = 0;
while(i<n)
for (i = 0; i < n; ++i) {
GRect Bottom = new GRect(50*i, 500-(i*20), 50, 20 );
Bottom.setFilled(true);
Bottom.setColor(new Color(255, 220, 220));
add(Bottom);
GRect Bottom2 = new GRect(50*i, 500-(i*20), 50, 20 );
Bottom2.setFilled(false);
add(Bottom2);
}
}
}
Möglichkeit 1 da erstelle ich mir ja eine Art Treppe aber wie bekomme ich jetzt die Schichten hin
import java.awt.Color;
import acm.graphics.GRect;
import acm.program.GraphicsProgram;
public class Pyramid extends GraphicsProgram {
public void run() {
int n = readInt("Enter the number of bricks in the bottom layer: ");
int i = 0;
for (i = 0; i < n; ++i) {
GRect Bottom = new GRect(50*i, 500, 50, 20 );
Bottom.setFilled(true);
Bottom.setColor(new Color(255, 220, 220));
add(Bottom);
GRect Bottom2 = new GRect(50*i, 500, 50, 20 );
Bottom2.setFilled(false);
add(Bottom2);
}
}
}
und das wäre Möglichkeit 2 da hab ich dann nur die unterste Schicht
1.Die 2 Blöcke erstelle ich weil ich bei dem 'true' Block ja nur einen roten bekommen, ohne die schwarze Umrandung
2. Die Farbe passt nicht, allerdings habe ich da auch noch nicht dran gearbeitet
3. Ich glaube das while ist unnötig oder?
4. Wie muss ich die denn ändern?
zu 3.) Du wirst (vermutlich) zwei Schleifen schachteln müssen, allerdings ist die while-Schleife an der Stelle deplatziert und dürfte auch nicht wirklich funktionieren, wie du es vermutlich beabsichtigt hast.
zu 4.) Mal dir das ganze mal für n = 1, n = 2, ... auf, dann solltest du eine Regelmäßigkeit feststellen, die du dann mittels einer mathematischen Funktion darstellen können solltest. Das ganze musst du dann nur noch implementieren.
Irgendwie stehe ich gerade ein wenig auf dem schlauch.. Wie bekomme ich denn die beiden Möglichkeiten überhaupt erstmal zusammen? also so dass sich das nach oben baut und gleichzeitig die Spalten füllt?
Aber was ist denn meine Funktion für die x & y Koordinate? wenn ich das jetzt so habe gibt er mir eine Blockreihe ganz oben und eine weiter unten aus?
Tut mir leid wenn ich ein wenig anstrengend bin, bin leider noch ein ziemlicher anfänger
Ich sitze gerade in einer Vorlesung, kann gerne später nochmal versuchen, dir zu helfen. Ich will dir die Lösung aber auch nicht vorgeben, da du sonst nichts dabei lernst Wie gesagt, zeichne dir das ganze auf, überleg dir, welche Werte die Koordinaten haben und wie du das mit deinen zwei Schleifen realisieren kannst.
for (int y = 0; y < n ; y++) {
for (int x = 0; x < n; x++) {
GRect Bottom = new GRect(200- (x * 50), 50+ (y * 25), 50, 50);
Bottom.setFilled(true);
Bottom.setColor(new Color(255, 0, 0));
add(Bottom);
GRect Bottom2 = new GRect(200- (x * 50), 50+ (y * 25), 50, 50);
Bottom2.setFilled(false);
add(Bottom2);
Also wenn ich das jetzt so habe gibt er mir ein Viereck und keine Pyramide aus & das viereck hat immer 5 Blöcke in die Breite wie bekomme ich es jetzt hin dass die anzahl der Blöcke von stufe zu stufe weniger werden und einrücken?
Lager doch bitte den Code zum Zeichnen der Blöcke in eine Methode aus. Dadurch musst du in Zukunft immer nur eine Rechnung anpassen außerdem ist der gepostete Code der beiden verschachtelten Schleifen dann kürzer und einfacher
Java:
add(createGRect(x, y, true));
add(createGRect(x, y, false));
.....
public GRect createGRect(int x, int y, boolean filled) {
GRect rect = new GRect(200- (x * 50), 50+ (y * 25), 50, 50);
rect.setFilled(filled);
return rect;
}
Immer wenn du die Reihe erhöhst muss du entweder die Grenzbedingung von der inneren Schleife reduzieren, oder den Startwert der inneren Schleife erhöhen.
Ich würde eher dazu tendieren den Startwert zu erhöhen!
Tipp: Schau erstmal das du die Aufgabe löst die jeweils nächste Reihe immer einen Stein weniger hat. Wenn du dann diese Treppe hast kann man sich um die Einrückung kümmern.
Also n habe ich oben in der Eingabe, also wird n auf das gesetzt was der Nutzer eingibt, trotzdem haben ich egal bei welcher Zahl 5 Blöcke. und wenn ich den Startwert (also x+1) erhöhe werden von den 5 Spalten 2 weiß..
Und das mit der Treppe ist ja mein größtes Problem wenn ich die erstmal hätte würde ich das einrücken bestimmt hinbekommen.
Immer wenn du die Reihe erhöhst muss du entweder die Grenzbedingung von der inneren Schleife reduzieren, oder den Startwert der inneren Schleife erhöhen.
Ich würde eher dazu tendieren den Startwert zu erhöhen!
Aber wie mache ich das denn dass ich einen weniger zeichne?
Ist mein code denn vom ding her überhaupt richtig? weil die Ausgabe ist nicht so ganz das erwartete Resultat
Was heißt "x+1" wo schreibst du das hin?
Bei deinem Code oben hast du x jedesmal mit 0 initialisiert. Du sollest es beim 1.mal mit 0 initialisieren, beim 2.mal mit 1, beim 3.mal mit 2 usw.
Ich kann es schlecht testen. Warum ist deine erste Koordinate 200 - 50x? Das kommt mir schon mal inkorrekt vor.
Mit den Angaben von @Joose hast du eigentlich alles, was du brauchst.
Wie schon weiter oben gesagt, lagere doch den Code zum Erstellen in eine Methode aus.
Dadurch verringert sich der Inhalt der Schleife und wird lesbarer und verständlicher!
Mit Hilfe des Debuggers und/oder Konsoleausgaben wäre dir das schon aufgefallen
Die Hälfte deiner Blöcke wird nicht sichtbar gezeichnet. Außerdem sind deine Blöcke quadratisch, und überlagern sich jeweils (ganz gut zu erkennen an der letzten Reihe)
Hier ein angepasster Code
Java:
static final int BLOCK_HEIGHT = 25;
static final int BLOCK_WIDTH = 25;
static final int MARGIN_LEFT = 200;
static final int MARGIN_TOP = 50;
public void run() {
int n = readInt("Enter the number of bricks in the bottom layer: ");
for (int y = 0; y < n; y++) {
for (int x = 0; x < n; x++) {
add(createRect(x, y, true));
add(createRect(x, y, false));
}
}
}
public GRect createRect(int x, int y, boolean filled) {
int xKoordinate = MARGIN_LEFT + (x * 50);
int yKoordinate = MARGIN_TOP + (y * 25);
System.out.println("X: " + yKoordinate + ", Y: " + yKoordinate);
GRect rect = new GRect(xKoordinate, yKoordinate, BLOCK_WIDTH, BLOCK_HEIGHT);
rect.setFilled(filled);
if(filled) {
// farbe ändern
rect.setColor(new Color(255, 0, 0));
}
return rect;
}
Damit sollte die Blöcke alle korrekt gezeichnet werden.
Damit du eine Treppe hinbekommst, musst du dafür sorgen das "x" nicht jedesmal bei 0 anfängt sondern beim 1.mal mit 0, beim 2.mal mit 1, usw.
Denke dabei das x die Zählervariable der inneren Schleife ist, du hast noch eine äußere Schleife die ebenfalls eine Zählervariable hat
1.) Warum mit so einer großen Pyramide testen? Fange mit einer einfachen an mit der Basis 2
2.) Es sollte auch etwas auf die Konsole geschrieben worden sein, dort kannst du dir die Koordinaten der jeweiligen Blöcke anschauen
3.) Mein Fehler die BLOCK_WIDTH sollte natürlich 50 sein, außerdem bei der Berechnung von X stand "BLOCK_WIDTH - ..." habe es vorhin noch auf "BLOCK_WIDTH + ..." geändert!
Wie Xelsarion schon darauf hingewiesen hat, diese Frage wurde schon mehrmals beantwortet.
War so freundlich und habe dir die entsprechenden Stellen rausgesucht.
Lies dir unsere Beiträge bitte aufmerksam durch, da können hilfreiche Sachen drinnen stehen
Sollte dir etwas unklar sein dann zitiere die entsprechende Stelle und Frage nach.
Immer wenn du die Reihe erhöhst muss du entweder die Grenzbedingung von der inneren Schleife reduzieren, oder den Startwert der inneren Schleife erhöhen.
Ich würde eher dazu tendieren den Startwert zu erhöhen!
Damit du eine Treppe hinbekommst, musst du dafür sorgen das "x" nicht jedesmal bei 0 anfängt sondern beim 1.mal mit 0, beim 2.mal mit 1, usw.
Denke dabei das x die Zählervariable der inneren Schleife ist, du hast noch eine äußere Schleife die ebenfalls eine Zählervariable hat
Das habe ich ja verstanden dass ich meine Zählvariable erhöhen muss allerdings ist mir gerade nicht ganz klar wie.. ich dachte das würde ich mit dem '++i' automatisch machen
Ich habe geschrieben (wie oben nochmals zitiert) : Den Startwert der inneren Schleife erhöhen.
Sobald die innere Schleife abgearbeitet ist kommt die äußere wieder dran, erhöht die Zählervariable und startet dann wieder die innere Schleife.
Jedesmal startet die innere Schleife mit x = 0, aber wie schon 2x geschrieben soll sich dieser Wert ändern.
Beim 1.mal soll x mit 0 initialisiert werden
Beim 2.mal soll x mit 1 initialisiert werden
........
oder du reduzierst die Grenz-/Abbruchbedingung
Beim 1.mal läuft die Schleife bis x < n - 0 erfüllt ist
Beim 2.mal läuft die Schleife bis x < n - 1 erfüllt ist
.........
achso, aber dann ist doch x=0 genrell falsch oder nicht? wie schreibe ich denn sowas dass der Wert sich erhöht, also jeden Durchgang neu initialisiert..
Tut mir leid wenn ich hier rüberkomme wie der größte Anfänger
Jein für den 1.Durchlauf der inneren passt es ja.
Aber damit du bei allen weiteren Durchläufen andere Startwerte hast musst du natürlich etwas anderes schreiben.
Du brauchst einen Wert der mit 0 initialisiert wird. Und nach jedem vollständigen Durchlauf der inneren Schleife erhöht wird.
(Bedenke du hast auch eine außere Schleife mit Zählervariable )
public GRect createRect(int x, int y, boolean filled) {
int xKoordinate = MARGIN_LEFT +(x * 50);
int yKoordinate = MARGIN_TOP - (y * 25);
Ahh also ich habe jetzt x=y gesetzt und habe schonmal diese Treppe.. Wenn ich das jetzt noch einrücken will muss dafür aber doch in der Schleife stehen oder?
Genau für die Einrückung musst du nun die Berechnung für die xKoordinate anpassen.
Je nachdem ob du die Steine nach links oder rechts rücken willst musst du etwas addieren oder subtrahieren.
Code:
int xKoordinate = MARGIN_LEFT + (x * 50) - ??; // wenn die Treppe von links nach rechts AUFsteigt
int xKoordinate = MARGIN_LEFT + (x * 50) + ??; // wenn die Treppe von links nach rechts ABsteigt
(Je Reihe beträgt die Einrückung einen halben Block)
Die 1.Reihe (unterste) ist um 0 halbe Blöcke verschoben
Die 2.Reihe ist um einen halben Block verschoben
Die 3.Reihe ist um zwei halbe Blöcke verschoben
Die 4.Reihe ist um drei halbe Blöcke verschoben
.......
Jetzt musst du halt nur noch logisch überlegen wie du dir das ausrechnest
Überlege es dir, zeichne es dir vl mit Stift+Papier vor, probiere herum und lass dir die Werte auf der Konsole ausgeben.
Ja genau ich muss die jetzt um halbe Blöcke, also bei meinen Blöcken um 25*??, einrücken d.h. um 25*x allerdings ist die Brechnung für die xKoordinate ja außerhalb der Schleife also passt er wenn ich *x rechne ja nur das letzte x an.
Wie bekomme ich das jetzt in die Schleife?
Ich sehe keinen Grund in der Schleife irgendwas "*x" zu rechnen.
Überlege doch wo denn bisher die xKoordinate berechnet wird ..... warum nicht dort die Berechnung anpassen?
Außerdem habe ich dir im Post davor schon gezeigt welche Zeile du anpassen musst.
Das habe ich schon in einem vorherigen Post gemeint. Du sollst die die Antworten von uns AUMERKSAM durchlesen.
ja es ist mir klar was ich ändern muss und wie ich es ändern muss, aber wenn ich da jetzt einfach nur -25 rechne ist das ja quatsch weil ich das dann nur in einer Zeile ändere. Korrigiert mich wenn ich quatsch erzähle
Warum änderst du damit nur an einer Zeile etwas?
Ja eine Codezeile, aber jede Reihe von Blöcken wird dadurch verschoben. Hättest du es ausprobiert wäre es dir aufgefallen.
Würdest du Konsolenausgaben oder den Debugger verwenden (was auch schon mehrmals erwähnt wurde) dann wäre der Ablauf deines Programmes klar geworden.
Du hast 2 verschachtelte Schleifen und in diesen Schleifen wird eine Methode aufgerufen. Dies Methode bekommt als Parameter den x und y Wert übergeben.
Un dieser x und y Wert wird in den Schleifen jeweils erhöht.
==> Die Methode wird sehr oft aufgerufen und immer mit einem anderen x bzw. y Wert!
Ahhhh.. Jetzt ist mir ein Licht aufgegangen.. ich hatte die ganze zeit *x aber das war ja schwachsinn. Jetzt habe ich es auf *y geändert und es funktioniert, die Pyramide ist schonmal da.
Fehlt nur noch der Farbverlauf....
Der Ansatz da ist ja irgendwie auch klar mit jedem Durchgang muss die Farbe heller werden.. aber wenn ich mit 0 anfange kann das funktionieren?
Warum sollt es nicht funktionieren?
Probiere es einfach mal aus versuche unterschiedliche Ansätze die deiner Meinung nach passen müsste.
Verwende Konsoleausgaben um die Werte für die Farbe zu kontrollieren usw.
Klar funktioniert das, wenn du auf der untersten Ebene mit (250, 0, 0) anfängst, ist die Regel für jede einzelne Ebene eben (250, aktuelleEbene * 220 / anzahlEbenen, aktuelleEbene * 220 / anzahlEbenen).
schon gut das Programm läuft mittlerweile! Vielen vielen Dank schonmal dass ihr es bisher mit mir ausgehalten habt jetzt hätte ich allerdings ein problem bei einem neuen Programm
Java:
public class Tac extends GraphicsProgram {
public void run() {
int row = 0;
int column = 0;
int i = 0;
add(new GLine(200, 100, 200, 400));
add(new GLine(300, 100, 300, 400));
add(new GLine(100, 200, 400, 200));
add(new GLine(100, 300, 400, 300));
for (i = 0; i <= 8; ++i)
;
{
switch (i) {
case 0:
case 2:
case 4:
case 6:
case 8:
row = readInt("row: ");
while (row > 3 || column < 1) {
row = readInt("row between 1&3");
}
column = readInt("column: ");
while (column > 3 || column < 1) {
column = readInt("column between 1&3");
}
add(new GLine(100 * column, 100 * row, 100 + 100 * column, 100 + 100 * row));
add(new GLine(100 * column, 100 + 100 * row, 100 + 100 * column, 100 * row));
break;
case 1:
case 3:
case 5:
case 7:
case 9:
row = readInt("row: ");
while (row > 3 || row < 1) {
row = readInt("row between 1&3");
}
column = readInt("column: ");
while (column > 3 || column < 1) {
column = readInt("column between 1&3");
}
GArc A = new GArc(100 * row, 100 * column, 100, 100, 360, 360);
A.setFilled(false);
A.setColor(Color.BLACK);
add(A);
break;
}
}
}
}
Dann mach bitte deswegen ein neues Thema auf! Da ich nicht annehme das diese Programm viel mit Pyramide am Hut hat (und selbst wenn ist es etwas anderes ).
Und wie @Xelsarion schon gesagt hat: Eine genauere Beschreibung ist hilfreich. Wie sollte es funktionieren, was solltest du bekommen, was bekommst du stattdessen?
Ist ja alles gut und schön, aber die Schleife funktioniert. Sie besteht allerdings nur aus einer Leeranweisung. Nimm mal das Semikolon hinter der for-Zeile weg !!!
Ich würde gerne so eine Pyramide wie im Anhang programmieren, sodass der Nutzer eingeben kann aus wie vielen Blöcken das 'Fundament' besteht und der Farbverlauf soll auch so sein wie gezeigt ((new Color(255, 0, 0)Farbe vom untersten Block) und ((new Color(255, 220, 220)Farbe vom obersten Block) die Blöcke sollen 'GRects' aus dem ACM paket sein. Vielen Dank schonmal!
