1. #include <stdlib.h>
2. #include <stdio.h>
4. //sans aucune garantie, utilisation à vos risques etc!
6. #define NB_DES_MAX 6 //~47000 lignes déjà mais on peut augmenter si besoin (+recompiler)
8. int main(int argc, char** argv)
9. {
10.     if(argc!=2)
11.         return 0;
12.    
13.     int nb_des=atoi(argv[1]);
14.    
15.     if(nb_des<=0 || nb_des>NB_DES_MAX)
16.         return 0;
17.    
18.     char des[NB_DES_MAX+1];
19.     int i=0;
20.    
21.     for(i=0; i<nb_des; i++)
22.         des[i]='1';
23.     des[i]='\0';
24.    
25.     i=0;
26.    
27.     while(i<nb_des)
28.     {
29.         if(!i)
30.             puts(des);
31.        
32.         des[nb_des-i-1]++;
33.        
34.         if(des[nb_des-i-1]=='7')
35.         {
36.             des[nb_des-i-1]='1';
37.             i++;
38.         }
39.         else
40.             i=0;
41.     }
42.    
43.     return 0;
44. }

from __future__ import print_function
import argparse
 
def wrap_increment(n, max, min=1):
    if n == max:
        return (min, True)
 
    else:
        return (n+1, False)
 
def iterate_dices_combinations(dice_count=3, dice_faces=6):
    dices_combination = [1 for x in range(dice_count)]
 
    carry = False
    while not carry:
        yield dices_combination
 
        carry = True
        for index, dice in enumerate(dices_combination):
            dices_combination[index], carry = wrap_increment(dice, dice_faces)
 
            if not carry:
                break
 
 
args = argparse.ArgumentParser()
args.add_argument('-d', '--dices', type=int, default=3, help='Number of dices')
args.add_argument('-f', '--faces', type=int, default=6, help='Number of faces per dices')
args.add_argument('-ds', '--dices-separator', default='', type=str, help='Separator between dices in string output')
args.add_argument('-cs', '--combinations-separator', default='\n', type=str, help='Separator between dices combinations in string output')
args = args.parse_args()
 
for dices in iterate_dices_combinations(args.dices, args.faces):
    print(args.dices_separator.join(map(str, dices)), end=args.combinations_separator)

import argparse
 
def wrap_increment(n, max, min=1):
    if n == max:
        return (min, True)
 
    else:
        return (n+1, False)
 
def iterate_dices_combinations(dice_count=3, dice_faces=6):
    dices_combination = [1 for x in range(dice_count)]
 
    carry = False
    while not carry:
        yield dices_combination
 
        carry = True
        for index, dice in enumerate(dices_combination):
            dices_combination[index], carry = wrap_increment(dice, dice_faces)
 
            if not carry:
                break
 
 
args = argparse.ArgumentParser()
args.add_argument('-d',     '--dices',              type=int, default=3,            help='Number of dices')
args.add_argument('-f',     '--faces',              type=str, default="ABCDEF",     help='Dice faces name, one char per face')
args.add_argument('-ds',    '--dices-separator',    type=str, default='',           help='Separator between dices in string output')
args.add_argument('-pre',   '--prefix',             type=str, default='Resultat: ', help='Prefix for each combination in string output')
args.add_argument('-post',  '--postfix',            type=str, default='\n',         help='Postfix for each combination in string output')
args = args.parse_args()
 
for dices in iterate_dices_combinations(args.dices, len(args.faces)):
    print(args.prefix, end='')
    print(args.dices_separator.join(map(lambda x: args.faces[x-1], dices)), end=args.postfix)

1. >python dices.py -f itr
2. Resultat: iii
3. Resultat: tii
4. Resultat: rii
5. Resultat: iti
6. Resultat: tti
7. Resultat: rti
8. Resultat: iri
9. Resultat: tri
10. Resultat: rri
11. Resultat: iit
12. Resultat: tit
13. Resultat: rit
14. Resultat: itt
15. Resultat: ttt
16. Resultat: rtt
17. Resultat: irt
18. Resultat: trt
19. Resultat: rrt
20. Resultat: iir
21. Resultat: tir
22. Resultat: rir
23. Resultat: itr
24. Resultat: ttr
25. Resultat: rtr
26. Resultat: irr
27. Resultat: trr
28. Resultat: rrr

