C Auxílio para Resolução de Exercício de Vetores em C

[SkyWylker]

Spoiler

Antes que alguém pense que quero apenas a resposta, peço que leia todo o post. Obrigado.

 

Boa noite caros informáticos!

Estou aqui para pedir auxílio na Linguagem C novamente!

O exercício é longo, então, fiz como me foi ensinado: dividir e conquistar!

 

Citação

1. Criar um algoritmo que preencha um vetor de 30 posições com números múltiplos de 2, até a posição 60.
2. Após, imprima em linhas separadas, o número que foi preenchido e qual a posição do vetor que esse número.
3. Por último, imprima os vetores do menor para maior, separado por vírgula e com ponto final depois do último.

 

A parte 2 e 3 estou empacado e não estou conseguindo fazer.

Eu fiz alguns testes como colocar o if junto do for e separar o printf e declarar os vetores separados dentro de chaves.
Mas não é nada prático e sei que tem como fazer de maneira mais eficiente.

Gostaria de um auxílio em como finalizar. 

Peço um pouco de paciência pois estou bem no começo e não sou expert (ainda ) e quero aprender como faz.
Esse foi o código que consegui fazer até agora.

Citação

 

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

int main (){

  int vetor[60];

  for (int i = 2; i < 60; ++i){  // Define um ciclo, adicionando +1 ao vetor, enquanto o número for menor que 60
        printf("%i\n", vetor[i]);
      }

    if(i % 2 == 0){  //Se o resto da divisão for igual a 0, o número será par.
    printf("Endereços: %i",vetor[i]);
    }

return 0;
  
}

 

 

 

Muito obrigado, de coração.
 

[arfneto]

1 hora atrás, SkyWylker disse:

• Criar um algoritmo que preencha um vetor de 30 posições com números múltiplos de 2, até a posição 60.
• Após, imprima em linhas separadas, o número que foi preenchido e qual a posição do vetor que esse número.
• Por último, imprima os vetores do menor para maior, separado por vírgula e com ponto final depois do último.

 

Olá!

1. Quem escreveu isso podia ter escrito mais claramente. Um vetor de 30 posições tem, imagino, 30 posições. E se você escrever além da posição 29, já que as posições no vetor começam em zero, seu programa deve cancelar por violação de acesso ou outro erro assim. Provavelmente o que era para estar escrito era algo assim: Criar um algoritmo que preencha um vetor de 30 posições com números múltiplos de 2 até o número 60. Como metade dos números é par até 60 temos 30 deles e o vetor vai ficar cheio...
2. O segundo item também não está bem redigido: imagino que a ideia era mostrar o múltiplo de 2 e a posição do vetor que ele acabou ocupando, um par valor/posição por linha
3. Esse também não está bom: imagino que era para imprimir os valores e não os vetores, já que vetor só tem um --- ao menos é o que diz no item 1 --- do menor para o maior, separado por vírgula e com ponto ao final

Provavelmente para 5 pares seria para imprimir

2 0
4 1
6 2
8 3
10 4

E depois 

2,4,6,8,10.

De volta ao problema (supondo que o enunciado seja esse): O primeiro --- 2 --- estará na posição zero. O segundo --- 4-- na posição 1 e assim por diante.

Então o valor do vetor na posição y é

y = 2x + 2

E para y = 29, o último, teremos 60, como esperado desde o ensino fundamental

 

De volta ao C

 

Então temos um vetor de 30 posições a ser preenchido com múltiplos de 2. Pode ser declarado

int    vetor[30];

Tem claro muitas opções pra isso. Exemplos

 

Opção: um comando for usando a funcao

    // 1
    for (int i = 0; i<30; i = i+1)
    {
        vetor[i] = i + i + 2;
    }

Opção: um comando for usando os limites de 2 e 60 inclusive

    // 2
    i = 0;
    for (int valor = 2; valor <= 60; valor = valor + 2)
    {
        vetor[i] = valor;
        i = i + 1;
    }

Opção: um comando do{}while() usando o valor e o indice

    //3 
    valor = 2;
    i = 0;
    do
    {
        vetor[i] = valor;
        valor += 2;
    } while (valor <= 60);

Opção: um comando while similar

    //4
    valor = 2;
    i = 0;
    while (i < 30)
    {
        vetor[i] = valor;
        valor += 2;
        i = i + 1;
    }

