Programmieren lernen

/**
 * 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)

/**************************************\
|  VERWENDBARE PARAMETER:              |
|--------------------------------------|
|  joint .......... num (def: 0) .. mm |
|  reservePctg .... num (def: 5) .. %  |
|  tileHeight...... num ........... cm |
|  tileWidth ...... num ........... cm |
|  useSpareTiles .. bol                |
|  wallHeight ..... num ........... cm |
|  wallWidth ...... num ........... cm |
\**************************************/
function getTileAmount(args) {
  args.joint = parseInt(args.joint) / 10 || 0;
  args.reservePctg = parseInt(args.reservePctg) || 5;
  let hgt = parseInt(args.tileHeight) + args.joint,
      wth = parseInt(args.tileWidth) + args.joint,
      cols = Math.ceil(args.wallHeight / hgt),
      rows = Math.ceil(args.wallWidth / wth),
      res = args.reservePctg / 100 + 1;
  if (args.useSpareTiles) {
    // bleibt in einer spalte mehr als 70 % der höhe einer kachel,
    // spart man sich eine kachel in der nächsten:
    if (args.wallHeight % hgt > args.tileHeight * .7)
      cols -= Math.floor(rows / 2);
    // dito für die zeilen:
    if (args.wallWidth % wth > args.tileWidth * .7)
      rows -= Math.floor(cols / 2);
  }
  return Math.ceil(cols * rows * res);
}

/* DER REST IST FÜR DAS PRAKTIKANTY. */

// funktion zur verarbeitung der eingabemaske
function calc() {
  document.getElementById('output').innerHTML =
    getTileAmount({
      wallHeight: document.getElementById('wh').value,
      wallWidth: document.getElementById('ww').value,
      tileHeight: document.getElementById('th').value,
      tileWidth: document.getElementById('tw').value,
      joint: document.getElementById('j').value,
      reservePctg: document.getElementById('p').value,
      useSpareTiles: document.getElementById('r').checked
    });
}

// eingabemaske
document.write(`
  <h1>Muro:</h1>
  <p>
    Lar?o: <input id="ww" type="number" onchange="calc()" value="360"> cm<br>
    Alto: <input id="wh" type="number" onchange="calc()" value="270"> cm
  </p>
  <h1>Plato:</h1>
  <p>
    Lar?o: <input id="tw" type="number" onchange="calc()" value="13"> cm<br>
    Alto: <input id="th" type="number" onchange="calc()" value="15"> cm
  </p>
  <p>
    Junto: <input id="j" type="number" onchange="calc()" value="3"> mm<br>
    Rezervo: <input id="p" type="number" onchange="calc()" value="5"> %<br>
    <input id="r" type="checkbox" onchange="calc() checked"> Uzu pecojn
  </p>
  <p id="output"></p>
`);
                

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

// NET 6.x | C# 10.x | VS-2022

var lst = new List<Tiler>
{
    new Tiler(9.1, 10.1, 3, 5),
    new Tiler(360, 270, 13, 15),
    new Tiler(360, 270, 13, 15, 2.5),
    new Tiler(360, 270, 13, 15, 2.5, true),
    new Tiler(360, 265, 13, 15, 2.5, true)
};

lst.ForEach(x => Console.WriteLine(x));

class Tiler
{
    private const double REUSEABLE_PERCENT = 70;
    private const double RESERVE_PERCENT = 5;
    private readonly double _jointWidth = 0;
    private readonly double _tileWidth = 0;
    private readonly double _tileHeight = 0;

    public Tiler(double wallWidth, double wallHeight, double tileWidth, double tileHeight, double jointWidth = 0, bool reuse = false)
    {
        WallWidth = wallWidth;
        WallHeight = wallHeight;
        _tileWidth = tileWidth;
        _tileHeight = tileHeight;
        _jointWidth = jointWidth;
        Reuse = reuse;
    }

