Simple opgave - svær at løse!

for (int idx = 0; idx < arr1.Count-1; idx++) {
  ...
  for (int idx2 = 0; idx2 < arr2.Count-1; idx2++) {
  }
}

det er da ikke dynamisk... koden skal virke lige meget hvor mange arraylister der er og ligemeget hvor mange string hver liste indeholder...dvs. man kender ikke antallet af løkker når man koder det...

Det er dynamisk, da det er arraylistens Count-property, du skal bruge. Den fortæller hvor mange elementer, der er i array-lsiten.

I know...men tror ikke helt du forstår hvad jeg vil så....hvis jeg har 5 arraylister, med 10 strings i hver...så vil jeg køre alle kombinationer ígennem som indeholder en string fra hvér arrayliste...dvs. alle kombinationer vi i dette tilfælde indeholder 5 strings.
Men idet at antallet af arraylister og strings variere, kender jeg ikke antallet af løkker på forhånd...og det er derfor jeg går kold...:)

Hver gang, du tilføjer et element til en array-liste, bliver Count propertyen ændret. Derfor skal du bruge Count-propertyen som øvre grænse.

Prøv at poste din kode

Jeg har ingen kode, idet jeg ikke aner hvordan jeg skal lave det...tror stadig ikke at du forstår mig...? jeg har x-antal arraylister med x-antal strings i...data kommer fra x-antal forskellige filer...dvs. når jeg først har indlæst data fra div. filer til arraylisterne så ændres deres størrelse ikke.

eks.

fil1 indeholder:

hej
goddag
godaften

fil2 indeholder

Kurt
Ole
Hans

fil3 indeholder:

farvel
vi ses
ciao

Fil4 indholder

Julie
Camilla
Hans
Thomas
Ulrik

en kombination vil dermed se således ud : 1-1-1-1 : Hej Kurt farvel Hans.
en anden kombinatione: 2-3-1-5 : Goddag Hans farvel Ulrik.

Der står et ord pér linie i hver txt fil jeg indlæser og ud fra dette indlæser jeg data til arraylisterne...MEN hele humlen ligger jo i, at jeg IKKE kender antallet af filer og hvor mange ord/linier hver fil indeholder og derfor heller ikke kender til antallet af arraylister og løkker som skal benyttes...you understand...? :)

sorry! Kombination: 1-1-1-1 vil selvfølgelig give: Hej Kurt farvel Julie!

Prøv at kigger her:

http://www.eksperten.dk/spm/624798

Men pas på, hvis dine lister bliver for store løber du hurtigt ind i memory problemer...

hmm...ja det er noget lignende! Det må være det Arne V kalder permutationer idet jeg jo også KUN har interesse i kombinationer hvori et element fra HVER liste indgår!

Jeg kan dog stadig ikke helt gennemskue det...er der ikke en som er i stand til at lave en rekursiv metode, som gennemløber alle permutationer for x-antal lister som indeholder x-antal elementer?! det ville jeg virkelig sætte stor pris på!

#!/usr/bin/env python
# -*- coding: UTF-8 -*-
def arraysProduct( arrays ):

    if len( arrays ) == 1:
        return arrays[0]
    res = arraysProduct( arrays[1:] )
    Res = []
    for val1 in res:
        for val2 in arrays[ 0 ]:
            Res.append( val2 + " " + val1 )

    return Res
       
if __name__ == "__main__":
    arrays= [
              [ "hej", "goddag", "godaften",],
              [ "Kurt", "Ole", "Hans", ],
              [ "farvel", "vi ses", "ciao", ],
              [ "Julie", "Camilla", "Hans", "Thomas", "Ulrik", ],
            ] 
    print "\n".join( arraysProduct( arrays ) )


