Buch Cover Buch Cover Buch Cover Buch Cover

Web-Code: - Webcode Help

Truhen aus Plexiglas (Anweisungen und Abfolgen)

Für die Herstellung von Plexiglastruhen werden hochwertiges Plexiglas und massive Zinkrohre verbaut. Die Truhen sind quaderförmig, besitzen demnach sechs rechteckige Seitenflächen aus Plexiglas (Boden + Deckel + vier Seitenwände). Alle zwölf Kanten bestehen auf der vollen Länge aus je einem Zinkrohr. Da jede Truhe andere Maße aufweist, wird ein Programm benötigt, bei welchem die drei Größen Breite, Höhe und Tiefe (B x H x T) je in cm eingegeben werden können. Das Programm soll die total benötigte Fläche an Plexiglas (Summe der 6 Seitenflächen in cm2) und zusätzlich die benötigte totale Rohrlänge (Summe der 12 Kantenlängen) ausgeben. Geben Sie zudem das Volumen (in cm³) aus.

Quader

Zusammenfassung

Schreiben Sie ein Programm, das die folgenden Eingabedaten verarbeitet:

 

Eingabedaten: Breite, Höhe und Tiefe je in cm.

Ausgabe:

  • Rohrlänge (= totale Kantenlängen) in cm

  • Plexiglasfläche (= totale Oberfläche) in cm²

  • Volumen (= Inhalt der Truhe) in cm³

 

(Bemerkung: Rechteckfläche = Breite x Höhe; Quadervolumen = Breite x Höhe x Tiefe)

 

0 Kommentare

Bitte melde dich an um einen Kommentar abzugeben

17 Lösung(en)

import java.util.Scanner;

public class Plexiglastruhe {
  public static void main(String[] args) {
    new Plexiglastruhe().top();
  }
  
  void top() {
    float breite = einlesen("Breite");
    float hoehe  = einlesen("Höhe");
    float tiefe  = einlesen("Tiefe");
    
    float volumen = breite * hoehe * tiefe;
    float flaeche = 2 * (breite * hoehe + 
                         breite * tiefe +
                         hoehe  * tiefe);
    float kanten  = 4 * (breite + hoehe + tiefe);
    
    ausgabe("Volumen", volumen);
    ausgabe("Fläche",  flaeche);
    ausgabe("Kanten",  kanten);
  }
  
  Scanner sc = new Scanner(System.in);
  float einlesen(String frage) {
      System.out.println("Bitte " + frage + " eingeben:");
      return sc.nextFloat();
  }
  
  void ausgabe(String mass, float wert) {
      System.out.println(mass + " beträgt " + wert);
  }
  
} // end of class Plexiglastruhe
                

Lösung von: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

#!/usr/bin/ruby
# -*- coding: utf-8 -*-

# @autor Philipp Gressly Freimann
# April 2011
#
# Aufgabe programmieraufgaben.ch
# Volumen, Oberflaeche und Kantenlänge eines Quaders berechnen


def hauptprogramm() 
  breite, tiefe, hoehe = einlesen()
  volumen, oberflaeche, kantenlaenge = berechnung(breite.to_i, tiefe.to_i, hoehe.to_i)
  ausgabe("Volumen",    volumen     )
  ausgabe("Oberfläche", oberflaeche )
  ausgabe("Kanten",     kantenlaenge)
end

def ausgabe(text, wert) 
  print "#{text}: #{wert}\n"
end

def einlesen()
  print "Breite, Tiefe und Höhe eingeben: "
  return STDIN.gets.scan(/(\d*)[,; ](\d*)[,; ](\d*)/).flatten
end

def volumenRechnen(b, t, h) 
  return b * t * h
end

def flaecheRechnen(b, t, h)
  # Deckel(Boden) + Front(Back) + Seitenwände
  return  (b*t + b*h + t*h) * 2
end

def kantenRechnen(b, t, h)
  return 4*(b + t + h)
end

def berechnung(b, t, h) 
  vol     = volumenRechnen(b, t, h)
  flaeche = flaecheRechnen(b, t, h)
  kanten  = kantenRechnen (b, t, h)
  return vol, flaeche, kanten
end

# start
hauptprogramm()
                

Lösung von: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

/* Autor: ph. gressly */
/* Datum: 19. April 2011 */
/* Volumen, Oberfläche und (totale) Kantenlänge eines Quaders. */

#include <stdio.h>

/**
 * Lesen der drei Kantenlängen Breite, Höhe, Tiefe:
 */
