Grüße an alle,
hier mal mein Beitrag zum Coding-Quiz (1. Stufe).
Ein paar Worte vorweg:
Man benötig dazu eine DB (im Code 'Test') mit der Tabelle 'raetsel', die wie folgt aufgebaut ist:
id | Frage | Lösung | Schwierigkeitsgrad

Solltet Ihr außerdem noch ein paar echo-Befehle bzw. ganze Algorithmen in den Kommentaren finden -> die waren nur für zwischenzeitliche Tests gedacht und ich war am Ende zu faul um alle zu suchen und zu entfernen

Also hier dann mal mein Code:

PHP-Code:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<title>Rätsel-Generator Stufe 1</title>
</head>

<body>

<table border='0' cellspacing='0' cellpadding='0' align='center' width=''>
<tr>
    <td>
<form method='POST' action='<?php $PHP_SELF?>'>
<font>Bitte geben Sie Ihr gewünschtes Lösungswort ein! <br>(Bitte keine Punkte oder Sonderzeichen)</font><br><br>
<input type='text' name='L_Wort' value='' maxlength='50' size='50'><br>
<font>Wählen Sie jetzt noch eine Schwierigkeitsstufe:</font><br>
<input type='radio' name='Schwierigkeitsgrad' value='Leicht'>Leicht
<input type='radio' name='Schwierigkeitsgrad' value='Mittel'>Mittel
<input type='radio' name='Schwierigkeitsgrad' value='Schwer'>Schwer
<br><br>
<input type='submit' name='Bestätigen' value='Bestätigen'>
</form>
    </td>
</tr>
</table><br><br>