hej Kurt farvel Julie
goddag Kurt farvel Julie
godaften Kurt farvel Julie
hej Ole farvel Julie
goddag Ole farvel Julie
godaften Ole farvel Julie
hej Hans farvel Julie
goddag Hans farvel Julie
godaften Hans farvel Julie
hej Kurt vi ses Julie
goddag Kurt vi ses Julie
godaften Kurt vi ses Julie
hej Ole vi ses Julie
goddag Ole vi ses Julie
godaften Ole vi ses Julie
hej Hans vi ses Julie
goddag Hans vi ses Julie
godaften Hans vi ses Julie
hej Kurt ciao Julie
goddag Kurt ciao Julie
godaften Kurt ciao Julie
hej Ole ciao Julie
goddag Ole ciao Julie
godaften Ole ciao Julie
hej Hans ciao Julie
goddag Hans ciao Julie
godaften Hans ciao Julie
hej Kurt farvel Camilla
goddag Kurt farvel Camilla
godaften Kurt farvel Camilla
hej Ole farvel Camilla
goddag Ole farvel Camilla
godaften Ole farvel Camilla
hej Hans farvel Camilla
goddag Hans farvel Camilla
godaften Hans farvel Camilla
hej Kurt vi ses Camilla
goddag Kurt vi ses Camilla
godaften Kurt vi ses Camilla
hej Ole vi ses Camilla
goddag Ole vi ses Camilla
godaften Ole vi ses Camilla
hej Hans vi ses Camilla
goddag Hans vi ses Camilla
godaften Hans vi ses Camilla
hej Kurt ciao Camilla
goddag Kurt ciao Camilla
godaften Kurt ciao Camilla
hej Ole ciao Camilla
goddag Ole ciao Camilla
godaften Ole ciao Camilla
hej Hans ciao Camilla
goddag Hans ciao Camilla
godaften Hans ciao Camilla
hej Kurt farvel Hans
goddag Kurt farvel Hans
godaften Kurt farvel Hans
hej Ole farvel Hans
goddag Ole farvel Hans
godaften Ole farvel Hans
hej Hans farvel Hans
goddag Hans farvel Hans
godaften Hans farvel Hans
hej Kurt vi ses Hans
goddag Kurt vi ses Hans
godaften Kurt vi ses Hans
hej Ole vi ses Hans
goddag Ole vi ses Hans
godaften Ole vi ses Hans
hej Hans vi ses Hans
goddag Hans vi ses Hans
godaften Hans vi ses Hans
hej Kurt ciao Hans
goddag Kurt ciao Hans
godaften Kurt ciao Hans
hej Ole ciao Hans
goddag Ole ciao Hans
godaften Ole ciao Hans
hej Hans ciao Hans
goddag Hans ciao Hans
godaften Hans ciao Hans
hej Kurt farvel Thomas
goddag Kurt farvel Thomas
godaften Kurt farvel Thomas
hej Ole farvel Thomas
goddag Ole farvel Thomas
godaften Ole farvel Thomas
hej Hans farvel Thomas
goddag Hans farvel Thomas
godaften Hans farvel Thomas
hej Kurt vi ses Thomas
goddag Kurt vi ses Thomas
godaften Kurt vi ses Thomas
hej Ole vi ses Thomas
goddag Ole vi ses Thomas
godaften Ole vi ses Thomas
hej Hans vi ses Thomas
goddag Hans vi ses Thomas
godaften Hans vi ses Thomas
hej Kurt ciao Thomas
goddag Kurt ciao Thomas
godaften Kurt ciao Thomas
hej Ole ciao Thomas
goddag Ole ciao Thomas
godaften Ole ciao Thomas
hej Hans ciao Thomas
goddag Hans ciao Thomas
godaften Hans ciao Thomas
hej Kurt farvel Ulrik
goddag Kurt farvel Ulrik
godaften Kurt farvel Ulrik
hej Ole farvel Ulrik
goddag Ole farvel Ulrik
godaften Ole farvel Ulrik
hej Hans farvel Ulrik
goddag Hans farvel Ulrik
godaften Hans farvel Ulrik
hej Kurt vi ses Ulrik
goddag Kurt vi ses Ulrik
godaften Kurt vi ses Ulrik
hej Ole vi ses Ulrik
goddag Ole vi ses Ulrik
godaften Ole vi ses Ulrik
hej Hans vi ses Ulrik
goddag Hans vi ses Ulrik
godaften Hans vi ses Ulrik
hej Kurt ciao Ulrik
goddag Kurt ciao Ulrik
godaften Kurt ciao Ulrik
hej Ole ciao Ulrik
goddag Ole ciao Ulrik
godaften Ole ciao Ulrik
hej Hans ciao Ulrik
goddag Hans ciao Ulrik
godaften Hans ciao Ulrik

