C Calcular a razão e verificar se pertence ao PA

DanielC4 · 13 de junho de 2022

O problema: "Peça ao usuário que informe dois inteiros, sendo um valor inicial e uma razão. Preencha um vetor de 10 posições começando pelo valor inicial e incrementando-o com a razão (progressão aritmética - PA). Depois peça um número para que seja verificado se ele pertence à PA e informe o resultado na tela."

O meu código foi o seguinte:

#include <stdio.h>
#include <stdlib.h>
int main (){
int r, n, i;
int sequencia[10];

printf ("Digite um termo inicial:\n");
scanf ("%d", &sequencia[0]);

printf ("Digite uma razão:\n");
scanf ("%d", &r);

printf ("Digite um número a ser pesquisado na sequência:\n");
scanf ("%d", &n);

for (i = 0; i <= 9; i++){
    printf ("\n%d\n", sequencia[i]);

}

while (sequencia[0] <= sequencia[9]){
        printf ("%d\n", sequencia[0]);
sequencia[0] += r;
}

if (n != sequencia[0] && n != sequencia[1] && n != sequencia[2] && n != sequencia[3] && n != sequencia[4] && n != sequencia[5] && n != sequencia[6] && n != sequencia[7] && n != sequencia[8] && n != sequencia[9]){
printf ("\nO número %d não se encontra na sequência.\n", n);
}
else {
printf ("\nO número %d se encontra na sequência.\n", n);
}

return 0;
}

O codeblocks não me informou sobre nenhum erro, mas quando os termos da sequência são imprimidos na tela, vários números estranhos aparecem (0 e 4199705, por exemplo). Alguém saberia me dizer o que há de errado?

arfneto · 13 de junho de 2022

O Code::Blocks não vai te dizer que ocê não calculou os termos da PA.

E já que estamos falando disso, porque não calculou os 10 termos e colocou no vetor sequencia[] ? Seu programa vai perguntar um número ao usuário e procurar por ele no vazio?

22 minutos atrás, DanielC4 disse:


printf ("Digite um termo inicial:\n");
scanf ("%d", &sequencia[0]);

printf ("Digite uma razão:\n");
scanf ("%d", &r);

TESTE SEMPRE o retorno de scanf(). É ingênuo seguir adiante.
mostre os valores que leu para ficar seguro de que as coisas estão saindo como você espera.
Ao perguntar algo NÃO mude de linha ao mostrar a pergunta. É chato e ninguém gosta disso. Deixe o cursor na mesma linha...

devair1010 · 14 de junho de 2022

@DanielC4 esses números estranhos que aparecem são valores desconhecidos que já estavam na memória onde o compilador reservou um espaço para o vetor e as variáveis criadas , e como você não inicializou nenhuma delas , e durante o programa as que não foram modificadas recebendo algum valor , ainda conterão o mesmo que tinham no início , ou seja , lixo de memória , e seu código modificado ficou assim :

#define _WIN32_WINNT 0x600
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
int prototipo(int , int , int* );
int main()
{
  HANDLE _h = GetStdHandle(STD_OUTPUT_HANDLE);
  SetConsoleTextAttribute( _h , 15 + (12 << 4 ) );
  int r   = 0;
  int n   = 0;
  int i   = 0;                       /// inicializar as variaveis
  int ret = 0;
  int sequencia[10] = {0};           /// inicializar todas as posições do
                                     /// vetor com zero
  printf("Digite um termo inicial: ");
  ret = scanf("%d", &sequencia[0]);  /// apenas um numero será armazenado no vetor
  printf("Ret= %d\n",ret);
  if(ret != 1)return 0;
  printf("Digite uma razAo: ");
  scanf ("%d", &r);
  printf("Digite um nUmero a ser pesquisado na sequEncia: ");
  scanf ("%d", &n);
  printf("\n");
  for( i=0; i<10; i++ )              /// esse modo eh mais normal
  {
    printf (" Sequencia[%d]= %3d \n",
            i , sequencia[i]       );/// aqui sem inicializar o vetor
  }                                  /// as posições acima de zero contem valores
                                     /// desconhecidos , lixo de memória
  while (sequencia[0] <= sequencia[9])
  {
    printf ("sequEncia[0] = %d\n", sequencia[0]);
    sequencia[0] += r;
  }
  int flg = 0;                       /// uma bandeira de verificacao igual a falso
  for(i=0; i<10; i++)                /// percorrer todas as posições do vetor
  {
    if (n == sequencia[i] )          /// se algum numero no vetor for igual a n
    {
      flg = 1;                       /// marca como verdadeiro , pois encontrou
      break;                         /// sai desse Loop for
    }
  }
  printf("\n O nUmero %d ", n);
  if( ! flg )                        /// se flg não for verdadeiro
  {
    printf ("não ");
  }
  printf ("se encontra na sequEncia.\n");

  SetConsoleTextAttribute( _h , 7 + (0 << 4 ) );
  printf("\n\n\n");
  return 0;
}
int prototipo(int a, int b, int* c)
{
  return 0;
}

