Buch Cover Buch Cover Buch Cover Buch Cover

Web-Code: - Webcode Help

Plattenleger Placido (Schleifen)

Plattenleger Placido muss oft rechteckige Wände mit rechteckigen
Platten verlegen. Er hat seine eigene Methode entwicklet, damit er
vorab jeweils nicht zu viele, aber auch nicht zu wenige Platten einkauft:

Zunächst misst er die Breite der zu verlegenden Wand und teilt diese durch
die Breite der Platten. Dies ergibt für ihn die Anzahl der zu
verlegenden Spalten. Natürlich rundet er dabei auf die nächste ganze Platte
auf, damit die Wand komplett belegt wird.
Dasselbe macht er mit der Höhe der Wand, indem er diese durch die Höhe
der Platten teilt. Auch hier rundet er auf und erhält somit die zu
verlegenden Reihen.

Nun multipliziert er die Anzahl Spalten mit
derjenigen der Reihen, was ihm die effektive Anzahl einzukaufender
Platten ergibt.

Am Schluss fügt Placido dem Resultat noch 5% Reserve hinzu. Die
Reserve ist wichtig, denn einige Platten gehen beim Transport, andere
beim Verlegen in Brüche. Die so erhaltene Zahl rundet er wieder
auf die nächste ganze Zahl auf, was ihm die Einkaufszahl an Platten
ergibt.


Schreiben Sie ein Programm, bei dem Placido die folgenden Eingaben
machen kann:
* Breite der Wand
* Breite einer Platte
* Höhe der Wand
* Höhe einer Platte

Ihr Programm gibt nun die Anzahl der geforderten Platten aus.
Ob Sie dies mit einer Schleife oder mit einer Formel lösen, sei ganz
Ihnen überlassen.

Tipp mit einer Formel:
Berechnen Sie die (aufgerundete) Anzahl Zeilen und die (aufgerundete) Anzahl Spalten
unabhängig voneinander. Dabei kann jeweils die analoge Rechnung gemacht werden.
Danach multiplizieren Sie beide Zahlen, fügen die 5% hinzu und runden nochmals auf.

Tipp mit einer Schleife:
Starten Sie am Punkt links unten in der Ecke (x = 0.0, y = 0.0) und legen Sie Zeile für Zeile an.
Eine Zeile ist fertig, wenn eine neue Platte über dem Mauerende platziert werden müsste.
Eine Variable gibt an, wie viel Platten insgesamt verlegt sind. Die Variablen x und y bezeichnen jeweils die linke untere Ecke der als nächstes zu verlegenden Platte. Beim Verlegen wird sowohl der Zähler um eins erhöht, wie auch die Variable x um die Plattenbreite erhöht wird. Jedesmal, wenn die Wandbreite rechts überschritten ist, wird x auf 0.0 zurückgesetzt, aber y um die Plattenhöhe erhöht. Sobald y die Wandhöhe übersteigt, endet das Programm.


Optimierung 1: Zwischen zwei Platten steht jeweils eine Fuge von 1 bis 3 Millimetern.
Placido rechnet diese Breite bei den Platten
dazu, um bei großen Wänden jeweils die eine oder andere Spalte (oder
Zeile) einsparen zu können. Ihr Programm nimmt zusätzlich die
Fugenbreite entgegen und berücksichtigt diese. Die Reserve (5%) wird nun erst ganz
am Schluss hinzugerechnet.


Optimierung 2: Manchmal bleibt bei einer Zeile oder Spalte pro
Platte mehr als 70% übrig (mit anderen Worten: Einige Platten werden
nur zu 30% oder weniger verwendet). Bei solchen Platten verwendet
Placido die Resten (um 180? gedreht) weiter, um so noch weitere Platten zu sparen.
Schreiben Sie das Programm so um, dass zusätzlich zur Berücksichtigung
der Fugenbreite auch die Anzahl wiederverwendbarer Restteile mit in
die Rechnung einbezogen wird. Die 5% Reserve wird wieder erst ganz am Schluss dazugezählt.
Achtung beim Einsparen der Platten, dass keine Eckplatte doppelt eingespart wird!

0 Kommentare

Bitte melde dich an um einen Kommentar abzugeben

2 Lösung(en)

/**
 * 2019-04-01
 * phi@gress.ly
 * Programmieraufgabe Plattenleger Placido
 * (Web Code awtq-itnq)
 */

package ch.programmieraufgaben.sequenz;