void eingabe(int * breite, int * hoehe, int * tiefe) {
  printf("Breite: ");
  scanf ("%d",       breite);
  printf("Höhe  : ");
  scanf ("%d",       hoehe );
  printf("Tiefe : ");
  scanf ("%d",       tiefe );
}

/**
 * Berechne Volumen, Oberfläche und Kantenlängen eines Quaders
 * bei gegebenen Kanten b(breite), h(hoehe) und t(tiefe).
 */
void berechnungen(int b, int h, int t, 
                  int* volumen, int* flaeche, int* kanten) {
  *volumen = b * h * t;
  *flaeche = 2 * (b * h + b * t + h * t);
  *kanten  = 4 * (b + t + h);
}

/**
 * Ausgabe der berechneten Werte 
 * Volumen, (Ober)fläche, totale Kanten(länge)
 */
void ausgabe(int volumen, int flaeche, int kanten) {
   printf("Volumen: %d\n", volumen);
   printf("Fläche : %d\n", flaeche);
   printf("Kanten : %d\n", kanten);
}

/**
 * Hauptprogramm:
 * Eingabe: Breite, Höhe, Tiefe
 * Ausgabe: Volumen, Fläche, (totale) Kanten(länge)
 */
main() {
  int breite, hoehe, tiefe;
  eingabe(&breite, &hoehe, &tiefe);
  
  int volumen, flaeche, kanten;
  berechnungen(breite, hoehe, tiefe, &volumen, &flaeche, &kanten);

  ausgabe(volumen, flaeche, kanten);
}

                

Lösung von: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

<?xml version="1.0" encoding="utf-8" ?>
<!-- phi@gress.ly / 19. April 2011 -->
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
 <head>
  <title>Truhen aus Plexiglas</title>
  <meta   http-equiv="Content-Script-Type" content="text/javascript"/>
  <script type      ="text/javascript"     src    ="truhen.js"
  ></script>
 <link rel="stylesheet" href="truhen.css" type="text/css" />
 </head>

 <body>
  <h1>Truhen aus Plexiglas</h1>
  <p>Diese Webseite berechnet Volumen, Oberfläche und totale
  Kantenlänge einer quaderförmigen Truhe (z. B. aus Plexiglas).</p>

  <form>
   <span id="lblBreite">Breite:</span> 
     <input id="breiteInput" type="text" /><br />
   <span id="lblHoehe">Höhe:</span>

     <input id="hoeheInput" type="text"  /><br />
   <span id="lblTiefe">Tiefe:</span>
     <input id="tiefeInput" type="text"  /><br />
   <input type="button" value="Berechnen"    onclick="berechnen();" />
   <input type="reset"  value="Zurücksetzen" />
  </form>

  <p>Volumen:     <span id="volumenSpan"></span></p>

  <p>Obelfläche:  <span id="flaecheSpan"></span></p>
  <p>Kantenlänge: <span id="kantenSpan" ></span></p>
 </body>
</html>
<!-- ---------------------------------------------------- -->

/***********  truhen.js  **********************>
/**
 * Philipp Gressly Freimann
 * www.programmieraufgaben.ch (Web-Code kimn-4b4h)
 * Datum: 19. 4. 2011
 * 
 * Berechne das Volumen, die Oberfläche und die totale Kantenlänge eines Quaders.
 * 
 */

function berechnen() {
  var kanten = werteAbholen();
  ausgabe("volumen",  volumen(kanten));
  ausgabe("flaeche",  flaeche(kanten));
  ausgabe("kanten",   totaleKantenlaenge(kanten));
}

function werteAbholen() {
  var kanten = new Array(3);
  kanten[0] = wertAbholen("breite");
  kanten[1] = wertAbholen("hoehe");
  kanten[2] = wertAbholen("tiefe");
  return kanten;
}

function wertAbholen(bezeichnung) {
  var feld;
  feld = document.getElementById(bezeichnung + "Input");
  var str;
  str = feld.value;
  return str * 1; // in Zahl umwandeln
}

function ausgabe(spanId, wert) {
  span = document.getElementById(spanId + "Span");
  span.innerHTML = wert;
}

function volumen(kanten) {
  var b, h, t;
  b = kanten[0];
  h = kanten[1];
  t = kanten[2];
  return b * h * t;
}

function flaeche(kanten) {
  var b, h, t;
  b = kanten[0];
  h = kanten[1];
  t = kanten[2];    
  // Front/Back + Deckel/Boden + 2 Seitenwände
  return 2 * (b*h + b*t + h*t);
}

