일련의 숫자를 나타내는 알고리즘

Question

나는 생성 할 일련의 수를 가지며, 어떤 종류의 알고리즘 (반복적이거나 재귀적인, 중요하지 않음)을 사용하여 생성하려고합니다.

문맥 화 :이 숫자는 목록의 목록에 대한 반복 색인입니다. 나는 순열 (결합, 나는 정확하게 모른다)을 할 필요가 있지만, 나는 그리스트의 모든 위치의 모든 조합을 생성 할 필요가있다.

순서와 내가 얻으려고 노력하고있는 출력은 다음과 같습니다

1 1 
2 1 
3 1 
4 1 
5 1 

1 2 
2 1 
3 1 
4 1 
5 1 

1 3 
2 1 
3 1 
4 1 
5 1 

1 4 
2 1 
3 1 
4 1 
5 1 

1 5 
2 1 
3 1 
4 1 
5 1 

1 1 
2 2 
3 1 
4 1 
5 1 

1 2 
2 2 
3 1 
4 1 
5 1 

1 3 
2 2 
3 1 
4 1 
5 1 

1 4 
2 2 
3 1 
4 1 
5 1 

1 5 
2 2 
3 1 
4 1 
5 1 

1 1 
2 3 
3 1 
4 1 
5 1 

1 2 
2 3 
3 1 
4 1 
5 1 

1 3 
2 3 
3 1 
4 1 
5 1 

1 4 
2 3 
3 1 
4 1 
5 1 

1 5 
2 3 
3 1 
4 1 
5 1 

1 1 
2 4 
3 1 
4 1 
5 1 

등등 ... 마지막 상태는 다음과 같습니다

1 5 
2 5 
3 5 
4 5 
5 5 

참고 각 줄 바꿈에 단계입니다 반복 또는 재귀. 알고리즘은 일반 사항이어야합니다. 내가 작성한이 코드는 도움이 될 수 있지만 원하는 것은 아닙니다. :(

List<List<int>> lstDays = new List<List<int>> 
{ 
    new List<int>{1,2,3,4,5}, //day 18 
    new List<int>{1,2,3,4,5}, //day 19 
    new List<int>{1,2,3,4,5}, //day 22 
    new List<int>{1,2,3,4,5}, //day 23 
    new List<int>{1,2,3,4,5}, //day 24 
}; 

for(int i=0;i<lstDays.Count;i++) 
{ 
    for(int j=0;j<lstDays[i].Count;j++) 
    { 
     for(int k=0;k<lstDays.Count;k++) 
     { 
      Console.Write(k+1); 

      //Console.Write(j+1); 

      Console.Write('\n'); 
     } 
     Console.Write('\n'); 
    } 
} 

나는 당신이 나를 도울 수 있기를 바랍니다 (!

이

Answer 1

은 유서 깊은 에릭 Lippert의 아래의 의견을 바탕으로, OPS 원래의 의도에 대한 편집 :

public void OutputSequence(int length){ 
    Recurse(length-1, Enumerable.Range(1, length).ToArray(), new int[length]); 
} 

public void Recurse(int position, int[] arr, int[] state){ 
    if (position == -1){ 
     PrintState(state); 
     return; 
    } 

    for (int i = 0; i < arr.Length; i++) 
    {   
     state[position] = arr[i]; 
     Recurse(position-1, arr, state); 
    } 
} 

public void PrintState(int[] state){ 
    for (int i = 0; i < state.Length; i++) 
     Console.WriteLine ("{0} {1}",i+1, state[i]);   

     Console.WriteLine(); 
} 

OutputSequence(5);이 영업 이익은 원래 요청의 출력을 제공 할 것입니다.

올드 대답은

당신이 찾고있는 것은 Cartesian Product라고합니다. LINQ는 당신의 친구입니다 :

var pairs = from i in Enumerable.Range(1, 5) 
      from j in Enumerable.Range(1, 5) 
      select new {i, j}; 

foreach(var p in pairs) 
    Console.WriteLine ("{0} {1}", p.i, p.j); 

편집 : 그냥 재미를 위해, 여기에 N 진 직교 제품을 할 수있는 방법이 있습니다.

public IEnumerable<IEnumerable<int>> NAryCartesianProduct(int upper, int times){ 
    if (times == 0) 
     return Enumerable.Empty<IEnumerable<int>>(); 

    var nums = Enumerable.Range(1, upper);   
    IEnumerable<IEnumerable<int>> products = nums.Select(i => new[]{i}); 

    for (int i = 1; i < times; i++) 
    { 
     products = from p in products 
        from n in nums 
        select p.Concat(new [] {n});          
    }  

    return products; 
} 

그리고 지금 당신은 당신이 전에 한 것을 얻을 수 있습니다 : 난 그냥 빨리 이것을 해킹의 시간을 제외하고 모두 새 배열을 만드는 것보다 더 효율적인 방법이있을거야

var p = NAryCartesianProduct(5, 2); 

foreach(var i in p) 
    Console.WriteLine (i); 

:)

다음은이에 훨씬 더 많은 정보를 대답입니다 : Generating all Possible Combinations

EDIT2 : 분명히 원래 링크는 대답의 발신은 SO에서입니다 게시하다. 나는 지금까지 끝까지 읽지 않았다.

Answer 2

당신은 이런 식으로 작업을 수행 할 수 있습니다

int[] second = new[] {0,0,0,0,0}; 
bool finish = false; 
while (true) { 
    for (int i = 0 ; i != 5 ; i++) { 
     Console.WriteLine("{0} {1}", i+1, second[i]+1); 
    } 
    Console.WriteLine(); 
    int p = 0; 
    do { 
     second[p]++; 
     if (second[p] == 5) { 
      second[p] = 0; 
      p++; 
     } else { 
      break; 
     } 
    } while (p != 5); 
    if (p == 5) break; 
} 

두 번째 숫자의 순서가 배열 "창의적에 저장됩니다 "라는 second. do/while 루프"간격 "이 배열은 기재 -5- 번호가 다섯 자리수 별개로 저장된 것처럼.

H 예 : demo on ideone입니다.