Jump to content
jtc-carr

Valores para vetor

Recommended Posts

jtc-carr

Boa noite,

Isto deve ser muito básico, mas não estou a conseguir preciso que os valores fiquem num vetor e não nas variáveis, já tentei de varias formas e não dá, depois preciso de somar o numero de números apresentados e retirar os repetidos ajudem-me

//Listar numeros de 00000 até a
int i, j, k, w, h, a = 1;

for (i = 0; i <= a; i++)
  for (j = 0; j <= a; j++)
    for (k = 0; k <= a; k++)
      for (w = 0; w <= a; w++)
        for (h = 0; h <= a; h++)
          printf ("%d%d%d%d\t", i, j, k, w, h);

 

Share this post


Link to post
Share on other sites
PsySc0rpi0n

Isso é o código todo que tens? Se queres os valores num vector, onde está declarado esse vector? E não consegui perceber bem o que é pretendido. Tens um enunciado?

Não sei se é isto que se pretende,em termos de "algoritmo":

declarar um vector;

declarar variável que vai definir com quantos valores vou trabalhar;

pedir os valores ao utilizador ou gerá-los aleatoriamente e guardá-los no vector anteriormente declarado;

percorrer o vector e somar todos os valores (não percebi se isto foi pedido) e guardar o resultado numa nova variável;

percorrer o vector (no mesmo ciclo do anterior ou num novo) e detectar os números repetidos. Aqui terás várias abordagens possíveis. Depende do que é pedido. "Retirar" os valores é para os apagar do vector e mover os restantes valore por forma a não ficarem posições vazias (a zero) no vector ou é apenas para apresentar na consola quais os números repetidos encontrados?


Kurt Cobain - Grunge misses you

Nissan GT-R - beast killer

Share this post


Link to post
Share on other sites
jtc-carr

O enunciado completo:

/******************************************************************************
Considere o seguinte código que gera todos os números de 0000 a 'a'
Refaça o programa utilizando vetores com o valor maximo 20000
Remova os duplicados e mostre quantos números foram apresentados
O resultado deverá ser 0000 .(...). 1111
                       Foram mostrados .(...). números
*******************************************************************************/

#include <stdio.h>

int main()
{

int i, j, k, w, h, a = 1;

for (i = 0; i <= a; i++)
  for (j = 0; j <= a; j++)
    for (k = 0; k <= a; k++)
      for (w = 0; w <= a; w++)
        for (h = 0; h <= a; h++)
          printf ("%d%d%d%d\t", i, j, k, w, h);
}

Alguém que me possa ajudar, não estou a conseguir avançar, obrigado Joana

Share this post


Link to post
Share on other sites
PsySc0rpi0n

Esse enunciado parece-me horrível. Não consigo perceber com exactidão o que é pedido.

Se o 'a=1', porque raio é que fala em '0000'??? Se começa em '0' (ou '0000' ou o que quer que seja - para mim '0000' e '0' é a mesma coisa) e 'a=1', então só pode haver dois números, sendo eles o 0 e o 1. Se só pode haver 2 números, não percebo o 20000. Não percebo se o 20000 é o tamanho do vector se é o a quantidade de números a ser gerada.

Depois pede para remover os duplicados. Mais uma vez, se só pode haver 2 números, o 0 e o 1, não percebo que repetições é que se vão dar. E por fim, pede para mostrar quantos números foram apresentados. Apresentados????????? Apresentados onde? Que eu saiba, ainda não houve números apresentados.

@jtc-carr, o que eu disse a cima, não é ironia nem sarcasmo. É que eu não entendo mesmo como se consegue fazer um enunciado desses.

 

Agora, especulando, será que é para gerar zeros e uns nas 4 posições que fala o enunciado quando diz '0000' uma vez que o enunciado diz que começa em '0000' e termina em 'a=1'??? Se não for isto, sinceramente não percebo o que é pedido.

Se for isto, então o valor 20000 já pode fazer sentido, tal como os números repetidos para remover. O 20000 pode ser para gerar 20000 números binários e logicamente haverá números repetidos, pois com 4 bits, podemos ter apenas 16 números diferentes, de 0 a 15.

 

Edited by PsySc0rpi0n

Kurt Cobain - Grunge misses you

Nissan GT-R - beast killer

Share this post


Link to post
Share on other sites
jtc-carr
Em 22/11/2018 às 19:58, PsySc0rpi0n disse:

O enunciado é besta mesmo
O que a professora diz é que são 5 locais onde se guardam números, i, j, k, w, h e nesse caso de 0000 temos que i=0,j=0,k=0,w=0,h=0 até 11111 se o a=1  00000, 00001, 00010......