function totaleKantenlaenge(kanten) {
  var b, h, t;
  b = kanten[0];
  h = kanten[1];
  t = kanten[2];    
  // Jede Kante kommt 4 Mal vor.
  return 4* (b + h + t);
}

function eingabepruefung() {
 // TODO: check if input valid.  
}
                

Lösung von: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

# python3

# Plexiglaskiste
# Ausgaben:
# 1. Rohlänge in cm
# 2. Plexiglasfläche in quadrat-cm
# 3. Volumen in kubik-cm

def eingabe():
    nr = 1
    masse = list()
    while len(masse) < 3:
        try:
            i = float(input('{0}. Mass in cm: '.format(nr)))
            masse.append(i)
            nr += 1
        except:
            print('Falsche Eingabe! Bitte nochmal')

    return masse

q = eingabe()
print()
print('Rohrlänge:       {0} cm'.format((q[0]+q[1]+q[2])*2))
print('Plexiglasfläche: {0} cm\u00b2'.format(q[0]*q[1]*2 + q[0]*q[2]*2+q[1]*q[2]*2))
print('Volumen:         {0} cm\u00b3'.format(q[0]*q[1]*q[2]))
                

Lösung von: Frank Schneider ()

a = input("Breite = ")
b = input ("Hoehe = ")
c = input("Tiefe =" )
print "Rohrlaenge =", 4*(a + b + c), "Zentimeter"
print "Plexiglasflaeche =", 2*(a*b + a*c + b*c), "Quadratzentimeter"
print "Volumen =", a*b*c, "Kubikzentimeter"
                

Lösung von: Name nicht veröffentlicht

/**
 * Programmieraufgaben.CH
 *
 * date  : 2011-10-15
 * author: philipp gressly freimann (Santis Training AG)
 * PL/1: www.iron-spring.com
 */

Truhen:
  procedure options(main);
  
  declare breite       fixed(31) init(2),
          hoehe        fixed(31) init(3),
          tiefe        fixed(31) init(4);
  
  declare oberflaeche  fixed(31),
          kantenlaenge fixed(31),
          volumen      fixed(31);

  /* Berechnungen */
  volumen      = breite * hoehe * tiefe;
  kantenlaenge = 4 * (breite + tiefe + hoehe);
  oberflaeche  = 2 * (breite * tiefe + breite * hoehe + tiefe * hoehe);

  put skip list('Volumen     : ', volumen);
  put skip list('Oberflaeche : ', oberflaeche);
  put skip list('Rohrlaenge  : ', kantenlaenge);

end Truhen;
                

Lösung von: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

*&---------------------------------------------------------------------*
*& Report  Z_PLEXIGLAS_TRUHEN
*&
*&---------------------------------------------------------------------*
*& 
*& Programmiersprache ist eigentlch ABAP
*&---------------------------------------------------------------------*

REPORT  Z_PLEXIGLAS_TRUHEN.

set BLANK LINES on.

PARAMETERS: l_width TYPE p DECIMALS 2,
            l_height TYPE p DECIMALS 2,
            l_depth TYPE p DECIMALS 2.


DATA: l_pipelength_result TYPE p DECIMALS 2,
      l_area_result TYPE p DECIMALS 2,
      l_volume_result TYPE p DECIMALS 2.


l_pipelength_result = 4 * l_width + 4 * l_height + 4 * l_depth.

l_area_result = 2 * l_height * l_width + 2 * l_width * l_depth + 2 * l_height * l_depth.

l_volume_result = l_height * l_width * l_depth.

WRITE: /, 'Plexi-Box Calculator'.

uline.

WRITE: / l_pipelength_result, ' cm pipes are neccessary.'.
WRITE: / 'Moreover the area of the Box amounts ', l_area_result, ' square centimeters'.
WRITE: / 'And t
                

Lösung von: Benjamin Kluszynski (( Coder :-) ))

"""Truhen aus Plexigals"""

b = float(input("Breite: "))
h = float(input("Höhe: "))
t = float(input("Tiefe: "))

def flaeche(b,h,t):
    if b == t == h:
        die_flaeche = b*t*6
    else:
        die_flaeche = (b*h*2)+(b*t*2)+(t*h*2)
    print("Die Fläche der Truhe beträgt ", die_flaeche, "cm²")

def volumen(b,h,t):
    das_volumen = b*h*t
    print("Das Volumen der Truhe beträgt ", das_volumen, "cm³")

def kanten (b,h,t):
    die_kanten = b*4+t*4+h*4
    print("Die Länge der Rohre beträgt ", die_kanten, "cm")

