3. ideale Grösse ermitteln.

ideale Grösse ermitteln.

  • J

    Ich hab folgendes, ein Feld welches x Pixel hoch ist und y Pixel breit.

    Darauf will ich z Karten in der optimalen (maximalen) Grösse verteilen wobei die Karten doppelt so hoch sind wie breit sind.
    Wie finde ich raus wieviele Reihen und Spalten ich brauche und wie gross dann die Karten sind !?

    Ich hab irgendwie gerade einen rechnerischen Blackout 😞

    PS: Soll ein Memoryspiel werden, damit ihr ungefähr wisst was rauskommen soll.

    0
  • I

    so in der Art?

    #define ICH_WILL_DIE_KARTENGROESSE_VORGEBEN 
//#define ICH_WILL_DIE_KARTEN_PRO_ZEILE_UND_SPALTE_VORGEBEN 

int main(int argc, char* argv[])
{
	double SpielfeldBreite = 640;
	double SpielfeldHoehe = 480;
	double KartenHoehe, KartenBreite, KartenanzahlProZeile, KartenanzahlProSpalte;

#if defined ICH_WILL_DIE_KARTENGROESSE_VORGEBEN
	KartenBreite = 20;
	KartenHoehe = KartenBreite / 2;
	KartenanzahlProZeile = SpielfeldBreite / KartenBreite;
	KartenanzahlProSpalte =  SpielfeldHoehe / KartenHoehe;
#endif

#if defined ICH_WILL_DIE_KARTEN_PRO_ZEILE_UND_SPALTE_VORGEBEN
	KartenanzahlProZeile = 5;
	KartenanzahlProSpalte = 4;
	KartenBreite = SpielfeldBreite / KartenanzahlProZeile;
	KartenHoehe = SpielfeldHoehe / KartenanzahlProSpalte;
#endif

	return 0;
}
    0
  • K

    Transformiere die Aufgabe durch Verdoppeln von x zunächst auf quadratische Karten der Seitenlänge a.
    Geg.: double x = 2 * x_alt, double y, int z
    Ges.: double a, int z_x, int z_y mit z_x * z_y >= z und x * y - z * a² minimal und z_x * a <= x und z_y * a <= y.
    Lösung: Durchzaehlen aller möglichen z_x und z_y!

    double BesteKantenLaenge(double x, double y, int z)
{
	int z_x, z_y;
	double a_best = 0, frei_min = x * y;
	for(z_x = 1; z_x <= z; ++z_x)
		for(z_y = z / z_x; z_y <= z; ++z_y)
			if(z_x * z_y >= z)
			{
				double breite = x / z_x;
				double hoehe = y / z_y;
				double a = (breite < hoehe) ? breite : hoehe;
				double frei = x * y - z * a * a;
				if(frei < frei_min)
				{
					frei_min = frei;
					a_best = a;
				}
			}
	return a_best;
}
    0
  • V

    Nicht als Code, aber sollte allgemein funktionieren, hat zumindest nach einigen Testrechnungen immer Karte.x doppelt so hoch sein lassen wie Karte.y:

    Fensterfläche = A
    Quadratseite = a
    x = Höhe
    y = Breite

    1. Fenster.x * Fenster.y = A
    2. Wurzel(A / z) = a
    3. a * 1/3 = help
    4. a + help = Karte.x
    5. a- help = Karte.y

    Code-Hacker

    0
  • J

    @illuminator
    weder noch, das wäre zu einfach, ich möchte die maximale grösse der Karte vorgeben mit der idealen Verteilung von Spalten und Zeilen bei einer Kartengrösse die dabei höhe = 2*breite ist. ALso so eine art mischmach deiner defines.

    @Krösus
    das sieht interessant aus, probier ich mal aus.

    @Code-Hacker
    das scheint zu stimmen 🙂

    Gegeben x = 600 y = 800 z = 20

    1. 600x800 = 480000
    2. sqr(480000/20) ~= 154
    3. 154/3 ~= 51
    4. 154+51 = 205
    5. 154-51 = 103

    danke leutz.

    0
  • V

    Natürlich hast du dabei wirklich die maximale größe, also ist zwischen den einzelnen Karten kein Platz, d.h. man müsste die breite und die höhe gegebenenfalls etas verkleinern.

    Code-Hacker

    0
  • K

    Code-Hackers Beispiel weitergeführt:
    In y passen 800 / 205 = 3,90.., also 3 Karten
    In x passen 600 / 103 = 5,82..., also 5 Karten
    Zusammen nur 15 Karten!
    Im Algorithmus fehlt noch ein kleiner Schritt: Karte_x und Karte_y müssen sukzessiv um 1 bzw. 2 Pixel verkleinert werden, bis Anzahl_x * Anzahl_y >= z.

    0
  • V

    Ähm.....
    moment!

    x=600
    dazu: 154+51 = 205 <- Karte.x

    y=800
    dazu: 154-51 = 103 <- Karte.y

    Also:
    600/205 = 2,9
    800/103 = 7,7
    2,9*7,7=22,33

    Wobei auch hier das Problem ist das wenn man abschneidet nur 2*7 hat und somit 14 Karten.
    Also irgendwie nicht wirklich das Wahre..... 🙄

    Code-Hacker

    0
Anmelden zum Antworten