Tabellenfelder kombinieren

Neue Frage »

( -: roland :- ) Auf diesen Beitrag antworten »
Tabellenfelder kombinieren
Gegeben sei eine Tabelle mit 3x3 Feldern:

A B C
D E F
G H I

Damit lassen sich z.B. die meisten herkömmlichen Web-Layouts realisieren
(logo, header, left-menu, content, right-menu, footer).

Es gibt 36 mögliche Kombinationen

ABCDEFGHI,
ABCDEF, ABDEGH, BCEFHI, DEFGHI,
ABDE, BCEF, DEGH, EFHI,
ABC, ADG, BEH, CFI, DEF, GHI,
AB, AD, BC, BE, CF, DE, DG, EF, EH, FI, GH, HI,
A, B, C, D, E, F, G, H, I

und 27 unmögliche

CFGHI, ADGHI, ABCFI, ABCDG,
ACDFGI, ABCGHI,
CDEFGHI, BCEFGHI, ADEFGHI, ACDFGHI, ABDEGHI, ABCFGHI, ABCEFHI, ABCDGHI, ABCDFGI, ABCDEGH, ABCDEFI, ABCDEFG,
BCDEFGHI, ACDEFGHI, ABDEFGHI, ABCEFGHI, ABCDFGHI, ABCDEGHI, ABCDEFHI, ABCDEFGI, ABCDEFGH

Das ist sozusagen Level 1. Aber wie finde ich alle (möglichen und vollständigen) Kombinationen dieser Kombinationen?

Ich habe eine kleine Maschine gebastelt: http://rh-balingen.de/machine/table-maker.htm
Die kann das praktisch umsetzen, was ich aber gern schon theoretisch voraussagen können möchte.
wisili Auf diesen Beitrag antworten »
RE: Tabellenfelder kombinieren
Es ist noch Vieles unklar.
1. Willst du 3x3 verallgemeinern auf mxn?
2. Was meint «Kombinationen dieser Kombinationen»?
3. Die «möglichen» Kombinationen scheinen alle «Rechtecksinhalte bestehend aus Buchstaben» des 3x3-Schemas zu sein. Aber was sind unmögliche? Die Komplemente? Wieso dann weniger?
4. Was heisst «vollständig»?

Hinweis: Mit den Buchstaben A bis I lassen sich 512 Mengen bilden!
( -: roland :- ) Auf diesen Beitrag antworten »

Hallo!

