Arquivo da tag: C

Enésimo termo da sequência Fibonacci sem recursividade em C

O programa a seguir calcula e exibe um elemento da sequência Fibonacci. O programa foi construído sem o uso de recursividade.
O que deixa o código um pouco menos elegante, mas evita certas limitações da recursão frente à valores muito altos.

fib

//================================================================
// Descricao: O programa calcula e mostra o enésimo termo
//            da sequência Fibonacci sem uso de recursividade.
//================================================================

// Bibliotecas
#include <stdio.h>
#include <stdlib.h>

// Protótipo da função fibonacci
int fibonacci(int n);

// Função Principal
int main(int argc, char** argv) {
	int n;

    // Lê a posição do termo
    printf("Digite a posicao: ");
    scanf("%d", &n);

    // Imprime o termo
    printf("O termo: %d\n", fibonacci(n));

    system("pause");
    return 0;
}

// Função Fibonacci
int fibonacci(int n) {
	int anterior = 0,
		proximo = 1,
		aux,
  		i;

	// Se for o primeiro número da lista
	if(n == 1) {
		return 0;
	// Se for o segundo número da lista
 	} else if(n == 2) {
 		return 1;
	// Se for um número a partir da terceira posição
  	} else {
  		// Calcula os valores dois a dois até chegar na posição requerida
		for(i = 3; i <= n; i++) {
			aux = proximo;
			proximo = anterior + proximo;
			anterior = aux;
		}
		return proximo;
  	}
}

Gerador de Números Primos – C

primos
/*
 * Gera números primos a partir de um limite superior estabelecido.
 *
 */
#include <stdio.h>
#include <stdlib.h>

int main() {
    int n, nMax, i, j, totalDivisores;

    // Recebe o limite para exibição dos números primos
    printf("Digite o limite superior para os numeros primos(Minimo 2): ");
    scanf("%d", &nMax);

    // Verifica se o limite superior é um número válido
    // O menor número primo é 2
    while(nMax < 2) {
        system("cls");
        printf("Digite o limite superior para os numeros primos(Minimo 2): ");
        scanf("%d", &nMax);
    }

    // Verifica se o número é primo e imprime o valor na tela
    for(i = 0; i <= nMax; i++) {
        totalDivisores = 0;
        // Conta os divisores para verificar se o valor é primo
        for(j = 1; j <= i; j++) {
            if(i % j == 0) {
                totalDivisores++;
            }
        }
        // Se o total de divisores é dois, imprime o primo com formatação de 4 casas
        if(totalDivisores == 2) {
            printf("%4d ", i);
        }
    }

    printf("n");
    system("pause");
    return 0;
}

Jogo Adivinhe o Número

CUsersClaudionorDesktopgnumber.exe
//================================================================
// Descrição: Jogo "Adivinhe o número"
//================================================================

// Libs
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

// Função main
int main(int argc, char** argv)
{
    int n, x,  limite_inferior, limite_superior, acertou, tentativas;

    // Inicia o gerador de números aleatórios
    srand(time(NULL));

    // Inicaliza as variáveis
    acertou = 0;            // Verifica se o jogador acertou o número
    tentativas = 0;         // Total de tentativas
    limite_inferior = 0;    // Limite inferior
    limite_superior = 101;  // Limite superior
    n = (rand() % 100) + 1; // Número gerado aleatoriamente

    // Loop principal
    do {
        // Limpa a tela
        system("cls");

        // Imprime o total de tentativas e pede um número ao jogador
        printf("Total de tentativas: %dn", tentativas);
        printf("Digite um numero(Esta entre %d e %d): ", limite_inferior, limite_superior);
        scanf("%d", &x);

        // Aumenta em 1 o número de tentativas
        tentativas++;

        // Verifica se o jogador ganhou ou diminui os limites ao redor do número
        if(x > n) {
            limite_superior = x;
        } else if(x < n) {
            limite_inferior = x;
        } else {
            acertou = 1;
        }
    }while(!acertou);

    // Imprime o resultado após o jogador ganhar o jogo
    system("cls");
    printf("Parabens, o numero e: %dn", n);
    printf("Total de tentativas: %dn", tentativas);

    // Pausa o programa até alguma tecla ser pressionada
    system("pause");
    return 0;
}

Fatorial Sem Recursividade – C

fat
//================================================================
// Descrição: Mostra o fatorial de um dado número sem
//            recursividade
//================================================================

// Libs
#include <stdio.h>
#include <stdlib.h>

// Função main
// Main Function
int main(int argc, char** argv)
{
 int n, fatorial, i;

 printf("Digite o numero: ");
 scanf("%d", &n);

 // Calcula o fatorial
 fatorial = 1;
 for(i = n; i > 0; i--) {
    fatorial *= i;
 }

 printf("Fatorial de %d: %dn", n, fatorial);

 system("pause");
 return 0;
}