arfneto · 14 de junho de 2022

12 horas atrás, devair1010 disse:

esses números estranhos que aparecem são valores desconhecidos que já estavam na memória onde o compilador reservou um espaço para o vetor e as variáveis criadas

Sim, @devair1010 mas entenda que nesse caso nem é assim importante inicializar:

Trata-se de uma progressão aritmética, a popular PA e é preciso preencher o vetor com os termos e de nada adianta preencher o vetor com algo que não sejam os termos, já que logo em seguida o vetor vai ser pesquisado em busca de um número que o programa vai ler... Foi o que eu disse antes.

De nada adianta colorir a tela de um programa não faz o mínimo esperado.

12 horas atrás, devair1010 disse:

for(i=0; i<10; i++)                /// percorrer todas as posições do vetor
  {
    if (n == sequencia[i] )          /// se algum numero no vetor for igual a n
    {
      flg = 1;                       /// marca como verdadeiro , pois encontrou
      break;                         /// sai desse Loop for
    }
  }

Não escreva assim. Declare o i DENTRO do loop. NUNCA deixe uma variável global na função com um nominho desses: i. É pedir problemas. E eles virão sempre.

E náo precisa dessa construção.

Trata-se de uma PA e o loop só faz isso.

Então o simples:

ao encontrar um número maior é porque não tem o que procura. Retorna falso
Se sair do loop é porque não tem o que procura. Retorna falso
Se achou o número então... achou o número e retorna verdadeiro

Ansi C · 4 de maio de 2024

@DanielC4

Bom Dia

Para mim, teu programa falhou já no início, isso mesmo, meu mestre!

Ao solicitar um termo… alguém entrou com ele e o programa escreveu isto:

0
0
0
...

É coluna densa de valores desconexos.

A propósito, o número que alguém entrou era um inteiro.

Veja:

Digite um termo inicial:
0xff

Digite uma razão:

Digite um número a ser pesquisado na sequência:


0

...

145003

...

0

-13008

7
...

Em 13/06/2022 às 20:07, DanielC4 disse:

Peça ao usuário que informe dois inteiros

Ele informou, 0xff um inteiro, né?

Deu nisso, sequer tem a oportunidade dum segundo.

...

O especificador nos argumentos da scanf não concorda com a mensagem na solicitação, que também não está de acordo com enunciado. Parece bobagem, eu sei!

@devair1010 tua expressão também falhou no valor para termo.

arfneto · 6 de maio de 2024

Citação

"Peça ao usuário que informe dois inteiros, sendo um valor inicial e uma razão. Preencha um vetor de 10 posições começando pelo valor inicial e incrementando-o com a razão (progressão aritmética - PA). Depois peça um número para que seja verificado se ele pertence à PA e informe o resultado na tela."

O codeblocks não me informou sobre nenhum erro, mas quando os termos da sequência são imprimidos na tela, vários números estranhos aparecem (0 e 4199705, por exemplo). Alguém saberia me dizer o que há de errado?

Muito está errado nesse programa, com problemas na lógica, no modo de escrever um programa nessa linguagem, no uso de `scanf` e mesmo na compreensão do que é uma Progressão Aritmética, do ensino fundamental.