Vermutlich ist das Problem in der Tat eins der Mengenlehre, von der ich aber dummerweise überhaupt nichts verstehe (hab' 1972 Abi gemacht).

Wie kommt man auf die Zahl 512, und wie kommt man an die 512 Teilmengen?

Unter "unmöglichen Kombinationen" verstehe ich solche Teilmengen, die kein Rechteck innerhalb der Vollmenge darstellen,
unter "vollständig" einerseits Sets von Teilmengen, die in ihrer Summe die Vollmenge ABCDEFGHI ergeben, andererseits die Gesamtheit solcher Sets.

In einer Tabelle <table>...</table>sind nur Rechtecke darstellbar, Überlappungen sind dabei nicht möglich, lediglich Zusammenfassungen
<td colspan=x rowspan=y>...</td>;
Lücken stellen zwar kein wirkliches Problem dar, sind aber zumindest unschön.
Eine Erweiterung auf maximal 5x5 wäre evtl. für Sonderfälle (z.B. Submenu etc.) noch sinnvoll, aber spätestens ab da würde es unübersichtlich.

( -: roland :- )
( -: roland :- ) Auf diesen Beitrag antworten »

64 "mögliche" und "vollständige" Kombinationen hab' ich "von Hand" gefunden und umgesetzt:
http://rh-balingen.de/machine/tabellen.htm
Es gibt aber noch einige mehr (allerdings wohl eher weniger als 512 insgesamt).

( -: roland :- )
( -: roland :- ) Auf diesen Beitrag antworten »

Noch mal ich.
Die 27 aufgeführten "unmöglichen" Kombinationen sind an sich irrelevant (und sehr unvollständig).
Sie ergeben sich als Restmengen der aufgeführten 36 "möglichen" Kombinationen, sind aber alle in "mögliche" Kombinationen aufteilbar ...

( -: roland :- )
wisili Auf diesen Beitrag antworten »

512 ist 2^9 und das ist die Anzahl der Teilmengen von M = {A,B,C,D,E,F,G,H,I}.
Als Beweishilfe verwende ich die 0-1-Codierung einer Teilmenge:
Die Teilmenge { A, C, D, G } kann z. B. codiert werden als 1 0 1 1 0 0 1 0 0
d.h. für jedes Element eine 1, für fehlende eine 0.
0-1-Sequenzen der Länge 9 gibt es genau 2^9 = 512 (Variationen).

Kann man die «möglichen» Tabellen so umschreiben?:
Beim m x n Gitter (=Tabelle) entfernt man einzelne kürzeste innere Gitterstäbe so, dass jede Teilfläche ein Rechteck bleibt.
Oder konstruktiv formuliert (statt destruktiv), sogar rekursiv:
1. Man startet mit einem Horizontal-Vertikal-Rechteck.
2. Man stoppt oder legt eine horizontale oder eine vertikale teilende Verbindung: Das Rechteck zerfällt in 2 Rechtecke.
3. Man wendet 2. auf eines oder beide der entstandenen Rechtecke an.

Ich hege den Verdacht, dass die beiden Algorithmen nicht genau dasselbe leisten.
 
 
( -: roland :- ) Auf diesen Beitrag antworten »

Ich muß das jetzt erst mal versuchen zu verstehen.

Die 2 hoch 9 Möglichkeiten fallen als Lösung meines Problems definitiv aus, denn die zusammenfaßbaren Einzelelemente müssen neben- und/oder unter-einander liegen.

Was ich mir schon mal überlegt hatte, ob vielleicht eine Art "Bubble-Sort"-Lösung denkbar wäre - daß man sich einerseits von der kleinstmöglichen Variante, also 1x1-Kombinationen (A,B,C,D,E,F,G,H,I), andererseits von der größtmöglichen Variante, also der 3x3-Kombination (ABCDEFGHI) an die Gesamtzahl der Möglichkeiten heranarbeitet? Die Schwierigkeit für mich ist aber bisher immer die stringente Weiterverarbeitung der entstehenden Restmengen geblieben.

( -: roland :- )
( -: roland :- ) Auf diesen Beitrag antworten »

Vielleicht führt dieser Ansatz weiter -
Für jedes der 9 Tabellenfelder gibt es nur eine begrenzte Anzahl an möglichen Kombinationen (1x1, 2x1, 1x2, 3x1, 1x3, 2x2, 3x2, 2x3, 3x3); wenn man der Reihe nach von A nach B vorgeht, schließt jede gewählte Variante für die nachfolgenden Felder bestimmte Varianten aus ( ABDE z.B. alle B-, D- und E-Varianten ) :

A, AB, AD, ABC, ADG, ABDE, ABCDEF, ABDEGH, ABCDEFGHI
B, BC, BE, BCEH, BCEF, BCEFHI
C, CF, CFI
D, DE, DG, DEF, DEGH, DEFGHI
E, EF, EH, EFHI
F, FI
G, GH, GHI
H, HI
I
wisili Auf diesen Beitrag antworten »

Ich verstehe immer noch nicht ganz, was du suchst. Die Berechnung der Zahl der Möglichkeiten ist ja nicht primär wichtig, sondern die algorithmische Erzeugung derselben. Dazu muss aber klar sein, welche Tabelleneinteilungen gültig sind, und welche nicht. Diese Frage scheint mir noch unbeantwortet zu sein. Ist z.B. das Set AB DG HI CF E
zulässig? Der oben beschriebene rekursive Algorithmus könnte es nicht erzeugen.
( -: roland :- ) Auf diesen Beitrag antworten »

Ja, diese Kombination ist möglich. Sie erzeugt folgende Tabelle:

<table>
<tr>
<td colspan='2' rowspan='1'>A (2x1)</td>
<td colspan='1' rowspan='2'>C (1x2)</td>
</tr>
<tr>
<td colspan='1' rowspan='2'>D (1x2)</td>
<td colspan='1' rowspan='1'>E (1x1)</td>
</tr>
<tr>
<td colspan='2' rowspan='1'>H (2x1)</td>
</tr>
</table>
wisili Auf diesen Beitrag antworten »

Dann leistet das Folgende das Richtige? a. oder b.?
Beim m x n Gitter (=Tabelle) entfernt man einzelne innere Gitterstäbe so, dass (a. bei jedem Schritt, b. im Endresultat) jede Teilfläche ein Rechteck bleibt.
( -: roland :- ) Auf diesen Beitrag antworten »

Diese Variante gehört übrigens zu denen, die mich veranlaßt haben, als Layout-Grundgerüst keine absolut positionieten DIV's zu verwenden, wie in meiner alten "Maschine"

http://rh-balingen.de/machine/

sondern eine Tabelle

http://rh-balingen.de/machine/table-maker.htm
( -: roland :- ) Auf diesen Beitrag antworten »

Ja, das klingt richtig.
Und wie würde man das machen?
wisili Auf diesen Beitrag antworten »

Deine neue Maschine könnte auf die 4 +-Knöpfe in den Kreuzungen der +-Zeilen und +-Spalten verzichten, nicht wahr? Dann bleiben (mit den verbliebenen +-Knöpfen) eben genau die Eliminationen einzelner Gitterstäbe übrig.
Deine Maschine funktioniert anscheinend. Was willst du noch?
( -: roland :- ) Auf diesen Beitrag antworten »

Korrekt, die Kreuzungen sind nicht notwendig (erleichtern aber die Eingabe und verdeutlichen optisch den Stand der Dinge). Funktionieren tut die Maschine in der Tat, aber eben nur nach manueller Wahl der Kombination; ich würde aber gern dem Nutzer der Maschine eine Vorab-Übersicht geben, welche Kombinationsmöglichkeiten ihm gegeben sind. Und dafür müßte ich eben alle möglichen Kombinationen systematisch suchen und finden können
wisili Auf diesen Beitrag antworten »

Mit dem beschriebenen Algorithmus finde ich (pascalprogrammiert) 322 mögliche Tabellen.
Habe heute leider keine Zeit mehr, es genauer zu prüfen.
( -: roland :- ) Auf diesen Beitrag antworten »

Hab' noch mal ein wenig pseudo-kodiert:

Für A habe ich die möglichen Voll-Sets gesucht,
für die übrigen B bis I die ineinander enthaltenen Varianten;
mir schwebt auch schon ein Code vor, aber noch recht verschwommen.
===================================================
[ ABCDEFGHI ],
[ ABCDEF + GHI ],
[ ABDEGH + CFI ],
[ ABDE + ( CFI + GH || DF + GHI ) ],
[ ABC + DEFGHI ],
[ ADG + BCEFHI ],
[ AB + ( C + DEFGHI || CFI + DEGH ) ],
[ AD + ( BCEFHI + G || BCEF + GHI ) ],
[ A + ( BCEFHI + DG || DEFGHI || BC ) ];
===================================================
[ BCEFHI || BCEH + FI || BEH + CFI || BC + EF + HI ],
[ BCEF || BC + EF || BE + CF ],
[ BEH || BE + H || B + EH ],
[ BC || B + C ],
[ BE || B + E ],
[ B ],
---------------------------------------------------
[ CFI || CF + I || C + FI ),
[ CF || C + F ],
[ C ],
---------------------------------------------------
[ DEFGHI || DEGH + FI || DEF + GHI || DG + EH + FI ],
[ DEGH || DE + GH || DG + EH ],
[ DEF || DE + F || D + EF ],
[ DE || D + E ],
[ DG || D + G ],
[ D ],
---------------------------------------------------
[ EFHI || EF + HI || EH + FI ],
[ EF || E + F ],
[ EH || E + H ],
[ E ],
---------------------------------------------------
[ FI || F + I ],
[ F ],
---------------------------------------------------
[ GHI || GH + I || G + HI ],
[ GH || G + H ],
[ G ],
---------------------------------------------------
[ HI || H + I ],
[ H ],
---------------------------------------------------
[ I ];
===================================================
wisili Auf diesen Beitrag antworten »

Ohne Erklärung verstehe ich nichts. Hier die 322 möglichen «3x3-Layouts»:

[attach]13385[/attach]
( -: roland :- ) Auf diesen Beitrag antworten »

Hallo!

Das ist genau das, was ich suchte! Wie sieht der dazugehörige Algorithmus aus?
Hätte übrigens nie gedacht, daß es so viele Möglichkeiten gibt!
Vielen Dank!

( -: roland :- )
( -: roland :- ) Auf diesen Beitrag antworten »

Zur Erklärung meines Pseudo-Codes:

Für A sind bereits alle größtmöglichen Kombinationen erfaßt.
Als nächsten Schritt hätte ich versucht, eine verschachtelte Schleife zu programmieren, mit der dann so lange neue Lösungen mit den jeweils größtmöglichen (also in der Reihenfolge : 3x2, 2x3, 2x2, 3x1, 1x3, 2x1, 1x2) Kombinationen gesucht würden, bis zum Schluß nur noch die 1x1-Varianten enthalten wären.
Aber verschwommen ist diese Idee von einem Code für mich immer noch ...

Notfalls werde ich jetzt Dein Ergebnis von Hand weiterbearbeiten, und zwar nach diesem Muster:

A,BC,DG,EFHI = [ 2,3,0,4,5,0,0,0,0 ]
==========
2 3 0
4 5 0
0 0 0
==========

0 für 0x0 (muß evtl noch unterschieden werden in 1x0 und 0x1 !)
2 für 1x1
3 für 2x1
4 für 1x2
5 für 2x2
6 für 3x1
7 für 1x3
8 für 3x3
wisili Auf diesen Beitrag antworten »

Zitat:
Original von ( -: roland :- )
Für A sind bereits alle größtmöglichen Kombinationen erfaßt.


«Kombination» bedeutet Teilrechteck, nicht wahr? Du versuchst es mit den 9 minimalen Teilrechtecken A, B, ... .

Ich habe mit den 12 inneren Kanten gearbeitet: Die nimmt man mit, oder lässt sie weg. Das gibt zunächst 2^12=4096 Möglichkeiten. Dann habe ich die U- und L-förmigen Gebilde ausgeschieden, es blieben 322.
Die Ausscheidungskriterien sind nicht kompliziert: Man betrachtet die 4 inneren Kantenendpunkte und zählt dort die endenden Kanten. 0, 3 und 4 sind erlaubt. 2 ist nur erlaubt, wenn die beiden Kanten sich geradlinig fortsetzen, d.h. keinen rechten Winkel bilden.

Mein Think-Pascal-Programm läuft nur auf Macintosh und nur System 9, nützt dir vermutlich nichts.
( -: roland :- ) Auf diesen Beitrag antworten »

Nochmals: TAUSEND DANK !!!

Wie gesagt, ich schlage mich mit dem Problem schon wochenlang herum
(immer mal wieder) - und Du hast es in 2 Tagen gelöst!
Werde mir speziell das L- und U-Problem noch mal etwas genauer anschauen,
das läßt sich in Javascript mit Sicherheit auch formulieren.

( -: roland :- )
( -: roland :- ) Auf diesen Beitrag antworten »

Ein paar reine Verständnisfragen:

U-Strukturen werden durch den verbotenen Wert 1 als Summe der endenden Kanten an einem inneren Kantenendpunkt eliminiert?

Nach Deiner Definition wäre dann also dies korrekt:
A,BC,DG,EFHI = [ 0,1,0,0,0,0,1,1,1,1,0,1 ] ?

Und die 4 inneren Kantenendpunkte entsprechen meinen Kreuzungen?
Hätten demzufolge für die gleiche Kombination also die Werte [ 0,0,0,4 ] ?

( -: roland :- )
( -: roland :- ) Auf diesen Beitrag antworten »

Mhm, dachte zunächst, ich hätte es verstanden. Aber dann mußte ich feststellen, daß das nicht so ist.
Denn meine Kreuzung darf nur 0 oder 4 einmündende Verbindungen haben, entspricht also nicht Deinen inneren Kantenendpunkten.
Grübel, grübel ...

( -: roland :- )
wisili Auf diesen Beitrag antworten »

Zitat:
Original von ( -: roland :- )
Ein paar reine Verständnisfragen:
1. U-Strukturen werden durch den verbotenen Wert 1 als Summe der endenden Kanten an einem inneren Kantenendpunkt eliminiert?
2. Nach Deiner Definition wäre dann also dies korrekt: A,BC,DG,EFHI = [ 0,1,0,0,0,0,1,1,1,1,0,1 ] ?
3. Und die 4 inneren Kantenendpunkte entsprechen meinen Kreuzungen?
4. Hätten demzufolge für die gleiche Kombination also die Werte [ 0,0,0,4 ] ?


Zu 1. Ja, so habe ich es gemeint.
Zu 2. Ja, in meinem Programm wird jede Zahl 0, 1, ..., 4095 als 12-stellige Dualzahl verwendet.
Zu 3. Ja, und wenn man bei dir MLBL und MCBC auswählt, hat der Knoten links unten 2 Kanten (das habe ich bei dir gelernt).
Zu 4. Nein, sondern [ 0,2,2,4 ]
( -: roland :- ) Auf diesen Beitrag antworten »

Hallo!

hab' gerade einen Versuch gestartet, der zumindest dicht ranzukommen scheint
(allerdings: knapp vorbei ist auch daneben - es werden nur 256 Lösungen gefunden) :

<script>
function kein_L() {
return (
(x01 + x03 + x04 + x06 !=1) &&
(x02 + x04 + x05 + x07 !=1) &&
(x06 + x08 + x09 + x11 !=1) &&
(x07 + x09 + x10 + x12 !=1) &&!(
(x01 + x03 == 2 && x04 + x06 != 0) ||
(x01 + x04 == 2 && x03 + x06 != 0) ||
(x02 + x04 == 2 && x05 + x07 != 0) ||
(x02 + x05 == 2 && x04 + x07 != 0) ||
(x06 + x08 == 2 && x09 + x11 != 0) ||
(x06 + x09 == 2 && x08 + x11 != 0) ||
(x07 + x09 == 2 && x10 + x12 != 0) ||
(x07 + x10 == 2 && x09 + x12 != 0))
);
}

var xx = 0;
for (var x01 = 0; x01 < 2; x01 ++)
for (var x02 = 0; x02 < 2; x02 ++)
for (var x03 = 0; x03 < 2; x03 ++)
for (var x04 = 0; x04 < 2; x04 ++)
for (var x05 = 0; x05 < 2; x05 ++)
for (var x06 = 0; x06 < 2; x06 ++)
for (var x07 = 0; x07 < 2; x07 ++)
for (var x08 = 0; x08 < 2; x08 ++)
for (var x09 = 0; x09 < 2; x09 ++)
for (var x10 = 0; x10 < 2; x10 ++)
for (var x11 = 0; x11 < 2; x11 ++)
for (var x12 = 0; x12 < 2; x12 ++)
// liefert : 4096
if (kein_L()) xx ++; alert(xx);
// liefert : 256
</script>
wisili Auf diesen Beitrag antworten »

Für den Knoten 1-3-4-6 links oben hast du

(x01 + x03 == 2 && x04 + x06 != 0) ||
(x01 + x04 == 2 && x03 + x06 != 0) ||

Fehlt da nicht noch

x06 + x03 == 2 && x04 + x01 != 0) ||
(x06 + x04 == 2 && x03 + x01 != 0) ||