import java.util.Scanner;


public class Placido {

	public static void main(String[] unused) {
		new Placido().top();
		return;
	}


	//
	double reserveFactor           =  1.05  ; // = 105% = 5% mehr
	double prozentWiederverwendung = 30     ; // <= 30% wird wiederverwendet


	void top() {
		//eingabeVonHand();
		alleTestFaelle();
		return;
	}


	void eingabeVonHand() {
		double breiteWand   = einlesenDouble("Breite der Wand"  );
		double breitePlatte = einlesenDouble("Breite der Platte");
		double hoeheWand    = einlesenDouble("Höhe der Wand"    );
		double hoehePlatte  = einlesenDouble("Höhe der Platte"  );
		double fugenBreite  = einlesenDouble("Breite der Fuge"  );

		int platten;

		platten = anzPlatten(breiteWand, breitePlatte, hoeheWand, hoehePlatte, fugenBreite, false);
		System.out.println("Anzahl Platten ohne                 'resuse': " + platten);

		platten = anzPlatten(breiteWand, breitePlatte, hoeheWand, hoehePlatte, fugenBreite, true);
		System.out.println("Anzahl Platten mit Berücksichtigung 'resuse': " + platten);

		return;
	}


	int anzPlatten(double  breiteWand  ,
	               double  breitePlatte,
	               double  hoeheWand   ,
	               double  hoehePlatte ,
	               double  fugenBreite ,
	               boolean halbeWiederverwenden) {
		double rechteckBreite = breitePlatte + fugenBreite;
		double rechteckHoehe  = hoehePlatte  + fugenBreite;

		int anzZeilen  = naechsGroessereGanzzahl(hoeheWand  / rechteckHoehe );
		int anzSpalten = naechsGroessereGanzzahl(breiteWand / rechteckBreite);

		int anzPlatten = anzZeilen * anzSpalten;
		if(halbeWiederverwenden) {
			anzPlatten = halbeWiederverwenden(breiteWand, breitePlatte,
			                                  hoeheWand, hoehePlatte,
			                                  fugenBreite, anzZeilen, anzSpalten,
			                                  anzPlatten);
		}
		return reserveDazuUndAufrunden(anzPlatten);
	}


	// Double aufrunden (Hier eine genügend genaue Vereinfachung von Math.ceil())
	double epsilon = 1e-12d; // sehr kleine Zahl, um korrekt aufzurunden
	int naechsGroessereGanzzahl(double dbl) {
		return (int) (dbl  + 1 - epsilon);
	}


	public int halbeWiederverwenden(double breiteWand, double breitePlatte,
			double hoeheWand, double hoehePlatte, double fugenBreite, int anzZeilen,
			int anzSpalten, int anzPlattenBreite_x_Hoehe) {
		int resultat;
		int reuseHoehe  = anzWiederverwertbareTeile(hoehePlatte , hoeheWand , fugenBreite, anzSpalten);
		int reuseBreite = anzWiederverwertbareTeile(breitePlatte, breiteWand, fugenBreite, anzZeilen );


		int anzPlattenNachAbzugWiederwendnung = anzPlattenBreite_x_Hoehe -reuseHoehe - reuseBreite;
		// Ecke kann nicht doppelt gespart werden!
		if(reuseHoehe > 0 && reuseBreite > 0 && gerade(anzZeilen) & gerade(anzSpalten)) {
			anzPlattenNachAbzugWiederwendnung = anzPlattenNachAbzugWiederwendnung + 1;
		}
		resultat = anzPlattenNachAbzugWiederwendnung;
		return resultat;
	}


	/**
	 * Analog zu "anzPlatten(siehe unten)", jedoch wird die Fugenbreite automatisch
	 * auf 0.0mm gesetzt.
	 */
	int anzPlatten(double  breiteWand  ,
	               double  breitePlatte,
	               double  hoeheWand   ,
	               double  hoehePlatte ,
	               boolean halbeWiederverwenden) {
		return anzPlatten(breiteWand, breitePlatte, hoeheWand, hoehePlatte, 0.0d, halbeWiederverwenden);
	}


	boolean gerade(int n) {
		return 0 == n % 2;
	}


	public int reserveDazuUndAufrunden(int plattenOhneReuseOhnePerc) {
		return (int) (plattenOhneReuseOhnePerc*reserveFactor + 1 -epsilon);
	}


