class Emile {

    /**
     * Décompose un nombre 'n' (> 0) en la suite de ses chiffres.  En
     * sortie, le tableau 'chiffre' contient la décomposition de n
     * suivi de -1.
     */
    static void decompose(int n, int[] chiffre) {
        int i, j, taille;
        // décomposition de n :
        // unité de n dans chiffre[0], dizaine de n dans chiffre[1], ...
        i = 0;
        do {
            chiffre[i] = n % 10;
            i++;
            n = n / 10;
        } while (n != 0) ;

        // on marque la fin du tableau
        chiffre[i] = -1;

        // Inversion du tableau chiffre : construction de son tableau
        // miroir de sorte que le chiffre de poids fort de n soit dans
        // chiffre[0].  On ne touche pas à la case de chiffre qui
        // contient -1.
        taille = i - 1;
        j = taille;
        for (i = 0; i <= taille / 2; i++) {
            int tmp = chiffre[i];
            chiffre[i] = chiffre[j];
            chiffre[j] = tmp;
            j--;
        }
    }

    /**
     * Recherche le code d'Émile, à 'nchiffres' chiffres.
     * Place le résultat dans le tableau 'combi' qui doit être assez
     * grand.
     */
    static void decode(int[] combi, int nchiffres) {
        int[] chiffre = new int[50]; // variable temporaire servant à
                                     // parcourir les chiffres d'un
                                     // nombre (50 devrait être assez
                                     // grand)
        int ch; // la position du chiffre de la combinaison qu'on cherche
        int i;  // parcourt la suite de nombres 1, 2, 3, ...
        int n1; // le nombres de '1' écrits
        boolean enreg; // vaut vrai si le prochain caractère fait
                       // partie de la combinaison

        enreg = false;
        ch = 1;
        n1 = 0;
        for (i = 1; ch <= nchiffres; i++) {
            //-- on decompose i
            decompose(i, chiffre);
            //-- parcourt la chaine ainsi formée
            for (int k = 0; chiffre[k] != -1; k++) {
                if (enreg) {        // on a trouvé un bout du code
                    combi[ch - 1] = chiffre[k];
                    enreg = false;
                    ch++;
                }
                if (chiffre[k] == 1) // on a trouvé un '1'
                    n1++;
                if (n1 == ch * 1000) // le prochain chiffre fait partie du code
                    enreg = true;
            }
        }
    }

    public static void main(String[] args) {
        final int N = 6;
        int[] combi = new int[N];

        decode(combi, N);

        System.out.print("La combinaison : " + combi[0]);
        for (int k = 1; k < N; k++)
            System.out.print("-" + combi[k]);
        System.out.println();
    }
}