Opção: um comando for com os valores e índices dentro do comando

    //5
    for (valor = 2, i = 0; i < 30; i = i + 1, valor=valor+2)
    {
        vetor[i] = valor;
    }

Opção romântica:

O comando goto e um label como nos anos 60:

    //6
    valor = 2;
    i = 0;
de_novo:
    vetor[i] = valor;
    i++;
    valor += 2;
    if (i < 30) goto de_novo;

O código para mostrar os valores pode ser algo assim

    printf("vetor:\n");
    for (int i = 0; i < n-1; i++) printf("%d, ", vetor[i]);
    printf("%d.\n", vetor[n - 1]);

E mostraria algo assim

vetor:
2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60.

Escrever um par por linha é similar...

[SkyWylker]

Bom dia @arfneto. 
Muito obrigado pela ajuda. Consegui compreender algumas opções. Outras não muito pois não cheguei ainda nelas.

 

Tenho apenas três dúvidas:

 

Primeira:

• Na opção de imprimir os valores: por que você usou o n?
  n-1 e vetor[n - 1]
  Se não entendi errado, é para chamar o número que está armazenado - 1(resultando em um par)?

Segunda:

• Eu confundi ao digitar os enunciados e coloquei que preciso imprimir do menor para MAIOR....
  Mas é ao contrário. Em ordem decrescente.
  Usei meu Google-Fu, fiz alguns testes com códigos que achei na internet mas não mudou nada. Sempre imprime na ordem crescente.

Terceira:

• O programa não está parando a execução no 60. Ele continua indefinidamente até obter Segmentation Fault:
  Como posso corrigir isso?

 

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

int main (){

int vetor[30], valor, i, n;


for (int i = 0; i<30; i = i+1)
    {
        vetor[i] = i + i + 2;
    }

printf("Ordem Decrescente:\n");
    for (int i = 0; i < n-1; i++) printf("%i,\n ", vetor[i]);
    printf("%i.\n", vetor[n - 1]);
  
return 0;

}

Novamente, muitíssimo obrigado!

 

[arfneto]

4 horas atrás, SkyWylker disse:

Na opção de imprimir os valores: por que você usou o n?
n-1 e vetor[n - 1]
Se não entendi errado, é para chamar o número que está armazenado - 1(resultando em um par)?

 

Talvez tenha entendido errado. Foi usado esse índice apenas porque nesse caso --- o ultimo --- não vai usar a vírgula e sim o ponto depois do cara. Então até o penúltimo você usa o loop que imprime com a vírgula depois. E apenas para o último imprime com o ponto depois Entendeu? 

 

4 horas atrás, SkyWylker disse:

Mas é ao contrário. Em ordem decrescente.
Usei meu Google-Fu, fiz alguns testes com códigos que achei na internet mas não mudou nada. Sempre imprime na ordem crescente

 

Eu suspeitava. Era muito fácil pra ser só isso: imprimir de dois jeitos a mesma coisa

A própria biblioteca padrão do C tem uma rotina para classificar. Ao menos uma. Nem precisa do Google.

é declarada assim:

void qsort(
        void*        endereco_inicial,
        size_t       total_de_items,
        size_t       tamanho_de_cada_um,
        int          (*funcao_que_compara)(const void *, const void*))

E ela classifica o próprio vetor. No seu caso não tem problema porque não vai usar mais. São só 4 parâmetros e pode parecer assustador mas na verdade é bem óbvio...

1. onde estão os valores a classificar: você passa o endereço do vetor claro
2. quantos são: fácil: são  30
3. qual o tamanho deles? Fácil: sizeof(int)
4. Como saber qual de dois deles é maior? Esse é o caso de uma função: você escreve uma que retorna um número menor que zero se o primeiro é menor, 0 se os dois são iguais e um número maior que 0 se o segundo é maior

Só que no seu caso os elementos são inteiros então basta retornar (a-b) certo?  afinal

• se (a>b) a diferença é positiva
• se (a-b) a diferença é zero
• se (a<b) (a-b) é sem surpresas negativo

Então

int funcao_que_compara(const void* a, const void* b)
{
    int* primeiro = (int*)a;
    int* segundo =  (int*)b;
    return -(*primeiro - *segundo);
}

