Ir ao conteúdo
  • Cadastre-se
lohayne27

C++ função que determine a posição dos dígitos

Recommended Posts

Boa noite

Eu estou com muita dificuldade para fazer uma parte do código, na qual  devo criar uma função que me retorne a posição dos dígitos de um numero inteiro.

Por exemplo , numero 546

       posição= 012

5 na posição 0,4 na posição 1,6 na posição 2.

desde já agradeço pela ajuda

Compartilhar este post


Link para o post
Compartilhar em outros sites

Função completa e teste

Digito_Posicao.c

Spoiler

/*  =========================================================================
    Linguagem: C'11 Compilador 4.9.2 GCC mingW32 Thread model: posix
     Programa: Digito_Posicao.c
         Data: 12 / 4 / 2018    13:10
        Autor: Mauro Britivaldo
    =========================================================================  */

/*  INCLUDE */
/*  Incluir permite chamar as funçőes ou macros */
#include <stdio.h>  /* printf; puts; scanf; ...*/
#include <assert.h> /* assert; ... */
#include <inttypes.h>/* uintmax_t; ...*/

/*  DEFINE */
/*  Definir o macro customizado */
#define posicao_t unsigned/* se é posiçăo só pode ser năo negativo */
#define decimal_t uintmax_t/* tipo padrăo inteiro sem sinal max bits */
#define IOdecimal "%"PRIuMAX/* mascara de dados para entrada/saída */
#define POSICAO_INVALIDA exp/* etiqueta de exception */

/*  ------------------------------------------------ DIGITO_NA_POSICAO ------
    Funçăo DIGITO_NA_POSICAO

    PROPÓSITO:   Retorna o dígito correspondente ao índice solicitado

    PARÂMETROS:
          indice (IN) -- posição da qual deseja identificar o dígito
          numero (IN) -- conjunto de dígito / número decimal positivo

    RETORNA:     Sem bem sucedido o dígito identificado na posiçăo de número

    ERROS:       Caso solicite a posição para índices maiores que o mais
          significativo e se o número for negativo.


    ALGORITMO:   Sistema decimal é de base 10. Tem cada casa na sequência
          assim é produto da potência de 10. O expoente da potência é a
          posição da unidade a partir do 0; da direita para esquerda.
          Exemplo:

          [!]O símbolo ( ^ ) representa operação de potência
          Base ^ Expoente * Dígito = Casa Decimal.
          Valor = Soma de todas as Casa Decimais
          Base = 10

          Se Valor = 2018 Então

                  3 2 1 0  = Expoentes
                  2 0 1 8  = Dígito

            8 * (10 ^ 0 =    1) =    8
            1 * (10 ^ 1 =   10) =   10
            0 * (10 ^ 2 =  100) =  000
            2 * (10 ^ 3 = 1000) = 2000
                                  ----+
                                  2018

          Observe que o enunciado do problema é logicamente inverso
          as casas decimais, porque para a questão o índice mais
          significativo é o menor índice 0. Que na ordem computacional dos
          dos números decimais é o menos significativo.

          ###### ETAPAS DO PROCESSO
          INICIO
            1# Step/> Fazer cópia do número
            2# Step/> Determinar a base decimal do dígito mais significativo
            3# Step/> Fazer cópia de número, Escaner o valor índice até 0
            3.1# Step/> Fazer a cópia perde o dígito mais significativo a
               cada intereção de decremento no índice
            3.2# Step/> Testar se ainda tem dígitos e se ainda tem índices
               se a base for igual a 0 finalizar com erro.
            3.3# Step/> Se índice for igual a zero finaliza escanear e
               retorna a divisão do dígito mais significativo restante
               pela sua base correspondente.
          FINAL
    Resolve.
    -------------------------------------------------------------------------  */
decimal_t digito_na_posicao_( posicao_t indice, decimal_t numero ){
/*  VARIÁVEIS  */
  register decimal_t valor;/* backup de  numero */
  register posicao_t exp;/* base decimal do dígito mais significativo na
                            variável: numero */

    exp   = 1;/* atribuir valor 1 */
    valor = numero;/* atribuir o valor em var: numero */
    while( valor /= 10 ){/* dividir por 10, atribuir o resultado fazer até
    que valor tenha 0 */
             exp *= 10;/* multiplicar por 10, atribuir o resultado */}
    valor  = numero;/* atribuir o valor em var: numero */
    while( indice-- ){/* fazer até que o decremento seja igual a 0 */
             valor %= exp;/* modular pelo valor em var: exp, atribuir o
             resultado */
             exp /= 10u;/* dividir por 10, atribuir o resultado */
             assert( POSICAO_INVALIDA );/* Testar se o valor em exp é sezo,
             se verdadeiro então finalizar rotina com erro */ }
  return( valor / exp );/* retorna o valor do dígito identificado */ }

/*  ------------------------------------------------------------- MAIN ------  */
int main( void ){
/*  VARIÁVEIS */
  posicao_t indice;/* índice do valor a ser identificado */
  decimal_t numero;/* base / conjunto de elementos de valor */

    puts("[ -- ] FUNCAO: DIGITO NA POSICAO" );
    printf( "[ << ] Entre com numero: " );
    scanf( IOdecimal, &numero );
    printf( "[ << ] Entre com indice: " );
    scanf( "%u", &indice );

    printf( "[ >> ] O digito "IOdecimal" foi identificado!\n",
               digito_na_posicao_( indice, numero ));

    printf( "[ Ok ] Fim da funcao.\n");
    return 0; }

 

Debugger Online: Digito_Posicao

Posição Inteiro Dígito Função Documentação   

:thumbsup:

 

DigitoPosicao.png

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

Crie uma conta ou entre para comentar

Você precisar ser um membro para fazer um comentário

Criar uma conta

Crie uma nova conta em nossa comunidade. É fácil!

Crie uma nova conta

Entrar

Já tem uma conta? Faça o login.

Entrar agora





Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas publicações sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×