Ich verteidige das nicht, aber das kannst du als Anfänger und ohne Background nicht beurteilen, insofern ist es auch müßig, darüber zu diskutierenBeBur schrieb:
Starke Aussage für jemanden, der gerade an 30 Zeilen Algorithmus versagt.n/a schrieb:
An der Uni in Algorithmen und Datenstrukturen (1 und 2) musst du Pseudocode in den Prüfungen schreiben (mit Papier, Stift und Hand...), also jadx1 schrieb:
Ich fühle mich nur gekränkt, wenn zu Unrecht behauptet würde, mein Code sei sch****BeBur schrieb:
dx1 schrieb:
from typing import List, Tuple, Set
from copy import deepcopy
all_patterns = []
def get_usable_points(current_pattern: List[int]) -> Set[int]:
all_points = (1, 2, 3, 4, 5, 6, 7, 8, 9)
usable_points = set(all_points)
for used in current_pattern:
usable_points.remove(used)
for shadowed in get_shadowed_points(current_pattern):
usable_points.discard(shadowed)
return usable_points
def get_shadowed_points(current_pattern: List[int]) -> Set[int]:
try:
current_point = current_pattern[-1]
except IndexError:
current_point = 0
shadowed = set([])
if 1==current_point:
if not 2 in current_pattern:
shadowed.add(3)
if not 4 in current_pattern:
shadowed.add(7)
if not 5 in current_pattern:
shadowed.add(9)
if 3==current_point:
if not 2 in current_pattern:
shadowed.add(1)
if not 6 in current_pattern:
shadowed.add(9)
if not 5 in current_pattern:
shadowed.add(7)
if 7==current_point:
if not 8 in current_pattern:
shadowed.add(9)
if not 4 in current_pattern:
shadowed.add(1)
if not 5 in current_pattern:
shadowed.add(3)
if 9==current_point:
if not 8 in current_pattern:
shadowed.add(7)
if not 6 in current_pattern:
shadowed.add(3)
if not 5 in current_pattern:
shadowed.add(1)
if 2==current_point:
if not 5 in current_pattern:
shadowed.add(8)
if 4==current_point:
if not 5 in current_pattern:
shadowed.add(6)
if 6==current_point:
if not 5 in current_pattern:
shadowed.add(4)
if 8==current_point:
if not 5 in current_pattern:
shadowed.add(2)
return shadowed
def get_all_patterns(min_length: int):
all_patterns = []
max_length = 9
for i in range(min_length, max_length+1):
get_patterns_of_length(i)
def get_patterns_of_length(length: int):
for i in get_usable_points([]):
pattern = [i]
recursively_get_patterns(pattern, length)
def recursively_get_patterns(current_pattern: List[int], target_length: int) -> None:
if len(current_pattern) < target_length:
for i in get_usable_points(current_pattern):
new_pattern = deepcopy(current_pattern)
new_pattern.append(i)
recursively_get_patterns(new_pattern, target_length)
else:
all_patterns.append(current_pattern)
return None
def main():
get_all_patterns(4)
print(len(all_patterns))
main()
BeBur schrieb:
BeBur schrieb:
Habe mich da ziemlich unklar ausgedrückt. Ich meinte damit nur, dass es viele nicht-Schleifenvariablen gibt, die sehr kurze bzw. einstellige Variablennamen haben.xpad.c schrieb:
Ändert nichts an der Aussage, auch bei Javascript gibt es Iteratoren und zugehörige Schleifenkonstrukte.xpad.c schrieb:
Das würde ich sagen ist eher ein User-Problem der dann einen falschen Font eingestellt hat. Meistens stellen sich solche Fragen aber gar nicht erst, weil man gar nicht so viele generische Schleifenvariablen benötigt.xpad.c schrieb:
Damit liegst du richtig... Es wäre besser gewesen, anstattBeBur schrieb:
r res oder sum zu verwenden
n/a schrieb:
Drexel schrieb:
Drexel schrieb:
a kommt doch gar nicht vor...Und ja, ich sehe die exception. Die erlaubt ggf. kurze Variablennamen wenn der scope klein ist. Das der style guide etwas erlaubt heißt aber noch lange nicht, dass das beliebig in einem code review durch geht, sondern erlaubt etwas Flexibilität in Einzelfällen (z.B. das eine Variable die nur über 3 Zeilen verwendet wird
tmp genannt wird). Der erste Satz des Guides sagt ganz klar:Und nennt auch klar die Gründe dafür, die gelten in aller Regel natürlich auch für Variablen mit kleinem scope:
Dann war das bei euch besser geregelt als bei uns. Gerade in der Einführung in C wurde schlecht lesbarer Code seitens Dozent und Tutoren tendenziell eher als "cool" angesehen. Da gab es keine Überlegungen, ob das irgendwie gut verständlich ist.n/a schrieb:
BeBur schrieb:
function calcAllPatterns(n) {
let totalPatterns = 0;
for (let len = 2; len <= n * n; len++) {
totalPatterns += calcPatterns1(n, len);
}
console.log(totalPatterns);
return totalPatterns;
}
function calcPatterns(n, minLen) {
let totalPatterns = calcPatterns1(n, minLen);
console.log(totalPatterns);
return totalPatterns;
}
function calcPatterns1(n, len, last = -1, visited = new Set()) {
if (visited.size == len) {
return 1;
}
let sum = 0;
if (last == -1) {
for (let i = 0; i < n * n; i++) {
visited.add(i); // Start from each cell
for (let j = 0; j < n * n; j++) {
if (!visited.has(j) && !hasPredecessor(i, j, n)) {
visited.add(j);
sum += calcPatterns1(n, len, i, visited);
visited.delete(j);
}
}
visited.delete(i);
}
return sum;
}
for (let i = 0; i < n * n; i++) {
if (!visited.has(i) && !hasPredecessor(last, i, n)) {
visited.add(i);
sum += calcPatterns1(n, len, i, visited);
visited.delete(i);
}
}
return sum;
}
function hasPredecessor(origin, target, n) {
let x1 = parseInt(origin / n);
let y1 = origin % n;
let x2 = parseInt(target / n);
let y2 = target % n;
if (x1 == x2) {
return Math.abs(y1 - y2) > 1; // Same row, not adjacent columns
}
if (y1 == y2) {
return Math.abs(x1 - x2) > 1; // Same column, not adjacent rows
}
return Math.abs(x1 - x2) > 1 || Math.abs(y1 - y2) > 1; // Diagonal adjacency check
}
calcPatterns(2, 2); // Example for 2x2 grid with min length 2 -> 12
calcPatterns(2, 3); // Example for 2x2 grid with min length 3 -> 24
calcPatterns(3, 2); // Example for 3x3 grid with min length 2
// 12 14 15 21 23 24 25 26 32 35
// 36 41 42 45 47 48 51 52 53 54
// 56 57 58 59 62 63 65 68 69 74
// 75 78 84 85 86 87 89 95 96 98 -> 40
calcPatterns(3, 3); // -> 160 ?
calcAllPatterns(2); // -> 60 ?
calcAllPatterns(3); // -> 10296 ?Der an den Client ausgelieferte Produktivcode wird minifiziert. Sobald man debuggen (= den Code lesen) möchte schaltet man minifizierung ja aus. Oder meintest du das im Sinne "im Vergleich mit minifiziertem, obfuskiertem Code war das doch richtig gut lesbar ;p"?n/a schrieb:
Ein 3x3 Grid mit exakt Länge zwei kommt bei mir auf 56 Möglichkeiten. Dier fehlen bspw. 1-6, 1-8, also die 16 Kombinationen im 30° Winkel, die in #7 angesprochen wurden.n/a schrieb:
und ich vermute, ein Knoten "snappt", sobald die direkte Verbindungslinie diesen schneidet