    private double WallWidth { get; }
    private double WallHeight { get; }
    private double TileWidth { get => _tileWidth + JointWidth; }
    private double TileHeight { get => _tileHeight + JointWidth; }
    private double JointWidth { get => _jointWidth / 10.0; }
    private bool Reuse { get; }
    private static double ReuseablePercent => REUSEABLE_PERCENT / 100;
    private static double ReservePercent => RESERVE_PERCENT / 100 + 1;
    private double Columns => Math.Ceiling(WallWidth / TileWidth);
    private double Rows => Math.Ceiling(WallHeight / TileHeight);
    private bool TilesReuseableRow => (Rows * TileHeight - WallHeight) > (TileHeight * ReuseablePercent);
    private bool TilesReuseableColumn => (Columns * TileWidth - WallWidth) > (TileWidth * ReuseablePercent);
    private double TilesReuseRows => Math.Ceiling(TilesReuseableRow ? ((int)Math.Floor(Columns / 2)) : Rows);
    private double TilesReuseColumns => Math.Ceiling(TilesReuseableColumn ? ((int)Math.Floor(Rows / 2)) : Columns);
    public double Tiles => Math.Ceiling(((Columns * Rows) - (Reuse ? (TilesReuseColumns + TilesReuseRows) : 0)) * ReservePercent);
    public double TilesExactly => Math.Ceiling((Columns * Rows) - (Reuse ? (TilesReuseColumns + TilesReuseRows) : 0));
    public double TilesReserve => Tiles - TilesExactly;
    public override string ToString() => $"Stück: {Tiles} Exakt: {TilesExactly} Reserve: {TilesReserve} Fuge: {JointWidth} Wiederv.: {Reuse}";
}
                

Lösung von: Jens Kelm (@JKooP)

// C++ 17

#include <iostream>
#include <vector>

constexpr double REUSEABLE_PERCENT{ 70 };
constexpr double RESERVE_PERCENT{ 5 };

class Tiler {
    double wall_width_{};
    double wall_height_{};
    double tile_width_{};
    double tile_height_{};
    double joint_width_{};
    bool reuse_{};
    const double reuseable_percent_{ REUSEABLE_PERCENT / 100 };
    const double reserve_percent_{ RESERVE_PERCENT / 100 + 1 };
    const double get_columns();
    const double get_rows();
    const bool get_tile_is_reuseable_row();
    const bool get_tile_is_reuseable_col();
    const double get_tiles_reuse_rows();
    const double get_tiles_reuse_cols();
public:
    Tiler(double wall_width, double wall_height, double tile_width, double tile_height, double joint_width = 0, bool reuse = false) :
        wall_width_{ wall_width }, wall_height_{ wall_height }, tile_width_{ tile_width }, tile_height_{ tile_height }, joint_width_{ joint_width }, reuse_{ reuse } {}
    const double get_tiles();
    const double get_tiles_exactly();
    const double get_tiles_reserve();
    friend std::ostream& operator<<(std::ostream&, Tiler&);
};

const double Tiler::get_columns() {
    return ceil(wall_width_ / tile_width_);
}

const double Tiler::get_rows() {
    return ceil(wall_height_ / tile_height_);
}

const bool Tiler::get_tile_is_reuseable_row() {
    return (get_rows() * tile_height_ - wall_height_)> (tile_height_ * reuseable_percent_);
}

const bool Tiler::get_tile_is_reuseable_col() {
    return (get_columns() * tile_width_ - wall_width_) > (tile_width_ * reuseable_percent_);
}

const double Tiler::get_tiles_reuse_rows() {
    return ceil(get_tile_is_reuseable_col() ? (int)floor(get_columns() / 2) : get_rows());
}

const double Tiler::get_tiles_reuse_cols() {
    return ceil(get_tile_is_reuseable_col() ? (int)floor(get_rows() / 2) : get_columns());
}

const double Tiler::get_tiles() {
    return ceil(((get_columns() * get_rows()) - (reuse_ ? (get_tiles_reuse_cols() + get_tiles_reuse_rows()) : 0)) * reserve_percent_);
}

const double Tiler::get_tiles_exactly() {
    return ceil((get_columns() * get_rows()) - (reuse_ ? (get_tiles_reuse_cols() + get_tiles_reuse_rows()) : 0));
}

const double Tiler::get_tiles_reserve() {
    return get_tiles() - get_tiles_exactly();
}

std::ostream& operator<<(std::ostream& os, Tiler& t) {
    os << "Stueck: " << t.get_tiles() << " Exakt: " << t.get_tiles_exactly();
    os << " Reserve: " << t.get_tiles_reserve() << " Fuge: " << t.joint_width_;
    return os << " Wiederverwertung: " << (t.reuse_ ? "JA" : "NEIN");
}

int main() {
    std::vector<Tiler>tiler{
        {9.1, 10.1, 3, 5},
        {360, 270, 13, 15},
        {360, 270, 13, 15, 2.5},
        {360, 270, 13, 15, 2.5, true},
        {360, 265, 13, 15, 2.5, true} };

    for(auto& t : tiler)
        std::cout << t << "\n";
}
                

Lösung von: Jens Kelm (@JKooP)