Preciso aprender a fazer essa questão

Bruno.Chaves · 14 de outubro de 2019

Ler um vetor A usando While ou Do-While de 10 números. Após, ler mais um número e guardar em uma variável X.
Armazenar em um vetor M o resultado de cada elemento de A multiplicado pelo valor X.
Logo após, imprimir o vetor M.

devair1010 · 14 de outubro de 2019

@Bruno.Chaves a interpretação é que você precisa criar então dois vetores , o A e o M , e uma variável x , depois ler o que for digitado usando o comando scanf , e para multiplicar use o símbolo * asterísco , faça seu código e poste aqui para vermos como está e em que podemos ajudar .

DiF · 14 de outubro de 2019

Caro usuário,

Seja bem-vindo ao Fórum do Clube do Hardware.

No intuito de servir como fonte de pesquisa no caso de instituições de ensino, informamos que incorrer no resolvimento por completo de questões relacionadas a disciplinas escolares de cursos técnicos e faculdades podem ser revistas e removidas pela Equipe de Moderação do Clube do Hardware.

Para sanar dúvidas sobre esse tipo de problema, por gentileza, publique o passo a passo do desenvolvimento da questão, projeto, monografia ou conteúdo em dúvida para que possamos analisar se a resposta está correta ou não, ou para que possa ser auxiliado com a dúvida no desenvolvimento do exercício.

Infelizmente, não há como resolver os trabalhos pelos usuários. O objetivo do Fórum do Clube do Hardware é auxiliar seus usuários a encontrar soluções para que possam sanar suas dúvidas, e não de trazer soluções prontas para seus usuários.. Além disso, copiar e colar respostas que não são de autoria própria do qualquer usuário é considerado plágio, o que é ilegal.

Esperamos que compreenda.

Atenciosamente,

Equipe Clube do Hardware

.if · 14 de outubro de 2019

char x,i=0, a[10],m[10]; while(i++<10)

scanf("%d",&a);scanf

("%d",&x);i=0;

while(i++<10) m=a*x;i=0;

while(i++<10)

printf("%d", m[i]);

Pode funcionar mas o resultado não é elegante bem como como não é como escrevi o fonte (online) de propósito. Se fizer ctrl-c ctrl-v e funcionar, queira no mínimo retornar mencionando que entendeu e que vai aprimorar o código e melhorar o fonte.

abç

Ansi C · 16 de outubro de 2019

@Bruno.Chaves , Boa noite!

VETORES

^{Tempo médio de leitura: 15 minutos}

São estruturas de dados e estáticos; coleção de um só tipo definido pelo programador, é também um objeto ponteiro. Seu nome é ao mesmo tempo sua referência para coleção de dados na memória. Seu acesso é linear por meio da "aritmética de ponteiros" ^Wikipédia. Utiliza-se a seguinte notação tanto para leitura quanto para gravação de seus elementos.

nome_do_vetor [índice_do_vetor]

_{Acima 0 ... 9 são os índices de um vetor com possibilidade para 10 elementos.}

^{Os índices [0], [2], [3], [5] e [6] acessam elementos gravados em suas células de memória.}

Imagine

Um vetor é, igual na ilustração, uma tabela de 1 linha e X colunas dentro da memória sendo cada coluna 1 elemento do vetor. Cada coluna ou elemento nessa linha é uma célula de memória de tamanho equivalente. Essas células podem se combina, digitalmente, para definir durante sua declaração um tipo de dados completamente novo. O meio de acesso ao dados nessas células é o índice do vetor. O índice do vetor é um valor inteiro no qual se aplica automaticamente a aritmética de ponteiro.

C'11

int inteiro;
/* declara uma variável do tipo inteiro tem 1 célula de memória do tipo (int) */

int inteiros [10];
/* declara um vetor com nome `inteiros` tem 10 células de memória do tipo (int)*/

inteiro = 1999;
/* atribui o elemento 1999 na posição 0 (primeira  única) da variável  */

inteiros [5] = 2015;
/* atribui o elemento 2015 na posição 6 índice 5 */

5 [inteiros] = 2015;
/* agora de outro jeito atribui o elemento 2015 na posição 6 índice 5 */

