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

[lohayne27]

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

[Ansi C]

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