As respostas até parecem não endereçar esses problemas e até criam outros, então pode haver utilidade em alguma discussão agora, para uma questão de '22

Porque deu errado?

Esse trecho do programa tenta primeiro mostrar a PA e depois calcular os valores. Sem sentido.

for (i = 0; i <= 9; i++){
    printf ("\n%d\n", sequencia[i]);

}

while (sequencia[0] <= sequencia[9]){
        printf ("%d\n", sequencia[0]);
sequencia[0] += r;
}

esse não é o conceito de PA. Isso --- que está na ordem errada --- também está errado. Isso levaria apenas a

        p[0] = p[0] + 9r;

só que a definição de PA 'de termos p e razão r é

	p[i+1] = p[i] + r;

e claramene iria deixar o resto da sequência sem qualquer alteração. Como o valor sequer foi inicializado então o resultado é indefinido, UB na literatura.

é claro que se a razão for negativa sequencia[0] só vai diminuir, e o programa vai entrar em loop até cancelar
levou uns anos pra arrumarem isso em C mas foi feito nos anos 70 e as variáveis de controle de um loop podem e devem ser declaradas no loop --- claro, a menos que a lógica impeça --- em especial para nomes ingênuos como i
evite as chaves desnecessárias a menos que sua empresa ou escola obrigue seu uso
use funções. `C` é inútil sem funções: você precisa de uma função para:
- preencher uma PA
- mostrar uma PA
- obter razão, termo inicial e termo a pesquisar na série
- uma função para pesquisar na PA

Usando funções você simplifica tudo. Pode testar em separado e usar em outros programas. E é pra isso que se escreve código.

mais sobre o código original

Isso é até eficiente nesse caso:

    if (n != sequencia[0] && n != sequencia[1] &&
        n != sequencia[2] && n != sequencia[3] &&
        n != sequencia[4] && n != sequencia[5] &&
        n != sequencia[6] && n != sequencia[7] &&
        n != sequencia[8] && n != sequencia[9])
    {
        printf(
            "\nO número %d não se encontra na sequência.\n",
            n);
    }
    else
    {
        printf(
            "\nO número %d se encontra na sequência.\n", n);
    }

Mas tem pouco sentido. E se fossem 10 mil termos? Use um loop.

não escreva programas interativos. Coloque essa parte depois que o programa estiver pronto. Só perde tempo com isso, inventando números a cada teste
não inclua headers que não usa. Espere precisar deles e então inclua.

@devair1010 pra que serviria isso no exemplo?

	int prototipo(int, int, int*);

Sobre esse trecho

#define _WIN32_WINNT 0x600
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>

Isso praticamente limita o uso do exemplo a maquinas rodando Windows. Pode ser exagerado para um programa simples de busca em vetor. Alguns leitores usam MAC ou Linux

    for (i = 0; i < 10; i++)  /// esse modo eh mais normal
    {
        printf(
            " Sequencia[%d]= %3d \n", i,
            sequencia[i]);  /// aqui sem inicializar o vetor
    }  /// as posições acima de zero contem valores
       /// desconhecidos , lixo de memória
    while (sequencia[0] <= sequencia[9])
    {
        printf("sequEncia[0] = %d\n", sequencia[0]);
        sequencia[0] += r;
    }

Sei que em do original, mas como eu disse, isso está errado. Teste seu programa. Teste seu programa com valor inicial = -42 e razão -42. Sem surpresas ele entra em loop...

  ret = scanf("%d", &sequencia[0]);  /// apenas um numero será armazenado no vetor
  printf("Ret= %d\n",ret);
  if(ret != 1)return 0;
  printf("Digite uma razAo: ");
  scanf ("%d", &r);
  printf("Digite um nUmero a ser pesquisado na sequEncia: ");
  scanf ("%d", &n);

Se testou uma vez o retorno de `scanf` é porque sabe a razão. Porque não usou nas outras chamadas?

@Ansi C

Em 04/05/2024 às 09:08, Ansi C disse:

É coluna densa de valores desconexos.