E as matrizes, o que são ?

As matrizes também são vetores. Como se cada elemento para um vetor fosse outro, logicamente, um outro vetor também. Tem-se um vetor de vetores? Sim... em que cada elemento nele é de fato outro(s) vetor(es) completamente equidistante(s). É dessa maneira que se pensa as matrizes. Vetores em tantas dimensões quanto há em memória no sistema.

Os vetores de vetores ou simplesmente matrizes são todos do mesmo tipo de dados.

int matriz [2][10];
/* declaro um vetor de vetores ou simplesmente matriz com 2 vetores de 10 elementos. Talvez esse notação, a primeira vista, seja abstrata de mais... apelamos uma pouco mais não muito porque a linguagem não nos permite ser mais literais do que tenho abaixo */

int matriz [][10] = {int[10]{}, int[10]{}};
/* declaro uma matriz com 2 vetores de 10 elementos cada vetor nela. Note o 10 no final da notação de matrizes e o 10 no final da notação de vetores, isso é uma regra e deve ser seguida. Note os elementos do vetor de vetores */

Ponteiro

É uma variável que armazena uma referência. As referências são índices de células de memória na memória do sistema. É possível acessar uma referência a partir do índice de um vetor, assim tal qual fazemos com as variáveis, por meio do operador unário & (ampersand).

C'11

int inteiros [10];
/* declara um vetor com nome `inteiros` com 10 células de memória do tipo (int)*/

inteiros [5] = 2015;
/* atribui o elemento 2015 na posição 6 índice 5 */

&inteiros [5];
/* Acessa o índice da célula de memória na memória onde gravou 2015. 
O índice do vetor é 5, mas o índice da célula de memória que é a referência é também um número imprevisível quando analisado isoladamente, ao certo podemos dizer que esse número é x + 5 onde x é a referência salva no nome do vetor. */

veja mais

Enquanto, Faça Enquanto

É uma estrutura de decisão com iteração. Os comandos while (pt.: enquanto) e do while (pt.: faça enquanto) são do tipo que se repetem a si e a um bloco de código quando sua condição de existência persiste.

_{Acima um fluxograma da estrutura de repetição while.}

^{Enquanto a condição B for verdadeira o procedimento C se repete.}

É composto de:

Proposição lógica binária B que admite apenas dois valores no resultado : Não (0), Sim (diferente de 0)
Bloco de código C com os comandos que deseja repetir enquanto o resultado da proposição na estrutura de decisão B é diferente de 0.

Esse tipo de comando é útil com vetores e matrizes, pois essas estruturas são indexadas logo o uso de repetições para ler ou gravar em suas células é prático, minimizam o tamanho do programa, aumenta a produtividade e legibilidade do código. Imagine que o número de células que precisamos ler e gravar são do mesmo tipo e em quantidade... precisamos repetir o comando de leitura (muito chato), bastando apenas e portanto, obter um objeto indexável (vetor) e uma estrutura de repetição pra fazer todo esse trabalho em menos linhas de código.

C'11

/* Liste os números de 0 até 10 no vetor de 11 posições */

int i = 0;   /* < Índice i */
int vt [11]; /* < Vetor de 11 posições */

while (11 > i)
/* Enquanto 11 é maior que i */
{ /* Início do bloco While */
	vt [i] = i;
	/* atribua na posição i do vetor o elemento i */

	++i;
	/* pre-incremente a variável i; o mesmo que i = 1 + i */
  
} /* Fim do bloco While */

veja mais.

Operadores Matemáticos Binários: Multiplicação

_{A multiplicação pode ser também a versão sintética da adição quando de termos iguais.}

^{2 * 2 = 2 + 2 e se fosse 3 * 2 teríamos 3 + 3.}

É a operação binária que se pode resumir em adições sucessivas de parcelas iguais. Na linguagem C por exemplo, seu sinal só pode assumir uma forma gráfica canônica; a de um asterisco ( * ) e entre dois valores.

C'11

int produto;
/* declaro uma variável int de nome produto */

produto = 2 * 2;
/* atribuo a variável o resultado da multiplicação */