1. >python dices.py -f itr -post ^
2. Plus ?
3. Plus ? postfix^
4. Plus ?
5. Plus ?
6. Resultat: iii
7. postfix
8. Resultat: tii
9. postfix
10. Resultat: rii
11. postfix
12. Resultat: iti
13. postfix
14. Resultat: tti
15. postfix
16. Resultat: rti
17. postfix
18. Resultat: iri
19. postfix
20. Resultat: tri
21. postfix
22. Resultat: rri
23. postfix
24. Resultat: iit
25. postfix
26. Resultat: tit
27. postfix
28. Resultat: rit
29. postfix
30. Resultat: itt
31. postfix
32. Resultat: ttt
33. postfix
34. Resultat: rtt
35. postfix
36. Resultat: irt
37. postfix
38. Resultat: trt
39. postfix
40. Resultat: rrt
41. postfix
42. Resultat: iir
43. postfix
44. Resultat: tir
45. postfix
46. Resultat: rir
47. postfix
48. Resultat: itr
49. postfix
50. Resultat: ttr
51. postfix
52. Resultat: rtr
53. postfix
54. Resultat: irr
55. postfix
56. Resultat: trr
57. postfix
58. Resultat: rrr
59. postfix

args.add_argument('-post',  '--postfix', type=str, default='\npostfix\n', help='Postfix for each combination in string output')

import argparse
 
def wrap_increment(n, max, min=1):
    if n == max:
        return (min, True)
 
    else:
        return (n+1, False)
 
def iterate_dices_combinations(dice_count=3, dice_faces=6):
    dices_combination = [1 for x in range(dice_count)]
 
    carry = False
    while not carry:
        yield dices_combination
 
        carry = True
        for index, dice in enumerate(dices_combination):
            dices_combination[index], carry = wrap_increment(dice, dice_faces)
 
            if not carry:
                break
 
class splitFile:
    def __init__(self, name, lines):
        self.name           = name
        self.lines          = lines
        self.file           = None
        self.currentLine    = 0
        self.fileCount      = 0
 
    def __enter__(self):
        return self
 
    def getNewFilename(self):
        if self.lines <= 0:
            return self.name
        else:
            self.fileCount += 1
            return self.name + str(self.fileCount)
 
    def write(self, str, linecount=1):
        if self.file is None:
            self.open()
 
        self.file.write(str)
        self.currentLine += linecount
 
        if self.currentLine >= self.lines and self.lines > 0:
            self.close()
 
 
    def close(self):
        if self.file is not None:
            self.file.close()
            self.file = None
 
    def open(self):
        self.file = open(self.getNewFilename(), 'w')
        self.currentLine = 0
 
    def __exit__(self, etype, value, traceback):
        self.close()
 
args = argparse.ArgumentParser()
args.add_argument('-d',     '--dices',              type=int, default=3,            help='Number of dices')
args.add_argument('-f',     '--faces',              type=str, default="ABCDEF",     help='Dice faces name, one char per face')
args.add_argument('-ds',    '--dices-separator',    type=str, default='',           help='Separator between dices in string output')
args.add_argument('-pre',   '--prefix',             type=str, default='Resultat: ', help='Prefix for each combination in string output')
args.add_argument('-post',  '--postfix',            type=str, default='\n',         help='Postfix for each combination in string output')
args.add_argument('-o',     '--output',             type=str, default='comb',       help='Output file')
args.add_argument('-s',     '--split',              type=int, default=-1,           help='Split output every')
args = args.parse_args()
 
with splitFile(args.output, args.split) as output:
    for dices in iterate_dices_combinations(args.dices, len(args.faces)):
        output.write(args.prefix, linecount=0)
        output.write(args.dices_separator.join(map(lambda x: args.faces[x-1], dices)), linecount=0)
        output.write(args.postfix, linecount=1)

1. python dices.py -o fichierDeSortie -s 10000