bauerdata>> du har forstået hvad jeg vil...men kan du ikke lave en metode i C# som modtager en arrayliste som indeholder x-antal arraylister, som så igen indeholder a-antal strings?

Gider ikke at programmere i c#. Sorry
Du kan se hvor svært det er.
Jeg løste det i python på et øjeblik 8-)

Den som kan lave en C# metode, som modtager en arrayliste som indeholder x-antal arraylister, som hver igen indeholder x-antal strings? Får de 150 points!!

Et bud kunne være:

static void Main(string[] args)
        {
            Test t = new Test();
            ArrayList[] al = new ArrayList[t.Listing.Count];
            for (int i = 0; i < t.Listing.Count; i++)
            {
                al.SetValue(t.Listing[i], i);
            }

            t.VisitAll(al);
        }

-------------------------------------------

public class Test
    {
        private string test11 = "test11";
        private string test12 = "test12";
        private string test13 = "test13";
        private string test14 = "test14";
        private string test21 = "test21";
        private string test22 = "test22";
        private string test23 = "test23";
        private string test24 = "test24";
        private string test31 = "test31";
        private string test32 = "test32";
        private string test33 = "test33";
        private string test34 = "test34";
        private string test41 = "test41";
        private string test42 = "test42";
        private string test43 = "test43";
        private string test44 = "test44";
        private ArrayList l1;
        private ArrayList l2;
        private ArrayList l3;
        private ArrayList l4;
        private ArrayList listing;

        public Test()
        {
            l1 = new ArrayList();
            l2 = new ArrayList();
            l3 = new ArrayList();
            l4 = new ArrayList();
           
           

            l1.Add(test11);
            l1.Add(test12);
            l1.Add(test13);
            l1.Add(test14);

            l2.Add(test21);
            l2.Add(test22);
            l2.Add(test23);
            l2.Add(test24);

            l3.Add(test31);
            l3.Add(test32);
            l3.Add(test33);
            l3.Add(test34);

            l4.Add(test41);
            l4.Add(test42);
            l4.Add(test43);
            l4.Add(test44);

            listing = new ArrayList();

            listing.Add(l1);
            listing.Add(l2);
            listing.Add(l3);
            listing.Add(l4);
        }

        public ArrayList Listing
        {
            get { return this.listing; }
        }

                protected virtual void Visit(System.Collections.IEnumerator[] a)
        {
            string head = "";
            for (int j = 1; j < a.Length; j++)
            {
                System.Console.Write("{0}{1}", head, a[j].Current);
                head = " ";
            }
            System.Console.WriteLine();
        }
        public void VisitAll(params System.Collections.IEnumerable[] m)
        {
            // Initialize.
            int n = m.Length;
            int j;
            System.Collections.IEnumerator[] a = new System.Collections.IEnumerator[n + 1];
            for (j = 1; j <= n; j++)
            {
                a[j] = m[j - 1].GetEnumerator();
                a[j].MoveNext();
            }
            a[0] = m[0].GetEnumerator();
            a[0].MoveNext();
            for (; ; )
            {
                Visit(a);
                // Prepare to add one.
                j = n;
                // Carry if necessary.
                while (!a[j].MoveNext())
                {
                    a[j].Reset();
                    a[j].MoveNext();
                    j -= 1;
                }
                // Increase unless done.
                if (j == 0)
                {
                    break; // Terminate the algorithm
                }
            }
        }

    }

