Arquivo do autor:admin

Fatorial com Recursividade – Ruby

1 resposta

Administrador Prompt de Comando

#================================================================
# Descrição: Mostra o fatorial de um dado número recursivamente
#================================================================

# Função recursiva do fatorial
def fatorial(n)
	if(n > 1)
		return n * fatorial(n-1)
	else
		return 1
	end
end

# Lê um valor e converte em um número inteiro
puts "Digite um numero: "
n = gets.to_i()

# Calcula o fatorial
fat = fatorial(n)

#Converte os números em texto e imprime o fatorial do número	
puts "Fatorial de " + n.to_s + ": " + fat.to_s

Fatorial sem Recursividade – Ruby

Deixe um comentário 
Administrador Prompt de Comando

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

# Lê um valor e converte em um número inteiro
puts "Digite um numero: "
n = gets.to_i()

# Calcula o fatorial
fatorial = 1
for i in 1..n
	fatorial = fatorial * i
end

#Converte os números em texto e imprime o fatorial do número
puts "Fatorial de " + n.to_s + ": " + fatorial.to_s

Fatorial Sem Recursividade – C

Deixe um comentário 
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

Deixe um comentário 
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

1 resposta

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

Deixe um comentário

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

3 respostas 

//================================================================
// 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

Deixe um comentário 

/*
 * 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

Deixe um comentário 

//================================================================
// 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;
}