Algoritmos

Algoritmo MDC (máximo divisor comum) em C

Seguindo os algoritmos, vou postar agora o algoritmo de MDC (Máximo Divisor Comum) utilizando função recursiva, um método rápido e fácil para encontrar o

MDC

.
O mesmo é encontrado em vários lugares e existem vários modos de serem feitos, porém o método que eu escolhi para calcular foi com função recursiva.
Uma breve explicação da função é que, o retorno dela, é ela mesma utilizando os parâmetros atualizados, sendo assim, enquanto calcula, vai retornando os novos valores para a função até achar o valor calculado.
Como eu disse, existem vários métodos a serem feitos, caso alguém queira dar alguma dica só comentar. :D

//
//  MDC.c
//  Máximo Divisor Comum
//
//  Created by Ayrton Jose Lopes on 03/06/13.
//  Copyright (c) 2013 Ayrton Jose Lopes. All rights reserved.
//

#include <stdio.h>

int tor= 0, i= 0;

/* Função recursiva que retorna o valor do MDC */
int mdc(int n, int d){
    if (d== 0) {
        return n;
    }
    else {
        return mdc(d, n%d);
    }
}

int main(){
    int n= 0, d= 0;
    scanf("%d", &tor);
    for (i= 0; i< tor; i++) {
        scanf("%d %d", &n, &d);
        printf("%d\n", mdc(n, d));
    }
    return 0;
}

O algoritmo imprime somente o valor calculado.

OBS:

Os algoritmos são testados no linux e todos estão funcionando.

Algoritmo conversão de base em C(binário, octal e hexadecimal)

Olá galera, tudo certo? Como estudante de computação, todos chegamos em um momento para fazer o tal “algoritmo de conversão de base”. Fiz ele com funções e procedimentos. Creio eu que ficou bem comentado, caso alguém tenha dúvida só comentar que eu respondo.

//
//  conversao_de_bases.c
//  conversão de Base
//
//  Created by Ayrton Jose Lopes on 23/06/13.
//  Copyright (c) 2013 Ayrton Jose Lopes. All rights reserved.
//


#include <stdio.h>
#include <string.h>
#include <math.h>
#define valorMaximo 100

/* Declaração de Variáveis Globais */

char valorBase[valorMaximo]; // Vetor que armazena o valor convertido
int valorDecimal;

/* Fim da declaração*/

/* Procedimento que inverte as posições do vetor*/
void inverteVetor(char *Vet, int count){
    int j= 0, k= 0; // contadores do laço
    char aux[valorMaximo]; // variavel auxiliar de troca
    j= 0;
    k= count-1;
    while (j < k) {
        aux[j]= Vet[j];
        Vet[j]= Vet[k];
        Vet[k]= aux[j];
        j++;
        k--;
    }
}
/* Fim do Procedimento */

/* Função que converte um número decimal para as bases de 2, 8 e 16 */
char* decToAll(int decValue, int Base){
    int i= 0, value= 0;
    while (decValue) {
        value= decValue%Base;
        /* Caso a base seja menor do que 10 ou o resto menor que 10 (no caso de outras bases maiores do que 10 terem restos maiores que 11)
         irá fazer o cálculo normal de resto, acrescentando no vetor o valor convertido 
         OBS: soma-se +48 (valor na tabela asci cujo valor é 0) pois está sendo acrescentado em um vetor de char, e não de inteiro ou flutuante */
        if (Base<= 10 || value< 10) {
            valorBase[i]= value+48;
        }
        /* Se o restor for maior do que 11, ele irá fazer o call na função que converte os restos em letras, e irá acrescentar no vetor */
        else {
            valorBase[i]= value+55;
        }
        decValue/= Base;
        i++;
    }
    valorBase[i]= '\0';
    inverteVetor(valorBase, i);
    return valorBase;
}
/* Fim da função */

/* Função que converte de qualquer base para decimal */
int allToDec(char *Num, int Base){
    int tamanho= 0;
    tamanho= (int)strlen(Num);
    inverteVetor(Num, (int)strlen(Num));
    for (int i= 0; i< tamanho; i++) {
        /* Se o valor está entre os números na tabela ascii, diminui-se 48 para calcular o valor */
        if (Num[i]>= 48 && Num[i]<= 59) {
            valorDecimal+= pow(Base, i)*(Num[i]-48);
        }
        /* Caso o valor não seja os números (tabela ascii), subtrai-se 65 valor A e soma-se 10 para calcular o valor */
        else {
            valorDecimal+= pow(Base, i)*(Num[i]-65+10);
        }
    }
    return valorDecimal;
}
/* Fim da função*/

/* Função que escolhe a opção de conversão de base*/
void convertion(int valueOption){
    int value= 0, base= 0;
    switch (valueOption) {
        case 1:
            printf("Digite um número de decimal para converter: ");
            scanf("%d", &value);
            printf("Digite a base para qual deseja converter (2, 8 e 16): ");
            scanf("%d", &base);
            printf("O valor convertido é: %s", decToAll(value, base));
            break;
            
        case 2:
            printf("Digite um número em binário para converter para qualquer base: ");
            scanf("%s", valorBase);
            printf("Digite a base para qual deseja converter (8, 10 e 16): ");
            scanf("%d", &base);
            printf("O valor convertido é: %s", decToAll(allToDec(valorBase, 2), base));
            break;
            
        case 3:
            printf("Digite um número em octal converter para qualquer base: ");
            scanf("%s", valorBase);
            printf("Digite a base para qual deseja converter (2, 10 e 16): ");
            scanf("%d", &base);
            printf("O valor convertido é: %s", decToAll(allToDec(valorBase, 8), base));
            break;
            
        case 4:
            printf("Digite um número em octal converter para qualquer base: ");
            scanf("%s", valorBase);
            printf("Digite a base para qual deseja converter (2, 8 e 10): ");
            scanf("%d", &base);
            printf("O valor convertido é: %s", decToAll(allToDec(valorBase, 16), base));
            break;
            
        default:
            break;
    }
}
/* Fim do procedimento */

int main(){
    int choose= 0, option= 0;
    
    printf("1-Conversão de bases.\n");
    printf("Escolha uma opção: ");
    scanf("%d", &choose);
    printf("\n");
    //Switch que escolhe a opção desejada pelo usuário
    switch (choose) {
        case 1:
            printf("Digite um valor de 1 até 6\n\n");
            printf("1-Decimal para qualquer base.\n");
            printf("2-Binário para qualquer base.\n");
            printf("3-Octal para qualquer base.\n");
            printf("4-Hexadecimal para qualquer base.\n");
            printf("Opção: ");
            scanf("%d", &option);
            convertion(option);
            break;
            
        default:
            break;
    }
    
    return 0;
}

OBS:

O código está foi compilado no GCC e está 100% funcional, não testei no windows, por isso não sei dizer se está funcionando ou não.

OBS 2:

Apesar de eu ter comentado somente as bases de 2, 8, 10 e 16, funciona para conversão de qualquer base abaixo de 16.
Obrigado e até a próxima :D