Программа для генерации текста

А вдруг комунить надо будет

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
if(argc != 2)
{
fprintf(stderr, "gen: wrong param count\nUse `gen pattern`\n");
return 1;
}

const int patternSize = strlen(argv[1]);

char *buffer = malloc(patternSize);
int *bufferSize = malloc((patternSize) * sizeof(int));
buffer[patternSize] = '\0';
int passed = 1;

memset(buffer, argv[1][0], patternSize);
memset(bufferSize, 0, patternSize);

printf("%s\n", buffer);

int i = patternSize -1 ;
while(passed)
{
if(bufferSize[i] >= patternSize - 1)
{
if(i == 0)
{
passed = 0;
}
else
{
bufferSize[i] = 0;
buffer[i] = argv[1][bufferSize[i]];
--i;
}
}
else
{
++bufferSize[i];
buffer[i] = argv[1][bufferSize[i]];
i = patternSize - 1;
printf("%s\n", buffer);
}
}

free(buffer);
free(bufferSize);

return 0;
}

#!/bin/bash
printf '%s\n' `cat /dev/urandom | tr -d -c "$2" | dd bs=1 count=$1 2>/dev/null`

А какие требования к тексту?

пермутации что ли? можно и короче:

#include <stdio.h>
#include <string.h>

void
shift(char *s, int n)
{
        char ch = *s;
        char *d = s++;

        while (n--)
                *d++ = *s++;

        *--s = ch;
}

void
doit(char *p, char *s, int n)
{
        int i = n--;

        if (n == 0)
                puts(p);
        else
                while (i--) {
                        doit(p, s + 1, n);
                        shift(s, n);
                }
}

int
main(int argc, char **argv)
{
        char    *buf;

        if (argc < 2)
                return -1;

        buf = strdup(argv[1]);
        doit(buf, buf, strlen(buf));
        free(buf);

        return 0;
}

а не, пардон -- у тебя немного другое

Рандом не подходит.
Вообщем смысл данной программы в генерации каких-то случайных данных, но чтобы их можно было использовать как текст, поэтому они генерятся из специально заданных символов. А длина у получаемых строк равна количеству символов.
Т.е.
gen "A0"
сгенерит четыре строки
AA
A0
0A
00
Еще это называется декартовым произведением.

Все равно спасибо

> Но мне интересно есть ли готовые решения.

Если бы это было нужно хоть кому-то, то были бы готовые решения.

% python -c "from itertools import product; from sys import argv; print('\n'.join(''.join(v) for v in product(*([argv[1]]*int(argv[2])))))" AB0 3

AAA
AAB
AA0
ABA
ABB
AB0
A0A
A0B
A00
BAA
BAB
BA0
BBA
BBB
BB0
B0A
B0B
B00
0AA
0AB
0A0
0BA
0BB
0B0
00A
00B
000

на схеме с уже заданными лексемами.

(define LEXEMS '("A" "B" "0"))

(define (cartesian-product lst1 lst2)
   (define (loc-cartesian-product lst1 lst2)
       (map (lambda (x)
           (map (lambda (y) (string-append x y))
                lst1))
         lst2))
    (flatten (loc-cartesian-product lst1 lst2))) 

(define (make-words lst)
  (define (loc-make-words lst1 lst2 length-lst)
     (cond
       [(= 1 length-lst) lst1]
       [(loc-make-words (cartesian-product lst1 lst2) lst (- length-lst 1))]) 
   )(loc-make-words lst lst (length lst))

вообще, недавно как раз реализовывали just for fun декартовы произведения на разных ЯП. 

module Main where

import System.Environment

step [] alph = []
step (el:list) alph = (map (el:) alph) ++ (step list alph)

run alph 1 = map (:[]) alph
run alph i = step alph $ run alph (i-1)

main = do
    (n:[alph]) <- getArgs
    putStrLn $ show $ run alph $ read n

--Предлагается писькомерялка -- у кого программа ОПа выйдет короче

http://vannadis.livejournal.com/168855.html?mode=reply

здесь мы просто декартовыми произведениями развлекались. Короче всего получается на Баше и Питоне.

А быстрее? :)

выдай набор тестов) могу проверить на схеме и на жабе)

хотя знаешь, если тебе нужны именно рандомные слова из символов, то можно сделать проще.
 То есть генерируешь рандомное число от от 0 до (length-1), берешь соответствующий символ из массива. И повторяешь (length-1)раз с конкатенацией.

иначе если делать просто вывод всех вариантов - запаришься, о хранении даже думать не хочется. Для 8 символов 8^8 слов. 

Опять-таки на схеме

(define LEXEMS '("A" "B" "0" "G" "H" "O" "P" "9" "j"))

(define (make-words lst)
  (define (loc-make-words out-str lst-lenght)
    (cond
      [(= 0 lst-lenght) out-str]
      [ (loc-make-words (string-append (list-ref lst (random (length lst))) out-str) (- lst-lenght 1))]))
    (loc-make-words "" (length lst)))


out:

> (make-words LEXEMS)
"P9Aj9GB9H"
> (make-words LEXEMS)
"B9HHPPPOP"
> (make-words LEXEMS)
"HHBG0PHAP"