VB, POMOC!

for i1 = 1 to (k-n+1)
   for i2 = 2 to (k-n+2)
      for i3 = 3 to (k-n+3)
        ....
          for in = n to k
               'niz brojeva i1, i2, i3,..., in predstavlja jednu kombinaciju
               'ovdje ide prikaz kombinacije na način koji ti odgovara
          next in
        ....
      next i3
   next i2
next i1

Function sledKombinacija(ByVal n As Integer, ByRef k As Integer, ByVal komb() As Double, ByRef pomocniNiz() As Double) As Integer
        Dim l As Integer = k
        Dim x As Double
        Dim i, y As Integer


        Do While (l > 0 And komb(l) = pomocniNiz(n))
            l = l - 1
            n = n - 1
        Loop
        If (l < 1) Then
            Return 0
        End If

        x = komb(l)
        For i = 1 To n
            If pomocniNiz(i) = x Then
                y = i
            End If
        Next

        Do
            komb(l) = pomocniNiz(y + 1)
            y = y + 1
            l = l + 1
        Loop While l <= k
        Return 1

    End Function

//--------------------------------------
// Systematically generate combinations.
//--------------------------------------

import java.math.BigInteger;

public class CombinationGenerator {

  private int[] a;
  private int n;
  private int r;
  private BigInteger numLeft;
  private BigInteger total;

  //------------
  // Constructor
  //------------

  public CombinationGenerator (int n, int r) {
    if (r > n) {
      throw new IllegalArgumentException ();
    }
    if (n < 1) {
      throw new IllegalArgumentException ();
    }
    this.n = n;
    this.r = r;
    a = new int[r];
    BigInteger nFact = getFactorial (n);
    BigInteger rFact = getFactorial (r);
    BigInteger nminusrFact = getFactorial (n - r);
    total = nFact.divide (rFact.multiply (nminusrFact));
    reset ();
  }

  //------
  // Reset
  //------

  public void reset () {
    for (int i = 0; i < a.length; i++) {
      a[i] = i;
    }
    numLeft = new BigInteger (total.toString ());
  }

  //------------------------------------------------
  // Return number of combinations not yet generated
  //------------------------------------------------

  public BigInteger getNumLeft () {
    return numLeft;
  }

  //-----------------------------
  // Are there more combinations?
  //-----------------------------

  public boolean hasMore () {
    return numLeft.compareTo (BigInteger.ZERO) == 1;
  }

  //------------------------------------
  // Return total number of combinations
  //------------------------------------

  public BigInteger getTotal () {
    return total;
  }

  //------------------
  // Compute factorial
  //------------------

  private static BigInteger getFactorial (int n) {
    BigInteger fact = BigInteger.ONE;
    for (int i = n; i > 1; i--) {
      fact = fact.multiply (new BigInteger (Integer.toString (i)));
    }
    return fact;
  }

  //--------------------------------------------------------
  // Generate next combination (algorithm from Rosen p. 286)
  //--------------------------------------------------------

  public int[] getNext () {

    if (numLeft.equals (total)) {
      numLeft = numLeft.subtract (BigInteger.ONE);
      return a;
    }

    int i = r - 1;
    while (a[i] == n - r + i) {
      i--;
    }
    a[i] = a[i] + 1;
    for (int j = i + 1; j < r; j++) {
      a[j] = a[i] + j - i;
    }

    numLeft = numLeft.subtract (BigInteger.ONE);
    return a;

  }
}