C#

IEnumerator<int[]> en = GetPermutations().GetEnumerator()
while (en.MoveNext())
{
  int[] permutation = en.Current;

  // Your code
}

public bool SkipPermutations(IEnumerator en, int count)
{
  for(;count > 0; count--)  // Note the initial semicolon - Don't need to initialize
    if (!en.MoveNext()) return false;

  return true;
}

if (!SkipPermutations(en, 4)) break;

I wrote:

Of course I will not be satisfied with a solution like running empty for loop to skip a number of permutations.

Ian Shlasko wrote:

a boolean fla

this.data[n - 1] = 1;  // right-most element is set to 1.

for (int i = n - 2; i >= 0; --i)
{
  this.data[i] = temp[i];
  for (int j = i + 1; j < n; ++j)
  {
    if (this.data[j] >= this.data[i])
      ++this.data[j];
  }
}

struct
{
  int ElementValue  // Actual value
  int SkipForward   // Number of blanks following this element
  int SkipBackwards // Number of blanks preceding this element
}

harold aptroot wrote:

edit: then you could skip x iterations by just adding x to the "permutation number"

// Gets the fist permutation of given order which starts with a given beginning.
public void First(int[] beginning, int order)
{
    var check = new bool[order];
    for (int i = 0; i < beginning.Length; i++)
    {
        check[beginning[i]] = true;
        data[i] = beginning[i];
    }
    int checkI = 0;
    for (int i = beginning.Length; i < order; i++)
    {
        while (check[checkI]) 
            checkI++;
        data[i] = checkI;
        checkI++;
    }
}

public static IEnumerable<Permutation> GetPermutations(int order)
{
    var permutation = new Permutation(order);
    while ((permutation = permutation.GetSuccessor()) != null)
        yield return permutation;
}

var perm = new Permutation(5);
var beginning = new[] { 1 };
foreach (Permutation permutation in Permutation.GetPermutations(5))
{
    if (permutation.StartsWith(beginning))
    {
        permutation.First(new [] { 2}, perm.Order);
    }
    Console.WriteLine("{0} {1} {2} {3} {4}", permutation[0], permutation[1], permutation[2], permutation[3], permutation[4]);
}