O programa da professora apresenta esses números 00000 a 11111 mas ela quer isso feito com vectores e não ciclos
depois comparar os números saídos, e neste caso 00001=00010=00101=00110..... e só podemos apresentar no printf 00001 00011 ....
quer que contemos quantos valores apresentamos
E tudo feito de modo a que se o a for outro numero o programa funcione

Share this post


Link to post
Share on other sites
PsySc0rpi0n

Mas mesmo assim tem que haver ciclos. Senão como é que vais gerar números até preencher o vector?


Kurt Cobain - Grunge misses you

Nissan GT-R - beast killer

Share this post


Link to post
Share on other sites
Rui Carlos
4 horas atrás, PsySc0rpi0n disse:

Senão como é que vais gerar números até preencher o vector?

Podia-se usar recursividade.

Mas penso que o objectivo do problema é mais guardar os valores num array do que remover os ciclos.  Trocando o printf por um sprintf consegue-se guardar os valores num array.  Contar os valores também é trivial, é só colocar um contador no ciclo.  Não percebi quais são as condições de paragem que devem ser usadas nos ciclos.

Share this post


Link to post
Share on other sites
jtc-carr
20 horas atrás, Rui Carlos disse:

Podia-se usar recursividade.

Mas penso que o objectivo do problema é mais guardar os valores num array do que remover os ciclos.  Trocando o printf por um sprintf consegue-se guardar os valores num array.  Contar os valores também é trivial, é só colocar um contador no ciclo.  Não percebi quais são as condições de paragem que devem ser usadas nos ciclos.

consigo passar os valores para um array

programa[2000][5]

programa[soma][0]=i
programa[soma][1]=j
programa[soma][2]=k
programa[soma][3]=w
programa[soma][4]=h

 

