Tenho meu código dessa forma:
srand(time(NULL))
for(i = 0; i < 100; i++){
vetA[i] = rand() % 100 - 50;
}
Eu preciso preencher o vetor com números aleatórios entre -50 e 50 sem repetição, pensei em entrar no vetor e na posição em que repete gerar outro número aleatório que ainda não exista, porém não sei como manipular meu vetor e realizar isso.
Crie um vetor contendo os números de -50 à +50, esse vetor será sua “caixinha de números”.
Aí você sorteia uma posição desse array, remove, o número daquela posição e coloca num outro vetor que é a “caixinha dos números sorteados”.
Poderia me dar um exemplo de código? Porque eu entendo um pouco como deve ser feito, mas não tenho conhecimento suficiente pra fazer.
vetA[i] = rand() % 100 - 50;
vetB[i] = rand() % 100 - 50;
Eu compreendi essa parte de dois vetores com os números aleatórios
Não, minha ideia não foi fazer dois vetores com números aleatórios.
A ideia foi fazer um vetor com os números que você tem disponível para sortear.
E aí ir sorteando uma posição do array de números.
Digamos que você tem uma “caixinha 1” com os números abaixo:
+----+----+----+----+----+
valor | 1 | 2 | 3 | 4 | 5 |
+----+----+----+----+----+
posição 0 1 2 3 4
E você tem outra “caixinha 2” vazia, conforme abaixo:
+----+----+----+----+----+
valor | | | | | |
+----+----+----+----+----+
posição 0 1 2 3 4
Aí você vai sortear uma posição pra remover um item da “caixinha 1”, digamos que foi a posição 2.
Você vai remover o número na posição 2 da “caixinha 1” e inserir ele na posição 0 da “caixinha 2”:
+----+----+----+----+----+
valor | 1 | 2 | | 4 | 5 |
+----+----+----+----+----+
posição 0 1 2 3 4
+----+----+----+----+----+
valor | 3 | | | | |
+----+----+----+----+----+
posição 0 1 2 3 4
Em seguida você vai sortear outra posição pra remover um item da “caixinha 1”, digamos que foi a posição 4.
Você vai remover o número na posição 4 da “caixinha 1” e inserir ele na posição 1 da “caixinha 2”:
+----+----+----+----+----+
valor | 1 | 2 | | 4 | |
+----+----+----+----+----+
posição 0 1 2 3 4
+----+----+----+----+----+
valor | 3 | 5 | | | |
+----+----+----+----+----+
posição 0 1 2 3 4
Em seguida você vai sortear outra posição pra remover um item da “caixinha 1”, digamos que foi novamente sorteado a posição 2.
Aí você vai ver, opa, na posição 2 não tem mais nada, pois eu já removi esse conteúdo.
Então você sorteia novamente, digamos que seja a posição 0.
Você vai remover o número na posição 0 da “caixinha 1” e inserir ele na posição 2 da “caixinha 2”:
+----+----+----+----+----+
valor | | 2 | | 4 | 5 |
+----+----+----+----+----+
posição 0 1 2 3 4
+----+----+----+----+----+
valor | 3 | 5 | 1 | | |
+----+----+----+----+----+
posição 0 1 2 3 4
E assim sucessivamente.
Se você quiser fazer algo mais elaborado pra não correr o risco de sortear posições vazias, você pode recriar a sua “caixinha 1” toda vez que remover um elemento.
Por exemplo, suponha que ela esteja cheia:
+----+----+----+----+----+
valor | 1 | 2 | 3 | 4 | 5 |
+----+----+----+----+----+
posição 0 1 2 3 4
Aí você sorteia a posição 3 e remove esse elemento, a caixinha vai ficar assim:
+----+----+----+----+----+
valor | 1 | 2 | 3 | | 5 |
+----+----+----+----+----+
posição 0 1 2 3 4
Perceba que agora a posição 3 está vazia, uma alternativa é você recriar a caixinha para ficar com um elemento a menos, assim:
+----+----+----+----+
valor | 1 | 2 | 3 | 5 |
+----+----+----+----+
posição 0 1 2 3
Dessa forma você não correrá o risco de sortear uma posição vazia.
Mas e nessa caixinha eu obter dois números iguais, quando for sortear no meu vetor principal posso ter dois números repetidos e o que minha questão solicita é sem repetição.
+----+----+-----+-----+----+
valor | 1 | 2 | 1 | 4 | 4 |
+----+----+----+-----+-----+
posição 0 1 2 3 4O enunciado diz que você terá que sortear números entre -50 e 50.
Pois bem, isso te dá os seguintes valores para sortear:
-50 -49 -48 -47 -46 -45 -44 -43 -42 -41 -40 -39 -38 -37 -36 -35 -34 -33 -32 -31 -30 -29 -28 -27 -26 -25 -24 -23 -22 -21 -20 -19 -18 -17 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
Como funciona um sorteio no mundo real?
São colocadas bolinhas numeradas não repetidas dentro de um globo.
O sorteio nada mais é do que remover uma bolinha aleatoriamente desse globo.
É isso que você vai fazer, a “caixinha 1” é o vetor que representa o globo com as bolinhas.
A “caixinha 2” são as bolinhas que foram removidas aleatoriamente do globo e representam o resultado do sorteio.
Então você vai jogar os valores de -50 à 50 dentro da “caixinha 1” (vai fazer um laço for pra isso).
Em seguida vai sorteando uma posição.
Remove o item dessa posição e joga na primeira posição livre da “caixinha 2”.
Vai fazendo isso até esvaziar a “caixinha 1”.
No final a “caixinha 2” terá os valores em ordem aleatória.
O que eu tenho é isso:
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main(){
int caixa[101] = {
-50, -49, -48, -47, -46, -45, -44, -43, -42, -41,
-40, -39, -38, -37, -36, -35, -34, -33, -32, -31,
-30, -29, -28, -27, -26, -25, -24, -23, -22, -21,
-20, -19, -18, -17, -16, -15, -14, -13, -12, -11,
-10, -9, -8, -7, -6, -5, -4, -3, -2, -1,
0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50
};
int vetA[101], i;
srand(time(NULL));
for(i = 0; i < 101; i++){
vetA[i] = rand() % caixa[100];
printf("Pos - %d\nNumero sorteado: %d\n", i, vetA[i]);
}
}
A variável que contém todos os valores e a que recebe valores sorteados de dentro dela, mas como eu poderia fazer para assim que ele recebesse valor X o mesmo fosse removido de dentro do meu array?
Basicamente é isso:
vetorDestino[posicaoDestino] = vetorOrigem[posicaoOrigem];
vetorOrigem[posicaoOrigem] = vazio;
Exemplo:
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main() {
int caixinha1[101] = {
-50, -49, -48, -47, -46, -45, -44, -43, -42, -41,
-40, -39, -38, -37, -36, -35, -34, -33, -32, -31,
-30, -29, -28, -27, -26, -25, -24, -23, -22, -21,
-20, -19, -18, -17, -16, -15, -14, -13, -12, -11,
-10, -9, -8, -7, -6, -5, -4, -3, -2, -1,
0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
50
};
int caixinha2[101];
int vazio = -100; // um número que não faz parte dos valores sorteáveis
srand(time(NULL));
// sortear valores da caixinha1 e pôr na caixinha2
int i;
for(i = 0; i < 101; i++) {
int posicaoSorteada = rand() % 101;
while (caixinha1[posicaoSorteada] == vazio) {
posicaoSorteada = rand() % 101;
}
caixinha2[i] = caixinha1[posicaoSorteada]; // colocar valor da caixinha1 na caixinha2
caixinha1[posicaoSorteada] = vazio; // marcar posição da caixinha1 como vazia
}
// imprimir conteúdo da caixinha2
for(i = 0; i < 101; i++) {
printf("%3d - Numero sorteado: %4d\n", i, caixinha2[i]);
}
return 0;
}#include<stdio.h>
#include<stdlib.h>
#include<locale.h>
#include<time.h>
main(){
setlocale(LC_ALL, "Portuguese");
srand(time(NULL));
int i, j, n, inferior, superior, avaliacao;
printf("Números aleatórios sem repetições.\n\n");
printf("Quantos números deseja sortear? ");
scanf("%d", &n);
int A[n];
printf("Informe o limite inferior do intervalo de sorteio: ");
scanf("%d",&inferior);
avaliacao = inferior+n-1;
printf("\nInforme o limite supeior do intervalo de sorteio.\n");
do{
printf("\t\tATENÇÃO!\nO seu limite superior deve ser de no mínimo %d: ", avaliacao);
scanf("%d",&superior);
}while(superior<avaliacao);
for(i=0;i<n;i++){
A[i]=inferior+rand()%(superior+1-inferior);
}
for(j=0;j<n;j++){
for(i=0;i<n;i++){
while(A[j]==A[i]&&j!=i){
A[i]=inferior+rand()%(superior+1-inferior);
j=0;
}
}
}
printf("\n$$ * ");
for(i=0;i<n;i++){
printf("%2d * ",A[i]);
}
printf("$$\n");
return 0;
}