Fatorial Com Recursividade – C

fatrec
//================================================================
// Descrição: Mostra o fatorial de um dado número com
//            recursividade
//================================================================

// Protótipo da função fatorial
int fatorial(int n);

// Libs
#include
#include

// Função main
// Main Function
int main(int argc, char** argv)
{
 int n, i;

 printf("Digite o numero: ");
 scanf("%d", &n);

 printf("Fatorial de %d: %dn", n, fatorial(n));

 system("pause");
 return 0;
}

// Função do fatorial
int fatorial(int n) {
    if(n == 0) {
        return 1;
    } else {
        return n * fatorial(n-1);
    }
}
decimal

Conversão Decimal para Binário – C

Você precisa converter um número decimal para binário em C e agora?

Por meio desse programa você vai poder entender como e porque é simples realizar essa tarefa de uma forma elegante e rápida.

A forma aqui apresentada tem um olhar diferente se comparada a forma manual de conversão em que realizamos sucessivas divisões do número por 2 e agrupamos os restos para gerar o resultado.

Tomamos como base um inteiro de 32 bits para realizar nossa conversão. O que faremos é verificar bit a bit em cada uma das 32 posições o seu valor e o imprimir na tela (1 ou 0), até formar o número desejado.

Esse algoritmo segue os seguintes passos para alcançar nosso objetivo:

  1. Lê o número
  2. Para cada bit, realiza uma operação de deslocamento até à última casa da esquerda para direita
  3. Realiza uma operação lógica & com o número 1, tendo como resultado 0 ou 1, que será impresso na tela até formar o nosso número desejado.

//================================================================
// Descrição: Lê um número decimal e imprime a sua forma binária
//================================================================
 
// Libs
#include <stdio.h>
#include <stdlib.h>
 
// Função Main
int main() {
 int n; // Número de entrada
 int r; // Resultado do deslocamento
 int i; // Contador
 
 // Lê o número
 printf("Digite o numero: ");
 scanf("%d", &n);
 
 // Utiliza um número de 32 bits como base para a conversão.
 for(i = 31; i >= 0; i--) {
	// Executa a operação shift right até a 
 	// última posição da direita para cada bit.
	r = n >> i;
 		
	// Por meio do "e" lógico ele compara se o valor 
 	// na posição mais à direita é 1 ou 0 
	// e imprime na tela até reproduzir o número binário.
	if(r & 1) {
		printf("1");
	} else {
 	 	printf("0");
	}
 }
 
 printf("\n");
 
 system("pause");
}

Continua com dúvidas? Tem uma sugestão diferente da abordada? Deixe um comentário, vamos discutir e construir conhecimento.

Enésimo termo da sequência Fibonacci – C

fib

//================================================================
// Descrição: O programa calcula e imprime o enésimo termo
//            da sequência Fibonacci, de forma recursiva
//================================================================

// Libs
#include <stdio.h>
#include <stdlib.h>

// Protótipo da função fibonacci
int fibonacci(int n);

// Função main
// Main Function
int main(int argc, char** argv)
{
    int n;
    
    // Lê a posição do termo
    printf("Digite a posicao: ");
    scanf("%d", &n);
    
    // Imprime o termo
    printf("O termo: %dn", fibonacci(n));
    
    system("pause");
    return 0;
}

// Função fibonacci
int fibonacci(int n) {
    if(n == 1) {
        return 0;
    } else if(n == 2) {
        return 1;
    } else {
        return fibonacci(n-1) + fibonacci(n-2);
    }
}

Fórmula de Bháskara – C

//================================================================
// Descricao: O programa calcula e mostra o resultado de uma
// equacao do segundo grau.
//================================================================

// Libs
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

// Funcaoo main
// Main Function
int main(int argc, char** argv)
{
 float a, b, c, x1, x2, delta;

 // Le os termos da equacao
 printf("Digite o valor do termo a: ");
 scanf("%f", &a);
 printf("Digite o valor do termo b: ");
 scanf("%f", &b);
 printf("Digite o valor do termo c: ");
 scanf("%f", &c);

 // Calcula o valor de x1
 delta = b*b - 4*a*c;
 x1 = (-b + sqrt(delta)) / (2*a);
 x2 = (-b - sqrt(delta)) / (2*a);

 // Imprime os resultados
 if(delta < 0) {
 printf("A equacao nao possui raizes reais.n");
 } else {
 printf("O valor de x1: %.2fn", x1);
 printf("O valor de x2: %.2fn", x2);
 }

 system("pause");
 return 0;
}

Pixels Aleatórios em SDL – C

/*
 * Desc: O programa desenha pixels em posições e cores aleatórias
 *       usando a função putpixel, que pode ser encontrada na
 *       documentação da SDL, na parte de exemplos.
 */
