Last active
January 30, 2023 00:52
-
-
Save HiroNakamura/d5323a3aff5d5fc7b85607ec8831ddeb to your computer and use it in GitHub Desktop.
Programación en lenguaje C, 2da parte
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
#include<stdio.h> | |
#include<stdlib.h> | |
#include<conio.h> | |
int pwstatus[8] = { 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 } ; | |
int pbstatus[8] = { 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 } ; | |
char board[8][8] = { | |
{ 'R' , 'H' , 'C' , 'K' , 'Q' , 'C' , 'H' , 'R' }, | |
{ 'P' , 'P' , 'P' , 'P' , 'P' , 'P' , 'P' , 'P' }, | |
{ ' ' , ' ' , ' ' , ' ' , ' ' , ' ' , ' ' , ' ' }, | |
{ ' ' , ' ' , ' ' , ' ' , ' ' , ' ' , ' ' , ' ' }, | |
{ ' ' , ' ' , ' ' , ' ' , ' ' , ' ' , ' ' , ' ' }, | |
{ ' ' , ' ' , ' ' , ' ' , ' ' , ' ' , ' ' , ' ' }, | |
{ 'p' , 'p' , 'p' , 'p' , 'p' , 'p' , 'p' , 'p' }, | |
{ 'r' , 'h' , 'c' , 'k' , 'q' , 'c' , 'h' , 'r' } | |
}; | |
void display(); | |
void change( int , int , int , int ) ; | |
void pawn(int , int ) ; | |
void rook(int , int ) ; | |
void horse(int , int ) ; | |
void camel( int , int ) ; | |
void king( int , int ) ; | |
void queen( int , int ) ; | |
void pawnb( int , int ) ; | |
void player1(); | |
void player2(); | |
int check(int , int ) ; | |
int check2(int , int ) ; | |
main() | |
{ | |
int x = 0 ; | |
char ch ; | |
printf( "\n\tWELCOME TO CHESS GAME" ) ; | |
printf( "\n\n\t By Shreeji , Neel , Kirtan " ) ; | |
getch(); | |
system( "cls" ) ; | |
do | |
{ | |
x++ ; | |
system( "cls" ) ; | |
display(); | |
if( (x%2) == 0 ) | |
{ | |
player2(); | |
} | |
else | |
{ | |
player1(); | |
} | |
printf( " \n\nPress Enter To Continue ! \n\n " ) ; | |
ch = getch(); | |
}while( ch == 13 ) ; | |
} | |
void display() | |
{ | |
int i , j , k ; | |
printf( " " ) ; | |
for( i=0 ; i<8 ; i++ ) printf( " %d" , i ) ; printf( "\n" ) ; | |
for( k=0 ; k<8 ; k++ ) | |
{ | |
printf( " " ) ; | |
for( i=0 ; i<42 ; i++ ) { printf( "-" ) ; } printf( "\n" ) ; printf( "%d " , k ) ; | |
for( j=0 ; j<8 ; j++ ) { printf( "|| %c " , board[k][j] ) ; } | |
printf( "|| \n" ) ; | |
} | |
printf( " " ) ; | |
for( i=0 ; i<42 ; i++ ) { printf( "-" ) ; } printf( "\n" ) ; | |
} | |
void change( int r1 , int c1 , int r2 , int c2 ) | |
{ | |
char temp ; | |
temp = board[r1][c1] ; | |
board[r1][c1] = board[r2][c2] ; | |
board[r2][c2] = temp ; | |
} | |
void pawn( int r1 , int c1 ) // paido | |
{ | |
pwstatus[c1]++; | |
printf( "Available are: \n" ) ; | |
if( pwstatus[c1] == 1 ) | |
{ | |
if( board[r1+1][c1] == ' ' ) | |
printf( "%d%d , " , r1+1 , c1 ) ; | |
if( board[r1+2][c1] == ' ' ) | |
printf( "%d%d , " , r1+2 , c1 ) ; | |
} | |
else | |
{ | |
if(board[r1+1][c1] == ' ' ) | |
printf( "%d%d , " , r1+1 , c1 ) ; | |
if( check(r1+1 , c1+1) == 1 ) | |
printf( "%d%d* , " , r1+1 , c1+1 ) ; | |
if( check(r1+1 , c1-1) == 1 ) | |
printf( "%d%d* , " , r1+1 , c1-1 ) ; | |
} | |
} | |
void rook( int r1 , int c1 ) | |
{ | |
int i , j , n ; | |
printf( "Available are: \n" ) ; | |
n=c1; | |
printf( "Horizontally: \n" ) ; | |
while( board[r1][n-1] == ' ' ) | |
{ | |
if( n == 0 ) { break ; } | |
printf( "%d%d , " , r1 , n-1 ) ; | |
n-- ; | |
} | |
n=c1 ; | |
while( board[r1][n+1] == ' ' && (n+1) <= 7 ) | |
{ | |
printf( "%d%d , " , r1 , n+1 ) ; | |
++n ; | |
} | |
printf( "\nVertically:\n" ) ; | |
n = r1 ; | |
while( board[n-1][c1] == ' ' && n > -1 ) | |
{ | |
printf( "%d%d , " , n-1 , c1 ) ; | |
--n ; | |
} | |
n = r1 ; | |
while( (board[n+1][c1] == ' ') && ( (n) <= 7 ) ) | |
{ | |
printf( "%d%d , " , n+1 , c1 ) ; | |
++n ; | |
} | |
} | |
void horse( int r1 , int c1 ) | |
{ | |
printf( "Available are: " ) ; | |
if( board[r1+2][c1+1] == ' ' ) printf( "%d%d, " , r1+2 ,c1+1) ; | |
if( board[r1+2][c1-1] == ' ' ) { if( (c1-1) > -1 ) printf( "%d%d, " , r1+2, c1-1 ) ; } | |
if( board[r1+1][c1+2] == ' ' ) { if( (c1+2) != 8 ) printf( "%d%d, " , r1+1 , c1+2 ) ; } | |
if( board[r1-1][c1+2] == ' ' ) { printf( "%d%d, " , r1-1 , c1+2 ) ; } | |
if( board[r1-2][c1-1] == ' ' ) | |
{ | |
if( (c1-1) != -1 ) | |
printf( "%d%d, " , r1-2 , c1-1 ) ; | |
} | |
if( board[r1-2][c1+1] == ' ' ) printf( "%d%d, " , r1-2 , c1+1 ) ; | |
if( board[r1+1][c1-2] == ' ' ) printf( "%d%d, " , r1+1 , c1-2 ) ; | |
if( board[r1-1][c1-2] == ' ' ) | |
{ | |
if( (c1-2) != -1 ) | |
printf( "%d%d, " , r1-1 , c1-2 ) ; | |
} | |
} | |
void camel( int r1 , int c1 ) | |
{ | |
int a , b , c , d ; | |
printf( "Available are: \n" ) ; | |
a = 1 , b = 1 ; | |
while( board[r1-a][c1+b] == ' ' ) | |
{ | |
if( (r1-a) == -1 || (c1+b) == 8 ) break ; | |
printf( "%d%d , " , r1-a , c1+b ) ; | |
a++ ; | |
b++ ; | |
} | |
a = 1 , b = 1 ; | |
while( board[r1+a][c1-b] == ' ' ) | |
{ | |
if( (r1+a) == 8 || (c1-b) == -1 ) break ; | |
printf( "%d%d , " , r1+a , c1-b ) ; | |
a++ ; | |
b++ ; | |
} | |
a = 1 , b = 1 ; | |
while( board[r1+a][c1+b] == ' ' ) | |
{ | |
if( (r1+a) == 8 || (c1+b) == 8 ) break ; | |
printf( "%d%d , " , r1+a , c1+b ) ; | |
a++ ; | |
b++ ; | |
} | |
a = 1 ; | |
b = 1 ; | |
while( board[r1-a][c1-b] == ' ' ) | |
{ | |
if( (r1-a) == -1 || (c1-b) == -1 ) break ; | |
printf( "%d%d , " , r1-a , c1-b ) ; | |
a++ ; | |
b++ ; | |
} | |
} | |
void king( int r1 , int c1 ) | |
{ | |
printf( "Available are: " ) ; | |
if( board[r1][c1+1] == ' ' ) printf( "%d%d , " , r1 , c1+1 ) ; | |
if( board[r1][c1-1] == ' ' ) printf( "%d%d , " , r1 , c1-1 ) ; | |
if( board[r1+1][c1] == ' ' ) printf( "%d%d , " , r1+1 , c1 ) ; | |
if( board[r1-1][c1] == ' ' ) printf( "%d%d , " , r1-1 , c1 ) ; | |
if( board[r1+1][c1+1] == ' ' ) printf( "%d%d , " , r1+1 , c1+1 ) ; | |
if( board[r1-1][c1-1] == ' ' ) printf( "%d%d , " , r1-1 , c1-1 ) ; | |
if( board[r1-1][c1+1] == ' ' ) printf( "%d%d , " , r1-1 , c1+1 ) ; | |
if( board[r1+1][c1-1] == ' ' ) printf( "%d%d , " , r1+1 , c1-1 ) ; | |
} | |
void queen( int r1 , int c1 ) | |
{ | |
int x=1 , y=1 , a , b ; | |
printf( "Available are: " ) ; | |
printf( "Horizontal: " ) ; | |
while( board[r1][c1-y] == ' ' ) | |
{ | |
if( (c1-y) == -1 ) break ; | |
printf( "%d%d , " , r1 , c1-y ) ; | |
y++ ; | |
} | |
y = 1 ; | |
while( board[r1][c1+y] == ' ' ) | |
{ | |
if( (c1+y) == 8 ) break ; | |
printf( "%d%d , " , r1 , c1+y ) ; | |
y++ ; | |
} | |
printf( "Vertical: " ) ; | |
x = 1 ; | |
while( board[r1-x][c1] == ' ' ) | |
{ | |
if( (r1-x) == -1 ) break ; | |
printf( "%d%d , " , r1-x , c1 ) ; | |
x++ ; | |
} | |
x = 1 ; | |
while( board[r1+x][c1] == ' ' ) | |
{ | |
if( (r1+x) == 8 ) break ; | |
printf( "%d%d , " , r1+x , c1 ) ; | |
x++ ; | |
} | |
printf( "Diagonally: " ) ; | |
a = 1 , b = 1 ; | |
while( board[r1-a][c1+b] == ' ' ) | |
{ | |
if( (r1-a) == -1 || (c1+b) == 8 ) break ; | |
printf( "%d%d , " , r1-a , c1+b ) ; | |
a++ ; | |
b++ ; | |
} | |
a = 1 , b = 1 ; | |
while( board[r1+a][c1-b] == ' ' ) | |
{ | |
if( (r1+a) == 8 || (c1-b) == -1 ) break ; | |
printf( "%d%d , " , r1+a , c1-b ) ; | |
a++ ; | |
b++ ; | |
} | |
a = 1 , b = 1 ; | |
while( board[r1+a][c1+b] == ' ' ) | |
{ | |
if( (r1+a) == 8 || (c1+b) == 8 ) break ; | |
printf( "%d%d , " , r1+a , c1+b ) ; | |
a++ ; | |
b++ ; | |
} | |
a = 1 ; | |
b = 1 ; | |
while( board[r1-a][c1-b] == ' ' ) | |
{ | |
if( (r1-a) == -1 || (c1-b) == -1 ) break ; | |
printf( "%d%d , " , r1-a , c1-b ) ; | |
a++ ; | |
b++ ; | |
} | |
} | |
void pawnb( int r1 , int c1 ) // paido black | |
{ | |
pbstatus[c1]++; | |
printf( "Available are: \n" ) ; | |
if( pbstatus[c1] == 1 ) | |
{ | |
if( board[r1-1][c1] == ' ' ) | |
printf( "%d%d , " , r1-1 , c1 ) ; | |
if( board[r1-2][c1] == ' ' ) | |
printf( "%d%d , " , r1-2 , c1 ) ; | |
} | |
else | |
{ | |
if(board[r1-1][c1] == ' ' ) | |
printf( "%d%d , " , r1-1 , c1 ) ; | |
if( check2(r1-1 , c1-1) == 1 ) | |
printf( "%d%d* , " , r1-1 , c1-1 ) ; | |
if( check2(r1-1 , c1+1) == 1 ) | |
printf( "%d%d* , " , r1-1 , c1+1 ) ; | |
} | |
} | |
void player1() | |
{ | |
int p1 , p2 , c1 , r1 , c2 , r2; | |
printf( "\nPLAYER 1 - Big Case\n" ) ; | |
again1: | |
printf( "\nEnter Position of Element to change ( RC ): " ) ; | |
scanf( "%d" , &p1 ) ; | |
c1 = p1 % 10 ; | |
r1 = p1 / 10 ; | |
switch( board[r1][c1] ) | |
{ | |
case 'P': pawn( r1 , c1 ); | |
break ; | |
case 'R': rook( r1 , c1 ) ; | |
break ; | |
case 'H': horse( r1 , c1 ); | |
break ; | |
case 'C': camel( r1 , c1 ); | |
break ; | |
case 'K': king( r1 , c1 ) ; | |
break ; | |
case 'Q': queen( r1 , c1 ) ; | |
break ; | |
default: printf("Invalid Position ! ") ; goto again1 ; | |
} | |
printf( "\nEnter Position of Place to Send ( RC ): " ) ; | |
scanf( "%d" , &p2 ) ; | |
c2 = p2 % 10 ; | |
r2 = p2 / 10 ; | |
change(r1,c1,r2,c2) ; | |
} | |
void player2() | |
{ | |
int p1 , p2 , c1 , r1 , c2 , r2; | |
printf( "\nPLAYER 2 - Small Case \n") ; | |
again2: | |
printf( "\nEnter Position of Element to change ( RC ): " ) ; | |
scanf( "%d" , &p1 ) ; | |
c1 = p1 % 10 ; | |
r1 = p1 / 10 ; | |
switch( board[r1][c1] ) | |
{ | |
case 'p': pawnb( r1 , c1 ) ; | |
break ; | |
case 'r': rook( r1 , c1 ) ; | |
break ; | |
case 'h': horse( r1 , c1 ) ; | |
break ; | |
case 'c': camel( r1 , c1 ) ; | |
break ; | |
case 'k': king( r1 , c1 ) ; | |
break ; | |
case 'q': queen( r1 , c1 ) ; | |
break ; | |
default: printf( "Invalid Position ! " ) ; goto again2 ; | |
} | |
printf( "\nEnter Position of Place to Send ( RC ): " ) ; | |
scanf( "%d" , &p2 ) ; | |
c2 = p2 % 10 ; | |
r2 = p2 / 10 ; | |
change(r1,c1,r2,c2) ; | |
} | |
int check(int x , int y ) | |
{ | |
switch( board[x][y] ) | |
{ | |
case 'p': | |
case 'r': | |
case 'h': | |
case 'c': | |
case 'k': | |
case 'q': return 1 ; break ; | |
default: return 0 ; | |
} | |
} | |
int check2(int x , int y ) | |
{ | |
switch( board[x][y] ) | |
{ | |
case 'P': | |
case 'R': | |
case 'H': | |
case 'C': | |
case 'K': | |
case 'Q': return 1 ; break ; | |
default: return 0 ; | |
} | |
} | |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
// cc biorritmos.c -lm -o ejecutable.exe | |
#include <stdio.h> | |
#include <math.h> | |
#define PI 3.14159265358979323846 | |
#define DELTA 0.000001 | |
#define DIM 31 /* dimensao maxima para um vector mes */ | |
/* prototipos de funcoes */ | |
int menu( void ); | |
int numDias( int diaN, int mesN, int anoN, int mes, int ano ); | |
int diasDoAno( int ano ); | |
int diasDoMes( int ano, int mes ); | |
int anoInic( int diaN, int mesN, int anoN ); | |
int somaAnos( int anoN, int ano ); | |
int anoLim( int mes, int ano ); | |
int anoUnic ( int diaN, int mesN, int mes, int ano ); | |
void tabela( int mes, int ano, int t, int lim ); | |
double fisico( int t ); | |
double emocional( int t ); | |
double mental( int t ); | |
void diasPos( int t, int lim ); | |
int zeroComp( double n ); | |
void diasMax( int t, int lim ); | |
void diasNull( int t, int lim ); | |
void apresentaGrafico( double bio[], int dias, char c ); | |
void inicVector( double v[], int t, int qRitmo, int lim ); | |
int main( void ){ /* inicio da main */ | |
int diaN, mesN, anoN, mes, ano, t, dDMes, opcao = 1; | |
double bio[DIM]; | |
printf( "Bem vindo ao calculador de biorritmos\n" | |
"Introduza a data de nascimento e o mes a analisar:\n" ); | |
scanf( "%d%d%d%d%d", &diaN, &mesN, &anoN, &mes, &ano ); | |
t = numDias( diaN, mesN, anoN, mes, ano ); | |
dDMes = diasDoMes( ano, mes ); | |
printf( "\n" ); | |
while( opcao != 0 ){ /* inicio do ciclo */ | |
opcao = menu(); | |
switch( opcao ){ /* inicio do switch */ | |
case 1: | |
printf( "\n%d\n\n", t ); | |
break; | |
case 2: | |
printf( "\n" ); | |
tabela ( mes, ano, t, dDMes ); | |
printf( "\n" ); | |
break; | |
case 3: | |
printf( "\n" ); | |
diasPos( t, dDMes ); | |
printf( "\n\n" ); | |
break; | |
case 4: | |
printf( "\n" ); | |
diasMax( t, dDMes ); | |
printf( "\n\n" ); | |
break; | |
case 5: | |
printf( "\n" ); | |
diasNull( t, dDMes ); | |
printf( "\n\n" ); | |
break; | |
case 6: | |
printf( "\nGrafico do biorritmo fisico:\n" ); | |
inicVector( bio, t, 1, dDMes ); | |
apresentaGrafico( bio, dDMes, '.' ); | |
printf( "\n" ); | |
break; | |
case 7: | |
printf( "\nGrafico do biorritmo emocional:\n" ); | |
inicVector( bio, t, 0, dDMes ); | |
apresentaGrafico( bio, dDMes, '+' ); | |
printf( "\n" ); | |
break; | |
case 8: | |
printf( "\nGrafico do biorritmo mental\n" ); | |
inicVector( bio, t, -1, dDMes ); | |
apresentaGrafico( bio, dDMes, '*' ); | |
printf( "\n" ); | |
break; | |
case 9: | |
printf( "Introduza a data de nascimento e o mes a analisar:\n" ); | |
scanf( "%d%d%d%d%d", &diaN, &mesN, &anoN, &mes, &ano ); | |
t = numDias( diaN, mesN, anoN, mes, ano ); | |
dDMes = diasDoMes( ano, mes ); | |
printf( "\n" ); | |
break; | |
case 0: | |
break; | |
default: | |
opcao = 0; | |
} /* fim do switch */ | |
} /* fim do while */ | |
printf( "\nTerminou a execucao!\n" ); | |
return 0; | |
} /* fim da main */ | |
/** | |
* funcao que imprime menu e recolhe o valor da opcao | |
*/ | |
int menu( void ){ | |
int numOp; | |
printf( "Menu:\n" | |
"1 - Numero de dias decorridos desde a data de nascimento\n" | |
"2 - Tabela de biorritmos para o mes\n" | |
"3 - Dias positivos no mes\n" | |
"4 - Dias maximos no mes\n" | |
"5 - Dias nulos no mes\n" | |
"6 - Grafico do biorritmo fisico ao longo do mes\n" | |
"7 - Grafico do biorritmo emocional ao longo do mes\n" | |
"8 - Grafico do biorritmo mental ao longo do mes\n" | |
"9 - Introduzir novos dados\n" | |
"0 - Sair\n" | |
"Opcao: " ); | |
scanf( "%d", &numOp ); | |
return numOp; | |
} /* fim da funcao */ | |
/** | |
* funcao que calcula os dias desde o nascimento ate o primeiro dia do mes | |
*/ | |
int numDias( int diaN, int mesN, int anoN, int mes, int ano ){ | |
int somatorioDias = 0; | |
if( anoN == ano ) | |
somatorioDias = anoUnic( diaN, mesN, mes, ano ) + 1; | |
else | |
somatorioDias = anoInic( diaN, mesN, anoN ) + somaAnos( anoN, ano ) + anoLim( mes, ano ) + 1; | |
return somatorioDias; | |
} /* fim da funcao */ | |
/** | |
* funcao que calcula o numero de dias num ano | |
*/ | |
int diasDoAno (int ano){ | |
int dias = 365; | |
if (ano%4 == 0) | |
dias++; | |
return dias; | |
} /* fim da funcao */ | |
/** | |
* funcao que calcula o numero de dias num mes | |
*/ | |
int diasDoMes (int ano, int mes){ | |
int dias; | |
if (mes == 1 || mes == 3 || mes == 5 || mes == 7 || mes == 8 || mes == 10 || mes == 12) | |
dias = 31; | |
else if ( mes == 2 ){ /* inicio do if */ | |
if ( ano % 4 == 0) | |
dias = 29 ; | |
else dias = 28 ; | |
} /* fim do if */ | |
else dias = 30; | |
return dias; | |
} /* fim da funcao */ | |
/** | |
* funcao que calcula o numero de dias desde | |
* o nascimento ate ao fim do proprio ano | |
*/ | |
int anoInic ( int diaN, int mesN, int anoN ){ | |
int m, soma = 0; | |
soma = diasDoMes(anoN, mesN) - diaN; | |
m = mesN + 1; | |
while( m <= 12 ){ /* inicio do ciclo */ | |
soma += diasDoMes(anoN, m); | |
m++; | |
} /* fim do while */ | |
return soma; | |
} /* fim da funcao */ | |
/** | |
* funcao que calcula o total de dias entre | |
* o ano de nascimento e o ano a avaliar | |
*/ | |
int somaAnos ( int anoN, int ano ){ | |
int conta, soma = 0; | |
conta = anoN + 1; | |
while( conta < ano ){ /* inicio do ciclo */ | |
soma += diasDoAno(conta); | |
conta++; | |
} /* fim do while */ | |
return soma; | |
} /* fim da funcao */ | |
/** | |
* funcao que calcula os dias ja ocorridos do ano a avaliar | |
*/ | |
int anoLim ( int mes, int ano ){ | |
int m = 1, soma = 0; | |
while( m < mes ){ /* inicio do ciclo */ | |
soma += diasDoMes(ano, m); | |
m++; | |
} /* fim do while */ | |
return soma; | |
} /* fim da funcao */ | |
/** | |
* funcao que calcula, no caso extraordinario do ano de nascimento ser | |
* tambem o ano a avaliar, os dias ocorridos entre ambos os eventos | |
*/ | |
int anoUnic ( int diaN, int mesN, int mes, int ano ){ | |
int m, soma = 0; | |
soma = diasDoMes(ano, mesN) - diaN; | |
m = mesN + 1; | |
while( m < mes ){ /* inicio do ciclo */ | |
soma += diasDoMes(ano, m); | |
m++; | |
} /* fim do while */ | |
return soma; | |
} /* fim da funcao */ | |
/** | |
* funcao que calcula o biorritmo fisico para um dia t | |
*/ | |
double fisico( int t ){ | |
return sin( 2 * PI * t / 23 ) * 10; | |
} /* fim da funcao */ | |
/** | |
* funcao que calcula o biorritmo emocional para um dia t | |
*/ | |
double emocional( int t ){ | |
return sin( 2 * PI * t / 28 ) * 10; | |
} /* fim da funcao */ | |
/** | |
* funcao que calcula o biorritmo mental para um dia t | |
*/ | |
double mental( int t ){ | |
return sin( 2 * PI * t / 33 ) * 10; | |
} /* fim da funcao */ | |
/** | |
* funcao que imprime tabela dos biorritmos ao longo do mes | |
*/ | |
void tabela( int mes, int ano, int t, int lim ){ | |
int dias, contador = 1; | |
dias = t; | |
printf( "biorritmos do mes %d %d:\n", mes, ano ); | |
printf( " dia fisico emocional mental\n" ); | |
while ( contador <= lim ){ /* inicio do ciclo */ | |
printf( "%12d%12.6f%12.6f%12.6f\n", contador, fisico( dias ), emocional( dias ), mental( dias ) ); | |
contador++; | |
dias++; | |
} /* fim do while */ | |
} /* fim da funcao */ | |
/** | |
* funcao que calcula e imprime os dias positivos | |
*/ | |
void diasPos( int t, int lim ){ | |
int dias, contador = 1; | |
dias = t; | |
while ( contador <= lim ){ /* inicio do ciclo */ | |
if( !zeroComp( fisico( dias ) ) && ( fisico( dias ) > 0 ) && | |
( ( fisico( dias + 1 ) > 0 ) || zeroComp( fisico( dias + 1 ) ) ) && !zeroComp( emocional( dias ) ) && | |
( emocional( dias ) > 0 ) && ( ( emocional( dias + 1 ) > 0 ) || zeroComp( emocional( dias + 1 ) ) ) ) | |
printf( "%d ", contador ); | |
else if( !zeroComp( emocional( dias ) ) && ( emocional( dias ) > 0 ) && | |
( ( emocional( dias + 1 ) > 0 ) || zeroComp( emocional( dias + 1 ) ) ) && !zeroComp( mental( dias ) ) && | |
( mental( dias ) > 0 ) && ( ( mental( dias + 1 ) > 0 ) || zeroComp( mental( dias + 1 ) ) ) ) | |
printf( "%d ", contador ); | |
else if( !zeroComp( fisico( dias ) ) && ( fisico( dias ) > 0 ) && | |
( ( fisico( dias + 1 ) > 0 ) || zeroComp( fisico( dias + 1 ) ) ) && !zeroComp( mental( dias ) ) && | |
( mental( dias ) > 0 ) && ( ( mental( dias + 1 ) > 0 ) || zeroComp( mental( dias + 1 ) ) ) ) | |
printf( "%d ", contador ); | |
contador++; | |
dias++; | |
} /* fim do while */ | |
} /* fim da funcao */ | |
/** | |
* funcao que compara um double a zero | |
*/ | |
int zeroComp( double n ){ | |
double z = 0; | |
return ( ( n < ( z + DELTA ) ) && ( n > ( z - DELTA ) ) ); | |
} /* fim da funcao */ | |
/** | |
* funcao que calcula e imprime os dias maximos | |
*/ | |
void diasMax( int t, int lim ){ | |
int dias, contador = 1; | |
dias = t; | |
while( contador <= lim ){ /* inicio do ciclo */ | |
if( ( fisico( dias - 1 ) < fisico( dias ) ) && ( fisico( dias ) > fisico( dias + 1 ) ) ) | |
printf( "%d ", contador ); | |
else if( ( emocional( dias - 1 ) < emocional( dias ) ) && ( emocional( dias ) > emocional( dias + 1 ) ) ) | |
printf( "%d ", contador ); | |
else if( ( mental( dias - 1 ) < mental( dias ) ) && ( mental( dias ) > mental( dias + 1 ) ) ) | |
printf( "%d ", contador ); | |
contador++; | |
dias++; | |
} /* fim do while */ | |
} /* fim da funcao */ | |
/** | |
* funcao que calcula e imprime os dias nulos | |
*/ | |
void diasNull( int t, int lim ){ | |
int dias, contador = 1; | |
dias = t; | |
while( contador <= lim ){ /* inicio do ciclo */ | |
if( zeroComp( fisico( dias ) ) || ( ( ( fisico( dias ) < 0 ) && | |
( fisico( dias + 1 ) > 0 ) && !zeroComp( fisico( dias + 1 ) ) ) || | |
( ( fisico( dias ) > 0 ) && ( fisico( dias + 1 ) < 0 ) && !zeroComp( fisico( dias + 1 ) ) ) ) ) | |
printf( "%d ", contador ); | |
else if( zeroComp( emocional( dias ) ) || ( ( ( emocional( dias ) < 0 ) && | |
( emocional( dias + 1 ) > 0 ) && !zeroComp( emocional( dias + 1 ) ) ) || | |
( ( emocional( dias ) > 0 ) && ( emocional( dias + 1 ) < 0 ) && !zeroComp( emocional( dias + 1 ) ) ) ) ) | |
printf( "%d ", contador ); | |
else if( zeroComp( mental( dias ) ) || ( ( ( mental( dias ) < 0 ) && | |
( mental( dias + 1 ) > 0 ) && !zeroComp( mental( dias + 1 ) ) ) || | |
( ( mental( dias ) > 0 ) && ( mental( dias + 1 ) < 0 ) && !zeroComp( mental( dias + 1 ) ) ) ) ) | |
printf( "%d ", contador ); | |
contador++; | |
dias++; | |
} /* fim do while */ | |
} /* fim da funcao */ | |
/** | |
* funcao que ilustra o grafico de um biorritmo durante um mes | |
*/ | |
void apresentaGrafico( double bio[], int dias, char c ){ | |
int i, contaLinhas = 0; | |
while( contaLinhas <= 20 ){ /* inicio do ciclo */ | |
printf( "%3d|", 10 - contaLinhas ); | |
if( contaLinhas == 10 ){ /* inicio do if */ | |
for( i = 0; i < dias; i++ ){ /* inicio do ciclo */ | |
if( floor( bio[i] + 0.5 ) == 0 ) | |
printf( "-%c", c ); | |
else | |
printf( "-%d", ( i + 1 ) % 10 ); | |
} /* fim do for */ | |
printf( "dias" ); | |
} /* fim do if */ | |
else | |
for( i = 0; i < dias; i++ ){ /* inicio do ciclo */ | |
if( floor( bio[i] + 0.5 ) == ( 10 - contaLinhas ) ) | |
printf( "%c%c", c, c ); | |
else | |
printf( " " ); | |
} /* fim do for */ | |
printf( "\n" ); | |
contaLinhas++; | |
} /* fim do while */ | |
} /* fim da funcao */ | |
/** | |
* funcao que atribui os valores de um biorritmo de cada | |
* dia aos elementos de um vector mes | |
*/ | |
void inicVector( double v[], int t, int qRitmo, int lim ){ | |
int contador, dias; | |
dias = t; | |
if( qRitmo == 1 ) | |
for( contador = 0; contador < lim; contador++ ) | |
v[contador] = fisico( dias + contador ); | |
else if( qRitmo == 0 ) | |
for( contador = 0; contador < lim; contador++ ) | |
v[contador] = emocional( dias + contador ); | |
else | |
for( contador = 0; contador < lim; contador++ ) | |
v[contador] = mental( dias + contador ); | |
} /* fim da funcao */ | |
/** | |
* fim do codigo | |
*/ |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
// 1. | |
#include "modulo2.c" | |
int main(int argc, char const *argv[]){ | |
limpiar(); | |
test_a(); | |
test_b(); | |
test_c(); | |
test_d(); | |
test_e(); | |
test_f(); | |
test_g(); | |
return EXIT_SUCCESS; | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
#!/bin/bash | |
echo Compilando: $1 | |
gcc $1 -o ejecutable.exe | |
echo Ejecutando: | |
./ejecutable.exe | |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
#!/bin/bash | |
echo Compilando: $1 | |
cc $1 -lm -o ejecutable.exe | |
echo Ejecutando: | |
./ejecutable.exe |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/** | |
* Ejemplos en C | |
* Compilar: gcc programa.c -o salida | |
* Ejecutar: ./salida | |
*/ | |
// | |
/* | |
#include<stdio.h> | |
#include<math.h> | |
#include<assert.h> | |
#include<stdbool.h> | |
#include<stdlib.h> | |
#include<string.h> | |
#define MAX_STRING_SIZE 40 | |
#define LIMPIAR "clear" | |
void duplicadosArray(char texto[][MAX_STRING_SIZE]); | |
void recorrerArray(char texto[][MAX_STRING_SIZE]); | |
void recorrerArray(char texto[][MAX_STRING_SIZE]){ | |
puts("\t ====== [Recorremos arreglo] ======"); | |
for(int i=0; i < 3; i++){ | |
printf("Cadena: %s\n",texto[i]); | |
} | |
} | |
void duplicadosArray(char texto[][MAX_STRING_SIZE]){ | |
puts("\t ===== [A encontrar los duplicados] ====="); | |
for(int i=0;i < 3; i++){ | |
printf("Leemos: %s\n",texto[i]); | |
} | |
} | |
int main(int argc, char *argv[]){ | |
char texto[][MAX_STRING_SIZE] = {"primer texto","segundo texto aleatorio","tercer texto"}; | |
system(LIMPIAR); | |
recorrerArray(texto); | |
duplicadosArray(texto); | |
return 0; | |
} | |
*/ | |
// 66. | |
#include <stdio.h> | |
#include <string.h> | |
#include <ctype.h> | |
#include <unistd.h> | |
#include <assert.h> | |
#include <regex.h> | |
#include <stdlib.h> | |
// Definición de tipo de datos | |
typedef int Entero; | |
typedef float Flotante; | |
typedef char Caracter; | |
// Prototipos de función | |
void pausar(void); | |
void test1(void); | |
void test2(void); | |
void test3(void); | |
void test4(void); | |
void test5(void); | |
void pausar() | |
{ | |
sleep(2); | |
puts("Hecho"); | |
} | |
void test1(void) | |
{ | |
Entero entero = 32; | |
Entero *ptrEntero = &entero; | |
Entero *ptrNulo = NULL; | |
Caracter car = 'ß'; | |
Caracter *ptrCar = &car; | |
Flotante flotantes[2] = {2.3f, 4.6f}; | |
Flotante *ptrInicio = &flotantes[0]; | |
Flotante *ptrFin = &flotantes[1]; | |
puts("\t [ Punteros ]"); | |
printf("Numero entero: %d\n", entero); | |
printf("Direccion del numero entero: %p\n", ptrEntero); | |
if (ptrNulo != NULL) | |
{ | |
puts("Esto no se vera"); | |
} | |
// pause(); // Similar a system("pause"); | |
if (ptrCar != NULL) | |
{ | |
printf("Caracter: %c, Dir. de memoria: %p\n", car, ptrCar); | |
} | |
printf("Valor: %.2lf, Dir. de memoria: %p\n", flotantes[0], ptrInicio); | |
printf("Valor: %.2lf, Dir. de memoria: %p\n", flotantes[1], ptrFin); | |
// sleep(3); | |
// puts("Hecho"); | |
pausar(); | |
} | |
void test2() | |
{ | |
Entero numero = 1; | |
Flotante flotante = 5.6f; | |
Caracter car = 'A'; | |
unsigned short x = 0; | |
puts("\t Aserciones en C"); | |
assert(numero > 0); | |
assert(flotante == 5.6f); | |
assert(numero > x); | |
assert(x == 0); | |
} | |
void test3(void) | |
{ | |
unsigned short a, b; | |
puts("Escriba dos unsigned short separados por un espacio: "); | |
scanf("%hd %hd", &a, &b); | |
puts("\t Operaciones:"); | |
printf("\n%u + %u = %u\n", a, b, a + b); | |
printf("%u - %u = %u\n", a, b, a - b); | |
printf("%u * %u = %u\n", a, b, a * b); | |
printf("%u / %u = %u\n", a, b, a / b); | |
} | |
void test4(void) | |
{ | |
long long a, b; | |
puts("\nEscriba dos long long separados por un espacio: "); | |
scanf("%qd %qd", &a, &b); | |
puts("\t Operaciones:"); | |
printf("\n%qd + %qd = %qd\n", a, b, a + b); | |
printf("%qd - %qd = %qd\n", a, b, a - b); | |
printf("%qd * %qd = %qd\n", a, b, a * b); | |
printf("%qd / %qd = %qd\n", a, b, a / b); | |
} | |
void test5(void) | |
{ | |
char nombre[] = "Fernanda"; | |
int resultado; | |
regex_t expresion_regular; | |
printf("Nombre: %s\n",nombre); | |
// Compila la expresión regular | |
resultado = regcomp(&expresion_regular, "^F.*", 0); | |
if (resultado != 0) | |
{ | |
printf("Error al compilar la expresión regular\n"); | |
exit(EXIT_FAILURE); | |
} | |
// Verifica si la cadena cumple con la expresión regular | |
resultado = regexec(&expresion_regular, nombre, 0, NULL, 0); | |
if (resultado == 0) | |
{ | |
printf("El nombre cumple con el patrón\n"); | |
} | |
else | |
{ | |
printf("El nombre no cumple con el patrón\n"); | |
} | |
// Libera la memoria asignada a la expresión regular | |
regfree(&expresion_regular); | |
} | |
int main(int argc, char const *argv[]) | |
{ | |
system("clear"); | |
// test1(); | |
// test2(); | |
test3(); | |
test4(); | |
test5(); | |
pausar(); | |
return 0; | |
} | |
// 65. | |
/* | |
#include <stdio.h> | |
#include <stdlib.h> | |
#include <string.h> | |
float potencia(float a, float n); | |
float potencia(float a, float n){ | |
if(n<=0){ | |
return 1; | |
} | |
return (a*potencia(a,n-1)); | |
} | |
int main(int argc, char const *argv[]){ | |
if(argc > 1){ | |
for (int i=1; i< argc; i++) { | |
printf("arg%d = %s\n", i, argv[i]); | |
float entrada = atof(argv[i]); | |
float pot = potencia(entrada, (float)i); | |
printf(" %.2f : %d >>Potencia = %.2f\n",entrada,i,pot); | |
} | |
}else{ | |
printf("No hay argumentos: %d\n",argc); | |
} | |
return 0; | |
} | |
*/ | |
// 64. | |
/* | |
#include <stdio.h> | |
#include <stdlib.h> | |
#include <string.h> | |
int positivo(int n){ | |
if(n < 0){ | |
return n*(-1); | |
} | |
return n; | |
} | |
int negativo(int n){ | |
if(n > 0){ | |
return n*(-1); | |
} | |
return n; | |
} | |
int main(int argc, char const *argv[]){ | |
if(argc > 1){ | |
for (int i=1; i< argc; i++) { | |
printf("arg%d = %s\n", i, argv[i]); | |
printf("Positivo: %d\n",positivo(atoi(argv[i]))); | |
printf("Negativo: %d\n",negativo(atoi(argv[i]))); | |
} | |
}else{ | |
puts("No hay argumentos"); | |
} | |
return 0; | |
} | |
*/ | |
// 63. | |
/* | |
#include <stdio.h> | |
#include <stdlib.h> | |
#include <string.h> | |
int bisiesto(int x); | |
int bisiesto(int x){ | |
if(x%400 == 0){ | |
return 1; | |
}else if(x%100 == 0){ | |
return 0; | |
}else{ | |
return (x%4==0); | |
} | |
} | |
int main(int argc, char const *argv[]){ | |
int anyos[10] = {1981,2000,1994,2022,2002,1996,2003,1972,1987,1885}; | |
size_t tam = sizeof(anyos)/sizeof(int); | |
printf("Tam: %ld\n",tam); | |
for(int i=0; i < tam; i++){ | |
if(bisiesto(anyos[i])){ | |
printf("\t%d es año bisiesto\n",anyos[i]); | |
}else{ | |
printf("\t%d no es año bisiesto\n",anyos[i]); | |
} | |
} | |
return 0; | |
} | |
*/ | |
// 62. | |
/* | |
#include <stdio.h> | |
#include <stdlib.h> | |
#include <string.h> | |
#define LIMPIAR "clear" | |
#define FILA 3 | |
#define COLUMNA 4 | |
int multiplicar(int mat[FILA][COLUMNA]); | |
int multiplicar(int mat[FILA][COLUMNA]){ | |
int resultado[3][4]; | |
int i,j,k; | |
puts("Entramos a funcion multiplicar:"); | |
for ( i = 0; i < 3; i++) | |
{ | |
for (j = 0; j < 4; j++) | |
{ | |
resultado[i][j] = 0; | |
for ( k = 0; k < 4; k++) | |
{ | |
resultado[i][j] += mat[i][k] * mat[k][j]; | |
} | |
} | |
} | |
return resultado[i][j]; | |
} | |
int main(int argc, char const *argv[]){ | |
system(LIMPIAR); | |
int materias[FILA][COLUMNA]; | |
materias[0][0] = 2; | |
materias[0][1] = 4; | |
materias[0][2] = 5; | |
materias[0][3] = 0; | |
materias[1][0] = 3; | |
materias[1][1] = 1; | |
materias[1][2] = 3; | |
materias[1][3] = 2; | |
materias[2][0] = 6; | |
materias[2][1] = 8; | |
materias[2][2] = 2; | |
materias[2][3] = 7; | |
puts("Tratando de inicializar vector multidimensional..."); | |
// Aquí hay un error de inicialización >> invalid initializer | |
int resultado[FILA][COLUMNA] = multiplicar(materias); | |
puts("Hecho"); | |
return 0; | |
} | |
*/ | |
// 61. | |
/* | |
#include "pulsaciones.c" | |
#include <stdio.h> | |
#include <stdlib.h> | |
#include <string.h> | |
#define LIMPIAR "clear" | |
int main(int argc, char const *argv[]){ | |
Entero edad = 0; | |
Entero sexo = 0; | |
system(LIMPIAR); | |
puts("\t ====== [ Pulsaciones ] ======"); | |
puts("Introduce sexo [1. Femenino 2. Masculino] :"); | |
scanf("%d",&sexo); | |
puts("Introduce edad:"); | |
scanf("%d",&edad); | |
printf("Resultado: %.3f pulsaciones\n",getPulsaciones(edad, sexo)); | |
return 0; | |
} | |
*/ | |
// 60. | |
/* | |
#include <stdio.h> | |
#include <stdlib.h> | |
#include <string.h> | |
#define LIMPIAR "clear" | |
#define AUTENTICADO 1 | |
#define CODIGO "DL" | |
#define SUMA(X,Y) X+Y | |
int main(int argc, char const *argv[]){ | |
system(LIMPIAR); | |
puts("[Ejecutando servicio de Self Service]"); | |
if(AUTENTICADO == 1){ | |
puts("Usuario = Autenticado"); | |
if(strcmp(CODIGO,"DL") == 0){ | |
puts("Codigo = DL"); | |
puts("No se da de alta su servicio"); | |
} | |
} | |
if(SUMA(6,3) > 9){ | |
puts("A"); | |
} | |
if(SUMA(6,3) == 9){ | |
puts("B"); | |
} | |
if(SUMA(6,3) >= 9){ | |
puts("C"); | |
} | |
return 0; | |
} | |
*/ | |
// 59. | |
/* | |
#include <stdio.h> | |
#include <stdlib.h> | |
#include <string.h> | |
#define LIMPIAR "clear" | |
struct agendar{ | |
int id; | |
char usuario[50]; | |
char contrasena[50]; | |
char nomc[50]; | |
int tipo; | |
}datos; | |
void registroUsuario(){ | |
puts("\tRegistramos al usuario\n"); | |
FILE *ua = fopen("usuarios.txt", "a"); | |
if(ua == NULL){ | |
puts("No se pudo leer.\n"); | |
} | |
printf("Cree un ID: "); | |
scanf("%d", &datos.id); | |
printf("Crea un nombre de usuario: "); | |
fflush(stdin); | |
//gets(datos.usuario); | |
fgets(datos.usuario ,sizeof(datos.usuario), stdin); | |
printf("Crea una contrasena: "); | |
fflush(stdin); | |
//gets(datos.contrasena); | |
fgets(datos.contrasena, sizeof(datos.contrasena), stdin); | |
printf("Ingrese su nombre completo: "); | |
fflush(stdin); | |
//gets(datos.nomc); | |
fgets(datos.nomc, sizeof(datos.nomc), stdin); | |
printf("Tipo de usuario: 1, 2: "); | |
scanf("%d", &datos.tipo); | |
} | |
void huesped() | |
{ | |
int opH=0; | |
printf("Menu Huesped\n"); | |
printf("1. Buscar\n"); | |
printf("2. Mis Reservaciones\n"); | |
printf("3. Cancelar Reservacion\n"); | |
printf("4. Salir"); | |
scanf("%d", &opH); | |
} | |
void iniciarSesion() | |
{ | |
FILE *ur = fopen("usuarios.txt", "r"); | |
printf("Ingrese su nombre de usuario: "); | |
fflush(stdin); | |
//gets(datos.usuario); | |
fgets(datos.usuario, sizeof(datos.usuario), stdin); | |
printf("Ingrese su password: "); | |
fflush(stdin); | |
//gets(datos.contrasena); | |
fgets(datos.contrasena, sizeof(datos.contrasena), stdin); | |
system(LIMPIAR); | |
while(!feof(ur)){ | |
fread(&datos, sizeof(datos),1,ur); | |
printf("%s, %s\n", datos.usuario, datos.contrasena); | |
} | |
} | |
int main(int argc, char const *argv[]){ | |
int opcion=0, n=0, x, ctrl=-1, v=0, e=0; | |
char usuario[50], contrasena[50]; | |
while(opcion != 3){ | |
printf("Que desea hacer?\n"); | |
printf("1.Registrarme \n"); | |
printf("2.Iniciar sesion \n"); | |
printf("3.Salir \n"); | |
printf("Ingresa un numero: "); | |
scanf("%d",&opcion); | |
system(LIMPIAR); | |
switch(opcion){ | |
case 1:{ | |
registroUsuario(); | |
system(LIMPIAR); | |
break; | |
} | |
case 2:{ | |
iniciarSesion(); | |
system(LIMPIAR); | |
break; | |
} | |
case 3:{ | |
puts("Adios!\n"); | |
} | |
} | |
} | |
} | |
*/ | |
// 58. | |
/* | |
#include <stdio.h> | |
int main () { | |
int i, n, c; | |
printf ("Dimension del vector: "); | |
scanf ("%d", &n); | |
char num[n]; | |
for (i = 0; i < n; i++) { | |
printf ("Ingrese un numero: "); | |
scanf ("%d", &c); | |
if (c < 1) { | |
printf ("Ingrese un numero mayor que cero: "); | |
scanf ("%d", &c); | |
} | |
sprintf (&num[i], "%d", c); | |
} | |
printf("%s", num); | |
} | |
*/ | |
// 57. | |
/* | |
#include<stdio.h> | |
#include<string.h> | |
#include <math.h> | |
int main(int argc, char const *argv[]) { | |
char str[80]; | |
sprintf(str, "Valor de PI = %f", M_PI); | |
puts(str); | |
} | |
*/ | |
// 56. | |
/* | |
#include<stdio.h> | |
#include<assert.h> | |
#include<string.h> | |
#include<stdlib.h> | |
typedef int Entero; | |
typedef char *Cadena; | |
typedef struct{ | |
Cadena nombre; | |
int edad; | |
float peso; | |
float altura; | |
}Persona; | |
void destruyePersona(Persona *persona){ | |
assert(persona != NULL); | |
free(persona); | |
puts("\nSe ha destruido 'objeto' Persona"); | |
} | |
void imprimePersona(Persona *person){ | |
assert(person != NULL); | |
puts("\t [ DATOS DE LA PERSONA]\n"); | |
printf("Nombre: %s\n",person->nombre); | |
printf("Edad: %d\n",person->edad); | |
printf("Peso: %.2f\n",person->peso); | |
printf("Altura: %.2f\n",person->altura); | |
} | |
Persona *crearPersona(Cadena nombre, int edad, float peso, float altura){ | |
Persona *persona = (Persona*) malloc(sizeof(Persona)); | |
assert(persona != NULL); | |
persona->nombre = nombre; | |
persona->edad = edad; | |
persona->peso = peso; | |
persona->altura = altura; | |
return persona; | |
} | |
int main(int argc, char const *argv[]){ | |
Persona *myPersona = crearPersona("Alma Rana",2022-1985,60.0f,1.56f); | |
printf("Direccion de memoria:%p\n",myPersona); | |
imprimePersona(myPersona); | |
destruyePersona(myPersona); | |
return 0; | |
} | |
*/ | |
// 55. | |
/* | |
#include<stdio.h> | |
#include<time.h> | |
int main(int argc, char const *argv[]){ | |
time_t t = time(NULL); | |
struct tm tm = *localtime(&t); | |
printf("Tiempo de hoy: %d-%02d-%02d %02d:%02d:%02d\n", tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec); | |
return 0; | |
} | |
*/ | |
// 54. | |
/* | |
#include<stdio.h> | |
#include <regex.h> | |
#define LIMPIAR "clear" | |
void print_result(int return_value); | |
void print_result(int return_value){ | |
printf("Entrada: %d\n",return_value); | |
if (return_value == 0){ | |
printf("Patron encontrado.\n"); | |
} | |
else if (return_value == REG_NOMATCH){ | |
printf("Patron no encontrado.\n"); | |
} | |
else{ | |
printf("Ha ocurrido un error.\n"); | |
} | |
} | |
int main(int argc, char const *argv[]){ | |
system(LIMPIAR); | |
regex_t regex; | |
int return_value; | |
return_value = regcomp(®ex,"[:lower:]",0); | |
if(return_value == 0){ | |
puts("La compilacion fue exitosa.\n"); | |
} | |
else{ | |
puts("Error en la compilacion.\n"); | |
} | |
int return_value2; | |
return_value = regcomp(®ex,"ice",0); | |
return_value = regexec(®ex, "icecream", 0, NULL, 0); | |
printf("Regresa 1: %d\n",return_value); | |
print_result(return_value); | |
return_value2 = regcomp(®ex,"ice",0); | |
return_value2 = regexec(®ex, "frozen yoghurt", 0, NULL, 0); | |
printf("Regresa 2: %d\n",return_value2); | |
print_result(return_value2); | |
return 0; | |
} | |
*/ | |
// 53 | |
/* | |
#include <stdio.h> | |
int main(int argc, char *argv[]){ | |
int i,j,k; | |
int vec[] = {1,2,3,4,5,5,6}; | |
int tam = 7; | |
printf("Vector inicial: "); | |
//Mostrar vector inicial | |
for(i = 0; i < tam; i++){ | |
printf("%i, ",vec[i]); | |
} | |
//Código que elimina los elementos repetidos | |
for(i = 0; i < tam; i++){ | |
for(j = i+1; j < tam; j++){ | |
if(vec[i] == vec[j]){ | |
k = j; | |
while(k < tam)//Mientras k sea menor que la cantidad de elementos | |
{ | |
vec[k] = vec[k+1];//Copiará el elemento siguiente, | |
//Ejemplo en posición 1 copiará el valor de la posición la dos, y en la dos la tres y así sucesivamente. | |
++k;//Aumentamos el contador k en 1 | |
} | |
--tam;//Disminuimos el tamaño del vector ya que se eliminaron elementos repetidos. | |
--j; | |
}//Fin del if | |
}//Fin del bucle for con j | |
}//Fin del bucle for con i | |
printf("\nVector final: "); | |
//Mostrar vector final | |
for(i = 0; i < tam; i++){ | |
printf("%i, ",vec[i]); | |
} | |
return 0; | |
} | |
*/ | |
// 52. | |
/* | |
#include<stdio.h> | |
#include<string.h> | |
void intercambio(int *a, int *b); | |
void obtiene(void); | |
void recibe(const char** pptr); | |
void obtiene(){ | |
const char* mensaje; | |
recibe(&mensaje); | |
printf("Recibimos:%s\n",mensaje); | |
} | |
void recibe(const char** pptr){ | |
const char* str = "Aqui paso Doroteo Arango"; | |
*pptr = str; | |
} | |
void intercambio(int *a, int *b) { | |
int temp = *a; | |
*a = *b; | |
*b = temp; | |
} | |
int main(int argc, char const *argv[]){ | |
int a = 4, b= 5; | |
printf("a=%d , b=%d\n",a,b); | |
intercambio(&a,&b); | |
printf("a=%d , b=%d\n",a,b); | |
obtiene(); | |
return 0; | |
} | |
*/ | |
// 51. | |
/* | |
#include<stdio.h> | |
void obtengoNum(void); | |
void envioNum(int *passed); | |
void obtengoNum(){ | |
int n; | |
envioNum(&n); | |
printf("Tenemos el numero: %d\n", n); | |
} | |
void envioNum(int *passed){ | |
*passed = 33; | |
} | |
int main(int argc, char const *argv[]){ | |
obtengoNum(); | |
return 0; | |
} | |
*/ | |
// 50. | |
/* | |
#include<stdio.h> | |
#define VALOR 1.8 | |
#define MAX 1000 | |
int func1(int); | |
int func2(int,int); | |
int func3(int,int,int); | |
int func1(int num){ | |
return VALOR*num; | |
} | |
int func2(int x,int y){ | |
return MAX +(x+y); | |
} | |
int func3(int a,int b,int c){ | |
return a+b+c; | |
} | |
int main(int argc, char *argv[]){ | |
printf("Resultado 1:%d\n",func2(4,3)); | |
printf("Resultado 2:%d\n",func1(2)); | |
printf("Resultado 3:%d\n",func3(2,5,6)); | |
return 0; | |
} | |
*/ | |
// 49. | |
// http://www.aprendeaprogramar.com/mod/forum/discuss.php?d=564 | |
// compilar y crear ejecutable con: | |
// cc ejemplos.c -lm -o ejecutable.exe | |
/* | |
#include<stdio.h> | |
#include<math.h> | |
#include<ctype.h> | |
#include<curses.h> | |
#include<string.h> | |
#include<stdlib.h> | |
#define FALSE 0 | |
#define TRUE 1 | |
int esPrimo(int); | |
int esPrimo(int num){ | |
if(num < 2){ | |
return FALSE; | |
} | |
if(num%2==0){ | |
return num==2; | |
} | |
int raiz = (int)sqrt(num); | |
for(int i=3; i < raiz; i+=2){ | |
if(num%i==0){ | |
return FALSE; | |
} | |
} | |
return TRUE; | |
} | |
int main(int argc, char *argv[]){ | |
int numeros[5] = {13,3,5,22,0}; | |
for(int n=0; n < 5; n++){ | |
if(esPrimo(numeros[n])){ | |
printf("%d es numero primo \n",numeros[n]); | |
} | |
} | |
} | |
*/ | |
// 48. | |
/* | |
#include<stdio.h> | |
#include<ctype.h> | |
#include<curses.h> | |
#include<string.h> | |
#include<stdlib.h> | |
#include<stdio.h> | |
#include<time.h> | |
#define fahr(c) (1.8*c)+32 | |
#define cels(f) (f-32)/1.8 | |
int main(int argc, char *argv[]){ | |
const int TAM = 100; | |
for(double x = 0.0; x < TAM; x+=0.5){ | |
printf("Valor = %.2lf\n",x); | |
printf("Fahrenheit = %.2lf\n",fahr(x)); | |
printf("Celsius = %.2lf\n",cels(x)); | |
} | |
return 0; | |
} | |
*/ | |
// 47. | |
/* | |
#include<stdio.h> | |
#include<ctype.h> | |
#include<curses.h> | |
#include<string.h> | |
#include<stdlib.h> | |
#include<stdio.h> | |
#include<time.h> | |
#define COMANDO "clear" | |
int salir; | |
char s; | |
int main(){ | |
for(;;){ | |
system(COMANDO); | |
puts("\t¿Quieres salir? [S-s]"); | |
salir = getchar(); | |
s = salir; | |
//printf("Entrada:%d\n",salir); | |
//printf("Salida:%c\n",s); | |
if(s =='S' || s =='s'){ | |
puts("Salimos"); | |
break; | |
} | |
} | |
return 0; | |
} | |
*/ | |
// 46. | |
/* | |
#include<stdio.h> | |
#include<ctype.h> | |
#include<curses.h> | |
#include<string.h> | |
#include<stdlib.h> | |
#include<stdio.h> | |
#include<time.h> | |
#define FILA 2 | |
#define COLUMNA 8 | |
#define MAX 2 | |
#define COMANDO "clear" | |
int obtenerAleatorio(void); | |
int menu(void); | |
int obtenerAleatorio(){ | |
srand(time(NULL)); | |
return (rand()%MAX); | |
} | |
char moneda[FILA][COLUMNA] = {"CARA","CRUZ"}; | |
int opc; | |
char cara[7]; | |
char miCara[7]; | |
int salir; | |
char s; | |
int main(int argc, char *argv[]){ | |
for(;;){ | |
puts("\t Menu"); | |
do{ | |
puts("Elige CARA[0] o CRUZ[1], ctrl + c para salir:"); | |
scanf("%d",&opc); | |
}while(opc > 1); | |
strcpy(cara,moneda[obtenerAleatorio()]); | |
printf("Cara: %s\n",cara); | |
strcpy(miCara,moneda[opc]); | |
printf("Mi cara: %s\n",miCara); | |
int resultado = strcmp(cara,miCara); | |
switch (resultado){ | |
case 0: | |
puts("Ganas"); | |
break; | |
default: | |
exit(0); | |
break; | |
} | |
} | |
return 0; | |
} | |
*/ | |
// 45. | |
/* | |
#include<stdio.h> | |
#include<ctype.h> | |
#include<curses.h> | |
#include<string.h> | |
#include<stdlib.h> | |
#include<stdio.h> | |
#include<time.h> | |
#define FILA 2 | |
#define COLUMNA 8 | |
#define MAX 2 | |
#define COMANDO "clear" | |
int obtenerAleatorio(void); | |
int obtenerAleatorio(){ | |
srand(time(NULL)); | |
return (rand()%MAX); | |
} | |
char moneda[FILA][COLUMNA] = {"CARA","CRUZ"}; | |
int opc; | |
char cara[7]; | |
char miCara[7]; | |
int salir; | |
char s; | |
int main(int argc, char *argv[]){ | |
system(COMANDO); | |
do{ | |
puts("Elige CARA[0] o CRUZ[1]:"); | |
scanf("%d",&opc); | |
//printf("[%d]\n",opc); | |
}while(opc > 1 ); | |
strcpy(cara,moneda[obtenerAleatorio()]); | |
printf("Cara: %s\n",cara); | |
strcpy(miCara,moneda[opc]); | |
printf("Mi cara: %s\n",miCara); | |
if(strcmp(cara,miCara) == 0){ | |
puts("Ganas"); | |
}else{ | |
puts("Pierdes"); | |
} | |
for(;;){ | |
puts("\tQuieres salir? [N-n]"); | |
salir = getchar(); | |
s = salir; | |
//printf("Entrada:%d\n",salir); | |
//printf("Salida:%c\n",s); | |
if(s =='N' || s =='n'){ | |
break; | |
} | |
} | |
return 0; | |
} | |
*/ | |
// 44. | |
/* | |
#include<stdio.h> | |
#include<ctype.h> | |
#include<curses.h> | |
#include<string.h> | |
#include<stdlib.h> | |
#include<stdio.h> | |
#include<time.h> | |
#define FILA 2 | |
#define COLUMNA 8 | |
#define MAX 2 | |
int main(int argc, char *argv[]){ | |
system("clear"); | |
char moneda[FILA][COLUMNA] = {"AGUILA","SOL"}; | |
srand(time(NULL)); | |
int aleatorio = rand(); | |
printf("Aleatorio: %d\n",aleatorio); | |
aleatorio = random(); | |
printf("Aleatorio: %d\n",aleatorio); | |
aleatorio = rand()%MAX; // 0 y 1 | |
printf("Aleatorio: %d\n",aleatorio); | |
for(int i=0; i < MAX; i++){ | |
printf("%s\n",moneda[i]); | |
} | |
char hugo[7]; | |
char paco[7]; | |
char luis[7]; | |
strcpy(hugo,moneda[rand()%MAX]); | |
strcpy(paco,moneda[rand()%MAX]); | |
strcpy(luis,moneda[rand()%MAX]); | |
printf("Hugo: %s\n",hugo); | |
printf("Paco: %s\n",paco); | |
printf("Luis: %s\n",luis); | |
if(strcmp(hugo,paco)==0 && strcmp(hugo,luis)==0){ | |
puts("\tEmpate: nadie gana"); | |
}else{ | |
if(strcmp(hugo,paco)!=0 && strcmp(hugo,luis)!=0){ | |
puts("\tGana: Hugo"); | |
} | |
if(strcmp(luis,hugo)!=0 && strcmp(luis,paco)!=0){ | |
puts("\tGana: Luis"); | |
} | |
if(strcmp(paco,hugo)!=0 && strcmp(paco,luis)!=0){ | |
puts("\tGana: Paco"); | |
} | |
} | |
return 0; | |
} | |
*/ | |
// 43. | |
/* | |
#include<stdio.h> | |
#include<ctype.h> | |
#include<curses.h> | |
#include<string.h> | |
#include<stdlib.h> | |
#include<stdio.h> | |
#define FILA 3 | |
#define COLUMNA 2 | |
typedef int Entero; | |
int main(int argc, char *argv[]){ | |
int $_45; // compila | |
int z_$; // compila | |
//int opera = 1/0; // no compila | |
//int &yyM; // no compila | |
int c = 'x'; // compila | |
char x = c; // compila | |
//double x = 9.88; // no compila, x ya esta definido | |
//char x2 = &c; // no compila | |
char x3 = x; // compila | |
short _x__s=6; // compila | |
unsigned long $$54=23000l; // compila | |
unsigned int n = 87; // compila | |
unsigned int n2 = -87; // compila | |
//unsigned double double= 5.88; // no compila | |
//unsigned double real = 4; // no compila | |
//unsigned double realTwo = 4.0; //no compila | |
double Double = (double) 44; // compila | |
const int MAX = 300; // compila | |
const float FLOTANTE = 12.66f; // compila | |
//byte $_33 = 1; // no compila, no existe tipo byte en C | |
const Entero myNum = 199; // compila | |
//unsigned Entero myNumTwo = 34.909; // no compila, es tipo double/float | |
unsigned char cTwo = '\0'; // compila | |
{ | |
puts("Esto deberia funcionar"); // compila | |
} | |
typedef int Numeral; // compila | |
Numeral mynumeral = 0; // compila | |
int a = atoi(argv[0]); // compila | |
int arr[]={1,2,3,4}; // compila | |
int arrTwo[2]; // compila | |
arrTwo[0] = 2; // compila | |
arrTwo[1] = 3; // compila | |
// Igual a: | |
//int arrTwo[2] = {2,3}; | |
//arrTwo[2] = 6; // compila, pero el vector solo es de tamaño 2 | |
//arrTwo[3] = 1; // compila, pero el vector solo es de tamaño 2 | |
short arrThree[FILA][COLUMNA] = { | |
{1,2},{6,5},{4,3} | |
}; | |
for(int i=0; i<FILA; i++){ | |
for(int j = 0; j<COLUMNA; j++){ | |
printf("[ %d , %d ] = %d \n",i,j, arrThree[i][j]); | |
} | |
} | |
size_t tamanyo = sizeof(arr)/sizeof(arr[0]); | |
printf("Total elementos de el arrgelo es: %ld\n",tamanyo); | |
return 0; | |
} | |
*/ | |
// 42. | |
/* | |
#include<stdio.h> | |
#include<ctype.h> | |
#include<curses.h> | |
#include<string.h> | |
#include<stdlib.h> | |
#define COMANDO "gcc --version" | |
// #undef COMANDO | |
int main(int argc, char *argv[]){ | |
system("clear"); | |
puts("\t PROGRAMANDO EN C. "); | |
puts("Nos encontramos en:"); | |
system("pwd"); | |
puts("Listamos programas en C:"); | |
system("ls *c"); | |
#ifndef COMANDO | |
puts("Versión de Gnu/Linux GCC:"); | |
system(COMANDO); | |
#endif | |
puts("Versión de Gnu/Linux GCC:"); | |
system(COMANDO); | |
return 0; | |
} | |
*/ | |
// 41. | |
/* | |
#include<stdio.h> | |
#include<ctype.h> | |
#include<curses.h> | |
#include<string.h> | |
#include<stdlib.h> | |
int operacion(int, int, char); | |
int operacion(int a, int b, char opc){ | |
int resultado = 0; | |
if(opc == '+'){ | |
puts("\tSuma"); | |
resultado = a+b; | |
} | |
if(opc == '-'){ | |
puts("\tResta"); | |
resultado = a-b; | |
} | |
if(opc =='x'){ | |
puts("\tProducto"); | |
resultado = a*b; | |
} | |
if(opc == '/'){ | |
puts("\tDivision"); | |
if(b <= 0){ | |
resultado = a; | |
}else{ | |
resultado = a/b; | |
} | |
} | |
if(opc == '%'){ | |
puts("\tResiduo"); | |
resultado = a%b; | |
} | |
return resultado; | |
} | |
int main(int argc, char *argv[]){ | |
if(argc >= 3){ | |
int a = atoi(argv[1]); | |
int b = atoi(argv[2]); | |
char c = argv[3][0]; // tomar el primer caracter de la fila 3, columna 0 | |
printf("Entrada \t a = %d b = %d , operador: %c\n",a,b,c); | |
printf("Resultado: %d\n",operacion(a,b,c)); | |
}else{ | |
puts("\tDebes introducir tres argumentos: num1 num2 operador\n"); | |
} | |
return 0; | |
} | |
*/ | |
// 40. | |
// Compilar con: | |
// cc ejemplos.c -lm -o ejecutable.exe | |
/* | |
#include<stdio.h> | |
#include<stdlib.h> | |
#include<ctype.h> | |
#include<math.h> | |
int suma(int,int); | |
int resta(int,int); | |
int producto(int,int); | |
double division(int,int); | |
double potencia(double, int); | |
int radicacion(int); | |
int suma(int a, int b){ | |
return a+b; | |
} | |
int resta(int a, int b){ | |
return a-b; | |
} | |
int producto(int a, int b){ | |
return a*b; | |
} | |
double division(int a,int b){ | |
return (double) a/b; | |
} | |
double potencia(double b, int p){ | |
int i = 1; | |
double pot = 1.0; | |
while(i <= p){ | |
pot = pot * b; | |
i++; | |
} | |
return pot; | |
} | |
int radicacion(int a){ | |
return sqrt((double) a); | |
} | |
int main(int argc, char *argv[]){ | |
int a = 0, b = 0, mySuma = 0, myResta = 0, myProd = 0; | |
double myDiv = 0.0, myPot = 0.0; | |
do{ | |
system("clear"); | |
puts("Introduce dos numeros enteros mayor a cero:"); | |
printf("a = %d y b = %d\n",a,b); | |
scanf("%d %d",&a,&b); | |
}while(a <= 0 || b <= 0); | |
printf("Numeros introducidos: a=%d y b=%d\n",a,b); | |
mySuma = suma(a,b); | |
myResta = resta(a,b); | |
myProd = producto(a,b); | |
myDiv = division(a,b); | |
myPot = potencia((double) a,b); | |
printf("Suma = %d\n",mySuma); | |
printf("Resta = %d\n",myResta); | |
printf("Producto = %d\n",myProd); | |
printf("Division = %.3lf\n",myDiv); | |
printf("Potencia = %.0lf\n",myPot); | |
printf("Raiz de a = %d es: %d\n",a, radicacion(a)); | |
printf("Raiz de b = %d es: %d\n",b, radicacion(b)); | |
return 0; | |
} | |
*/ | |
// 39. | |
/* | |
#include<stdio.h> | |
#include<stdlib.h> | |
#include<string.h> | |
#include <ctype.h> | |
#define MAX 100 | |
int main(int argc, char *argv[]){ | |
char binario[MAX]; | |
int decimal; | |
int residuo; | |
char c; | |
do{ | |
puts("Introduce numero decimal:"); | |
scanf("%d",&decimal); | |
}while(decimal <= 0); | |
printf("Decimal: %d\n",decimal); | |
while(decimal >= 2){ | |
residuo = decimal % 2; | |
decimal = (int) decimal/2; | |
c = (char)residuo+'0'; | |
strcat(binario, &c); | |
//printf("Residuo = %d , Caracter = %c\n",residuo, c); | |
//printf("Binario: %s\n",binario); | |
} | |
c = (char)decimal+'0'; | |
strcat(binario, &c); | |
//printf("Binario: %s\n",binario); | |
//printf("Longitud: %ld\n",strlen(binario)); | |
char binarioFinal[MAX]; | |
int i, j,k; | |
for(i=0; binario[i] != '\0'; i++ ); | |
j=i-1; | |
for(k=0; k<=i; k++){ | |
binarioFinal[k]=binario[j]; | |
j--; | |
} | |
//for(k=0; k<i; k++){ | |
//printf("%c", binarioFinal[k]); | |
//} | |
printf("Binario final:%s\n",binarioFinal); | |
return 0; | |
} | |
*/ | |
// 38. | |
/* | |
#include<stdio.h> | |
#include<stdlib.h> | |
#include<string.h> | |
#include <ctype.h> | |
int obtenerEntero(){ | |
int resultado; | |
puts("Introduce numero:"); | |
scanf("%d",&resultado); | |
return resultado; | |
} | |
int main(int argc, char *argv[]){ | |
int respuesta = obtenerEntero(); | |
printf("Entero: %d\n",respuesta); | |
return 0; | |
} | |
*/ | |
// 37. | |
/* | |
#include<stdio.h> | |
#include<stdlib.h> | |
#include<string.h> | |
#include <ctype.h> | |
#define MAX 45 | |
char * obtenerCadena() { | |
char char1= 'm'; | |
char char2= 'y'; | |
char *str = malloc(3); | |
str[0] = char1; | |
str[1] = char2; | |
str[2] = '\0'; | |
char *resultado; | |
puts("Introduce cadena:"); | |
resultado = malloc(sizeof(resultado)+1); | |
fgets(resultado, sizeof(resultado), stdin); | |
return resultado; | |
} | |
int main(int argc, char *argv[]){ | |
char palabra[6] = {'H','e','l','l','o','\0'}; | |
printf("Palabra: %s\n",palabra); | |
printf("Longitud: %ld\n",(sizeof(palabra)-1)); | |
char letra = palabra[4]; | |
printf("Letra: %c\n",letra); | |
char oso[4] = {letra,'s',letra,'\0'}; | |
printf("Palabra: %s\n",oso); | |
char *respuesta = obtenerCadena(); | |
printf("Respuesta: %s\n",respuesta); | |
return 0; | |
} | |
*/ | |
// 36. | |
/* | |
#include<stdio.h> | |
#include<string.h> | |
#include <ctype.h> | |
int main(int argc, char *argv[]){ | |
char x = 'X'; | |
printf("Valor de x = %c\n",x); | |
printf("Longitud: %ld\n",sizeof(x)); | |
if(isalpha(x)){ | |
puts("Es alfabetico"); | |
} | |
if(!isdigit(x)){ | |
puts("No es numerico"); | |
} | |
if(!isspace(x)){ | |
puts("No es espacio en blanco"); | |
} | |
if(!islower(x) && isupper(x)){ | |
puts("No es minuscula"); | |
} | |
x = '3'; | |
printf("Valor de x = %c\n",x); | |
if(isdigit(x)){ | |
puts("Es numerico"); | |
} | |
if(!isalpha(x)){ | |
puts("No es alfabetico"); | |
} | |
char genero; | |
puts("Introduce tu genero:"); | |
scanf("%c",&genero); | |
printf("Tu genero es: %c\n",genero); | |
char str[2] = {genero , '\0'}; | |
printf("%c\n",str[0]); | |
if(strcmp(str, "M")==0){ | |
puts("Genero Masculino"); | |
}else if(strcmp(str, "F") ==0){ | |
puts("Genero Femenino"); | |
}else{ | |
puts("Genero indefinido"); | |
} | |
return 0; | |
} | |
*/ | |
// 35. | |
/* | |
#include<stdio.h> | |
#include<string.h> | |
typedef int Entero; | |
typedef char Cadena; | |
typedef struct Alefbet{ | |
Cadena nombre[10]; | |
Cadena significado[22]; | |
Entero valor; | |
}Alefbet; | |
Alefbet llenarAlefbet(Cadena *n, Cadena *s, Entero v){ | |
Alefbet result; | |
strcpy(result.nombre, n); | |
strcpy(result.significado, s); | |
result.valor = v; | |
return result; | |
} | |
int main(int argc, char *argv[]){ | |
Alefbet myAlef = llenarAlefbet("Gimmel","Benevolencia",3); | |
printf("Nombre: %s\n",myAlef.nombre); | |
printf("Significado: %s\n",myAlef.significado); | |
printf("Valor numerico: %d\n",myAlef.valor); | |
Cadena nombre[10]; | |
Cadena significado[22]; | |
Entero valor; | |
puts("Introduce nombre:"); | |
fgets(nombre, sizeof(nombre), stdin); | |
puts("Introduce significado:"); | |
fgets(significado, sizeof(significado), stdin); | |
puts("Introduce valor:"); | |
scanf("%d",&valor); | |
myAlef = llenarAlefbet(nombre,significado,valor); | |
printf("Nombre: %s, Significado %s, Valor: %d\n",myAlef.nombre,myAlef.significado,myAlef.valor); | |
return 0; | |
} | |
*/ | |
// 34. | |
/* | |
#include<stdio.h> | |
#include <stdlib.h> | |
#include<string.h> | |
#define TAM 45 | |
typedef char Caracter; | |
struct Alumno{ | |
Caracter *nombre; | |
Caracter *apellidos; | |
}; | |
struct Alumno alumno; | |
int main(int argc, char *argv[]){ | |
Caracter nombreTemp[TAM]; | |
Caracter apellidosTemp[TAM]; | |
puts("Introduce nombre:"); | |
fgets(nombreTemp, sizeof(nombreTemp), stdin); | |
puts("Introduce apellidos:"); | |
fgets(apellidosTemp, sizeof(apellidosTemp), stdin); | |
alumno.nombre = (char*)malloc(strlen(nombreTemp)*sizeof(char)); | |
alumno.apellidos = (char*)malloc(strlen(apellidosTemp)*sizeof(char)); | |
alumno.nombre = strcpy(alumno.nombre, nombreTemp); | |
alumno.apellidos = strcpy(alumno.apellidos, apellidosTemp); | |
printf("Alumno[ %s %s ]",alumno.nombre, alumno.apellidos); | |
return 0; | |
} | |
*/ | |
// 33. | |
/* | |
#include<stdio.h> | |
typedef int Entero; | |
typedef float Flotante; | |
typedef double Real; | |
struct Numero{ | |
Entero entero; | |
Flotante flotante; | |
Real real; | |
}; | |
struct Numero obtenerDatos(struct Numero myNum){ | |
struct Numero yourNum; | |
yourNum.entero = myNum.entero; | |
yourNum.flotante = myNum.flotante; | |
yourNum.real = myNum.real; | |
return yourNum; | |
} | |
struct Numero numeroComplejo(struct Numero myNumX, struct Numero myNumY){ | |
struct Numero yourNum; | |
yourNum.entero = myNumX.entero + myNumY.entero; | |
yourNum.flotante = myNumX.flotante + myNumY.flotante; | |
yourNum.real = myNumX.real + myNumY.real; | |
return yourNum; | |
} | |
int main(int argc, char *argv[]){ | |
struct Numero ourNumero; | |
struct Numero myNumX, myNumY; | |
Entero entero = 23; | |
Flotante flotante = 12.0f; | |
Real real = 89.3; | |
ourNumero.entero = entero; | |
ourNumero.flotante = flotante; | |
ourNumero.real = real; | |
printf("Entero: %d\n",obtenerDatos(ourNumero).entero); | |
printf("Flotante: %.2f\n",obtenerDatos(ourNumero).flotante); | |
printf("Real: %.2f\n",obtenerDatos(ourNumero).real); | |
puts("Introduce número entero:"); | |
scanf("%d",&entero); | |
puts("Introduce número flotante:"); | |
scanf("%f",&flotante); | |
puts("Introduce número real:"); | |
scanf("%lf",&real); | |
ourNumero.entero = entero; | |
ourNumero.flotante = flotante; | |
ourNumero.real = real; | |
printf("Entero: %d\n",obtenerDatos(ourNumero).entero); | |
printf("Flotante: %.2f\n",obtenerDatos(ourNumero).flotante); | |
printf("Real: %.2f\n",obtenerDatos(ourNumero).real); | |
myNumX.entero = 34; | |
myNumX.flotante = 12.5f; | |
myNumX.real = 20.33; | |
myNumY.entero = 12; | |
myNumY.flotante = 5.72f; | |
myNumY.real = 4.54; | |
printf("Entero: %d\n",obtenerDatos(myNumX).entero); | |
printf("Flotante: %.2f\n",obtenerDatos(myNumX).flotante); | |
printf("Real: %.2f\n",obtenerDatos(myNumX).real); | |
printf("Entero: %d\n",obtenerDatos(myNumY).entero); | |
printf("Flotante: %.2f\n",obtenerDatos(myNumY).flotante); | |
printf("Real: %.2f\n",obtenerDatos(myNumY).real); | |
printf("Entero [complejo]: %d\n",numeroComplejo(myNumX, myNumY).entero); | |
printf("Flotante [complejo]: %.2f\n",numeroComplejo(myNumX, myNumY).flotante); | |
printf("Real [complejo]: %.2lf\n",numeroComplejo(myNumX, myNumY).real); | |
return 0; | |
} | |
*/ | |
// 32. Obtener tiempo y año actual | |
/* | |
#include <stdio.h> | |
#include <time.h> | |
int main(){ | |
time_t t = time(NULL); | |
struct tm tm = *localtime(&t); | |
puts("Tiempo actual:"); | |
printf("now: %d-%02d-%02d %02d:%02d:%02d\n", tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec); | |
printf("Año: %d\n", tm.tm_year + 1900); | |
return 0; | |
} | |
*/ | |
// 31. | |
/* | |
#include <stdio.h> | |
#include <string.h> | |
#include <stdlib.h> | |
#include <ctype.h> | |
#define RESULTADO 0 | |
void mensaje10(); | |
void mensaje11(); | |
void mensaje20(); | |
void mensaje10(){ | |
puts("Es el no. 10"); | |
} | |
void mensaje11(){ | |
puts("Es el no. 11"); | |
} | |
void mensaje20(){ | |
puts("Es el no. 20"); | |
} | |
int main(int argc, char *argv[]){ | |
int resultado = 10/10; | |
if(resultado){ | |
printf("El resultado es: %d\n",resultado); | |
} | |
resultado = 220 % 200; | |
switch (resultado) | |
{ | |
case 10: mensaje10(); | |
break; | |
case 11: mensaje11(); | |
break; | |
case 20: mensaje20(); | |
break; | |
default: puts("Default!!"); | |
break; | |
} | |
return RESULTADO; | |
} | |
*/ | |
// 30. | |
/* | |
#include <regex.h> | |
#include <stdio.h> | |
#include <string.h> | |
#include <stdlib.h> | |
#include <ctype.h> | |
int main(int argc, char *argv[]){ | |
regex_t expr; | |
int valor; | |
valor = regcomp(&expr, "[:number:]", 0); | |
if(valor == 0){ | |
puts("Exito: El patron cumple"); | |
}else{ | |
puts("Error: El patron no cumple"); | |
} | |
valor = regcomp(&expr, "[:word:]", 0); | |
if(valor == 0){ | |
puts("Exito: El patron cumple"); | |
}else{ | |
puts("Error: El patron no cumple"); | |
} | |
return 0; | |
} | |
*/ | |
// 29. | |
/* | |
#include <stdio.h> | |
#include <string.h> | |
#include <stdlib.h> | |
#include <ctype.h> | |
#define TAM 22 | |
typedef long Item; | |
typedef unsigned int Entero; | |
struct Numero{ | |
char nombre[TAM]; | |
Item id; | |
Entero valor; | |
}; | |
typedef struct Numero TipoNumero; | |
int main(int argc, char *argv[]){ | |
TipoNumero tipoNumero = {"Complejo",12000, 33}, *puntero_tipo; | |
free(puntero_tipo); | |
return 0; | |
} | |
*/ | |
// 28. | |
/* | |
#include <stdio.h> | |
#include <string.h> | |
#include <stdlib.h> | |
#include <ctype.h> | |
#define MAX 22 | |
typedef char *Array[MAX]; | |
typedef struct{ | |
Array nombre; | |
Array significado; | |
Array valor; | |
Array simbolo; | |
}ALEFBET; | |
int main(int argc, char *argv[]){ | |
ALEFBET letras; | |
char *nombres[MAX] = {"ALEF","BET","GUIMMEL","DALET","HEI","VAU","ZAYIN","JET","TET","YUD","CAF","LAMED","MEM","NUN","SAMEJ","AYIN","PEI","TZADIK","KUF","RESH","SHIN","TAV"}; | |
char *significados[MAX] = {"Cabeza de buey; Maestro; Enseñanza; Elohim","Casa; Dualidad","Camello; Puente; Benevolencia","Puerta; Hombre pobre; Elevación","Sembrar; Contemplar; Ventana","Gancho; Conexión","Espada; Corona; Sostener; Alimentar","Temor; Vida; Eterno","Inclinación; Bastón; Cama; Debajo","Mano; Confianza; Acción; Responsabilidad","La Palma de la mano; Nube","Aprender; Enseñar","Agua; Imperfección","Heredero al trono; Reino; Paz","Orden; Sostener; Confiar; Anillo","Ojo; Color; Oveja; Manatial","Boca, Comunicación","Tzadik, Justo, Cazar; Caos","Ojo de agua; Mono; Vanidad; Rodear; Fortaleza","Cabeza; Principio; Insuficiencia","Diente; Virrey; Llama eterna; Cambio","Impresión; Sello; Firma; Pacto"}; | |
char *valores[MAX] = {"1","2","3","4","5","6","7","8","9","10","20","30","40","50","60","70","80","90","100","200","300","400"}; | |
char *simbolos[MAX] = {"א","ב","ג","ד","ה","ו","ז","ח","ט","י","כ","ל","מ","נ","ס","ע","פ","צ","ק","ר","ש","ת"}; | |
for(int i=0; i < MAX; i++){ | |
letras.simbolo[i] = simbolos[i]; | |
letras.nombre[i] = nombres[i]; | |
letras.significado[i] = significados[i]; | |
letras.valor[i] = valores[i]; | |
} | |
puts("==================[ ALEFBET ]===================="); | |
for(int i = 0; i < MAX; i++){ | |
printf("\t%s\n", letras.simbolo[i]); | |
printf("Nombre: %s\n", letras.nombre[i]); | |
printf("Valor numerico: %s\n", letras.valor[i]); | |
printf("Significado: %s\n", letras.significado[i]); | |
puts("================================================="); | |
} | |
return 0; | |
} | |
*/ | |
// 27. | |
/* | |
#include <stdio.h> | |
#include <string.h> | |
#include <stdlib.h> | |
#include <ctype.h> | |
typedef struct{ | |
char *nombre; | |
char *significado; | |
unsigned valor; | |
}ALEF; | |
int main(int argc, char *argv[]){ | |
int *puntero_entero = NULL; | |
//Asignar memoria para 1 dato int | |
puntero_entero = (int *)malloc(1*sizeof(int)); | |
*puntero_entero = 33; | |
printf("%p\n", puntero_entero); | |
puntero_entero = (int *)malloc(3*sizeof(int)); | |
*puntero_entero = 123; | |
printf("%p\n", puntero_entero); | |
ALEF letra; | |
letra.nombre = (char *)malloc(4*sizeof(char)); | |
letra.nombre = strcpy(letra.nombre,"ALEF"); | |
letra.significado = (char *)malloc(100*sizeof(char)); | |
letra.significado = strcpy(letra.significado,"Cabeza de buey; Maestro; Enseñanza; Elohim"); | |
letra.valor = 1; | |
printf("Nombre: %s\n",letra.nombre); | |
printf("Significado(s): %s\n",letra.significado); | |
printf("Valor: %d\n",letra.valor); | |
free(puntero_entero); | |
return 0; | |
} | |
*/ | |
// 26. | |
/* | |
#include <stdio.h> | |
#include <string.h> | |
#include <stdlib.h> | |
#include <ctype.h> | |
typedef struct Nodo Nodo; | |
struct Nodo{ | |
long item; | |
int valor; | |
Nodo *izq; | |
Nodo *der; | |
}; | |
int main(int argc, char *argv[]){ | |
Nodo *raiz = NULL; | |
raiz = (Nodo*)malloc(sizeof(Nodo)); | |
raiz->item = (long) (1200); | |
raiz->valor = 123; | |
raiz->izq = raiz->der = NULL; | |
printf("Item:%10ld,Valor:%10d\n", raiz->item, raiz->valor); | |
free(raiz); | |
return 0; | |
} | |
*/ | |
// 25. | |
/* | |
#include <stdio.h> | |
#include <string.h> | |
#include <stdlib.h> | |
#include <ctype.h> | |
int main(int argc, char *argv[]){ | |
if(argc > 0){ | |
for(int i=1; i < argc;i++){ | |
printf("Entrada: %s\n", argv[i]); | |
} | |
} | |
return 0; | |
} | |
*/ | |
// 24. | |
/* | |
#include <stdio.h> | |
#include <string.h> | |
#include <stdlib.h> | |
int main(int argc, char *argv[]){ | |
FILE *personas; | |
char texto[100]; | |
personas = fopen("PersonasInfo.txt","r"); | |
if(personas == NULL){ | |
puts("Error: no existe el archivo"); | |
exit(1); | |
} | |
puts("Leemos el archivo:"); | |
while(!feof(personas)){ | |
fgets(texto, 100, personas); | |
printf("%s\n", texto); | |
} | |
puts("Hecho: cerramos archivo"); | |
fclose(personas); | |
return 0; | |
} | |
*/ | |
// 23. Escribir en archivo | |
/* | |
#include <stdio.h> | |
#include <string.h> | |
#include <stdlib.h> | |
int main(int argc, char *argv[]){ | |
FILE *personas; | |
personas = fopen("PersonasInfo.txt","at"); | |
if(personas == NULL){ | |
puts("Error: no existe el archivo"); | |
exit(1); | |
} | |
puts("Escribimos en el archivo:"); | |
fputs("HERIBERTO ENRIQUEZ LARA\n",personas); | |
fputs("LAURA ESQUIVEL LOPEZ\n",personas); | |
fputs("JIMENA SANCHEZ PEREZ\n",personas); | |
fputs("ANA LAURA BERRIOZABAL YUNEZ\n",personas); | |
fputs("MILTON VERA TORRES\n",personas); | |
fputs("JUAN CARLOS ROMERO VARGAS\n",personas); | |
puts("Hecho: cerramos archivo"); | |
fclose(personas); | |
return 0; | |
} | |
*/ | |
// 22. | |
/* | |
#include <stdio.h> | |
#include <string.h> | |
int main(int argc, char *argv[]){ | |
int decimal = 0b101;// 5 | |
//char *binario = (char *) malloc(500 * sizeof(char)); | |
printf("No. decimal: %d\n", decimal); | |
//free(binario); | |
return 0; | |
}*/ | |
// 21. | |
/* | |
#include <stdio.h> | |
#include <string.h> | |
union Moneda{ | |
int valor; | |
char str[4]; | |
}; | |
int main(int argc, char *argv[]){ | |
char texto[5] = "SOL"; | |
union Moneda myMoneda; | |
myMoneda.valor = (int)200; | |
strcpy(myMoneda.str, texto); | |
printf("Valor: %d\n",myMoneda.valor); | |
printf("Lado: %s\n",myMoneda.str); | |
return 0; | |
} | |
*/ | |
// 20. | |
/* | |
#include <stdio.h> | |
#include <stdlib.h> | |
#include <string.h> | |
void almacenarNombre(char *n); | |
void almacenarApellidos(char *a); | |
void almacenarSueldoAnual(float s); | |
float calcularSueldoMensual(); | |
typedef struct{ | |
char *nombre; | |
char *apellidos; | |
float sueldoAnual; | |
}Empleado; | |
Empleado vendedor; | |
int main(){ | |
char nombreTemporal[100]; | |
char apellidosTemporal[250]; | |
float sueldoAnual; | |
puts("Introduce la información"); | |
printf("-Nombre:"); | |
//gets(nombreTemporal); | |
fgets(nombreTemporal, sizeof(nombreTemporal), stdin); | |
almacenarNombre(nombreTemporal); | |
printf("-Edad:"); | |
//gets(apellidosTemporal); | |
fgets(apellidosTemporal, sizeof(apellidosTemporal), stdin); | |
almacenarApellidos(apellidosTemporal); | |
puts("Datos almacenados"); | |
printf("-Sueldo:"); | |
scanf("%f",&sueldoAnual); | |
almacenarSueldoAnual(sueldoAnual); | |
return 0; | |
} | |
void almacenarNombre(char *n){ | |
vendedor.nombre = (char *)malloc(strlen(n)*sizeof(char)); | |
vendedor.nombre = strcpy(vendedor.nombre, n); | |
} | |
void almacenarApellidos(char *a){ | |
vendedor.apellidos = (char *)malloc(strlen(a)*sizeof(char)); | |
vendedor.apellidos = strcpy(vendedor.apellidos, a); | |
} | |
void almacenarSueldoAnual(float s){ | |
vendedor.sueldoAnual = s; | |
} | |
float calcularSueldoMensual(){ | |
return (vendedor.sueldoAnual/12.0); | |
} | |
*/ | |
// 19. Gestion de memoria | |
/* | |
#include<stdio.h> | |
#include<math.h> | |
#include<assert.h> | |
#include<stdbool.h> | |
#include<stdlib.h> | |
#include<string.h> | |
int main(){ | |
int numProductos; | |
puts("No. de productos vendidos:"); | |
scanf("%d",&numProductos); | |
float *numProdVendidos = (float*)malloc(numProductos * sizeof(float)); | |
for(int i=0; i < numProductos; i++){ | |
printf("Precio del producto no. %d\n",(i+1)); | |
scanf("%f",&numProdVendidos[i]); | |
} | |
puts("Liberamos memoria..."); | |
free(numProdVendidos); | |
return 0; | |
} | |
*/ | |
// 18. | |
/* | |
#include<stdio.h> | |
#include<math.h> | |
#include<assert.h> | |
#include<stdbool.h> | |
#include<stdlib.h> | |
#include<string.h> | |
typedef struct{ | |
long int cedula; | |
char nombre[15]; | |
int diab; | |
int mesb; | |
int anob; | |
}Persona; | |
int main(int argc, char *argv[]){ | |
char fech[10]; | |
char cedu[10]; | |
Persona personas; | |
FILE *f; | |
f = fopen("PersonasInfo.txt","a"); | |
fflush(stdin); | |
if(f==NULL){ | |
printf("No pude crear el archivo correctamente"); | |
exit(1); | |
} | |
fflush(stdin); | |
printf("\t\tIntroduzca el nombre de la persona\n"); | |
printf (" ->"); scanf ("%15[^\n]%*c",&personas.nombre); | |
fprintf(f,"Nombre: %s\n",personas.nombre); | |
fflush(stdin); | |
printf("\t\tIntroduzca la cedula de la persona\n"); | |
printf (" ->"); scanf ("%9[^\n]%*c",&cedu); | |
if(let(cedu)){ | |
printf("\nLa cedula digitada contiene caracteres\n"); | |
printf("\nRegresando al menu PERSONAS...\n"); | |
system ("pause"); | |
system ("cls"); | |
personasS(); | |
} | |
personas.cedula = atoi(cedu); | |
fprintf (f,"Cedula: %li\n",personas.cedula); | |
fflush(stdin); | |
printf("\nIngrese el dia de nacimiento: "); | |
printf (" ->"); scanf ("%10[^\n]%*c",&fech); | |
if(let(fech)){ | |
printf("\nEl dia digitado contiene caracteres\n"); | |
printf("\nRegresando al menu PERSONAS...\n"); | |
system ("pause"); | |
system ("cls"); | |
personasS(); | |
} | |
personas.diab=atoi(fech); | |
if(personas.diab>31 || personas.diab<1){ | |
printf("\nDia invalido\n"); | |
printf("\nRegresando al menu PERSONAS...\n"); | |
system ("pause"); | |
system ("cls"); | |
personasS(); | |
} | |
fprintf (f,"Dia de nacimiento: %i\n",personas.diab); | |
FILE *archivo = fopen("PersonasInfo.txt","a+"); | |
char c; | |
while ( (c=fgetc(archivo))!=EOF){ | |
putchar(c); | |
} | |
printf("\n"); | |
if(!archivo) { | |
fclose (archivo); | |
printf ("No se puede abrir el archivo: %s\n"); | |
} | |
while(!feof (archivo)) { | |
c = getc (archivo); | |
printf ("%c", c); | |
} | |
printf("\n"); | |
system("pause"); | |
system("cls"); | |
personasS(); | |
system("pause"); | |
fclose(archivo); | |
puts(" ====== Fin ====="); | |
return 0; | |
} | |
*/ | |
// 17. | |
/* | |
#include<stdio.h> | |
#include<math.h> | |
#include<assert.h> | |
#include<stdbool.h> | |
#include<stdlib.h> | |
#include<string.h> | |
typedef char *Array[10]; | |
typedef struct { | |
Array array; | |
}Estructura; | |
int main(int argc, char *argv[]){ | |
Estructura estructura; | |
estructura.array[0] = "1"; | |
estructura.array[1] = "2"; | |
estructura.array[2] = "3"; | |
estructura.array[3] = "4"; | |
estructura.array[4] = "5"; | |
estructura.array[5] = "6"; | |
estructura.array[6] = "7"; | |
estructura.array[7] = "8"; | |
estructura.array[8] = "9"; | |
estructura.array[9] = "10"; | |
char *array[10]; | |
puts("\t ====== Datos array ======="); | |
for(int i=0; i < 10; i++){ | |
printf("\t original: %s\n",estructura.array[i]); | |
// asignamos el valor contenido en estructura.array a array | |
array[i] = estructura.array[i]; | |
printf("\t copia: %s\n",array[i]); | |
} | |
return 0; | |
} | |
*/ | |
// 16. | |
/* | |
#include<stdio.h> | |
#include<math.h> | |
#include<stdlib.h> | |
#include<assert.h> | |
int divide(int dividendo, int divisor); | |
int divide(int dividendo, int divisor){ | |
int aux = 0; | |
int res = dividendo; | |
//printf("dividendo: %d\n",dividendo); | |
//printf("divisor: %d\n",divisor); | |
while(res !=0 ){ | |
//printf("res: %d\n",res); | |
res = res - divisor; | |
//printf("res: %d , aux: %d\n",res,aux); | |
aux+=1; | |
} | |
return aux; | |
} | |
int main(int argc, char *argv[]){ | |
int division = divide(4,2); | |
printf("Resultado 4/2 = %d\n",division); | |
printf("Resultado 6/3 = %d\n",divide(6,3)); | |
division = divide(10,5); | |
printf("Resultado 10/5 = %d\n",division); | |
division = divide(30,2); | |
printf("Resultado 30/2 = %d\n",division); | |
return 0; | |
} | |
*/ | |
// 15. | |
/* | |
#include<stdio.h> | |
#include<math.h> | |
#include<assert.h> | |
#include<stdbool.h> | |
#include<stdlib.h> | |
#include<string.h> | |
int main(int argc, char *argv[]){ | |
puts("Ejecutando comando Linux:"); | |
system("clear"); | |
system("ls"); | |
return 0; | |
} | |
*/ | |
// 14. | |
/* | |
#include<stdio.h> | |
#include<math.h> | |
#include<assert.h> | |
#include<stdbool.h> | |
#include<stdlib.h> | |
#include<string.h> | |
#define MAX 3 | |
typedef int Entero; | |
typedef char *Cadena; | |
typedef char *Cadenas[3]; | |
typedef struct{ | |
Entero identificador; | |
Cadena nombre; | |
Cadena apellidos; | |
Entero edad; | |
Cadenas materias; | |
}Alumno; | |
int main(int argc, char *argv[]){ | |
Alumno alu; | |
alu.identificador = 123; | |
alu.nombre = "Maria"; | |
alu.apellidos = "Corona Vera"; | |
alu.edad = 12; | |
alu.materias[0] = "Computacion"; | |
alu.materias[1] = "Inglés"; | |
alu.materias[2] = "Sociologia"; | |
printf("Alumno(a): %d %s %s\n",alu.identificador, alu.nombre, alu.apellidos); | |
printf("Tiene %d años de edad\n",alu.edad); | |
puts("\tMaterias:"); | |
for(int i=0; i < MAX; i++){ | |
printf("%s\n",alu.materias[i]); | |
} | |
return 0; | |
} | |
*/ | |
// 13. | |
/* | |
#include<stdio.h> | |
#include<math.h> | |
#include<assert.h> | |
#include<stdbool.h> | |
#include<stdlib.h> | |
#include<string.h> | |
#define MAX 7 | |
typedef struct{ | |
int identificador; | |
char *nombre; | |
char *apellidos; | |
int edad; | |
char *materias[7]; | |
}Alumno; | |
int main(int argc, char *argv[]){ | |
Alumno alumno; | |
alumno.identificador = 123; | |
alumno.nombre = "Juan Carlos"; | |
alumno.apellidos = "Romero Lopez"; | |
alumno.edad = 2021-2006; | |
alumno.materias[0]="Historia"; | |
alumno.materias[1]="Ciencias sociales"; | |
alumno.materias[2]="ciencias naturales"; | |
alumno.materias[3]="Matematicas"; | |
alumno.materias[4]="Educacion fisica"; | |
alumno.materias[5]="Educacion civica"; | |
alumno.materias[6]="Computacion e Inglés"; | |
printf("Alumno %d %s %s\n",alumno.identificador,alumno.nombre,alumno.apellidos); | |
printf("Tiene %d años de edad\n",alumno.edad); | |
puts("\tMaterias:"); | |
for(int i= 0; i < MAX; i++){ | |
printf("%s\n",alumno.materias[i]); | |
} | |
return 0; | |
} | |
*/ | |
// 12. | |
/* | |
#include<stdio.h> | |
#include<math.h> | |
#include<assert.h> | |
#include<stdbool.h> | |
#include<stdlib.h> | |
#include<string.h> | |
#define MAX 3 | |
typedef struct{ | |
char registro[9]; | |
char nombre[15]; | |
char gpoSangre[4]; | |
}Alumno; | |
int main(int argc, char *argv[]){ | |
Alumno alumnos[MAX] ={ | |
{"12001","Juan C","A+"}, | |
{"12004","Maria O","O-"}, | |
{"12008","Holga P","A+"} | |
}; | |
puts("\t *** [ Alumnos ] ***"); | |
for(int i=0; i < MAX; i++){ | |
printf("Registro: %s\n",alumnos[i].registro); | |
printf("Nombre: %s\n",alumnos[i].nombre); | |
printf("Gpo. de sangre: %s\n",alumnos[i].gpoSangre); | |
puts("---------------------------------------------"); | |
} | |
return 0; | |
} | |
*/ | |
// 11. | |
/* | |
#include<stdio.h> | |
#include<math.h> | |
#include<assert.h> | |
#include<stdbool.h> | |
#include<stdlib.h> | |
#include<string.h> | |
bool mayorA10000(double sueldo); | |
bool mayorA10000(double sueldo){ | |
if(sueldo >= 10000.00){ | |
return true; | |
} | |
return false; | |
} | |
bool esCasado(char estado[]){ | |
if(strcmp("casado", estado) == 0){ | |
return true; | |
} | |
return false; | |
} | |
int main(int argc, char *argv[]){ | |
if(argc > 2 && argc < 4){ | |
printf("Sueldo: %s\n",argv[1]); | |
char estado[7]; | |
strcpy (estado, argv[2]); | |
printf("Edo. civil: %s\n",estado); | |
if(mayorA10000(atof(argv[1]))){ | |
puts("El sueldo del empleado es menor $10,000.0"); | |
} | |
if(esCasado(estado)){ | |
puts("El empleado esta casado"); | |
} | |
}else{ | |
puts("El programa requiere 2 datos, ejemplo --> ./salida 19000.0 casado/soltero"); | |
} | |
return 0; | |
} | |
*/ | |
/* | |
//10. | |
#include<stdio.h> | |
#include<math.h> | |
#include<assert.h> | |
#include<stdbool.h> | |
#include<stdlib.h> | |
#include<string.h> | |
#define PI 3.141594342 | |
#define MINIMO -34.765444 | |
int cociente(int x, int y); | |
int cociente(int x, int y){ | |
if(x < y) | |
return 0; | |
else | |
return 1+cociente(x-y,y); | |
} | |
int main(int argc, char *argv[]){ | |
printf("Valor de PI: %f\n",PI); | |
puts("Usando pow:"); | |
printf("Resultado: %f\n",pow(PI,2)); | |
puts("Usando sqrt:"); | |
printf("Resultado: %f\n", sqrt(PI)); | |
puts("Usando floor:"); | |
printf("Resultado: %f\n", floor(PI)); | |
puts("Usando abs:"); | |
printf("Valor: %f , Resultado: %d\n",MINIMO, abs(MINIMO)); | |
int charToInt = atoi("11"); | |
double charToDouble = atof("17.9"); | |
long charToLong = atol("12345567"); | |
printf("int: %d, double: %f, long: %ld\n",charToInt, charToDouble, charToLong); | |
printf("Cociente de 4 y 3: %d\n",cociente(4,3)); | |
printf("Cociente de 9 y 5: %d\n",cociente(9,5)); | |
printf("Cociente de 7 y 23: %d\n",cociente(7,23)); | |
printf("Cociente de 120 y 100: %d\n",cociente(120,100)); | |
const char PATH[10] = "C:\\deps"; | |
printf("Estamos en la ruta: %s\n",PATH); | |
const int MAX = 10; | |
int i = 1; | |
while(i < MAX){ | |
printf("%d\n",i); | |
i++; | |
} | |
puts("************************************"); | |
while(i > 0){ | |
printf("%d\n",i); | |
i--; | |
} | |
const int TAM = 26; | |
char letras[26] = {'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'}; | |
for(int j = 0; j < TAM; j++){ | |
printf("%d\n",letras[j]); | |
} | |
return 33; | |
} | |
*/ | |
// 9. | |
/* | |
#include<stdio.h> | |
#include<math.h> | |
#include<assert.h> | |
#include<stdbool.h> | |
#include<stdlib.h> | |
#include<string.h> | |
int suma(int x, int y); | |
int suma(int x, int y){ | |
return x + y; | |
} | |
int main(int argc, char *argv[]){ | |
int x, y; | |
puts("Introduce dos numeros:"); | |
scanf("%d %d",&x, &y); | |
int resultado = suma(x,y); | |
printf("Suma: %d\n",resultado); | |
puts("\tTamaño de los tipos de datos:"); | |
printf("char: %lu\n", sizeof(char)); | |
printf("int: %lu\n", sizeof(int)); | |
printf("float: %lu\n", sizeof(float)); | |
printf("double: %lu\n", sizeof(double)); | |
return 0; | |
}*/ | |
// 8. | |
/* | |
#include <stdio.h> | |
#include <stdlib.h> | |
#include <string.h> | |
#include <stdbool.h> | |
#include <assert.h> | |
typedef bool Booleano; | |
typedef char Cadena[20]; | |
int main(int argc, char *argv[]){ | |
Booleano verdadero = true; | |
Booleano falso = false; | |
Cadena titulo = "Pedro Paramo"; | |
puts("Funciona correctamente!!"); | |
assert(titulo != NULL); | |
assert(12>11 == true); | |
assert(verdadero == true); | |
assert(!falso == true); | |
return 0; | |
} | |
*/ | |
// 7. | |
/* | |
#include <stdio.h> | |
#include <stdlib.h> | |
#include <string.h> | |
#include <stdbool.h> | |
int main(int argc, char *argv[]){ | |
bool verdadero = false; | |
if(45 > 44){ | |
verdadero = true; | |
} | |
if(verdadero){ | |
puts("Esto es verdadero y se vera en pantalla."); | |
} | |
return 0; | |
} | |
*/ | |
// 6. | |
/* | |
#include <stdio.h> | |
#include <stdlib.h> | |
#include <string.h> | |
typedef char Caracter[30]; | |
typedef int Entero; | |
typedef float Flotante; | |
struct Estudiante{ | |
Entero id; | |
Caracter nombre; | |
Caracter apellidos; | |
Entero edad; | |
}; | |
struct Matricula{ | |
Entero id; | |
Caracter curso; | |
Flotante precio; | |
Entero id_estudiante; | |
}; | |
int main(int argc, char *argv[]){ | |
Entero id = 45; | |
Caracter nombre = "Carolina"; | |
Caracter apellidos = "Perez"; | |
Entero edad = 10; | |
struct Estudiante estudiante; | |
//Usando estructuras | |
estudiante.id = id; | |
estudiante.edad = edad; | |
strcpy(estudiante.nombre,nombre); | |
strcpy(estudiante.apellidos,apellidos); | |
puts("*********************************"); | |
printf("Id: %d\n",estudiante.id); | |
printf("Nombre del estudiante: %s %s\n",estudiante.nombre, estudiante.apellidos); | |
printf("Edad: %d años \n",estudiante.edad); | |
struct Matricula matricula; | |
strcpy(matricula.curso,"Programando en C"); | |
matricula.precio = 129.0f; | |
matricula.id_estudiante = estudiante.id; | |
matricula.id = 13; | |
puts("*********************************"); | |
printf("Id del curso: %d\n",matricula.id); | |
printf("Curso: %s\n",matricula.curso); | |
printf("Precio: $%.1f\n",matricula.precio); | |
printf("Id del estudiante: %d\n",matricula.id_estudiante); | |
return 0; | |
} | |
*/ | |
// 5. | |
/* | |
#include <stdio.h> | |
#include <stdlib.h> | |
#include <string.h> | |
typedef char Caracter[30]; | |
typedef int Entero; | |
struct Modelo{ | |
Entero id; | |
char nombre[30]; | |
Caracter cedula; | |
}; | |
int main(int argc, char *argv[]){ | |
Caracter caracter = "General Hollenger"; | |
Entero entero = 34; | |
struct Modelo modelo; | |
printf("Caracter: %s\n",caracter); | |
printf("Entero: %d\n",entero); | |
//Usando estructura | |
modelo.id = 1; | |
strcpy(modelo.nombre,"MX-3221"); | |
strcpy(modelo.cedula,"T30303"); | |
printf("Id: %d\n",modelo.id); | |
printf("Nombre del modelo: %s\n",modelo.nombre); | |
printf("Cedula: %s\n",modelo.cedula); | |
return 0; | |
} | |
*/ | |
// 4. | |
/* | |
#include <stdio.h> | |
#include <stdlib.h> | |
#include <string.h> | |
typedef int Entero; | |
typedef float Flotante; | |
int main(int argc, char *argv[]){ | |
Entero entero = 65; | |
Flotante flotante = 32.7f; | |
printf("Entero: %d\n",entero); | |
printf("Flotante: %f\n",flotante); | |
return 0; | |
} | |
*/ | |
// 3. | |
/* | |
#include <stdio.h> | |
#include <stdlib.h> | |
#include <string.h> | |
int getEdad(int actual, int pasado); | |
int getEdad(int actual, int pasado){ | |
return actual - pasado; | |
} | |
int main(int argc, char *argv[]){ | |
printf("Tienes %d años de edad\n",getEdad(2021,1981)); | |
return 0; | |
} | |
*/ | |
// 2. | |
/* | |
#include <stdio.h> | |
#include <stdlib.h> | |
#include <string.h> | |
int doble(int num); | |
int triple(int num); | |
int residuo(int num); | |
int doble(int num){ | |
return num*num; | |
} | |
int triple(int num){ | |
return num*num*num; | |
} | |
int residuo(int num){ | |
return (num%5==0)&&(num%3==0); | |
} | |
int main(int argc, char *argv[]){ | |
puts("Obteniendo el doble de las entradas:"); | |
for(int i=1; i < argc ;i++){ | |
printf("Numero: %s , Doble: %d , Triple: %d \n",argv[i], doble(atoi(argv[i])), triple(atoi(argv[i]))); | |
if(residuo(atoi(argv[i])) == 1){ | |
printf("\tDivisible entre 3 y 5: %d\n",atoi(argv[i])); | |
} | |
} | |
return 0; | |
} | |
*/ | |
// 1. | |
/* | |
#include <stdio.h> | |
#include <stdlib.h> | |
#include <string.h> | |
int main(int argc, char *argv[]){ | |
printf("No. argumento(s): %d\n",argc); | |
printf("Nombre del programa: %s\n",argv[0]); | |
for(int i=1; i < argc ;i++){ | |
printf("Dato: %s\n",argv[i]); | |
} | |
return 0; | |
}*/ |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
#include "modulo2.h" | |
/** Strings **/ | |
void test_g(){ | |
char c[MAX],t[MAX]; | |
int u, i, m; | |
puts("\t[STRINGS EN C]"); | |
printf("Escriba una cadena (su tamaño no ha de superar los 99 caracteres):\n"); | |
scanf("%s",c); | |
printf("Cadena: %s\n",c); | |
m = strlen(c); | |
printf("Longitud: %d\n",m); | |
if(m>99){ | |
printf("\nEl largo de la cadena ha resultado ser demasiado grande"); | |
exit(1); | |
} | |
printf("\nDame la ubicacion en la cadena donde se insertara '@' (no dar una ubicacion que supere a la cadena):\n"); | |
scanf("\n%i",&u); | |
if(u>m){ | |
printf("\nLa ubicacion dada ha superado el largo de la cadena de la cadena"); | |
exit(1); | |
} | |
strcpy(t,c); | |
for(i=0;i<m;i++){ | |
if(i>=u-1){ | |
c[i+1]=t[i]; | |
} | |
} | |
c[u-1] = '@'; | |
printf("\n\tSalida: %s\n", c); | |
} | |
/** Punteros **/ | |
void test_f(){ | |
MyFloat flotante = 45.6f; | |
MyFloat *prt_flotante = &flotante; | |
puts("\t[PUNTEROS EN C]"); | |
// Direccion | |
printf("%p : %p\n",&flotante,prt_flotante); | |
// Valor | |
printf("%.2lf : %.2lf\n",flotante, *prt_flotante); | |
} | |
/** Punteros: mmap y munmap **/ | |
void test_e(){ | |
puts("\t [PUNTEROS EN C]"); | |
int N=5; | |
int *ptr = mmap ( NULL, N*sizeof(int),PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0 ); | |
if(ptr == MAP_FAILED){ | |
puts("El mapeo ha fallado\n"); | |
//return 1; | |
} | |
for(int i=0; i<N; i++){ | |
ptr[i] = i*10; | |
} | |
for(int i=0; i<N; i++){ | |
printf("[%d] ",ptr[i]); | |
} | |
puts("\n"); | |
int err = munmap(ptr, 10*sizeof(int)); | |
if(err != 0){ | |
puts("El desmapeo ha fallado\n"); | |
//return 1; | |
} | |
puts("Hecho\n"); | |
} | |
/** Punteros: memcpy y free **/ | |
void test_d(){ | |
char c[] = "Hola mundo"; | |
char* p = (char*)malloc(sizeof(char) * 11); | |
puts("\t [PUNTEROS EN C]"); | |
printf("Mensaje: %s\n", c); | |
printf("Direccion de memoria: %p\n", &c); | |
puts("Copiamos 'c' en 'p' con memcpy"); | |
memcpy(p, c, sizeof(c)); // Copiar 'c' en 'p' | |
printf("Mensaje copiado: %s\n", p); | |
printf("Direccion de memoria: %p\n", &p); | |
puts("Liberamos memoria con free"); | |
free(p); | |
puts("Hecho!!\n"); | |
} | |
/** Punteros **/ | |
void test_c(){ | |
MyInteger numero=455; | |
MyDouble real = 34.55; | |
MyFloat flotante = 90.6274f; | |
MyString strNumero = "578"; | |
MyInteger *ptr_numero = № | |
MyDouble *ptr_real = ℜ | |
MyFloat *ptr_float = &flotante; | |
MyString *ptr_str = &strNumero; | |
puts("\t [PUNTEROS EN C]"); | |
printf("Numero decimal:%d\n",numero); | |
printf("Direccion de memoria de numero: %p\n",&numero); | |
printf("Direccion de memoria de numero [con variable puntero]: %p\n",ptr_numero); | |
printf("Numero real:%.2lf\n",real); | |
printf("Dir. real:%p\n",ptr_real); | |
printf("Numero flotante:%.2f\n",flotante); | |
printf("Dir. flotante:%p\n",ptr_float); | |
printf("Cadena String:%s\n",strNumero); | |
printf("Dir. String:%p\n",ptr_str); | |
puts("Hecho!!\n"); | |
} | |
/** Limpiar pantalla **/ | |
void limpiar(){ | |
system(LIMPIAR); | |
} | |
/** Decimal a Hexadecimal **/ | |
void test_b(){ | |
MyInteger decimal; | |
Numero myNumero; | |
puts("\t [DE DECIMAL A HEXADECIMAL]"); | |
puts("Introduce numero decimal:"); | |
scanf("%d",&decimal); | |
printf("Numero hexadecimal: %X\n",decimal); | |
puts("Introduce otro numero decimal:"); | |
scanf("%d",&decimal); | |
myNumero.valorEntero = decimal; | |
printf("Numero hexadecimal: %x\n",myNumero.valorEntero); | |
} | |
/** Elegir un color **/ | |
void test_a(){ | |
Colores mycolor; | |
MyInteger opc=0; | |
puts("\t [ENUMERACIONES]"); | |
puts("\tElije un color:"); | |
puts("1. Rojo."); | |
puts("2. Verde."); | |
puts("3. Azul."); | |
scanf("%d",&opc); | |
if(opc > 0){ | |
switch (opc){ | |
case 1: | |
mycolor = RED; | |
puts("Color: Rojo"); | |
break; | |
case 2: | |
mycolor = GREEN; | |
puts("Color: Verde"); | |
break; | |
case 3: | |
mycolor = BLUE; | |
puts("Color: Azul"); | |
break; | |
default: | |
puts("Opcion no valida\n"); | |
break; | |
} | |
printf("Has elegido %d\n",mycolor); | |
} | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
#ifndef _MODULO2 | |
#define _MODULO2 | |
#include <stdio.h> | |
#include <stdlib.h> | |
#include <sys/mman.h> | |
#include <string.h> | |
#define LIMPIAR "clear" | |
#define MAX 100 | |
typedef enum {RED=1, GREEN = 2, BLUE =3} Colores; | |
typedef float MyFloat; | |
typedef int MyInteger; | |
typedef char* MyString; | |
typedef double MyDouble; | |
typedef struct{ | |
MyInteger valorEntero; | |
MyDouble valorDouble; | |
MyFloat valorFloat; | |
MyString tipo; | |
}Numero; | |
extern Numero myNumero; | |
void test_a(void); | |
void test_b(void); | |
void test_c(void); | |
void test_d(void); | |
void test_e(void); | |
void test_f(void); | |
void test_g(void); | |
void limpiar(void); | |
#endif |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
HERIBERTO ENRIQUEZ LARA | |
LAURA ESQUIVEL LOPEZ | |
JIMENA SANCHEZ PEREZ | |
ANA LAURA BERRIOZABAL YUNEZ | |
MILTON VERA TORRES | |
JUAN CARLOS ROMERO VARGAS |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
#include <stdio.h> | |
#include <stdlib.h> | |
#include <string.h> | |
typedef struct color{ | |
int codigo; | |
char color[20]; | |
} TColor,*PColor; | |
typedef struct conjunto | |
{ | |
PColor Arreglo; | |
int tope; | |
int max; | |
} TConjunto, *PConjunto; | |
PColor crearColor (int codigo, char color [20]) | |
{ | |
PColor c; | |
c=(PColor) malloc (sizeof(TColor)); | |
c->codigo=codigo; | |
strcpy(c->color,color); | |
return c; | |
} | |
void liberarColor(PColor c){ | |
free(c); | |
} | |
PConjunto crearConjuntoVacio(int n){ | |
PConjunto A; | |
A=(PConjunto)malloc(sizeof(TConjunto)); | |
A->Arreglo=(PColor) malloc (sizeof(TColor)*n); | |
A->tope=-1; | |
A->max=n-1; | |
return A; | |
} | |
void liberarConjunto(PConjunto A) | |
{ | |
free(A->Arreglo); | |
free(A); | |
return; | |
} | |
int buscarColor (PConjunto A, int codigo) | |
{ | |
int pos =-1; | |
int i; | |
for(i=0;i<=A->tope;i++) | |
if(A->Arreglo[i].codigo==codigo)pos=i; | |
return pos; | |
} | |
PConjunto insertarColor (PConjunto A, PColor c){ | |
int pos; | |
int i; | |
if(A->tope==A->max)return A; | |
pos=buscarColor(A,c->codigo); | |
if(pos==-1){ | |
A->tope++; | |
A->Arreglo[A->tope]=*c; | |
} | |
free (c); | |
return A; | |
} | |
PConjunto eliminarColor(PConjunto A, int pos) | |
{int i; | |
if(A->tope<pos)return A; | |
if(A->tope==pos) | |
{ A->tope--; | |
return A; | |
} | |
for(i=pos;i<A->tope;i++) | |
{A->Arreglo[i]=A->Arreglo[i+1]; | |
} | |
A->tope--; | |
return A; | |
} | |
int contarConjunto(PConjunto A) | |
{ | |
return (A->tope+1); | |
} | |
int esConjuntoVacio(PConjunto A) | |
{ | |
return (A->tope ==-1); | |
} | |
TColor copiarColor (PConjunto A, int pos) // | |
{ | |
PColor c; | |
if(pos <=A->tope) return A-> Arreglo[pos]; | |
//manejo del error | |
c = crearColor(0,""); | |
return *c; | |
} | |
PConjunto unionConjunto(PConjunto A,PConjunto B) | |
{ int n,i; | |
PConjunto G;PColor c; | |
G=crearConjuntoVacio(100); | |
n=contarConjunto (A); | |
for(i=0;i<=n-1;i++) | |
{c=crearColor(0,""); | |
*c=copiarColor(A,i); | |
G = insertarColor (G,c); | |
} | |
n=contarConjunto(B); | |
for(i=0;i<=n-1;i++) | |
{c=crearColor(0,""); | |
*c=copiarColor(B,i); | |
G=insertarColor(G,c); | |
} | |
return G; | |
} | |
PConjunto interseccionConjunto(PConjunto A, PConjunto B) | |
{int i,n,pos; | |
PConjunto G;PColor c; | |
G=crearConjuntoVacio(100); | |
n=contarConjunto(A); | |
for(i=0;i<=n-1;i++) | |
{pos=buscarColor(B,A->Arreglo[i].codigo); | |
if(pos>=0) | |
{ | |
c=crearColor(0,""); | |
*c=copiarColor(B,pos); | |
G=insertarColor(G,c); | |
} | |
} | |
return G; | |
} | |
void guardarConjunto(PConjunto A,char *archivo){ | |
FILE *f;int i; | |
TColor tc; | |
PColor pc; | |
f= fopen(archivo,"wb"); | |
for(i=0;i<=contarConjunto(A)-1;i++) | |
{ tc = copiarColor(A,i); | |
pc =&tc; | |
fwrite(pc,sizeof(tc),1,f); | |
} | |
fclose(f); | |
return; | |
} | |
PConjunto cargarConjunto(char *archivo) | |
{ | |
FILE *f; TColor tc; | |
PColor pc; PConjunto A; | |
A= crearConjuntoVacio(100); | |
if(!(f=fopen(archivo,"rb"))) return NULL; | |
while (fread(pc,sizeof(TColor),1,f)) | |
{A=insertarColor(A,pc); | |
} | |
fclose(f); | |
return A; | |
} | |
void imprimirColor(PColor c) | |
{ | |
printf("......................\n"); | |
printf("codigo:%i",c->codigo); | |
printf(" color:%s \n",c->color); | |
printf("\n"); | |
} | |
void imprimirConjunto(PConjunto A){ | |
int i; | |
for(i=0;i<=contarConjunto(A)-1;i++) | |
printf("codigo:%d= Color:%s \n",A->Arreglo[i].codigo, A->Arreglo[i].color); | |
printf("......................................\n"); | |
} | |
PConjunto restarConjunto(PConjunto A, PConjunto B) | |
{ | |
int i, n, pos; | |
PConjunto C;PColor c; | |
C = crearConjuntoVacio(100); | |
n = contarConjunto(A); | |
for (i=0; i<=n-1; i++) | |
{ | |
pos = buscarColor(B,A->Arreglo[i].codigo); | |
if (pos==-1) | |
{c = crearColor(0,""); | |
*c = copiarColor(A,i); | |
C = insertarColor(C,c); | |
} | |
} | |
return C; | |
} | |
int main(int argc,char *argv[]){ | |
PConjunto A,B,G,H,T,S,C,F,J,I; | |
PColor c; | |
A=crearConjuntoVacio(10); | |
B=crearConjuntoVacio(10); | |
c=crearColor(1,"blanco"); | |
A=insertarColor(A,c); | |
c=crearColor(2,"azul"); | |
A=insertarColor(A,c); | |
c=crearColor(3,"rojo"); | |
A=insertarColor(A,c); | |
c=crearColor(1,"amarillo"); | |
B=insertarColor(B,c); | |
c=crearColor(2,"azul"); | |
B=insertarColor(B,c); | |
c= crearColor(3,"rojo"); | |
B= insertarColor(B,c); | |
G= unionConjunto(A,B); | |
H= interseccionConjunto(A,B); | |
/* | |
guardarConjunto(A,"Archivo"); | |
T=cargarConjunto("Archivo"); | |
imprimirConjunto(T); | |
*/ | |
C = restarConjunto(A,B); | |
F = restarConjunto(A,B); | |
J = restarConjunto(B,A); | |
I = interseccionConjunto(F,J); | |
imprimirConjunto(I); | |
imprimirConjunto(J); | |
imprimirConjunto(A); | |
imprimirConjunto(B); | |
imprimirConjunto(C); | |
system ("PAUSE"); | |
return 0; | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
#include "pulsaciones.h" | |
Flotante getPulsaciones(Entero edad, Entero sexo){ | |
Flotante resultado = 0.0f; | |
switch(sexo){ | |
case 1: | |
puts("Sexo: Femenino"); | |
resultado = (220-edad)/TAM; | |
break; | |
case 2: | |
puts("Sexo: Masculino"); | |
resultado = (210-edad)/TAM; | |
break; | |
default: | |
puts("Sexo y edad: Undefined"); | |
resultado = 0.0f; | |
break; | |
} | |
return resultado; | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
#ifndef PULSACIONES_H | |
#define PULSACIONES_H | |
#define TAM 10 | |
#include<stdio.h> | |
typedef int Entero; | |
typedef float Flotante; | |
Flotante getPulsaciones(Entero, Entero); | |
#endif |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment