Autor Zpráva
DarkMeni
Profil
Zdravím,
Když mám pole, je možné nějak zjistit všechny možné kombinace mezi prvky vnořených polí?
Například:
//Pole
var pole = [
  [0, 1],
  [2],
  [3, 4],
  [5],
  [3],
  [0]
];
//A jako výstup potřebuju zase pole s poli všech možných kombinací:
var vystup = [
  [0, 2, 3, 5, 3, 0], //indexy: 0, 0, 0, 0, 0, 0
  [1, 2, 3, 5, 3, 0], //1, 0, 0, 0, 0, 0
  [0, 2, 4, 5, 3, 0], //0, 0, 1, 0, 0, 0
  [1, 2, 4, 5, 3, 0]  //1, 0, 1, 0, 0, 0
];
Tak tam by byly možné 4 různé kombinace, ale třeba:
var pole = [
  [0, 1, 2],
  [2],
  [3, 4],
  [5],
  [3],
  [0]
];
//...
var vystup = [
  [0, 2, 3, 5, 3, 0], //indexy: 0, 0, 0, 0, 0, 0
  [1, 2, 3, 5, 3, 0], //1, 0, 0, 0, 0, 0
  [2, 2, 3, 5, 3, 0], //2, 0, 0, 0, 0, 0
  [0, 2, 4, 5, 3, 0], //0, 0, 1, 0, 0, 0
  [1, 2, 4, 5, 3, 0], //1, 0, 1, 0, 0, 0
  [2, 2, 4, 5, 3, 0]  //2, 0, 1, 0, 0, 0
];
Tady by jich bylo už 6.
A nemůžu přijít na to, jak napsat to zpracování - co mám zadat do cyklu, a jak to při procházení posouvat, aby prošel všechno.
juriad
Profil
algoritmus:
do funkce si předáš pole
odřízneš první prvek (seznam možností pro první prvek výstupu)
pro každou hodnotu:
- vytiskneš hodnotu
- pokud má zbytek pole nenulovou délku:
- - zavoláš sám sebe se zbytkem pole

toto bude tisknout jednotlivé možnosti, přidání akumulace výsledků už by mělo být jednoduché
Borius
Profil
DarkMeni:
Přesně jak píše [#2] juriad.
Zkus se podívat na podobnou hotovou funkci.
_es
Profil
Borius:
Zkus se podívat na podobnou hotovou funkci.
Tá robí niečo iné, než chcel DarkMeni.

DarkMeni:
Skúsim to vysvetliť nejako zrozumiteľnejšie, pre druhý príklad z [#1]:
Spravíš si pole n počtu prvkov: [3,1,2,1,1,1]
Pole i: [0,0,0,0,0,0]
Potom si zostavíš cyklus, aby sa pole i menilo tak, že prvý prvok postupne od 0 do 2, druhý prvok sa zmeniť nedá, tretí prvok zmeníš na 1, zase sa vrátiš k prvému prvku, ..., skončíš pri najvyššej hodnote posledného prvku, pritom vždy z poľa pole pri každej zmene i vytvoríš jeden prvok-pole poľa výstupu.
DarkMeni
Profil
Díky vám všem za rady.
juriad:
První algoritmus jsem si sice dokázal představit a dokonce i nakreslit jak by měl fungovat, ale nedokázal jsem ho správně napsat (vracel buď duplicity, nebo nevracel všechny kombinace - takže jsem nenašel příležitost, kdy mam odstranit první vnořený prvek procházeného prvku základního pole a zavolat další funkci s novým polem (a tuhle nechat doběhnout), v případě že je procházený prvek delší než 1)

Borius:
Ta funkce je právě podobná a předělání na to, aby dělala to co chci, by mi asi trvalo moc dlouho.

_es:
Druhý algoritmus si zase nedokážu představit, ale nějak záhadně se mi podařilo to podobně podle rad s dalšími pomocnými proměnnými napsat:
var input = [[0, 1], [2], [3, 4], [5], [3], [0]],
    lengths = [],
    indexes = [],
    output = [],
    do_loop = true;
for(var key in input){
    lengths.push(input[key]['length'] - 1);
    indexes.push(0);
}
lengths[lengths['length'] - 1]++;
while(do_loop){
    var to_output = [],
        changed = false;
    for(var key in input){
        to_output.push(input[key][indexes[key]]);
        if(lengths[key] > indexes[key] && !changed){
            for(var index in indexes){
                if(index == key){
                    break;
                }
                indexes[index] = 0;
            }
            indexes[key]++;
            changed = true;
            if(typeof input[key][indexes[key]] == 'undefined'){
                do_loop = false;
            }
        }
    }
    output.push(to_output);
}
Kdyby někoho napadlo něco efektivnějšího, tak budu jedině rád když mi řekne co mám změnit.
Ale už i toto dělá to co chci, takže díky za rady.

Vaše odpověď

Mohlo by se hodit

Neumíte-li správně určit příčinu chyby, vkládejte odkazy na živé ukázky.
Užíváte-li nějakou cizí knihovnu, ukažte odpovídajícím, kde jste ji vzali.

Užitečné odkazy:

Odkud se sem odkazuje


Prosím používejte diakritiku a interpunkci.

Ochrana proti spamu. Napište prosím číslo dvě-sta čtyřicet-sedm: