Utilisez srand (1) et rand () pour générer 1000 nombres de 65 à 122 à l'exclusion de 91-96 en C

Vous souhaitez créer un tableau de 1 000 caractères comprenant des lettres majuscules et minuscules. Voir Table et description ASCII . Pour ce faire, vous devez créer une valeur aléatoire dans cette plage, puis vérifier si elle se trouve dans la plage des caractères exclus avant de la considérer comme un bon caractère et d'incrémenter l'index du tableau à répéter pour le suivant, par exemple

$ ./bin/randchars
 B m m d D I l G w L n C u O M w e c e o i T t K E y q f k r X V T E n d s y P m
 t V y p z Y U M C p x F l v v W m n t x F O B t j l r q V c L T X D l d p T n d
 E a W S w A F h y L v r w f d f y O K c n z y K G y O g U Z U W I S Z w C V b f
 B u H R t R s e q C k o I O A Z j V q k P g b f F E r Y f J v H u E m a R g Q y
 h y G O L w q d E K j b H F Z k c S j P C H p U f G K S I R d M F p J w z k W y
 h p V P P a z d p t k F O P a x Y j b e h t R i p Q Z L H G s O H C N l j y T M
 E b T A d b v F O o W x O g M X A X v A e T i c n F n n b X U U I l Q Q A w c Y
 o D h j h M q s m Y f r E Q Q e p y e a O G q e G e M W R H v A c c E Y r j y a
 n P r G m T n c q U i w C S u h W J y E q y v O s e p q K F t a j F U R v a z r
 c J d H a e x w j o u G b A y D q o F I m z b w n f r T a n J v E o s A V m x m
 Z A F G d j x K D t x i c I C I v a J q e p b K F O v t o v L m t o i q b n E B
 n H J j T K A y L w f a r W N e b z O M E z g k D h C r M c C e e C c A F W f N
 B l k c O j C S n t y p t r N F R H b v B C w H Y Z T G O o i U c g I J B X s G
 K N w x O y l N O L k m W q s K W M z l T G D H U N p W S l U a b x o p A W c W
 F S Y p I V n O Y H V l Y k e J E K c u q X u N r R S K b n b X G j m t x C B K
 n V L F G M C Q o w H E q M n z x b J y P F c B C e u M Q H i E o a G x M u w Q
 d I E c t B Q z p V Z i Q E U b D h f j N e g c z c c y Q d a L n m l D q L Y C
 e c P K p l r H I R c H m G j c O L G o J c I u z F v t b W r Z J I I c R k k D
 j R x U e m k g M t a b s d F l F o K G P S O j e z Z a l D F a H q M L b e n Z
 A I u G t r m E x t O E d k D C Q d f T y d l G R x R s w J E D Y y n L u k E A
 o h l j k B K N M J q q H H f Q z F N A a R E y H r B t Z G m G f p V W s t R Q
 A R w Q Q t J R h N I g w J Y N H K T n h B A v l V e n e E m M L I V p f T O g
 l o v h b i b V Z D d v q H m Z K q e S M H z e S f R w H F j g g K N N X I A q
 z r c Y B Z D T K S t p y Z D I K j K X o v x S N n S F O k G n S u q e n z K Y
 h Z j F y l v m i O z U a E Q D r w V l m r W P r a c H G G a p D u g o p Y V D

Pour calculer le nombre aléatoire dans la plage, vous devez soustraire la limite inférieure de la rage afin qu'elle soit basée sur zéro et ajouter 1 pour s'adapter à la plage complète. Vous générez votre module aléatoire au maximum réduit de la plage + 1 , puis ajoutez le minimum de la plage à la valeur aléatoire pour arriver à une valeur entre 'A' et 'z' . Ensuite, vous vérifiez simplement si la valeur est inférieure au minimum d'exclusion le plus bas ou au-dessus du maximum d'exclusion le plus élevé. Si c'est le cas, vous avez une bonne valeur, augmentez votre compteur d'index et continuez. Si votre valeur générée se situe dans la plage d'exclusion, l'index n'est pas modifié et vous réessayez simplement avec la valeur générée suivante.

En résumé, vous pouvez faire quelque chose comme:

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

#define NRAND 1000      /* if you need a constant, #define one (or more) */