<?php
if(isset($_POST['Bestätigen'])) {
    //Prüfen, ob etwas eingeschrieben bzw. ausgewählt wurde...
    if(!strlen($_POST['L_Wort'])) {
        $error_msg.= "<font>Bitte ein Lösungswort eintragen!</font><br>";
    }
    if(!strlen($_POST['Schwierigkeitsgrad'])) {
        $error_msg.= "<font>Bitte auch einen Schwierigkeitsgrad auswählen!</font><br>";
    }
    //Falls Error vorhanden, dann Fehlermeldung ausgeben ansonsten weiteren Code ausführen
    if($error_msg) {
    echo"<font>$error_msg</font><br>";
    } else {
            //Code -> DB auslesen und das Ausgelesene verarbeiten    
            //DB-Verbindung aufbauen
            @$db = new mysqli('localhost', 'root', '', 'Test');
            //Verbindungsprüfung
            if(mysqli_connect_errno()) {
            printf("Verbindung fehlgeschlagen: %s\n", mysqli_connect_error());
            exit();
            }
            
            //Lösungswort verarbeiten
            $L_Wort = $_POST['L_Wort'];
            //Wort noch gegen Angriffe absichern
            $L_Wort = mysql_escape_string($L_Wort);
            //Das Wort noch von ö,ä,ü,ß befreien, indem jene ausgetauscht werden
            $Suchen = array("/ö/", "/ä/", "/ü/", "/ß/", "/Ü/", "/Ä/", "/Ö/");
            $Ersetzen = array("oe", "ae", "ue", "ss", "Ue", "Ae", "Oe");
            $L_Wort = preg_replace($Suchen, $Ersetzen, $L_Wort);
            //Lösungswort auseinander nehmen
            //1. Anzahl der Buchstaben des Lösungswortes
            $Anzahl_Buchstaben_LW_Formular = strlen($L_Wort);
            //2. Jeden Buchstaben in das vorgefertigte Array schreiben
            //vorher noch auf Großschreibung umstellen
            $L_Wort = strtoupper($L_Wort);
            $L_W_Array = str_split($L_Wort,1);
            //3. Schleife über Anzahl der Elemente des Arrays -> entspricht ja der Anzahl der Buchstaben (nur um 1 verringert und bei 0 angefangen)
            //Abfrage für jeden Buchstaben -> welche Wörter mit zugehöriger Frage kommen in Frage
            for($a=0;$a<=($Anzahl_Buchstaben_LW_Formular-1);$a++) {
                //Array für die jeweilige Abfrage erstellen -> Name = Buchstabe_ und eine Zahl angehangen
                ${"Buchstabe_".$a} = array();
                //Zählvariable initialisieren
                $z = 0;
                //SQL-Abfrage -> Schwierigkeitsgrad JETZT beachten
                $Abfrage = mysqli_query($db, "SELECT * FROM raetsel WHERE Schwierigkeitsgrad = '$_POST[Schwierigkeitsgrad]'");
                while(@$datensatz = mysqli_fetch_array($Abfrage)) {
                    extract($datensatz);
                    
                    //Lösung erstmal in Großschreibung umwandeln lassen
                    $Lösung = strtoupper($Lösung);
                    //echo"$Lösung<br>";
                    //Derzeitigen Buchstaben des Gesamt-Lösungswortes im aktuellen Wort finden
                    $Lösung_2 = strrpos($Lösung, $L_W_Array[$a]);
                    if($Lösung_2 === false) {
                    } else {
                        ////////////////////////////////////////////////////////////////////////////////
                        //Implementierung - Prüfung, ob Wort schon vorhanden - Doppelfrage ausschließen
                        ////////////////////////////////////////////////////////////////////////////////
                        
                        
                        //Wie viele Elemente hat Buchstabe_? bisher?
                        $Anzahl_B_Array = count(${"Buchstabe_".$a});
                        //"Voranden"-Variable initialisieren -> wenn >0, dann ist etwas schon vorhanden
                        $vorhanden = 0;
                        //echo"$Anzahl_B_Array<br>";
                        //Absichern -> beim 1. Aufruf ist $Anzahl_B_Array = 0, deshalb muss das Wort, wenn es passt eingeschrieben werden
                        if($Anzahl_B_Array = 0) {
                            ${"Buchstabe_".$a}[$z] = "$Lösung";
                        } else {
                            //Schleife, um das Array auszulesen
                            for($u=0; $u<=Anzahl_B_Array-1; $u++) {
                                if($Lösung == "${"Buchstabe_".$a}[$u]") {
                                $vorhanden++;
                                } else {}
                            }
                        }

                        if($vorhanden == 0) {
                        ${"Buchstabe_".$a}[$z] = "$Lösung";
                        $z++;
                        } else {}
                        /*
                        ${"Buchstabe_".$a}[$z] = "$Lösung";
                        //NICHT VERGESSEN ZU STREICHEN -> FOLGENDES:
                        //echo"$b[$a]<br>";
                        $z++;
                        */
                    }
            }
            }
            
            
            //echo"$Buchstabe_1[14]<br>";
            //Jetzt muss aus jedem Array ein Wort zufällig ausgewählt werden
            //1. Wie viele Arrays sind überhaupt vorhanden? entspricht der $Anzahl_Buchstaben_LW_Formular-1
            $Wörter = array();
            $Pos_Lösungswort = array();
            for($c=0;$c<=($Anzahl_Buchstaben_LW_Formular-1);$c++) {
                $ArrayElemente = count(${"Buchstabe_".$c}); //Entspricht dem Maximalwert-1 für rand()
                //zufälliges Element aus dem aktuellen Array für das Rätsel auswählen
                $Auswahl = rand(0,$ArrayElemente-1);
                //...und in das finale Array schreiben
                $Wörter[$c] = ${"Buchstabe_".$c}[$Auswahl];
                //echo"$Wörter[$c]<br>";
                
            //soweit fertig -> jetzt müssen nur noch die entsrechenden Positionen der Buchstaben bezüglich des Buchstabens des Gesamt-Lösungswortes gefunden werden
            //Position ermitteln
            
            
            
                        ////////////////////////////////////////////////////////////////////////////////////////
                        //Implementierung - Prüfung, wie viele mögliche Positionen und dann auswählen (zufällig)
                        ////////////////////////////////////////////////////////////////////////////////////////
                        
                        
                        
        
            //Wie oft kommt der Suchstring in dem zu untersuchenden String vor -> man kann dan nochmal eine rand() laufen lassen, um die Lösungsposition variieren zu lassen
            $Anzahl_entsprechende_Buchstaben = substr_count($Wörter[$c], $L_W_Array[$c]);
            //Globales Array, das dann die Werte aufnimmt -> KANN STATISCHEN NAMEN HABEN; DA DIE FOR-Schleife OBEN IMMER WIEDER NEU DURCHLAUFEN WIRD
            $mögliche_Positionen = array();
            //echo"$Anzahl_entsprechende_Buchstaben";
            //Absicherung, falls das mögliche Lösungswort nur einen möglichen Lösungsbuchstaben des Gesamt-Lösungswortes enthält
            if($Anzahl_entsprechende_Buchstaben = "1") {
                $Pos_Lösungswort[$c] = (stripos($Wörter[$c], $L_W_Array[$c])+1);
            } else {
                //nach dem Rückgabewert wird jetzt eine Schleife geschrieben -> alle möglichen Positionen werden erfasst
                for($zv=0; $zv<=$Anzahl_entsprechende_Buchstaben-1; $zv++) {
                    if($zv = 0) {
                        $Pos_1 = stripos($Wörter[$c], $L_W_Array[$c]);
                        $mögliche_Positionen[$zv] = $Pos_1;
                    } else {
                        $vorher = "$zv-1";
                        $Pos_weiterhin = stripos($Wörter[$c], $L_W_Array[$c], $mögliche_Positionen[$vorher]);
                        $mögliche_Positionen[$zv] = $Pos_weiterhin;
                    }
                
                }
            
                //jetzt muss noch ein zufälliger, der in Frgae kommenden Pos_Werte, ausgewählt werden
                //-> der Maximalwert für rand() steht schon fest -> $Anzahl_entsprechende_Buchstaben-1
                $Auswahl_zufällig_Pos = rand(0,$Anzahl_entsprechende_Buchstaben-1);
                $Pos_Lösungswort[$c] = $mögliche_Positionen[$Auswahl_zufällig_Pos];
            }
            
            /*
            //einfache Variante
            $Position = strpos($Wörter[$c], $L_W_Array[$c]); //Keine Schleife zur Sicherung mehr notwendig, da ja schon bekannt ist, dass der Buchstabe enthalten sein muss
                $Pos_Lösungswort[$c] = $Position+1;
                //echo"$Pos_Lösungswort[$c]<br>";
            */
            }
            
    
        
            ////////////////////////////////////////////////////////
            //IMPLEMENTIERUNG DER POSITIONIERUNG
            ////////////////////////////////////////////////////////
    
    
//Elemente in dem Array ermitteln -> für Schleife wichtig
$Anzahl_Elemente = count($Wörter);
//Schleife zum auslesen und analysieren des Arrays
//Folgende Schleife ermittelt das Wort mit den meisten Buchstaben aus dem Array $Wörter
for($i = 0; $i<=$Anzahl_Elemente-1; $i++) {
    if($i == 0) {
        $Längstes_Wort = $Wörter[0];
    } else {
    
    $Längstes_Wort_Buchstaben_Anzahl = strlen($Längstes_Wort);
    $Anzahl_Buchstaben_Aktuell = strlen($Wörter[$i]);
        if($Längstes_Wort_Buchstaben_Anzahl < $Anzahl_Buchstaben_Aktuell) {
            $Längstes_Wort = $Wörter[$i];
            $Index_im_Array = $i;
        } else {
            $Längstes_Wort = $Längstes_Wort;
        }
    
    }
}
//echo"$Längstes_Wort";


//Konstante Anzahl der Felder von links nach rechts (ob frei gelassen oder nicht)
$Anzahl_Felder = 2*(strlen($Längstes_Wort) - 1);
//echo"$Anzahl_Felder";

//Tabelle wird erstellt - so oder so
echo"<table border='1' Cellspacing='0' cellpadding='0' align='center' width=''>";

//Wie oft soll <tr> "erstellt" werden -> entspricht der Anzahl der Array-Elemente
$Anzahl_Elemente = count($Wörter);

for($x=0; $x<=$Anzahl_Elemente-1; $x++) {
    echo"<tr>";
    //Anzahl der Felder ist ja Konstant -> zumindst in jedem Beispiel
    for($y=1; $y<=$Anzahl_Felder; $y++) {
        //Knackpunkt -> um wie viel Felder muss eingerückt werden? -> Wie viele müssen leer bleiben?
        //Lösung: Anzahl_Buchstaben_Längstes_Wort - an welcher Stelle befindet sich der Buchstabe für das Gesamtlösungswort
        $Einrücken = (strlen($Längstes_Wort) - $Pos_Lösungswort[$x]);
        //Es bleiben so viele Felder leer (von links gesehen), wie $Einrücken den Wert hat
        //Anzahl der Buchstaben des Aktuellen Wortes aus dem Array
        $Wort_Akt = strlen($Wörter[$x]);
        //$Wort_Aktuell_Lösungsbuchstabe
        $Wort_Akt_LB = $Pos_Lösungswort[$x];
        if($y >= ($Einrücken + 1) && $y<= ($Einrücken + $Wort_Akt)) {
            
                $farbe = ($Einrücken + $Pos_Lösungswort[$x]);
                if($y == $farbe) {
                echo"<td width='15' style='background-color:#8bbfc9;'><font><center>_</center></font></td>";
                } else {
                echo"<td width='15' style='background-color:#c0e7ee;'><font><center>_</center></font></td>";
                }
                
        } else {
            echo"<td width='15' style='background-color:#e6e6e6;'></td>";
        }
    }
    echo"</tr>";
}

echo"</table>";    


echo"<br><br><table border='0' Cellspacing='0' Cellpadding='0' align='center' width=''>";
for($v=0;$v<=$Anzahl_Elemente-1; $v++) {
//hier jetzt noch die zu den Antworten gehörenden Fragestellungen
$Fragen_Abfrage = mysqli_query($db, "SELECT * FROM raetsel WHERE Lösung = '$Wörter[$v]'");
while($datensatz = mysqli_fetch_array($Fragen_Abfrage)) {
    extract($datensatz);
    
    $Fragenummer = $v+1;
    echo"<tr><td>$Fragenummer.$Frage</td></tr>";
}
}
echo"</table>";
    
    
    }
}
                                
?>
</body>
</html>
P.S.
Das Skript schließt keine unerwünschten Sonderzeichen bei der Eingabe aus (d.h. er findet dann kein entsprechendes Lösungswort für die Zeile, in der es vorkommt) - Sie werden jedoch escaped.
Weiterhin sollte die DB gut gefüllt sein, um Mehrfachfragen auszuschließen (es gibt zwar einen Codeabschnitt der das übernimmt, jedoch bei 3 Datensätzen in der DB auch nicht viel machen kann ).
Bitte auch darauf achten, dass die Lösungswörter in der DB ohne ö,ü,ä,ß sind, das wird nämlich leider nicht geprüft....man was man noch alles hätte einbauen können (fällt einem immer zum Schluss ein)

Tja das dürfte das Wichtigste gewesen sein - falls es noch Fragen, Anregungen oder Kritik bezüglich des Codes gibt, dann einfach melden.

NEVER FORGET: GEISTIGES EIGENTUM RESPEKTIEREN UND NICHT STEHLEN!