flaeche(b,h,t)
volumen(b,h,t)
kanten(b,h,t)

                

Lösung von: Py Thon ()

static void Main(string[] args)
        {
            double x, y, z;
            Console.Write("Breite: ");
            string Breite = Console.ReadLine();
            x = Convert.ToDouble(Breite);

            Console.Write("Höhe: ");
            string Höhe = Console.ReadLine();
            y = Convert.ToDouble(Höhe);

            Console.Write("Tiefe: ");
            string Tiefe = Console.ReadLine();
            z = Convert.ToDouble(Tiefe);

            Console.WriteLine("Rohrlänge: " + (4*x + 4*y + 4*z) + " cm");
            Console.WriteLine("Plexiglasfläche: " + (2*x*y+2*x*z+2*y*z) + " cm^2");
            Console.WriteLine("Volumen: " + x*y*z + " cm^3");

            Console.ReadKey();
        }
                
// Autor:				Andy Großhennig
// Solution for task:	Truhen aus Plexiglas (Anweisungen und Abfolgen)

#include <iostream>

using namespace std;

// Structure: Define the chest
struct chest
{
	double d_arrXYZ[3];
	double dChestVolume, dGlassArea, dTubeLength; // Twelve borders
};

// Function: Get Width, Length and High
void getData(chest *chest)
{
	printf("Geben sie die Groessen der Truhe an:\n\nX: ");
	cin >> chest->d_arrXYZ[0];
	printf("\nY: ");
	cin >> chest->d_arrXYZ[1];
	printf("\nZ: ");
	cin >> chest->d_arrXYZ[2];
}

// Function: Calculate the length of the tubes, the size of the area of glass and the volume of the chest
void calculate()
{
	chest chest;

	getData(&chest);

	chest.dTubeLength = (chest.d_arrXYZ[0] * 4) + (chest.d_arrXYZ[1] * 4) + (chest.d_arrXYZ[2] * 4);

	chest.dGlassArea = ((chest.d_arrXYZ[0] * chest.d_arrXYZ[1]) * 2) + ((chest.d_arrXYZ[0] * chest.d_arrXYZ[2]) * 2) + ((chest.d_arrXYZ[1] * chest.d_arrXYZ[2]) * 2);

	chest.dChestVolume = chest.d_arrXYZ[0] * chest.d_arrXYZ[1] * chest.d_arrXYZ[2];

	printf("\n\nDie benoetigte Rohrlaenge betraegt: %.3f \nDie benoetigte Flaeche an Plexiglas betraegt: %.3f \nDas Volumen der Truhe betraegt: %.3f", chest.dTubeLength, chest.dGlassArea, chest.dChestVolume);
}

int main()
{
	calculate();
	
	printf("\n\n");
	system("Pause");
	return 0;
}
                

Lösung von: Andy Großhennig (Bundeswehr)

puts "Breite eingeben:"
width = gets.chomp.to_i
puts "Höhe eingeben:"
height = gets.chomp.to_i
puts "Tiefe eingeben:"
depth = gets.chomp.to_i

puts "Das Volumen beträgt #{width*height*depth} cm3"
puts "Die Plexiglasfläche beträgt #{2*(width*height)+2*(height*depth)+2*(width*depth)} cm2"
puts "Die totale Kantenlänge beträgt #{(4*width)+(4*height)+(4*depth)} cm"
                

Lösung von: Name nicht veröffentlicht

breite = int(input('Breadth: '))
hoehe = int(input('Hight: '))
tiefe = int(input('Depth: '))

volumen = breite * hoehe * tiefe

glasflaeche = (2 * breite * hoehe) + (2 * tiefe * hoehe) + (2 * breite * tiefe)

kantenlaenge = (breite + tiefe + hoehe) * 4

print('You will need', kantenlaenge, 'cm of zinc pipe,',
      glasflaeche, 'square cm of acrylic glass, and',
      'the volume is', volumen, 'cubic centimeters.')

                

Lösung von: Hilli Hilli ()

// eingabemaske
document.write(
   '<input type="number" id="width" onchange="compute()"> Breite (cm)<br>' +
   '<input type="number" id="height" onchange="compute()"> Höhe (cm)<br>' +
   '<input type="number" id="depth" onchange="compute()"> Tiefe (cm)<br>'+
   '<p id="out"></p>'
);