int produtos [10];
/* declaro um vetor de 10 posições do tipo int */

produtos [0] = produto;
/* atribuo a variável na posição 1, índice 0 do vetor produtos */

veja mais

Entrada e Saída

O método padrão de entrada é a função scanf, e de saída a função printf ambas da biblioteca stdio.h.

_{A biblioteca padrão da linguagem fornece duas funções de entrada / saída.}

^{scanf / printf, ambas de formatação; inclusive esse é o significado do f final.}

scanf

int scanf(const char *restrict format, ...);

Função padrão de nível intermediário para ler dados a partir de um fluxo padrão de arquivos de entrada do sistema. Detém 1 argumento essencial para sua funcionalidade e uma limite n determinado pela constante do sistema ARG_MAX: 1- string com formatação dos dados, n- lista de ponteiros para locais de memória de acesso não violável. Dentre os padrões nas opções de formatação destaco: "%f" (de flutuante) para leitura de sequência de caracteres que logo depois e convertido para o tipo de dados número real.

C'11

float numeros [BUFSIZ];
/* declara vetor do tipo flutuante (real), tamanho com buffer do sistemas */

scanf ("%f", &numeros [0]); 
/* ler informação a partir do fluxo padrão de entrada (padrão C é o teclado) */

veja mais

printf

int printf(const char *restrict format, ...);

Função padrão de nível intermediário, serve para escrever informações a partir de um fluxo padrão do arquivos de saída do sistema. Detém 1 argumento essencial para sua funcionalidade e quantidade n limitada de argumentos determinada pela constante do sistema ARG_MAX: 1- string com formatação dos dados, n- lista de valores. Dentre os padrões nas opções de formatação destaco: "%f" (de flutuante) para escrita de um número flutuante.

C'11

float numeros [BUFSIZ] = {10.0};
/* declara vetor do tipo flutuante, tamanho com buffer do sistemas e atribui o número 10 na primeira posição */

printf ("%f", numeros [0]); 
/* escreve a informação a partir do fluxo padrão de saída (padrão C é o console do sistema) */

veja mais

Exercício

Gravar num vetor ( A ) usando While ou Do-While de 10 números. Após, ler mais um último número e guardar em uma variável X. Armazenar em um vetor ( M ) o resultado de cada elemento de A multiplicado pelo valor X. Logo após, imprimir o vetor M.

Spoiler


#include <stdio.h>
/* Incluir todas funções E/S reconhecidas pelo padrão ISO 2018 */

int main (void)
/* Funcão principal de todo programa escrito em C */
{
        float A [10];
        /* declaro um vetor A com 10 posições do tipo flutuante */

        float M [10];
        /* declaro um vetor M com 10 posições do tipo flutuante */

        float X;
        /* declaro uma variável X do tipo flutuante */

        unsigned int i = 0; /* < índice do vetor e contador da instrução while */
        /* declaro uma variável i do tipo inteiro sem sinal */
  
        while (10u > i)
        /* Enquanto 10 é maior que i */
        {
                scanf ("%f%f", &A [i], &A [i + 1]);
                /* leia 2x números */

                i += 2;
                /* incremente i fazendo i = i + 2 */
        }
        scanf ("%f", &X);
        /* leia 1x número */

        i = 0; /* < índice do vetor e contador da instrução while */
        while (10u > i)
        /* Enquanto 10 é maior que i */
        {
                M [i]     = A [i]     * X;
                /* atribui o produto de Ai por X em Mi */

                M [i + 1] = A [i + 1] * X;
                /* atribui o produto de A(i + 1) por X em M(i + 1) */

                i += 2;
                /* incremente i fazendo i = i + 2 */
        }
        i = 0; /* < índice do vetor e contador da instrução while */
        while (10u > i)
        /* Enquanto 10 é maior que i */
        {
                printf ("%f %f ", M [i], M [i + 1]);
                /* escreve o valores dos elementos Mi e M(i + 1) na saída padrão */

                i += 2;
                /* incremente i fazendo i = i + 2 */
        }
        return 0;
        /* 0 retorno bem sucedido */
}