Esses parâmetros estranhos são porque essa rotina tem que funcionar para comparar qualquer coisa: int ou float ou structs ou sei lá. Então se você tiver uma struct com nome CEP e RG e CPF você pode ter uma rotina que classifica por cada critério desses e pode classificar por CEP ou nome ou RG só mudando o nome da função. Esse é um recurso muito importante.

 

A história curta é que basta passar o nome da função. Também por isso C é tão versátil

    qsort(vetor, 30, sizeof(int), funcao_que_compara);

classifica os caras em ordem decrescente, por causa desse comando

    return -(*primeiro - *segundo);

Note o sinal '-' que inverte a conta. Se usar

return (*primeiro - *segundo);

vai classificar em ordem crescente, claro. Basta ver a definição. Por favor não diga que eu poderia ter invertido os operandos e simplesmente ter escrito

    return (*segundo - *primeiro);

Eu só preferi manter na ordem.
 

4 horas atrás, SkyWylker disse:

O programa não está parando a execução no 60. Ele continua indefinidamente até obter Segmentation Fault:
Como posso corrigir isso?

 

No seu programa o valor de n não está definido... Talvez devesse declarar de imediato

int n = 30;

como no programa de teste

 

Em tempo: se precisar realmente escrever você uma rotina para classificar os caras escreva de novo. No enunciado não fala nada e isso faz parte do C desde sempre. qsort() é uma rotina muito otimizada.

 

Eis um programa de teste que imprime isso

vetor:
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.
vetor:
2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60.
vetor:
2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60.
vetor:
60, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60.
vetor:
2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60.
vetor:
2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60.
vetor:
2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60.


***** em ordem decrescente
vetor:
60, 58, 56, 54, 52, 50, 48, 46, 44, 42, 40, 38, 36, 34, 32, 30, 28, 26, 24, 22, 20, 18, 16, 14, 12, 10, 8, 6, 4, 2.


***** em ordem crescente
vetor:
2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60.

Assim você vê como é esperto o lance da função...

#define _CRT_SECURE_NO_WARNINGS
#include    "memory.h"
#include    <stdio.h>
#include    <stdlib.h>
#include    <string.h>

int compara_crescente(const void*, const void*);
int funcao_que_compara(const void*, const void*);
int mostra(int[], int);


int main(int argc, char** argv)
{
    int    vetor[30];
    int n = 30;
    int i;
    int valor;
    for (int i = 0; i < n; i++) vetor[i] = i;
    mostra(vetor, 30);

    // 1
    for (int i = 0; i<30; i = i+1)
    {
        vetor[i] = i + i + 2;
    }
    mostra(vetor, 30);

    // 2
    i = 0;
    for (int valor = 2; valor <= 60; valor = valor + 2)
    {
        vetor[i] = valor;
        i = i + 1;
    }
    mostra(vetor, 30);

    //3
    valor = 2;
    i = 0;
    do
    {
        vetor[i] = valor;
        valor += 2;
    } while (valor <= 60);
    mostra(vetor, 30);

    //4
    valor = 2;
    i = 0;
    while (i < 30)
    {
        vetor[i] = valor;
        valor += 2;
        i = i + 1;
    }
    mostra(vetor, 30);

    //5
        for (valor = 2, i = 0; i < 30; i = i + 1, valor=valor+2)
    {
        vetor[i] = valor;
    }
    mostra(vetor, 30);

    //6
    valor = 2;
    i = 0;
de_novo:
    vetor[i] = valor;
    i++;
    valor += 2;
    if (i < 30) goto de_novo;
    mostra(vetor, 30);

    printf("\n\n***** em ordem decrescente\n");
    qsort(vetor, 30, sizeof(int), funcao_que_compara);
    mostra(vetor, 30);

    printf("\n\n***** em ordem crescente\n");
    qsort(vetor, 30, sizeof(int), compara_crescente);
    mostra(vetor, 30);

    return 0;

}


int compara_crescente(const void* a, const void* b)
{
    int* primeiro = (int*)a;
    int* segundo = (int*)b;
    return (*primeiro - *segundo);
}


int funcao_que_compara(const void* a, const void* b)
{
    int* primeiro = (int*)a;
    int* segundo = (int*)b;
    return -(*primeiro - *segundo);
}

int mostra(int vetor[], int n)
{
    printf("vetor:\n");
    for (int i = 0; i < n - 1; i++) printf("%d, ", vetor[i]);
    printf("%d.\n", vetor[n - 1]);
    return 0;
}    // end mostra()

 

[SkyWylker]

Bom dia@arfneto !
Novamente, obrigado pela explicação. Tem coisas que não vi ainda e que não entendi muito bem, mas anotei tudo para consultar posteriormente. Gerou bastante conteúdo. Obrigado!

 

Porém, o código está quase acabado (eu acho... hehehe):

 

O enunciado diz:

Citação

Ao preencher cada posição do vetor, apresentar na tela, o número que foi preenchido e qual a posição do vetor que esse número foi inserido, em cada linha. 

 

Pelo que entendi, preciso imprimir a posição do vetor e o número dentro dela, certo? Assim:

[0] 2

[1] 4

[2] 6

Novamente, não sei se entendi errado e se isso é possível.
Porém, eu apenas consigo imprimir os números na tela, de ordem crescente (Imagem anexa)

 

 

A segunda parte é eu colocar o bendito ponto final após o último número.

Mesmo eu colocando o seu código

for (int i = 0; i < n - 1; i++) printf("%d, ", vetor[i]);

não deu certo. Ele imprime os números conforme a imagem anexa.
 

 

Segue o código até agora:

 

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

int main (){

int vetor[30], valor, i;
int n = 30;


for (int i = 0; i<30; i = i+1)
    {
        vetor[i] = i + i + 2;
    }

    int length = sizeof(vetor)/sizeof(vetor[0]);  
    printf("Posição dos Números no Vetor \n");
    /*Se eu não entendi errado, preciso imprimir o número e a sua posição dentro do vetor, certo?*/
    //[0] 2
    //[1] 4
    //[2] 6

    for (int i = 0; i < length; i = i+1) {   
        printf("%d\n", vetor[i]);   
    }

printf("Ordem Decrescente:\n"); // <--- Ponto final após o último.
    for (int i = 0, j=30; i <n; i++,j--) {
          printf("%i,\n", vetor[j-1]);      
    }
return 0;

}

 

Obrigado novamente!

[arfneto]

20 horas atrás, arfneto disse:

Talvez tenha entendido errado. Foi usado esse índice apenas porque nesse caso --- o ultimo --- não vai usar a vírgula e sim o ponto depois do cara. Então até o penúltimo você usa o loop que imprime com a vírgula depois. E apenas para o último imprime com o ponto depois Entendeu? 

 

Não, acho que não entendeu...

3 horas atrás, SkyWylker disse:

A segunda parte é eu colocar o bendito ponto final após o último número.

Mesmo eu colocando o seu código

 

Nós já discutimos isso... Você cortou a linha que imprime o último... Não é o "meu código" mas sim o "seu enunciado"...

Em 24/09/2019 às 12:02, SkyWylker disse:

Na opção de imprimir os valores: por que você usou o n?
n-1 e vetor[n - 1]
Se não entendi errado, é para chamar o número que está armazenado - 1(resultando em um par)?

E você falava sobre isso

    printf("vetor:\n");
    for (int i = 0; i < n - 1; i++) printf("%d, ", vetor[i]);
    printf("%d.\n", vetor[n - 1]);

E mesmo assim cortou a última linha

 

3 horas atrás, SkyWylker disse:

Pelo que entendi, preciso imprimir a posição do vetor e o número dentro dela, certo? Assim:

[0] 2

[1] 4

[2] 6

Novamente, não sei se entendi errado e se isso é possível.

 

Sim, já falamos disso... Apenas imprima a posição e o valor

Em 23/09/2019 às 22:52, SkyWylker disse:

Após, imprima em linhas separadas, o número que foi preenchido e qual a posição do vetor que esse número

 

Mas preste atenção: o enunciado diz o contrário e eu te mostrei um exemplo disso no tópico #2

Apenas um loop, e você imprime o par valor, i 

 

 E nada disse sobre ordenar o vetor... precisa escrever isso mesmo tendo uma função pra isso na linguagem? Entendeu o que te expliquei no programa de teste? Pode simplesmente usar qsort() como expliquei? Pouca chance de a gente escrever algo melhor ou achar algo melhor na internet...