que significa? densidade de coluna e conexão entre valores nesse caso?

Em 04/05/2024 às 09:08, Ansi C disse:

Ele informou, 0xff um inteiro, né?

Deu nisso, sequer tem a oportunidade dum segundo.

Não funciona assim. 0xff não é um inteiro. Zero é um inteiro. E é isso que vai ser lido. A "oportunidade de ler um segundo" não viria mesmo, mas não é por isso. É preciso consumir esses dados antes de chamar scanf de novo.

Digite um termo inicial:
0xff

Digite uma razão:

Digite um número a ser pesquisado na sequência:
```

Se perguntasse a um romano na idade média ele diria que XLII é 42, inteiro.

`scanf` pode ler valores em hexadecimal ou octal, mas não serão inteiros. E não pode resolver na hora da entrada como os valores serão lidos, porque tem que mudar o especificar de scanf e o programa que já está rodando deveria ser compilado de novo...

De todo modo usando especificadores %x serão valores abstratos e convertidos para o tipo dado pelo argumento para `scanf`.

- Se ler 49534E4100 usando %08x em uma máquina comum Intel e ler em um char[8] vai ver que leu "ANSI", sem surpresas
- Se ler 0x42280000 usando %4x na mesma máquina vai ler 42. em um float.
- Se ler 0xff em um char[8] usando %s vai ler "0xff" como esperado. Uma string.
- Se ler 0xff em um int usando %i vai ler 0. Nada mais.

EXEMPLO: Esse trecho de programa

    const char valor[] = "42280000";
    float      v_float = 0.;
    res = sscanf(valor, "%8x", (int*)&v_float);
    printf("res: %d, float: %f\n", res, v_float);

    const char ansi[20] = "49534E4100";
    char str[8]   = {0};
    res                 = sscanf(ansi, "%8x", (int*)str);
    printf("res: %d, string: \"%s\"\n", res, str);

    const char* xff = "0xff";
    res              = sscanf(xff, "%s", str);
    printf("res: %d, string: \"%s\"\n", res, str);

mostra os 3 casos

res: 1, float: 42.000000
res: 1, string: "ANSI"
res: 1, string: "0xff"

Em 04/05/2024 às 09:08, Ansi C disse:

O especificador nos argumentos da scanf não concorda com a mensagem na solicitação, que também não está de acordo com enunciado. Parece bobagem, eu sei!

Pode ser sim.

## EXEMPLO ##

Dois anos depois, um exemplo de como fazer isso usando as práticas comuns em

Escrevendo em torno dos dados:

Preenchendo os termos da P.A

 int preenche(
    int pa[], unsigned n_termos, int inicial, int razao)
{
    pa[0] = inicial;
    for (unsigned i = 1; i < n_termos; i += 1)
        pa[i] = pa[i - 1] + razao;
    return 0;
}

Mostrando na tela a tal PA

int mostra(
    int pa[], unsigned n_termos, int razao, const char* msg)
{
    if (msg != NULL) printf("%s", msg);
    printf(
        "\
    termo inicial: %i, razao: %i\n\
    %u termos:\n",
        pa[0], razao, n_termos);
    for (unsigned i = 0; i < n_termos; i += 1)
        printf("%d  ", pa[i]);
    printf("\n");
    return 0;
}

Buscando um termo na PA e retornando 1 se ele for encontrado, ou zero em caso contrário:

    int busca(int pa[], unsigned n_termos, int valor)
    {
        for (unsigned i = 0; i < n_termos; i += 1)
            if (pa[i] == valor) return 1;  // achou
        return 0;
    }

Usando isso esse programa faz o simples

  int main(void)
  {
      int pa[10];

      preenche(pa, 10, 1, 1);
      mostra(pa, 10, 1, "teste com r = 1\n");
      preenche(pa, 10, -22, -22);
      mostra(pa, 10, -22, "teste com r = -22\n");
      int termo = -220;
      int res   = busca(pa, 10, termo);
      printf("res = %d\n", res);
      res = busca(pa, 10, -22);
      printf("res = %d\n", res);
      res = busca(pa, 10, 0);
      printf("res = %d\n", res);

e mostra

teste com r = 1
    termo inicial: 1, razao: 1
    10 termos:
1  2  3  4  5  6  7  8  9  10
teste com r = -22
    termo inicial: -22, razao: -22
    10 termos:
-22  -44  -66  -88  -110  -132  -154  -176  -198  -220
res = 1
res = 1
res = 0

O exemplo completo

#include <stdio.h>
// busca 'valor' na 'pa' de 'n_termos`
int busca(int pa[], unsigned n_termos, int valor);
// mostra 'pa' na tela. 'msg' = mensagem opcional
int mostra(
    int pa[], unsigned n_termos, int razao,
    const char* msg);