#include <stdlib.h>
#include <time.h>
#include <SDL/SDL.h>

// Set the pixel
void putpixel(SDL_Surface *surface, int x, int y, Uint32 pixel);

// Variavel que representa a tela
SDL_Surface *screen = NULL;

// Ponto inicial da aplicação
int main(int argc, char *argv[])
{
    // Coordenadas do pixel
    int x, y;
    // Cor do pixel
    Uint32 pixel;
    // Flag de encerramento
	int bExit = 0;
	
	// Inicia o gerador de números aleatórios
	srand(time(NULL));
	
	// Inicializa a SDL com o Video e Audio
	if((SDL_Init(SDL_INIT_VIDEO) == -1))
		return 1;
    
	// Define a resolução 640x480 e 16 bits com "Double Buffer"
    screen = SDL_SetVideoMode(640, 480, 16, SDL_SWSURFACE | SDL_DOUBLEBUF);
	if (screen == NULL)
		return 2;
		
	// Muda o titulo da janela
	SDL_WM_SetCaption("Pixels Aleatórios - SDL", NULL);
	
	// Pinta a tela de azul
    SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 255));
	
	// Laço principal do programa
	while (!bExit)
	{
		SDL_Event  evento;

		// Verifica os eventos pendentes
		while (SDL_PollEvent(&evento))
		{
			switch (evento.type)
			{
				case SDL_KEYDOWN:
					// Verifica se foi pressionado uma tecla
 					switch(evento.key.keysym.sym)
					{
						case SDLK_ESCAPE:
							// Se a tecla foi ESC então sai
							bExit = 1;
							break;
					}
					break;
					
				case SDL_QUIT:
					// Se foi selecionador para fechar a janela
					bExit = 1;
					break;
			}
		}
		
		// Gera posições e uma cor aleatória
		x = rand() % 640;
		y = rand() % 480;
		pixel = SDL_MapRGB(screen->format, rand() % 256, rand() % 256, rand() % 256);
		
		// Pinta o pixel na tela
		putpixel(screen, x, y, pixel);
  		
		// Executa o Flip (vira o "Double Buffer")
		SDL_Flip(screen);
	}
	
	// Libera a memória alocada para a tela
	SDL_FreeSurface(screen);

	// Finaliza a biblioteca SDL e a aplicação
	SDL_Quit();
	
	return 0;
}

/*
 * Set the pixel at (x, y) to the given value
 * NOTE: The surface must be locked before calling this!
 */
void putpixel(SDL_Surface *surface, int x, int y, Uint32 pixel)
{
    int bpp = surface->format->BytesPerPixel;
    /* Here p is the address to the pixel we want to set */
    Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;

    switch(bpp) {
    case 1:
        *p = pixel;
        break;

    case 2:
        *(Uint16 *)p = pixel;
        break;

    case 3:
        if(SDL_BYTEORDER == SDL_BIG_ENDIAN) {
            p[0] = (pixel >> 16) & 0xff;
            p[1] = (pixel >> 8) & 0xff;
            p[2] = pixel & 0xff;
        } else {
            p[0] = pixel & 0xff;
            p[1] = (pixel >> 8) & 0xff;
            p[2] = (pixel >> 16) & 0xff;
        }
        break;

    case 4:
        *(Uint32 *)p = pixel;
        break;
    }
}

Substring – C

//================================================================
// Nome Do Arquivo: string_substring.c
// File Name: string_substring.c
//
// Descrição: O programa retorna uma string a partir de um dado
//            intervalo: [start, end[
//================================================================

// Libs
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// Protótipo da função
char* string_substring(char str[], int start, int end);

// Função main
// Main Function
int main(int argc, char** argv)
{
 char str[100], *sub;
 int start, end;
 
 // Lê a string
 printf("Digite a string: ");
 gets(str);
 printf("Digite a posição inicial: ");
 scanf("%d", &start);
 printf("Digite a posição final: ");
 scanf("%d", &end);
 
 // Retorna a substring
 sub = string_substring(str, start, end);
 
 // Imprime a substring
 printf("A substring: %sn", sub);
 
 system("pause");
 return 0;
}

char* string_substring(char str[], int start, int end) {
    int i, j;
    char *sub; 
    
    // Verifica valores incompatíveis e 
    // retorna NULL
    if(start >= end || end > strlen(str)) {
        return NULL;
    }
    
    // Aloca memória para a substring
    sub = (char *) malloc(sizeof(char) * (end - start + 1));
    
    // Copia a substring para a variável
    for(i = start, j = 0; i < end; i++, j++) {
        sub[j] = str[i];
    }
    
    // Terminador de string
    sub[j] = '&#092;&#048;';
    
    return sub;
}