	int anzWiederverwertbareTeile(double platte, double wand, double fuge, int anz) {
		double abschnitt     = abschnitt(platte, wand, fuge);
		double abschnittProc = abschnitt / platte * 100;
		if(istWiederverwendbar(abschnittProc)) { // wiederverwenden
			return anz / 2; // Nur jedes zweite kann Wiederverwendet werden.
		} else {
			return 0;
		}
	}


	double abschnitt(double platte, double wand, double fuge) {
		return wand % (platte + fuge);
	}


	boolean istWiederverwendbar(double abschnittProzentual) {
		return abschnittProzentual <= prozentWiederverwendung;
	}


	/**
	 * Die folgenden Testfälle prüfen diverse Breiten (B) und Höhen (H)
	 * von Wänden (w) und Platten (p). Die Fugenbreite (Fg) kann 
	 * weggelassen werden, wird dann einfach mit 0.0mm eingetragen.
	 * Der Parameter "reuse" sagt, ob eine Platte nach dem zerschneiden
	 * wiederverwendet (reused) werden darf. Dies ist nur möglich, wenn
	 * mehr als 70% der Platte unversehrt sind.
	 */
	void alleTestFaelle() {
		//    Stk + %  ,             Bw    Bp  Hw     Hp    Fg  reuse
		teste(  1  +  1, anzPlatten(  3   ,  3,  5   ,  5,      false));
		teste( 12  +  1, anzPlatten(  9.1 ,  3, 10.1 ,  5,      false));
		teste(  2  +  1, anzPlatten(  3   ,  3,  9   ,  5, 1  , false));
		teste(  2  +  1, anzPlatten(  3   ,  3,  8.9 ,  5, 1  , false));
		teste(  2  +  1, anzPlatten( 10   , 10, 11.9 ,  5, 1  , false));
		teste(  2  +  1, anzPlatten(  3   ,  3, 12.0 ,  5, 1  , false));
		teste(  3  +  1, anzPlatten(  3   ,  3, 12.1 ,  5, 1  , false));
		teste(  6  +  1, anzPlatten(  4.1 ,  3, 12.1 ,  5, 1  , false));
		teste( 10  +  1, anzPlatten( 13.8 ,  3, 13.2 ,  5, 1  , true ));
		teste(  7  +  1, anzPlatten( 12.1 ,  3, 10.0 ,  5, 1  , true ));
		teste(  5  +  1, anzPlatten( 19   ,  3,  5   ,  5, 1  , true ));
		teste( 12  +  1, anzPlatten( 16.16,  4,  8.9 ,  3, 1  , false));
		teste( 11  +  1, anzPlatten( 16.16,  4,  8.9 ,  3, 1  , true ));
		teste( 12  +  1, anzPlatten( 16.16,  4,  8.1 ,  3, 1  , false));
		teste(  9  +  1, anzPlatten( 16.16,  4,  8.1 ,  3, 1  , true ));
		teste( 16  +  1, anzPlatten( 16.0 ,  4, 12.85,  3, 1  , false));
		teste( 13  +  1, anzPlatten( 16.0 ,  4, 12.85,  3, 1  , true ));
		teste(  9  +  1, anzPlatten( 11.0 ,  4,  8.8 ,  3, 1  , false));
		teste(  7  +  1, anzPlatten( 11.0 ,  4,  8.8 ,  3, 1  , true ));
		teste(504  + 26, anzPlatten(360   , 13,270   , 15,      false));
		teste(384  + 20, anzPlatten(360   , 13,270   , 15, 2.5, false));
		teste(365  + 19, anzPlatten(360   , 13,265   , 15, 2.5, true ));
		teste(376  + 19, anzPlatten(360   , 13,270   , 15, 2.5, true ));
		teste(  7  +  1, anzPlatten(  6.1 ,  1,  4.5 ,  2, 1  , true ));
		teste(  7  +  1, anzPlatten( 10.1 ,  4,  8.1 ,  3, 1  , true ));
		return;
	}


	int testNummer = 0;
	void teste(int soll, int ist) {
		testNummer = testNummer + 1;
		System.out.print("Test " + testNummer);
		if(soll == ist) {
			System.out.println(" erfolgreich.");
		} else {
			System.out.println(" fehlerhaft!"  );
			System.out.println("   ist : " + ist );
			System.out.println("   soll: " + soll);
		}
		return;
	}


