"Puzzles mathématiques qui entraînent davantage le cerveau du programme" _Q61 (code: Ruby) -> Rust (& SQL)

Je pensais que la réécriture "puzzles mathématiques qui entraînent davantage le cerveau du programmeur" avec Rust pourrait être juste pour éviter le flou.

Q61: Tri échelonné

Ruby

q61_2.rb

N = 20

z = Hash.new(0)
z[[0,0]] = 1
1.upto(N) do |n|
    1.upto(N) do |k|
        z[[n,k]] = z[[n, k - 1]] + z[[n - 1, n - k]]
    end
end
puts 2 * z[[N, N]]

D'une manière ou d'une autre, dans le code à la p.287 du livre, la plage de la boucle interne est différente entre Ruby et JavaScript ... Le résultat correct est obtenu en Ruby, mais il arrive qu'il soit initialisé à 0.

Rust

main.rs

fn main() {
    println!("{}", q61());
}

pub fn q61() -> i64 {
    let mut z = [[0i64; 21]; 21];
    z[0][0] = 1;
    for n in 1..=20 {
        for k in 1..=n {
            let un = n as usize;
            let uk = k as usize;
            z[un][uk] = z[un][uk - 1] + z[un - 1][un - uk];
        }
    }
    return z[20][20] * 2;
}

Puisque la taille du tableau ne peut pas être spécifiée comme variable, elle est solide pour le moment. Rust est plutôt reconnaissant d'être paniqué quand quelque chose se passe. Lors de la résolution du puzzle, vous pouvez être assuré que la valeur limite sera reconnue.

SQL

À propos, dans les énigmes mathématiques, il y a beaucoup de questions qui répondent mathématiquement à la question "combien de modèles y a-t-il?" Dans le travail réel, même si le calcul du nombre de motifs peut être utilisé pour l'estimation, il existe de nombreuses situations dans lesquelles "Non, je veux le motif étendu lui-même". La raison principale est "Je veux créer des données de test". J'ai écrit la version SQL parce que "l'ordre alternatif" dans cette question peut être utile pour créer des données de test.

q61.sql

SELECT
    *
FROM
    (SELECT 1 AS v UNION ALL SELECT 2 UNION ALL SELECT 3 UNION ALL SELECT 4) AS c1,
    (SELECT 1 AS v UNION ALL SELECT 2 UNION ALL SELECT 3 UNION ALL SELECT 4) AS c2,
    (SELECT 1 AS v UNION ALL SELECT 2 UNION ALL SELECT 3 UNION ALL SELECT 4) AS c3,
    (SELECT 1 AS v UNION ALL SELECT 2 UNION ALL SELECT 3 UNION ALL SELECT 4) AS c4
WHERE
    (c1.v <> c2.v AND c1.v <> c3.v AND c1.v <> c4.v) AND
    (c2.v <> c3.v AND c2.v <> c4.v) AND
    (c3.v <> c4.v)
    AND (
    (c1.v < c2.v AND c2.v > c3.v AND c3.v < c4.v) OR
    (c1.v > c2.v AND c2.v < c3.v AND c3.v > c4.v))

Une fois exécuté, cela ressemble à ceci.

+---+---+---+---+
| v | v | v | v |
+---+---+---+---+
| 4 | 2 | 3 | 1 |
| 3 | 2 | 4 | 1 |
| 3 | 4 | 1 | 2 |
| 4 | 1 | 3 | 2 |
| 3 | 1 | 4 | 2 |
| 2 | 4 | 1 | 3 |
| 1 | 4 | 2 | 3 |
| 2 | 1 | 4 | 3 |
| 2 | 3 | 1 | 4 |
| 1 | 3 | 2 | 4 |
+---+---+---+---+
10 rows in set (0.00 sec)

Puisque SQL peut être considéré dans la théorie des ensembles, les données peuvent être extraites avec l'idée extrêmement simple «d'extraire des éléments qui correspondent aux conditions d'un ensemble possible».