? Aber eigentlich sollte ich nicht dreinreden: Ich kenne diese Sprache (Javascript?) nicht.
( -: roland :- ) Auf diesen Beitrag antworten »

Will's mal versuchen mit der Ergänzung der Bedingungen - und es ist in der Tat Javascript :-)
( -: roland :- ) Auf diesen Beitrag antworten »

mhm. das war's nicht. würde ganz im gegenteil die zahl der lösungen noch weiter verringern. aber so schnell geb' ich jetzt nicht mehr auf Augenzwinkern
( -: roland :- ) Auf diesen Beitrag antworten »

H E U R E K A !!!!
===========

function kein_L() {
return (
(x01 + x03 + x04 + x06 !=1) &&
(x02 + x04 + x05 + x07 !=1) &&
(x06 + x08 + x09 + x11 !=1) &&
(x07 + x09 + x10 + x12 !=1) &&! (
(x01 + x03 == 2 && x04 + x06 == 0) ||
(x04 + x06 == 2 && x01 + x03 == 0) ||
(x01 + x04 == 2 && x03 + x06 == 0) ||
(x03 + x06 == 2 && x01 + x04 == 0) ||
(x02 + x04 == 2 && x05 + x07 == 0) ||
(x05 + x07 == 2 && x02 + x04 == 0) ||
(x02 + x05 == 2 && x04 + x07 == 0) ||
(x04 + x07 == 2 && x02 + x05 == 0) ||
(x06 + x08 == 2 && x09 + x11 == 0) ||
(x09 + x11 == 2 && x06 + x08 == 0) ||
(x06 + x09 == 2 && x08 + x11 == 0) ||
(x08 + x11 == 2 && x06 + x09 == 0) ||
(x07 + x09 == 2 && x10 + x12 == 0) ||
(x10 + x12 == 2 && x07 + x09 == 0) ||
(x07 + x10 == 2 && x09 + x12 == 0) ||
(x09 + x12 == 2 && x07 + x10 == 0) ) );
}
wisili Auf diesen Beitrag antworten »