// calcula os valores e preenche os 'n_termos' da pa
// de razao 'razao' iniciando em 'inicial'
int preenche(
    int pa[], unsigned n_termos, int inicial, int razao);

int main(void)
{
    int pa[10];

    preenche(pa, 10, 1, 1);
    mostra(pa, 10, 1, "teste com r = 1\n");
    preenche(pa, 10, -22, -22);
    mostra(pa, 10, -22, "teste com r = -22\n");
    int termo = -220;
    int res   = busca(pa, 10, termo);
    printf("res = %d\n", res);
    res = busca(pa, 10, -22);
    printf("res = %d\n", res);
    res = busca(pa, 10, 0);
    printf("res = %d\n", res);

    const char valor[] = "42280000";
    float      v_float = 0.;
    res = sscanf(valor, "%8x", (int*)&v_float);
    printf("res: %d, float: %f\n", res, v_float);

    const char ansi[20] = "49534E4100";
    char str[8]   = {0};
    res                 = sscanf(ansi, "%8x", (int*)str);
    printf("res: %d, string: \"%s\"\n", res, str);

    const char* xff = "0xff";
    res              = sscanf(xff, "%s", str);
    printf("res: %d, string: \"%s\"\n", res, str);

    return 0;
}

int busca(int pa[], unsigned n_termos, int valor)
{
    for (unsigned i = 0; i < n_termos; i += 1)
        if (pa[i] == valor) return 1;  // achou
    return 0;
}

int mostra(
    int pa[], unsigned n_termos, int razao, const char* msg)
{
    if (msg != NULL) printf("%s", msg);
    printf(
        "\
    termo inicial: %i, razao: %i\n\
    %u termos:\n",
        pa[0], razao, n_termos);
    for (unsigned i = 0; i < n_termos; i += 1)
        printf("%d  ", pa[i]);
    printf("\n");
    return 0;
}

int preenche(
    int pa[], unsigned n_termos, int inicial, int razao)
{
    pa[0] = inicial;
    for (unsigned i = 1; i < n_termos; i += 1)
        pa[i] = pa[i - 1] + razao;
    return 0;
}

Ansi C · 6 de maio de 2024

1 hora atrás, arfneto disse:

Não funciona assim. 0xff não é um inteiro

Quem disse que não é um inteiro? Cite a fonte, por favor!

@arfneto

Boa tarde!

Não compilou, você falhou nos especificadores de formato ou argumento.

c'11 - gcc11.4

a.c:31:28: erro: formato ‘%x’ espera argumento do tipo ‘unsigned int *’, mas argumento 3 tem tipo ‘int *’ [-Werror=format=]
   31 |     res = sscanf(valor, "%8x", (int*)&v_float);
      |                          ~~^   ~~~~~~~~~~~~~~
      |                            |   |
      |                            |   int *
      |                            unsigned int *
      |                          %8x
a.c:36:43: erro: formato ‘%x’ espera argumento do tipo ‘unsigned int *’, mas argumento 3 tem tipo ‘int *’ [-Werror=format=]
   36 |     res                 = sscanf(ansi, "%8x", (int*)str);
      |                                         ~~^   ~~~~~~~~~
      |                                           |   |
      |                                           |   int *
      |                                           unsigned int *
      |                                         %8x

Seu programinha, supostamente, também não responde e não pergunta conforme o enunciado: além de não compilar.

Estou insatisfeito

Em 13/06/2022 às 20:07, DanielC4 disse:

Peça ao usuário que informe dois inteiros, sendo um valor inicial e uma razão. Preencha um vetor de 10 posições começando pelo valor inicial e incrementando-o com a razão (progressão aritmética - PA). Depois peça um número para que seja verificado se ele pertence à PA e informe o resultado na tela.

arfneto · 6 de maio de 2024

2 horas atrás, Ansi C disse:

Quem disse que não é um inteiro? Cite a fonte, por favor!

Use o trecho que te mostrei. 0xff. Não é um inteiro. É um valor abstrato. Eu te mostrei 3 exemplos. E está ao final do código do exemplo, então você pode testar por si mesmo.

E pode ler o que escrevi, em português, explicando o porque está errado. Esse é um forum, estilos e opiniões são ok, mas ainda o tema é C, C++ e C#. Uso essas linguagens regularmente e elas não são afeitas a opiniões, por outro lado.

Em C constantes em hexadecimal estão descritas no standard. Mas isso é para programas em C, para compilar o código.

Quando se usa um especificador como %8x em scanf para ler um valor hexadecimal é só isso: um valor abstrato.

Entenda que scanf não aloca memória então espera um endereço para onde transferir o valor. E vai fazer isso: scan formatted, afinal é de onde vem o nome da função. E o valor eventualmente escaneado vai ser transferido para o endereço passado. Nada mais. Por isso mostrei 3 exemplos usando float e char*. Usar int nada acrescentaria.

Se tem dúvida ainda, use um debugger e avalie. Não depende de minha opinião ou da sua.

2 horas atrás, Ansi C disse:

Boa tarde!

Não compilou, você falhou nos especificadores de formato ou argumento.

Pois é. Sobre não compilar sei que é frustrante copiar algum código de terceiros e não conseguir sequer compilar, mas o que posso te dizer é que isso é bobagem. Do compilador ou das opções de compilação de eventualmente usou. Postei também a saída do programa e incluí esse trecho que expliquei apenas para dar um exemplo de como usar, em 3 opções, como eu havia explicado. É difícil imaginar que um programa assim não compilasse...

Imagino que saiba ler as mensagens do compilador que usou. Num primeiro momento tratar todos eventuais avisos como erros pode até ser saudável, em especial para iniciantes, mas pode se transformar num exagero.

Você não se deu ao trabalho de mostrar as opções de compilação que usou. Não sei como reproduzir exatamente essa saída que conseguiu, e nem acho importante.

Vendo essa linha por exemplo:

2 horas atrás, Ansi C disse:

erro: formato ‘%x’ espera argumento do tipo ‘unsigned int *’, mas argumento 3 tem tipo ‘int *’ [-Werror=format=]
   31 |     res = sscanf(valor, "%8x", (int*)&v_float);

Vou explicar isso aqui porque outros podem ter dúvida:

se ler o exemplo verá que v_float é float
se ver o manual vai entender que scanf espera algo do tipo unsigned int* para carregar algo lido com %x
- &v_float é float* que por certo não é unsigned int* e é isso que seu compilador está reclamando. Isso seria um Warning e deveria gerar o código normalmente. Afinal reclamar de um ponteiro int* não ser unsigned int* é mesmo pedante.
mesmo o (int*) antes de &v_float já é um tanto exagerado. Não por acaso algumas das opções de compilação que tratam disso contém essa palavra...
- -Wpedantic
- --pedantic errors
- -Werror
apenas não compile com essas opções, ou complete o cast com unsigned
um ponteiro pós-anos90 em windows depende apenas do modelo de memória, x86 ou x64, e terá o mesmo comprimento. apontando para qualquer coisa: 4 ou 8 bytes nessas máquinas comuns. Um cast para mudar o tipo só é chato. Devia ter usado
Ao usar uma opção fora do padrão deve se preparar para resultados assim. E, por uma questão de isenção, acho que se usa uma opção assim em um forum público devia deixar isso explícito ao postar código ou ao sinalizar códigos de outros como não-compiláveis. E se preparar para alterar códigos que copie de forums. E considere que há dezenas de compiladores disponíveis e dizer simplesmente que não compila com o único que usou pode ser ingênuo ou exagerado.