Det er ikke pænt, men det skulle virke. Der er taget udgangspunkt i "Knuth’s algorithm "

Giver følgende:

test11 test21 test31 test41
test11 test21 test31 test42
test11 test21 test31 test43
test11 test21 test31 test44
test11 test21 test32 test41
test11 test21 test32 test42
test11 test21 test32 test43
test11 test21 test32 test44
test11 test21 test33 test41
test11 test21 test33 test42
test11 test21 test33 test43
test11 test21 test33 test44
test11 test21 test34 test41
test11 test21 test34 test42
test11 test21 test34 test43
test11 test21 test34 test44
test11 test22 test31 test41
test11 test22 test31 test42
test11 test22 test31 test43
test11 test22 test31 test44
test11 test22 test32 test41
test11 test22 test32 test42
test11 test22 test32 test43
test11 test22 test32 test44
test11 test22 test33 test41
test11 test22 test33 test42
test11 test22 test33 test43
test11 test22 test33 test44
test11 test22 test34 test41
test11 test22 test34 test42
test11 test22 test34 test43
test11 test22 test34 test44
test11 test23 test31 test41
test11 test23 test31 test42
test11 test23 test31 test43
test11 test23 test31 test44
test11 test23 test32 test41
test11 test23 test32 test42
test11 test23 test32 test43
test11 test23 test32 test44
test11 test23 test33 test41
test11 test23 test33 test42
test11 test23 test33 test43
test11 test23 test33 test44
test11 test23 test34 test41
test11 test23 test34 test42
test11 test23 test34 test43
test11 test23 test34 test44
test11 test24 test31 test41
test11 test24 test31 test42
test11 test24 test31 test43
test11 test24 test31 test44
test11 test24 test32 test41
test11 test24 test32 test42
test11 test24 test32 test43
test11 test24 test32 test44
test11 test24 test33 test41
test11 test24 test33 test42
test11 test24 test33 test43
test11 test24 test33 test44
test11 test24 test34 test41
test11 test24 test34 test42
test11 test24 test34 test43
test11 test24 test34 test44
test12 test21 test31 test41
test12 test21 test31 test42
test12 test21 test31 test43
test12 test21 test31 test44
test12 test21 test32 test41
test12 test21 test32 test42
test12 test21 test32 test43
test12 test21 test32 test44
test12 test21 test33 test41
test12 test21 test33 test42
test12 test21 test33 test43
test12 test21 test33 test44
test12 test21 test34 test41
test12 test21 test34 test42
test12 test21 test34 test43
test12 test21 test34 test44
test12 test22 test31 test41
test12 test22 test31 test42
test12 test22 test31 test43
test12 test22 test31 test44
test12 test22 test32 test41
test12 test22 test32 test42
test12 test22 test32 test43
test12 test22 test32 test44
test12 test22 test33 test41
test12 test22 test33 test42
test12 test22 test33 test43
test12 test22 test33 test44
test12 test22 test34 test41
test12 test22 test34 test42
test12 test22 test34 test43
test12 test22 test34 test44
test12 test23 test31 test41
test12 test23 test31 test42
test12 test23 test31 test43
test12 test23 test31 test44
test12 test23 test32 test41
test12 test23 test32 test42
test12 test23 test32 test43
test12 test23 test32 test44
test12 test23 test33 test41
test12 test23 test33 test42
test12 test23 test33 test43
test12 test23 test33 test44
test12 test23 test34 test41
test12 test23 test34 test42
test12 test23 test34 test43
test12 test23 test34 test44
test12 test24 test31 test41
test12 test24 test31 test42
test12 test24 test31 test43
test12 test24 test31 test44
...........
indtil alle er rendt igennem

Imponerende med al den kode. Det må være fedt at programmere i C#

Jeg håber at du er på .NET 2.0 !

:-)

using System;
using System.Collections.Generic;