O que dá o mesmo resultado que só com ciclos, mas ao comparar nunca me dá repetidos pois 0000, 00001, 00010, 00011 são sempre diferentes :(
pois não esta a comparar o h com o w, mas sim o resultado final, alguém que possa ajudar, fiz esta função mas não funciona

int Repetidos (int programa[2000][5],int i) {
  int a,b;
  while (a < i-1) {
    while (a<i -1 && programa[a][0]==programar[a+1[0] &&a<i -1 && programa[a][1]==programar[a+1[1]&&a<i -1 && programa[a][2]==programar[a+1[[2] &&
        a<i -1 && programa[a][3]==programar[a+1[3] &&a<i -1 && programa[a][4]==programar[a+1[4])
    {
      for(b=a; b < i-1;b++)
        programa[b][]=programa[b+1][];
      i--;
    }
    a++;
  }
}

 

Share this post


Link to post
Share on other sites
PsySc0rpi0n
programa[20000][5]

não é um vector... Isso é batota. 😛

Isso é uma matriz.

Se podes usar matrizes é uma coisa. Se não podes usar é outra.

Facilita um pouco com matrizes em termos de algoritmo, acho eu. Mas se puderes apenas usar vectores, o algoritmo poderia passar por algo como:

-Gerar 20000 números inteiros aleatórios entre 0 e 1, ou seja, um bit stream aleatório de 20000 bits (zeros e uns) e guardá-los num vector com 20000 índices.

-Criar função que compara 5 desses bits, 1 a 1, com os 5 bits seguintes. Se forem iguais, incrementa um contador. (Talvez usar outra variável para guardar a posição onde forem encontrados valores repetidos para depois os excluir quando se fizer o printf para apresentar os valores gerados excluindo os repetidos)

-Mostrar os valores não repetidos

Não tenho dúvidas que deve existir algoritmo mais fácil, mas de repente é o que me lembro.

20 horas atrás, Rui Carlos disse:

Podia-se usar recursividade.

Bem visto.


Kurt Cobain - Grunge misses you

Nissan GT-R - beast killer

Share this post


Link to post
Share on other sites
jtc-carr
11 horas atrás, PsySc0rpi0n disse:

programa[20000][5]

não é um vector... Isso é batota. 😛

Isso é uma matriz.

Se podes usar matrizes é uma coisa. Se não podes usar é outra.

Facilita um pouco com matrizes em termos de algoritmo, acho eu. Mas se puderes apenas usar vectores, o algoritmo poderia passar por algo como:

-Gerar 20000 números inteiros aleatórios entre 0 e 1, ou seja, um bit stream aleatório de 20000 bits (zeros e uns) e guardá-los num vector com 20000 índices.

-Criar função que compara 5 desses bits, 1 a 1, com os 5 bits seguintes. Se forem iguais, incrementa um contador. (Talvez usar outra variável para guardar a posição onde forem encontrados valores repetidos para depois os excluir quando se fizer o printf para apresentar os valores gerados excluindo os repetidos)

-Mostrar os valores não repetidos

Não tenho dúvidas que deve existir algoritmo mais fácil, mas de repente é o que me lembro.

 

Bem visto.

Isto não vai lá com matrizes e nem com vetores,e nem ciclos, os valores totais consigo gerar
agora aparecer somente esses "não duplicados" estou a ver que é difícil, não estou a ver forma de em c,00010 e 00100 serem iguais e eliminar o que aparecer em ultimo
se alguém souber o truque agradecia

Share this post


Link to post
Share on other sites
Rui Carlos
4 minutos atrás, jtc-carr disse:

Isto não vai lá com matrizes e nem com vetores,e nem ciclos, os valores totais consigo gerar
agora aparecer somente esses "não duplicados" estou a ver que é difícil, não estou a ver forma de em c,00010 e 00100 serem iguais e eliminar o que aparecer em ultimo
se alguém souber o truque agradecia

Por que razão é que o 00010 e o 00100 deveriam ser iguais?

Share this post


Link to post
Share on other sites
jtc-carr

Porque a professora diz que sim, que 00010 e 00100 e 01000 e 10000 são iguais e por isso só devia de aparecer um na contagem :(

Share this post


Link to post
Share on other sites
Rui Carlos
9 minutos atrás, jtc-carr disse:

Porque a professora diz que sim, que 00010 e 00100 e 01000 e 10000 são iguais e por isso só devia de aparecer um na contagem :(

Convinha que se tivesse definido isso de forma precisa no enunciado.  É complicado dar ajuda com um enunciado que é bastante omisso.

Questão: que dígitos podem fazer parte do número?  Só 0 e 1?

Em todo o caso, penso que o algoritmo para detectar um duplicado pode ser algo como:

for (int i = 1; i < 5; i++) {
  if (valor[i-1] > valor[i]) {
    duplicado = true;
  }
}

A ideia é que 00010, 00100, 01000 e 10000 são duplicados de 00001, que deve ter aparecido antes.  E o algarismo maior (neste caso o 1) aparece sempre em último pela primeira vez.  Por isso sempre que tens valor[i-1] > valor tens um valor duplicado.

Share this post


Link to post
Share on other sites
PsySc0rpi0n
1 hour ago, jtc-carr said:

Porque a professora diz que sim, que 00010 e 00100 e 01000 e 10000 são iguais e por isso só devia de aparecer um na contagem :(

Não vejo de que forma é que isso pode fazer sentido! Mas ela lá sabe. O que é preciso é que o enunciado seja claro, conciso e preciso!


Kurt Cobain - Grunge misses you

Nissan GT-R - beast killer

Share this post


Link to post
Share on other sites
jtc-carr

sim segundo a lógica dela quando 2 letras seguidas se juntam não podem gerar mais que uma vez o mesmo valor, se gera 00010 depois ja não pode gerar 00100 pois o 10 ja saiu, diz que tem a ver com rotações,, neste caso é para um, mas ela quer como genérico se mudar o valor para 2 ou 3 continuar a funcionar
ela deu mais uns dias para resolver-mos mas continuo a não entender

Share this post


Link to post
Share on other sites
PsySc0rpi0n

Eu não percebo é a lógica do que ela quer. Se o a=2 o problema mantém-se. 00002, 00020, 00202, 00022, etc . Não percebo quando é que ela considera valores iguais ou diferentes. 


Kurt Cobain - Grunge misses you

Nissan GT-R - beast killer

Share this post


Link to post
Share on other sites
jtc-carr

 ela quer que comparemos i, j, k, w, h, a uns com os outros em sistema de rotação  programa[a][0] comparar com programa[a][1] e programa[a][2] programa[a][3] programa[a][4] e se der i,j,k,w,h 000010 quer dizer que o próximo 10 já será repetido apareça onde aparecer seja no wh no kw , no jk, ou no ij, já revi varias vezes a função que fiz, mas continua a não funcionar nada, deveria ser  uma função repetidos com 5 variaveis

Cadeira besta esta

Share this post


Link to post
Share on other sites
PsySc0rpi0n

Mas quando usas 

programa[x][y]

estás a dizer que na posição X, Y está um valor qualquer. Não estás a comparar os índices, mas sim os valores contidos nos índices. 


Kurt Cobain - Grunge misses you

Nissan GT-R - beast killer

Share this post


Link to post
Share on other sites
HappyHippyHippo

acho que a conclusão teste tópico é única :

sem um enunciado que faça sentido, todo o conhecimento do mundo não resolve o problema


IRC : sim, é algo que ainda existe >> #p@p

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now

×
×
  • Create New...

Important Information

By using this site you accept our Terms of Use and Privacy Policy. We have placed cookies on your device to help make this website better. You can adjust your cookie settings, otherwise we'll assume you're okay to continue.