Até tentei reproduzir aqui, mas a única máquina que está livre agora e com esse compilador tem a versão 13.2.1 de outubro de 2023, e não dá nenhum erro.

TL;DR

Para quem nem leu, nem entendeu ou nem quer pensar nisso, pode usar esse trecho apenas para entender o que eu expliquei sobre scanf e entrada em hexadecimal

#include <stdio.h>
int main(void)
{
    const char valor[] = "42280000";
    float      v_float = 0.;
    int res = sscanf(valor, "%8x", (unsigned int*)&v_float);
    printf("res: %d, float: %f\n", res, v_float);

    const char ansi[20] = "49534E4100";
    char       str[8]   = {0};
    res = sscanf(ansi, "%8x", (unsigned int*)str);
    printf("res: %d, string: \"%s\"\n", res, str);

    const char* xff = "0xff";
    res             = sscanf(xff, "%s", str);
    printf("res: %d, string: \"%s\"\n", res, str);

    return 0;
}

E a saída deve ser

res: 1, float: 42.000000
res: 1, string: "ANSI"
res: 1, string: "0xff"

Essa parada de opções de compilação e plataformas e sistemas é importante. Conheça seu ambiente e seu compilador.

2 horas atrás, arfneto disse:

Em 04/05/2024 às 09:08, Ansi C disse:

É coluna densa de valores desconexos.

que significa? densidade de coluna e conexão entre valores nesse caso?

Ainda estou curioso pelo que seriam esses conceitos, se relacionados à pergunta.

2 horas atrás, Ansi C disse:

Esse seu programinha, supostamente, não responde e não pergunta conforme o enunciado: além de não compilar

Acha mesmo que um programa com essas funções incluídas

// busca 'valor' na 'pa' de 'n_termos`
int busca(int pa[], unsigned n_termos, int valor);
// mostra 'pa' na tela. 'msg' = mensagem opcional
int mostra(
    int pa[], unsigned n_termos, int razao,
    const char* msg);
// calcula os valores e preenche os 'n_termos' da pa
// de razao 'razao' iniciando em 'inicial'
int preenche(
    int pa[], unsigned n_termos, int inicial, int razao);

Não tem a ver com o enunciado?

E com a saída que mostrei

teste com r = 1
    termo inicial: 1, razao: 1
    10 termos:
1  2  3  4  5  6  7  8  9  10
teste com r = -22
    termo inicial: -22, razao: -22
    10 termos:
-22  -44  -66  -88  -110  -132  -154  -176  -198  -220
res = 1
res = 1
res = 0
res: 1, float: 42.000000
res: 1, string: "ANSI"
res: 1, string: "0xff"

Com duas PA?

Talvez eu não tenha me explicado bem afinal.

Ansi C · 6 de maio de 2024

@arfneto

Pedi, por favor, que cite a fonte de:

3 horas atrás, arfneto disse:

Não funciona assim. 0xff não é um inteiro.

Só isso: A Fonte?

São essas as minhas dúvidas:

Uma fonte daquela afirmação;
Um programa conforme o enunciado com mesma pergunta e resposta;
E que compila.

Se puder responder acertadamente com o texto do enunciado, responda,

senão tudo bem!

Em 13/06/2022 às 20:07, DanielC4 disse:

Peça ao usuário que informe dois inteiros, sendo um valor inicial e uma razão. Preencha um vetor de 10 posições começando pelo valor inicial e incrementando-o com a razão (progressão aritmética - PA). Depois peça um número para que seja verificado se ele pertence à PA e informe o resultado na tela."

***

Desde agora, obrigado

Antecipadamente!

arfneto · 7 de maio de 2024

4 horas atrás, Ansi C disse:

Só isso: A Fonte?

