2D Matrix für Profis :rolleyes:

  • geschlossen
  • Delphi

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • 2D Matrix für Profis :rolleyes:

    Hy Folk's

    ich hab nen PROBLEM an dem ich nich weiter komme und sich mein Gehirnschmaltz verdünnisiert.
    Hoffe das mir einer von euch hier weiter helfen kann!
    Also es geht um das Gennerieren eines Su.doku Feldes mit der VAR s (size).
    [Standard ist 9x9]
    ich bekomme keinen Code hin der über prüft, ob die Zahl schon in der Reihe (erst mal horizontal) drin ist.
    Hier mal mein Code... bin für alle Ideen, Anregungen, Verbesserungen, ... bin ich offen

    Quellcode

    1. // GLOBAL ist VAR Matrix : ARRAY[0..16,0..16] OF byte;
    2. //randomize ist auch schon mit drin ;)
    3. PROCEDURE GenMatrix(s:byte);
    4. VAR
    5. x,y : byte; //Für die Achsen
    6. r : byte;
    7. check : ... //am besten boolean
    8. BEGIN
    9. check:=true or 1;
    10. FOR x:=0 TO s-1 DO
    11. BEGIN
    12. IF x=0 DO Matrix[x,0]:=random(s)+1
    13. ELSE
    14. REPEAT
    15. r:=random(s)+1;
    16. FOR x-1 DOWNTO 0 DO
    17. IF r<>Matrix[x,0] THEN
    18. BEGIN
    19. Matrix[x,0]:=r;
    20. check:=true or 1;
    21. END;
    22. .... //muss hier noch was hin?
    23. UNTIL check=true or 1;
    24. END;
    25. FOR y:=1 TO s-1 DO
    26. BEGIN
    27. //dürfte / sollte so ähnlich wie oben aus sehen
    28. END;
    29. END;
    Alles anzeigen

    cya or00to
  • salve or00to,

    genau dasselbe projekt, was du vorhast, habe ich auch gemacht, jedoch nicht als eingabe - sonder anders herum, ich wollte nur die ziffern eingeben, und das prog. sollte mir alle lösungsvarianten ausspucken :D

    jedoch hab ich das verworfen, da die ausgabe mehr als lang wurde, und die suche nach den "richtigen" lösungen genau so schwierig wurde, wie die eigene lösung aus dem kopf... :confused:

    aber zu deinem problem : die lösung nennt sich permutation..... :)


    hier mal ein stückerl code dazu - was du brauchen kannst...

    Quellcode

    1. procedure CombiIntegers(const Values: array of Integer; Permutation: Boolean = True);
    2. // Gebe die Kombination bzw. Permutation der Integer in Values aus.
    3. // Die Liste wird aufsteigend sortiert erzeugt. Doppelte Werte sind
    4. // zulässig werden aber bei einer Permutation unterdrückt.
    5. var
    6. Patterns: array of Integer;
    7. procedure DoPrint;
    8. // diese procedure sollte ersetzt werden für eigene Ausgaben
    9. var
    10. I: Integer;
    11. begin
    12. for I := 0 to High(Patterns) -1 do Write(Patterns[I], ',');
    13. WriteLn(Patterns[High(Patterns)]);
    14. end;
    15. procedure DoCombi(Start, Stop: Integer);
    16. // erzeugt die Kombination der Elemente in Patterns zwischen Start zu Stop Index
    17. // diese Funktion arbeitet inplaced auf Patterns
    18. var
    19. Pos: Integer;
    20. Tmp: Integer;
    21. Last: Integer;
    22. begin
    23. if Start >= Stop then
    24. begin // Rekursionsende erreicht
    25. DoPrint;
    26. Exit;
    27. end;
    28. Last := -MaxInt;
    29. Pos := Start;
    30. while Pos <= Stop do
    31. begin
    32. // Elemente tauschen
    33. Tmp := Patterns[Pos];
    34. Patterns[Pos] := Patterns[Start];
    35. Patterns[Start] := Tmp;
    36. // müssen wir eine weitere Rekursion durchführen ?
    37. if not Permutation or (Tmp > Last) then // verhindere Duplikate !
    38. begin
    39. DoCombi(Start +1, Stop);
    40. Last := Tmp;
    41. end;
    42. Inc(Pos);
    43. end;
    44. // Elemente in Patterns um eins nach rechts rotieren um das
    45. // Originalpattern wieder herzustellen
    46. Tmp := Patterns[Start];
    47. while Start < Stop do
    48. begin
    49. Patterns[Start] := Patterns[Start +1];
    50. Inc(Start);
    51. end;
    52. Patterns[Start] := Tmp;
    53. end;
    54. procedure DoCreate;
    55. var
    56. I,J,K: Integer;
    57. begin
    58. SetLength(Patterns, Length(Values));
    59. // Insertion Sort, die Elemente müssen für eine Permutation sortiert
    60. // werden. Bei der Kombination ist dies nicht erforderlich.
    61. // Wir nutzen hier den relativ langsamen Insertion Sort, da es selten
    62. // der Fall ist das man alle Kombinationen von Feldern mit mehr als
    63. // 10 Elementen erzeugt. Bedenke was 10! bedeutet.
    64. for I := 0 to High(Values) do
    65. begin
    66. J := 0;
    67. while (J < I) and (Values[I] > Patterns[J]) do
    68. Inc(J);
    69. for K := I -1 downto J do
    70. Patterns[K +1] := Patterns[K];
    71. Patterns[J] := Values[I];
    72. end;
    73. end;
    74. begin
    75. DoCreate;
    76. DoCombi(0, High(Patterns));
    77. end;
    78. procedure CombiStrings(const Values: array of String; Permutation: Boolean = True); overload;
    79. // wie oben aber mit Strings
    80. type
    81. PPCharArray = array of PChar;
    82. var
    83. Patterns: PPCharArray;
    84. procedure DoPrint;
    85. var
    86. I: Integer;
    87. begin
    88. for I := 0 to High(Patterns) -1 do Write(Patterns[I], ',');
    89. WriteLn(Patterns[High(Patterns)]);
    90. end;
    91. procedure DoCombi(Start, Stop: Integer);
    92. var
    93. Pos: Integer;
    94. Tmp: PChar;
    95. Last: String;
    96. begin
    97. if Start >= Stop then
    98. begin
    99. DoPrint;
    100. Exit;
    101. end;
    102. Last := '';
    103. Pos := Start;
    104. while Pos <= Stop do
    105. begin
    106. Tmp := Patterns[Pos];
    107. Patterns[Pos] := Patterns[Start];
    108. Patterns[Start] := Tmp;
    109. if not Permutation or (AnsiCompareText(Tmp, Last) > 0) then
    110. begin
    111. DoCombi(Start +1, Stop);
    112. Last := Tmp;
    113. end;
    114. Inc(Pos);
    115. end;
    116. Tmp := Patterns[Start];
    117. while Start < Stop do
    118. begin
    119. Patterns[Start] := Patterns[Start +1];
    120. Inc(Start);
    121. end;
    122. Patterns[Start] := Tmp;
    123. end;
    124. procedure DoCreate;
    125. var
    126. I,J,K: Integer;
    127. begin
    128. SetLength(Patterns, Length(Values));
    129. for I := 0 to High(Values) do
    130. begin
    131. J := 0;
    132. while (J < I) and (AnsiCompareText(Values[I], Patterns[J]) > 0) do
    133. Inc(J);
    134. for K := I -1 downto J do
    135. Patterns[K +1] := Patterns[K];
    136. Patterns[J] := PChar(Values[I]);
    137. end;
    138. end;
    139. begin
    140. DoCreate;
    141. DoCombi(0, High(Patterns));
    142. end;
    Alles anzeigen



    ich hoffe, ich konnte dir damit ein wenig helfen...

    greetz KuschelBaer
    Das beliebteste Haustier der Deutschen ist und bleibt das halbe Hähnchen.