function compute() {
   var w = document.getElementById("width").value,
       h = document.getElementById("height").value,
       d = document.getElementById("depth").value;
       
    document.getElementById("out").innerHTML =
      'Rohrlänge: ' + (4 * w + 4 * h + 4 * d).toFixed(2) + ' cm<br>' + 
      'Plexiglasfläche: ' + (2 * w * h + 2 * h * d + 2 * w * d).toFixed(2) + 
         ' cm²<br>' +
      'Volumen: ' + (w * d * h).toFixed(2) + 'cm³';
}
                

Lösung von: Lisa Salander (Heidi-Klum-Gymnasium Bottrop)

object PlexiGlasCalc extends App {
def VolumenCalc(x:Int , y:Int , z:Int) : Int = {
  var Volumen = x*y*z
  return Volumen
}  
def PlexiGlasCalc(x:Int , y:Int , z:Int) : Int = {
  var Oberflaeche = 2*(x*y) + 2*(x*z) + 2*(y*z)
  return Oberflaeche 
}
def KantenCalc(x:Int , y:Int , z:Int) : Int = {
  var Kanten = (4*y)+(4*z)+(4*x)
  return Kanten
}
println("Plexiglas Rechner 2015 Scala")
println("Geben Sie die Höhe ein")
var hoehe:Int = scala.io.StdIn.readInt()
println("Geben Sie die Breite ein")
var breite:Int = scala.io.StdIn.readInt()
println("Geben sie die Tiefe ein")
var tiefe:Int = scala.io.StdIn.readInt()
var Volumen = VolumenCalc(hoehe,breite,tiefe)
var PlexiGlasGes = PlexiGlasCalc(hoehe,breite,tiefe)
var KantenLaenge = KantenCalc(hoehe,breite,tiefe)
println("Das Volumen beträgt: " + Volumen + "cm³")
println("Die Gesamt Fläche des Plexiglases beträgt " + PlexiGlasGes + "cm²")
println("Die Gesamt KantenLänge beträgt beträgt " + KantenLaenge + "cm")
}
                

Lösung von: Name nicht veröffentlicht

HTML-Code:


<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<form action="plexiglas.php" method="post">
    <input type="number" min="0" name="num1"> Länge (in cm)<br></input>
    <input type="number" min="0" name="num2"> Breite (in cm)<br></input>
    <input type="number" min="0" name="num3"> Höhe (in cm)<br></input>
    <input type="submit" value="Abschicken" /><input type="reset" />
</form>


</body>
</html>



PHP-Code:


<?php

$x = $_POST["num1"];
$y = $_POST["num2"];
$z = $_POST["num3"];


$volumen = $x * $y * $z;
$plexi = (($x * $z) * 4) + (($y * $z) * 2);
$rohr = $x * 4 + $y * 4 + $z * 4;

echo "Das Volumen beträgt: " . $volumen . " cm³<br>";
echo "Die Plexiglasfläche beträgt: " . $plexi . " cm²<br>";
echo "Die Rohrlänge beträgt: " . $rohr . " cm<br>";

?>
                

Lösung von: Maik Scheiermann (Powercloud GmbH)

REPORT TRUHE.

PARAMETERS: lv_laeng TYPE i,
            lv_breit TYPE i,
            lv_hoehe TYPE i.

DATA: lv_kanten  TYPE i,
      lv_flaeche TYPE i,
      lv_vol     TYPE i.

lv_kanten  = ( 4 * lv_laeng ) + ( 4 * lv_breit ) + ( 4 * lv_hoehe ).
lv_flaeche = ( 2 * lv_laeng * lv_breit ) + ( 2 * lv_laeng * lv_hoehe ) + ( 2 * lv_breit * lv_hoehe ).
lv_vol     = lv_laeng * lv_breit * lv_hoehe.

WRITE:/ 'Kantenlängen:',lv_kanten,' cm'.
NEW-LINE.
WRITE:/ 'Fläche      :',lv_flaeche,' cm2'.
NEW-LINE.
WRITE:/ 'Volumen     :',lv_vol,' cm3'.
                

Lösung von: Name nicht veröffentlicht

Verifikation/Checksumme:

Breite = 2, Höhe=3, Tiefe=4

Volumen = 24 cm3

Oberfläche = 52 cm2

Rohrlänge = 36 cm

Aktionen

Bewertung

Durchschnittliche Bewertung:

Eigene Bewertung:
Bitte zuerst anmelden

Meta

Zeit:
Schwierigkeit: k.A.
Webcode: kimn-4b4h
Autor: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

Download PDF

Download ZIP

Zu Aufgabenblatt hinzufügen