Se os exemplos e a explicação que eu deixei nos post anteriores (que achei até detalhada) --- e quem sabe o debugger em seu computador --- não foram capazes de te fazer entender talvez deva fazer abrir um tópico e fazer uma pergunta objetiva. Não estou de fato respondendo individualmente a você, então não vou mais fugir do assunto PA. Se mais usuários tiverem dúvida semelhante à sua, nesse tópico, voltamos a isso. O forum não é, claro, suporte individualizado, e a pergunta vem de junho de 2022, de outro usuário, @DanielC4

A fonte é a realidade: scanf não aloca memória, espera apenas um ponteiro para onde transferir os dados obtidos. Se vai ler algo usando um especificador em hexadecimal esses dados vão ser transportados linearmente para aquele endereço e vão ser interpretados dependendo do tipo de dado cujo endereço foi passado.

Por isso pode ainda precisar considerar coisas como alinhamento de memória e endianess, porque vai ser feita uma transferência cega, como um memcpy, se acaso conhece. Entendeu a razão dessa linha

    const char ansi[20] = "49534E4100";

gerar "ANSI", no exemplo?

Rode o programa que te mostrei. Se mesmo assim não entender tente o debugger e veja a memória. Ou poste uma questão, para não fugir do tópico aqui.

Em mais uma tentativa de explicar isso, veja um exemplo usando o debugger da MS: com o programa rodando, veja a memória no printf() logo depois da chamada a scanf.

Não sei de sua experiência com essas coisas, seus posts não foram suficientes para eu ter uma ideia, mas imagino que saiba usar o gdb além do gcc, por exemplo.

    const char valor[] = "42280000";
    float      v_float = 0.;
    res = sscanf(valor, "%8x", (unsigned int *)&v_float);
    printf("res: %d, float: %f\n", res, v_float);

Essa linha mostra o endereço de v_float num debugger, com o programa parado nessa linha:

Então você vai lá na memória e examina esse endereço:

e vê que o valor da string em hexa foi simplesmente lido como valores abstratos e copiado para o endereço de v_float no endereço terminando em D4... scanf fez isso, na linha anterior: antes dela v_float valia zero.

Entenda que esse é o modelo de memória x64, então os ponteiros tem 64bits, e o programa está rodando numa máquina Intel não Itanium, então Little Endian. Se não souber o que são essas coisas abra outros tópicos.

Essa é a "fonte". Espero que possa entender. No caso de o alvo ser um int daria na mesma: os bytes são apenas transferidos. scanf() é uma mão na roda.

Sobre o tópico e a pergunta original vou apenas repetir os comentários e as funções que já expliquei:

// busca 'valor' na 'pa' de 'n_termos`
int busca(int pa[], unsigned n_termos, int valor);
// mostra 'pa' na tela. 'msg' = mensagem opcional
int mostra(
    int pa[], unsigned n_termos, int razao,
    const char* msg);
// calcula os valores e preenche os 'n_termos' da pa
// de razao 'razao' iniciando em 'inicial'
int preenche(
    int pa[], unsigned n_termos, int inicial, int razao);

e como usar? Isso no exemplo do post #8

    preenche(pa, 10, -22, -22);
    mostra(pa, 10, -22, "teste com r = -22\n");

gera

teste com r = -22
    termo inicial: -22, razao: -22
    10 termos:
-22  -44  -66  -88  -110  -132  -154  -176  -198  -220

Ainda tem mesmo uma pergunta sobre esse tópico?

Entendeu que é uma PA de razão -22 a partir de -22?

E como busca um valor na PA? De novo do exemplo

    res = busca(pa, 10, -22);
    printf("res = %d\n", res);
    res = busca(pa, 10, 0);
    printf("res = %d\n", res);

gera

res = 1
res = 0

e isso quer dizer que -22 foi encontrado e 0 não foi...

Espero ter ajudado a quem ainda não tenha entendido isso.

Em 04/05/2024 às 09:08, Ansi C disse:

É coluna densa de valores desconexos.

A propósito, o número que alguém entrou era um inteiro.

Sei que já perguntei antes 2x e não respondeu, mas isso foge da minha compreensão. Se alguém entendeu e puder explicar tem meu interesse. Sobre densidade de colunas e conexão de valores nesse contexto.