	Scanner sc = new Scanner(System.in);
	double einlesenDouble(String frage) {
		System.out.println("Bitte geben Sie die " + frage + " ein: ");
		return sc.nextDouble();
	}

} // end of class PlattenlegerPlacido
                

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

import math

print('Eingabe in cm !')
WandBreite    = 381 #input('Breite der Wand: ')   # 381
WandHoehe     = 230 #input('Höhe der Wand: ')     # 230
PlattenBreite =  22 #input('Breite der Platte: ') # 22
PlattenHoehe  =  12 #input('Höhe der Platte: ')   # 11


def aufrunden(Zahl):
    return int(math.ceil(Zahl))

def Ausgabe(Wandbreite, WandHoehe):
    global Spalten
    global Zeilen
    
    S = WandBreite / PlattenBreite
    Z = WandHoehe / PlattenHoehe
    
    Spalten = aufrunden(S)
    Zeilen  = aufrunden(Z)
    
    print('\tSpalten:', S,', aufgerundet:', Spalten)
    print('\tZeilen: ', Z,', aufgerundet:', Zeilen)
    
    A = Spalten * Zeilen * 1.05    
    AnzahlPlatten = aufrunden(A)
    
    print('\n\tAnzahl Platten:', A, ', aufgerundet:', AnzahlPlatten)


## Berechnung
Ausgabe(WandBreite, WandHoehe)


## Berechnung 1
print('\nOptimierung 1, Fugenbreite abgezogen:')
FugenBreite  = 2 #input('Fugenbreite in mm: ')    # 2

SpaltenFugen = WandBreite // PlattenBreite -1
ZeilenFugen  = WandHoehe  // PlattenHoehe  -1

SpaltenFugenBreite = SpaltenFugen * FugenBreite / 10
ZeilenFugenBreite  = ZeilenFugen  * FugenBreite / 10

print('\tSpaltenfugen:', SpaltenFugen, 'Spaltenfugenbreite:', SpaltenFugenBreite, 'cm')
print('\tZeilenfugen: ', ZeilenFugen , 'Zeilenfugenbreite: ', ZeilenFugenBreite , 'cm')

EfekitveWandBreite = WandBreite - SpaltenFugenBreite
EfektiveWandHoehe  = WandHoehe  - ZeilenFugenBreite

Ausgabe(EfekitveWandBreite, EfektiveWandHoehe)


## Berechnung 2
print('\nOptimierung 2, wenn Plattenrest größer, gleich 70% :')

SpaltenRestPlatte = Spalten * PlattenBreite - EfekitveWandBreite 
print('Spaltenplattenrest in cm:', SpaltenRestPlatte, '==', round(100 * SpaltenRestPlatte / PlattenBreite), '%')

ZeilenRestPlatte = Zeilen * PlattenHoehe - EfektiveWandHoehe
print('Zeilenplattenrest  in cm:', ZeilenRestPlatte, '==', round(100 * ZeilenRestPlatte / PlattenHoehe), '%')

a = 0 
if (SpaltenRestPlatte / PlattenBreite) >= 0.7:
    Spalten -= 1
    a += 1
    
if (ZeilenRestPlatte / PlattenHoehe) >= 0.7:
    Zeilen -= 1
    a += 1

if a == 2:
    a = 1  # Eckplatte addieren
else:
    a = 0
    
A = Spalten * Zeilen * 1.05 +a  
AnzahlPlatten = aufrunden(A)
    
print('\n\tAnzahl Platten:', A, ', aufgerundet:', AnzahlPlatten)

                

Lösung von: Alex Groeg (Freies Lernen)

Verifikation/Checksumme:

                        Breite       , Höhe         , Weitere Angaben     
Stk = Exakt + Reserve , Wand , Platte, Wand , Platte, Fuge, Teile Wiederverwen
 13 =  12   +  1      ,   9.1,  3    ,  10.1,  5   
530 = 504   + 26      , 360  , 13    , 270  , 15        
404 = 384   + 20      , 360  , 13    , 270  , 15    , 2.5 
395 = 376   + 19      , 360  , 13    , 270  , 15    , 2.5 , true
384 = 365   + 19      , 360  , 13    , 265  , 15    , 2.5 , true

Aktionen

Bewertung

Durchschnittliche Bewertung:

Eigene Bewertung:
Bitte zuerst anmelden

Meta

Zeit: 1
Schwierigkeit: Mittel
Webcode: awtq-itnq
Autor: Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch)

Download PDF

Download ZIP

Zu Aufgabenblatt hinzufügen