Flächeninhalt eines Rechtecks berechnen

S

SamyMZ

Mitglied
Hallo

bin gerade hier fleißig am üben und würde gerne wissen ob dies richtig ist wenn ich den Flächeninhalt eines Rechtecks ausrechnen will
was nur aus Höhe und Breite besteht
Für eventuelle Korrekturen wäre ich sehr dankbar
Java: 
Public static void main (String[]arg 
  int Breite = a
  int Länge = b
  fläche (int a, int b)
  fläche= a*b
System.out.print

und falls es falsch bitte kurz erklären
 
weiß nicht genau wie man diese klammern { } schreibt
hab die eben nur kopiert
kann mir das vielleicht jemand sagen
also ich soll einfach nur ein programm schreiben in dem der flächeninhalt eines rechtecks berechnent
und hoffentlich sieht man da ein bisschen guten willen
bin ja bei null und geb mir ja mühe
und jemand kann mir da ein bisschen helfen
 
An dem Programm ist aber auch alles falsch.

Java: 
public class Test {
   public static int berechneFlaeche(int a, int b) {
      return a*b;
   }

   public static void main(String[] args) {  
       int breite = 42;
       int hoehe = 23;
       int flaeche = berechneFlaeche(breite, hoehe);
       System.out.println("Die Fläche eines Rechtecks mit der Höhe " + 
          hoehe + " und der Breite " + breite + " ist " + flaeche);
   }
}
 
hab noch ein paar weitere Fragen, aber hab zu denen keinen Lösungsansatz
darf ich die trotzdem stellen??
ohne gegen die regeln des forums zu verstoßen
 
ich lern gerade für ne uniklausur
für wirtschaftsinformatik und das ist mein allerletzter versuch
der letzte schein und dann bin ich mit der uni fertig
hab mir ein buch gekauft und auch in der bibliothek in literatur geguckt
aber kapier nicht so wirklich um was es geht
und die klausur ist nächsten mittwoch
und das meiste kann ich ja halbwegs
hab nur mit java und den komplexitäten meine probleme
 
seid ihr denn auch so gnädig und helft mir
ich muss ja auch nicht wirklich kapieren um was es geht
da die klausuraufgaben jedes jahr sehr ähnlich sind
und wenn ich die aufgaben kann wäre das schon ne riesen hilfe
und ich geb mir auch mühe und versuche nen ansatz zu finden
 
Du musst an der Klausur programmieren und willst das in einer Woche lernen? Na dann viel Spass. Zieh dir irgendwo die absoluten Basics rein (Operanden, Schleifen, Ausnahmen, Methoden usw...)

Wenn du das für Java nicht immer Internet findest (gibts sicher irgendwo), dann versuch es halt mal mit einer anderen Programmiersprache, die Basics sind (meist) die gleichen.
 
Das Programmieren ist nur ein Teil der Klausur
und eigentlich sind die Aufgaben ja relativ einfach
nur für mich halt nicht
🙂
und ich hock da schon seit 2 wochen dran
 
früher in der Schul war halt für mich Chemie ein totales Rätsel
und jetzt halt leider Java
und dieses Forum ist echt meine letzte Hoffnung
und wenn ihr mir nur bei 5-6Aufgaben die relativ flott gehen helfen würdet dann wäre mir schon extremst geholfen
 
OK DANKE

Was macht das folgende Programm

Java: 
Public static void main (String[] arg  {
  long zahl = 4711 ;
  long val = 0 ;
  while ( zahl>0) {
     val = val + zahl % 10 ;
     zahl = zahl / 10;
     }
System.out.print (" zahl: + val);
}
 
...also so etwas wie zahl/ 10 kannst du dir doch sicher denken?
zahl % 10 --> Division mit Rest ? Wikipedia

Zusammen mit dem Ergebnis welches dir das Programm ausgibt (wobei sich dort noch ein kleiner Fehler eingeschlichen hat), solltest du das also leicht selbst herausfinden ?!
 
Das Programm startet eine Schleife. Diese wird solange ausgeführt, wie die Variable zahl Grösser als 0 ist.
In der Schleife wird zur Variable val der Rest aus der Rechnung zahl/10 (geteilt durch) addiert. Also beim ersten Schleifendurchlauf: 0+4711/10
Da Punktrechnungen stärker als Strichrechnungen binden (Mathematik), wird zuerst der Rest berechnet, danach addiert.
Danach wird die Variable zahl durch 10 geteilt und die Schleife beginnt von vorne.

Ausgabe ganz am Ende: 0 : 13

Korrigierte Version:
Java: 
public static void main (String[] arg)  {
  long zahl = 4711 ;
  long val = 0 ;
  while ( zahl>0) {
     val = val + zahl % 10 ;
     zahl = zahl / 10;
   }
System.out.print (zahl+": "+ val);
}
 
val+(zahl%10)

10%7 --> 10/7 = 1, Rest 3 ..., also 4711/10 --> Rest 1

val + 1

Danach 4711 durch 10 teilen, ergibt 471 und die Schleife wiederholen.

Klar darfst du noch ne zweite Frage stellen ...
 
zahl = 4711
val =0

Begin Schleife:

val += 4711%10 --> 0+1 = 1
zahl= zahl/10 --> 471
--------

val += 471%10 --> 1+1 = 2
zahl = zahl/10 --> 47
--------

val += 47%10 --> 7+2 = 9
zahl = zahl/10 --> 4
--------

val += 4%10 --> 9+4 = 13
zahl = zahl/10 --> 0
--------

Ende Schleife:

val = 13

.......
 
Was macht das folgende Programm und welche Komplexität hat es??
Java: 
public static void main (String[] arg) {
   feld  = new int [] (7,3,2,47,11)
   int anz=5;
   int zahl;
   int zahl1;
   for ( int i=0 < anz; -1 ; j++)
      {
        zahl=feld [j];
        zahl1=feld [j+1]
       if (zahl1 < zahl)
            {feld [j] = zahl 1;
              feld [j+1] = zahl;
              }
         }
   }
 
Was macht das folgende Programm und welche Komplexität hat es??
Java: 
public static void main (String[] arg) {
   feld  = new int [] (7,3,2,47,11)
   int anz=5;
   int zahl;
   int zahl1;
   for ( int i=0 < anz; -1 ; j++)
      {
        zahl=feld [j];
        zahl1=feld [j+1]
       if (zahl1 < zahl)
            {feld [j] = zahl 1;
              feld [j+1] = zahl;
              }
         }
   }
 
da war ein fehler drin
das problem geht so

Java: 
public static void main (String[] arg) {
   feld  = new int [] (7,3,2,47,11);
   int anz=5;
   int zahl;
   int zahl1;
   for ( int i=0 < anz; -1 ; j++)
        for (int j=0; j<anz-1; j+++
           {
             zahl=feld [j];
             zahl1=feld [j+1]
             if (zahl1 < zahl)
                  {feld [j] = zahl 1;
                   feld [j+1] = zahl;
              }
         }
   }
 
SamyMZ hat gesagt.:
da war ein fehler drin
das problem geht so

Java: 
// …
Zum Vergrößern anklicken....

Das kann so nicht sein. Da fehlen vorne und hinten Klammern, die i-for-Schleife wird nicht verwendet, und einen +++-Operator kenne ich auch nicht. Gibt’s die Aufgaben nicht irgendwo online, wo Du hinlinken könntest?

Übrigens: Du kannst Deine Posts auch bearbeiten, indem Du auf „Ändern“ klickst – Du mußt nicht immer nochmal neu schreiben!
 
Wieso machst Du einfach nicht mal ein paar Ausgaben rein, die Du dann in der Konsole bestaunen kannst?
 
Ich vermute mal, das Programm soll so aussehen:

Java: 
public static void main (String[] arg) {
    feld = new int[](7, 3, 2, 47, 11);
    int anz = 5;
    int zahl;
    int zahl1;

    for (int i = 0; i < anz - 1 ; i++) {
        for (int j = 0; j < anz - 1; j++) {
            zahl = feld[j];
            zahl1 = feld[j+1]
            if (zahl1 < zahl) {
                feld[j] = zahl1;
                feld[j+1] = zahl;
            }
        }
    }
}

Das wäre dann ein Algorithmus, der die gegebene Liste aufsteigend sortieren soll. Wenn ich richtig gucke, dann hat der O(n^2).
 
Was macht das folgende Programme und welche Komplexität hat es??

Java: 
public static void main(String[] arg) {
   feld = new int [] {7,3,2,47,11};
   int anz=5;
   int zahl;
   int zahl1;
   for(int i=0;i<anz;i++) 
        for(int j=0;j<anz-1;j++)
            { 
             zahl = feld[j]; 
             zahl1=feld[j+1]; 
             if(zahl1 < zahl) 
                 {
                   feld[j]=zahl1; 
                   feld[j+1] = zahl; 
                   } 
               }
 }

hab das eben nochmal aus der datei kopiert
die aufgabe stammt von der uniseite und da kann man nur drauf zugreifen wenn man an der uni student ist
aber hab das eben kopiert und hier eingefügt
 
Sag Deinem Prof mal, daß er einen grausigen Stil hat … Die Antwort, die ich oben gegeben habe, dürfte aber stimmen. Oder hatte ich Tomaten auf den Augen? *g*
 
ok danke
aber kannst du mir das vielleicht bitte ein bisschen ausführlicher erklären
auf die aufgabe gibt es immerhin 9 Punkte also 9minuten
 
Das Programm macht bildlich gesprochen folgenes:

Du hast eine Liste mit Zahlen. Diese Liste hat n Einträge. Dann macht das Programm n mal Folgendes: Es nimmt jeden Eintrag und vergleicht den mit seinem Nachfolger. Ist der Eintrag größer als der Nachfolger, werden die beiden vertauscht.

Das kannst Du ja jetzt gedanklich etwas machen, dann merkst Du, was passiert.
 
OK DANKE

nächste Aufgabe
hoffentlich reiz ich hier die Netiquette nicht zu sehr aus

Gegeben sei folgendes Programm. n sei die Eingabe.
Java: 
x=2;
y=n;
z=0;
i=0;
while i<n do
    while z =/ (ungleich) y do
           if z>2
           {
                x=x+1;
             }
             z=z+1;
          end;
          =i+1;
          z=0;
end


i. Wie groß ist der Aufwand in Elementaroperationen T(n) für n>10? (7 min)
ii. Wie ist die asymptotische Laufzeitkomplexität (in Abhängigkeit von n)? (3 min)
iii. Welchen Wert hat die Variable x am Ende der Programmausführung (es kann davon
ausgegangen werden, dass n>10)? (5 min)
 
I. Da bin ich mir noch nicht sicher, T(n) ist auf jeden Fall größer 2n. Dazu kommt noch die innere while-Schleife, aus der ich spontan nicht ganz schlau werde.
II. T(n) dürfte Element von O(n) sein, allerdings ist das von I. abhängig …
III. Ausprobieren! Himm mal Stift und Papier und rechne das mal für ein beliebiges n > 10 aus.
 
OK DANKE DANKE!!!!
es gibt noch ein paar Aufgaben
aber werde mich jetzt mal an die Lösungsvorschläge setzen um versuchen die irgendwie nachvollziehen zu können
ich bin da später oder morgen wieder
da
 
Java: 
x=2;
y=n;
z=0;
i=0;
while i<n do
    while z =/ (ungleich) y do
           if z>2
           {
                x=x+1;
             }
             z=z+1;
          end;
          =i+1;
          z=0;
end
Wenn das wirklich Java - Code sein soll, dann ist das ein Verbrechen!!!
 

Aktuelle Jobs

Neue Themen

Ähnliche Themen

Flächeninhalt eines Kreises berechnen
Antworten: 19
Flächeninhalt von Papierformaten berechnen
Antworten: 6
Brauche Hilfe bei Bewegung eines Rechtecks [Applet]
Antworten: 5
Grafik als Hintergrund eines Rechtecks verwenden?
Antworten: 4
Koordinaten eines gedrehten Rechtecks
Antworten: 4

Zurück
Oben