namespace E
{
    public class Permuting
    {
        public delegate void Processor(string s);
        public static void Print(string s)
        {
            Console.WriteLine(s);
        }
        private static void Permute(string prefix, int ix, List<List<String>> data, Processor p)
        {
            foreach(string s in data[ix])
            {
                if(ix >= data.Count - 1)
                {
                    p(prefix + s);
                }
                else
                {
                    Permute(prefix + s, ix + 1, data, p);
                }
            }
        }
        public static void Permute(List<List<String>> data, Processor p)
        {
            Permute("", 0, data, p);
        }
        public static void Main(string[] args)
        {
            List<List<String>> data = new List<List<String>>();
            data.Add(new List<String>());
            data.Add(new List<String>());
            data.Add(new List<String>());
            data[0].Add("A");
            data[0].Add("B");
            data[0].Add("C");
            data[0].Add("D");
            data[1].Add("X");
            data[1].Add("Y");
            data[1].Add("Z");
            data[2].Add("1");
            data[2].Add("2");
            Permute(data, Print);
            Console.ReadLine();
        }
    }
}

Hej Arne - gamle dreng ;) Mange tak for din kode! Den er fornuftig ud... :-) Min udviklings maskine er imidlertidigt ramt at virus, så er pt. igang med at fikse den. Jeg vender tilbage hurtigt muligt, når det hele er oppe og køre og jeg har fået afprøvet din kode...!

Undgå virus brug linux og mac. :-)

Hej igen Arne! Jeg har kigget på din kode og får den til at generere følgende output:

AX1
AX2
AY1
AY2
AZ1
AZ2
BX1
BX2
BY1
BY2
BZ1
BZ2
CX1
CX2
CY1
CY2
CZ1
CZ2
DX1
DX2
DY1
DY2
DZ1
DZ2

Det er korrekt, men alligevel kun en del af resultatet...jeg ønsker nemlig flere af de mulige kombinationer....rækkefølgende har nemlig også en betydning i dette tilfælde, Eks. DZ2, er ikke det samme som ZD2, Z2D, 2DZ og 2ZD...

Hvordan får jeg alle kobinationerne med? Husk blot på at der altid skal indgå ét element fra hvér liste...dvs. i dette tilfælde, skal alle kobinationer indeholde 3 tegn! Jeg ved godt, at jeg kaldte det permutationer...men det er åbenbart ikke det korrekte ord...kender ikke det korrekte ord for dette her...

Mvh. PabloPablo

Det er jo lidt en aendring i forhold til dit eksempel.

Jeg kan se 3 forskellige maader at loese det paa:

1)  som i min kode ovenfor men hvor der kommer en metode ind imellem Permute og
    Processor som laver alle kombinationer
2)  som i min kode ovenfor men hvor der kommer en metode ind imellem Main og Permute
    som laver alle kombinationer af lister
3)  en klassisk permutatiosn algorime som i det link Mikkel fandt men hvor
    permutationer testes for om der er en fra hver liste

#!/usr/bin/env python
# -*- coding: UTF-8 -*-
import types
def arraysProduct( arrays ):
    """Recursive returns product off arrays"""
    if len( arrays ) == 1:
        return arrays[ 0 ]
    res = arraysProduct( arrays[ 1: ] )
    Res = []
    for val1 in res:
        for val2 in arrays[ 0 ]:
            val2 = [val2 ]
            if type(val1) is types.StringType:
                val2.append( val1 )
            else:
                val2.extend( val1 )
            Res.append( val2 )

    return Res

def permuteList( aList, bList=[] ):
    """
    En lille effektiv recursiv funktion som
    returnerer en liste af permutationer af aList
    """
    ret = []
    if not len( aList ):
        return [ "".join( bList ) ]
    for i in range( len( aList ) ):
        bList.append( aList.pop( i ) )
        ret.extend( permuteList( aList, bList ) )
        aList.insert( i, bList.pop() )
    return ret

if __name__ == "__main__":
    arrays= [
              [ "A", "B", "C", ],
              [ "X", "Y", "Z", ],
              [ "1", "2", ],
            ]
    p_arrays = arraysProduct( arrays )
    # print "\n".join( p_arrays )
    for array in p_arrays:
        print "\n".join( permuteList( array ) )