Der Fall 3x3 scheint befriedigend gelöst: 4096 Codes überprüfen ist machbar.
Der Fall 4x4 produziert aber bereits 2^24 = 16.8 Millionen Codes: ungemütlich.
Der Fall 5x5 hat 2^40 = 1000 Milliarden Codes: unmöglich.

Mit Gruss
wisili
( -: roland :- ) Auf diesen Beitrag antworten »

Hallo!

Was die Erweiterung angeht: 3x4 und 4x3 decken schon fast alles ab, was irgendwie noch von praktischer Relevanz ist.
Was mein Maschinchen angeht, so werde ich jetzt noch ein paar kleine, feine Features einbauen, die aus dem Spielzeug ein Werkzeug machen:

1.) Laden und Bestücken von iFrames für die einzelnen Zellen
2.) CSS-Formatierung : Zuweisen von Hintergund(-farbe) etc
3.) Interaktive Änderung von Höhen und Breiten der Zellen
4.) Nachträgliche Manipulation der Tabellenstruktur
5.) Festlegung von Höhe, Breite und Position der Gesamttabelle

Ist alles schon im Einzelnen erfolgreich vorgetestet.
Aber der Teufel steckt dann ja immer noch im Detail (z.B. Internet-Explorer) unglücklich
( -: roland :- ) Auf diesen Beitrag antworten »

Zwischenzeitlich ließ mir Mirco Ackermann noch eine andere (rekursive) Lösung zukommen:
http://rh-balingen.de/machine/zellen-javascript.htm

Vielen Dank auch dafür!

( -: roland :- )
Mirco Auf diesen Beitrag antworten »

Ein 4x4 Feld ist mit meinem Algorithmus noch lösbar. http://matheboard.ludibunda.ch/zellen-canvas.html
(Webkit kriegt es bei mir hin, für mozilla bin ich nicht genügend geduldig. Und IE geht wegen der Canvas eh nicht.)

Ist man nur in der Anzahl von Möglichkeiten interessiert, kann man es mit einem Ansatz von Dynamischer Programmierung relativ effizient lösen. (http://matheboard.ludibunda.ch/zellen-n.cpp)

    2x2: 8
    3x3: 322
    4x4: 70878
    5x5: 84231996
    6x6: 535236230270
    7x7: 18100579400986674
    8x8: 3250879178100782348462

8x8 ist etwa das Limit, da braucht es bei mir um die 2gb Speicher.
( -: roland :- ) Auf diesen Beitrag antworten »

Mir fiel eben noch ein vielleicht ganz interessantes Feature ein:
Da ja 5x5 oder gar mehr schwer bis unmöglich zu berechnen sind,
andererseits das Finden aller Möglichkeiten eher nur von akademischem Interesse ist,
hingegen das Finden bestimmter Möglichkeiten schon weit eher von praktischem Nutzen wäre :

Man suche z.B. in

A B C D E
F G H I J
K L M N O
P Q R S T
U V W X Y

lediglich nach allen Varianten mit BCD, FKP, JOT, VWX
oder, vermutlich noch effektiver:
nur Varianten mit GHILMNQRS ... Augenzwinkern
Mirco Auf diesen Beitrag antworten »

Die Offenen Ränder kann man relativ einfach implementieren, indem man einfach alle Rechtecke, die nicht passen, überspringt.

code:
1:
2:
3:
if ((x1 == 0 || x2 == width) && y1 > 1 && y1 < height-1) continue;
if ((y1 == 0 || y2 == height) && x1 > 1 && x1 < width-1) continue;

Für die Offene Mitte können auch einfach alle Rechtecke übersprungen werden, die nicht passen.

Die beiden Beispiele sind auf 4x5 eingestellt, funktionieren aber auch bei 5x5, allerdings fragt dann der Webbrowser ein oder zwei mal, ob man das Script wirklich weiterlaufen lassen will.

Es sind allerdings schon bei einer Größe von 4x5 mehr als viertausend Anordnungen möglich, ist das noch von praktischem Nutzen? verwirrt
( -: roland :- ) Auf diesen Beitrag antworten »

Nicht schecht, Herr Specht!
Wie gesagt, schon 3x3 deckt das Wichtigste ab, 3x4 und 4x3 sind schon Luxus,
aber gut zu wissen, daß es auch noch weiter geht Augenzwinkern

( -: roland :- )
( -: roland :- ) Auf diesen Beitrag antworten »

Wird wohl eine Weile dauern. bis meine Maschine fertig wird.
Vorläufig habe ich eine A-B-C-Version geschrieben,
die auch den Status der einzelnen Verknüpfungen direkt anzeigt
( die ersten 12 sind die "+"-. die letzten 4 die "x"-Felder )

http://rh-balingen.de/machine/myMachine.htm

( -: roland :- )
Neue Frage »
Antworten »



Verwandte Themen

Die Beliebtesten »
Die Größten »
Die Neuesten »