Algorithme

[kostia]

Bonjour à tous,
je recherche un algorithme me permettant de générer des suites de nombres...
Voici les listes
suite S qui est donnée
S(16) = S01-S02-S03-S04-S05-S06-S07-S08-S09-S10-S11-S12-S13-S14-S15-S16

L'algorithme doit pouvoir générer le tableau suivant a 2 dimensions : T(4,4)

S04-S01-S02-S03
S05-S08-S07-S06
S09-S12-S11-S10
S16-S13-S14-S15


points remarquables :
la somme des colonnes est identique
4+5+9+16=1+8+12+13 ....=34

L’algorithme doit fonctionner T(4,4) et T(4,6) et T(4,8), ... sachant qu'il y aura toujours 4 lignes et que le Tableau T est en fonction de S
S(16) => T(4,4)
S(24) => T(4,6)
S(32) => T(4,8)

Merci pour vos retours...

[fatal_error]

salut,

je pense qu'on s'en sort assez facilement: il suffit de numéroter en mode serpent:

Code: Tout sélectionner

32 31 30 29 28 27 26 25
17 18 19 20 21 22 23 24
16 15 14 13 12 11 10 09
01 02 03 04 05 06 07 08



deux lignes s'annulant entre elles

ex en nodejs

Code: Tout sélectionner

#!/usr/bin/node
function S(n){
    var c = n/4;
    var M = '0'.repeat(c).split('').map(x=>'1'.repeat(4).split(''));//indexed per column
    var iterate = function(i,j,fn){
        for(var i = 0;i<j;++i){fn(i)}
    }
    var reverse_iterate = function(i,j,fn){
        for(var i = j-1;i>=0;--i){fn(i)}
    }
    M[0].forEach((_,lineIndex)=>{
        var fn = lineIndex%2==0?iterate:reverse_iterate;
        fn(0,c, function(j){
            M[j][lineIndex] = n--;
        })
    })
    return M;
}
function print(M){
    var twoDigits = x=>('0'+x).slice(-2);
    var s = '';
    M[0].forEach((_,lineIndex)=>{
        M.forEach((_,colIndex)=>{
            s+=twoDigits(M[colIndex][lineIndex])+' ';
        })
        s+='\n';
    })
    console.log(s.trim());
}
print(S(32))


[kostia]

Bonjour, merci pour le retour...

Je ne pense pas que cette solution convienne..
en effet, il faut dans l'exemple avoir sur la 1ere ligne :
- le 1 en colonne 4
- le 2 en colonne 5
-le 3 en colonne 6
-le 4 en colonne 3
-le 5 en colonne 2
-le 6 en colonne 7
-le 7 en colonne 8
-le 8 en colonne 1

la 2eme ligne :
le 9 en colonne 1
le 10 en colonne 8
le 11 en colonne 7 ....

[fatal_error]

lidee est sensiblement la meme.
tu as la maniere de te deplacer qui est toujours la meme.
1 du debut, deux de la fin, deux du debut... et ce pr chaque ligne.
et la maniere d iterer, commencant par le plus gros et decrementant ou par le plus petit et incrementant...
rien de plus complexe a ce que je comprends, juste manipuler des modulo... pour savoir quelle operation choisir(increm/decrem)

ex dimplem...

Code: Tout sélectionner

//minimalist matrix
function M(h,w){
    this.h = h;
    this.w = w;
    this.m = [];
}
M.prototype.idx = function(i,j){
    return i*this.w+j;
}
M.prototype.set = function(i,j,v){
    this.m[this.idx(i,j)] = v;
}
M.prototype.toString = function(){
    var s = '';
    for(var i = 0;i<this.h; ++i){
        for(var j = 0; j<this.w; ++j){
            s += this.m[this.idx(i,j)]+' ';
        }
        s+='\n';
    }
    return s.substring(0, s.length-1);
}
/**
 * fills the line is the fashion 0 3 4 .. 6 5 2 1
 * @param  {instance of M} m [description]
 * @param  {index of line} i [description]
 * @param  {strategy} s [description]
 * @return {[type]}   [description]
 */
function fillLine(m, i, s){
    var left = asc(0);
    var right = desc(m.w-1);
    var offset = 1;
    for(var j=0;j<m.w;++j){
        var localStrat = ((j+offset)%4)<2?left:right;
        var v = s.get();
        var idx = localStrat.get();
        m.set(i,idx,('0'+v).slice(-2));
    }
}
function asc(z){
    return {
        get:()=>z++
    }
}
function desc(z){
    return {
        get:()=>z--
    }
}
function S(n){ 
    var c = n/4;
    var m = new M(4,c);
    var offset = 3;
    for(var i = 0; i<m.h; ++i){
        var strategy = ((offset+i)%4)<2?asc(i*m.w+1):desc((i+1)*m.w);
        fillLine(m, i, strategy);
    }
    return m.toString();
}
console.log(S(16))
console.log('--');
console.log(S(24))
console.log('--');
console.log(S(32))


c'est assez naïf, il y a certainement plus optimal