AX1
A1X
XA1
X1A
1AX
1XA
BX1
B1X
XB1
X1B
1BX
1XB
CX1
C1X
XC1
X1C
1CX
1XC
AY1
A1Y
YA1
Y1A
1AY
1YA
BY1
B1Y
YB1
Y1B
1BY
1YB
CY1
C1Y
YC1
Y1C
1CY
1YC
AZ1
A1Z
ZA1
Z1A
1AZ
1ZA
BZ1
B1Z
ZB1
Z1B
1BZ
1ZB
CZ1
C1Z
ZC1
Z1C
1CZ
1ZC
AX2
A2X
XA2
X2A
2AX
2XA
BX2
B2X
XB2
X2B
2BX
2XB
CX2
C2X
XC2
X2C
2CX
2XC
AY2
A2Y
YA2
Y2A
2AY
2YA
BY2
B2Y
YB2
Y2B
2BY
2YB
CY2
C2Y
YC2
Y2C
2CY
2YC
AZ2
A2Z
ZA2
Z2A
2AZ
2ZA
BZ2
B2Z
ZB2
Z2B
2BZ
2ZB
CZ2
C2Z
ZC2
Z2C
2CZ
2ZC

Arne >> Kan du give et eks. på punk 1 eller 2? :)

ja

men foerst i morgen

using System;
using System.Collections.Generic;

namespace E
{
    public class Permuting
    {
        public delegate void Processor(string s);
        public static void Print(string s)
        {
            Console.WriteLine(s);
        }
        private static void PermuteStrings(string prefix, int ix, List<String>[] data, Processor p)
        {
            foreach(string s in data[ix])
            {
                if(ix >= data.Length - 1)
                {
                    p(prefix + s);
                }
                else
                {
                    PermuteStrings(prefix + s, ix + 1, data, p);
                }
            }
        }
        public static void PermuteLists(List<List<String>> data, List<String>[] temp, int ix, bool[] used, Processor p)
        {
            if(ix >= temp.Length)
            {
                PermuteStrings("", 0, temp, p);
            }
            else
            {
                for(int i = 0; i < temp.Length; i++)
                {
                    if(!used[i])
                    {
                        used[i] = true;
                        temp[ix] = data[i];
                        PermuteLists(data, temp, ix + 1, used, p);
                        used[i] = false;
                    }
                }
            }
        }
        public static void PermuteLists(List<List<String>> data, Processor p)
        {
            List<String>[] temp = new List<String>[data.Count];
            bool[] used = new bool[data.Count];
            PermuteLists(data, temp, 0, used, p);
        }
        public static void Main(string[] args)
        {
            List<List<String>> data = new List<List<String>>();
            data.Add(new List<String>());
            data.Add(new List<String>());
            data.Add(new List<String>());
            data[0].Add("A");
            data[0].Add("B");
            data[0].Add("C");
            data[0].Add("D");
            data[1].Add("X");
            data[1].Add("Y");
            data[1].Add("Z");
            data[2].Add("1");
            data[2].Add("2");
            PermuteLists(data, Print);
            Console.ReadLine();
        }
    }
}

Arne >> Mange tak for din kode! Læg et svar og få dine velfortjente points ! ;)

Hej Arne kan du ikke lige lave det så den returnerer resultatet i stedet for at udskrive det.
Det er meget nemmere at bruge hvis man kan få resultattet og spørge på indholdet.

svar

bauerdata>

En string er ustruktureret data og absolut ikke en god måde at håndtere det på.

Men hvis du vil have det som String så:

            StringWriter sw = new StringWriter();
            PermuteLists(data, sw.WriteLine);
            Console.WriteLine(sw.ToString());

eller som List<String>:

            List<String> ls = new List<String>();
            PermuteLists(data, ls.Add);
            foreach(string s in ls)
            {
                Console.WriteLine(s);
            }

Tak nummer to er helt ok :o)