int main (void) {
    
    int rval[NRAND] = {0};                      /* array to hold 1000 values  */
    size_t nrand = 0;                           /* number of values generated */
    
    srand (time(NULL));                         /* seed random number generator */
    
    do {    /* loop */
        rval[nrand] = rand() % ('z' - 'A' + 1) + 'A';    /* get rand value in range */
        /* if the value isn't in the inner exclusion range */
        if (rval[nrand] <= 'Z' || 'a' <= rval[nrand])
            nrand++;                                        /* increment counter */
    } while (nrand < NRAND);            /* while less than 1000 numbers generated */
    
    for (int i = 0; i < NRAND; i++) {   /* output results in 25 x 40 grid */
        if (i && i % 40 == 0)
            putchar ('\n');
        printf (" %c", rval[i]);
    }
    putchar ('\n');
}

Exemple d'utilisation / sortie

En sortie en 25 lignes de 40 caractères, vous auriez:

#define NRAND 1000      /* if you need a constant, #define one (or more) */
...
    size_t nrand = 0;                           /* number of values generated */
    ...
    do {    /* loop */
        rval[nrand] = rand() % ('z' - 'A' + 1) + 'A';    /* get rand value in range */
        /* if the value isn't in the inner exclusion range */
        if (rval[nrand] <= 'Z' || 'a' <= rval[nrand])
            nrand++;                                        /* increment counter */
    } while (nrand < NRAND);            /* while less than 1000 numbers generated */

Vous pouvez vérifier rapidement que 'A' et 'Z' sont présents ainsi que 'a' et 'z' (et pas de non-caractères amusants)

Regardez les choses et faites-moi savoir si vous avez d'autres questions.

Eh bien, voici comment je le ferais. Vous n'avez besoin d'appeler rand() qu'une fois par caractère, et il n'est pas nécessaire de créer un tableau contenant à la fois les alphabets majuscules et minuscules. La fonction generate_random_letters() renvoie une chaîne, j'ai donc ajouté un octet nul à la fin pour que vous puissiez l'imprimer sans planter:

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

char *generate_random_letters(int length) {
    int i, r;
    char *p, *s;
    p = s = malloc(length+1);
    for (i=0; i<length; i++) {
        r = rand() % 52 + 'A';
        if (r > 'Z') r += 'a' - 'Z' - 1;
        *p++ = r;
    }
    *p = '\0';
    return s;
}

int main() {
    char *str;
    srand(1);
    str = generate_random_letters(1000);
    puts(str);
    free(str);
    return 0;
}

Je commence par supposer que vous avez une fonction rand() , générant un nombre à virgule flottante aléatoire entre 0 et 1 (la valeur maximale n'est jamais générée).

Cette supposition semble fausse: la fonction rand() génère un nombre entier compris entre 0 et RAND_MAX inclus. Eh bien, dans ce cas, écrivons une nouvelle fonction small_rand() , qui génère un nombre aléatoire entre 0 et 1, comme suit:

if (random_number < 26)
    result = random_number + 65
else
    result = random_number - 26 + 97;

Vous commencez ensuite par générer un nombre aléatoire compris entre 0 et 51 (il y en a 52 au total, le double de 26 étant le nombre de nombres dans l'alphabet). Cela peut être fait, soit en utilisant 52 comme paramètre d'entrée, soit en multipliant le nombre aléatoire standard par 52:

int random_number = (int) (small_rand() * 52);

Une fois que vous avez cela, vous faites la distinction: est le nombre dans la plage 0-25, puis vous choisissez la plage entre 65 et 91. Est le nombre dans la plage 26-51, puis vous choisissez la plage entre 97 et 122:

double small_rand() {
    return (rand()) / ((double)RAND_MAX + 1); // the typecast is needed to avoid integer division
}

Pour une solution totalement portable, vous pouvez simplement générer des nombres aléatoires dans la plage 0 .. 51 et les utiliser comme index dans le jeu de caractères autorisés:

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

#define NRAND 1000

int main() {
    int array[NRAND];

    srand(1);  /* if you are requested to initialize the random number generator
                  with a specific value so the output is predictable. Otherwise
                  you could use srand(time(NULL)); */
    
    for (int i = 0; i < NAND; i++) {
        array[i] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"[rand() % 52];
    }
    
    for (int i = 0; i < NRAND; i++) {
        putchar(array[i]);
        putchar(" \n"[i % 40 == 39];  // arrange the output in rows of 40 elements
    }
    return 0;
}