Skip to content

Instantly share code, notes, and snippets.

@HiroNakamura

HiroNakamura/PersonasInfo.txt

Last active January 30, 2023 00:52
Show Gist options
  • Save HiroNakamura/d5323a3aff5d5fc7b85607ec8831ddeb to your computer and use it in GitHub Desktop.
Save HiroNakamura/d5323a3aff5d5fc7b85607ec8831ddeb to your computer and use it in GitHub Desktop.
Download ZIP
Programación en lenguaje C, 2da parte
Raw
ajedrez.c
#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 ;
}
}
Raw
biorritmos.c
// 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
*/
Raw
cursoprogramaenc.c
// 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;
}
Raw
ejecutar.sh
#!/bin/bash
echo Compilando: $1
gcc $1 -o ejecutable.exe
echo Ejecutando:
./ejecutable.exe
Raw
ejecutarMath.c
#!/bin/bash
echo Compilando: $1
cc $1 -lm -o ejecutable.exe
echo Ejecutando:
./ejecutable.exe
Raw
ejemplos.c
/**
* 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(&regex,"[: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(&regex,"ice",0);
return_value = regexec(&regex, "icecream", 0, NULL, 0);
printf("Regresa 1: %d\n",return_value);
print_result(return_value);
return_value2 = regcomp(&regex,"ice",0);
return_value2 = regexec(&regex, "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;
}*/
Raw
modulo2.c
#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 = &numero;
MyDouble *ptr_real = &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);
}
}
Raw
modulo2.h
#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
Raw
PersonasInfo.txt
HERIBERTO ENRIQUEZ LARA
LAURA ESQUIVEL LOPEZ
JIMENA SANCHEZ PEREZ
ANA LAURA BERRIOZABAL YUNEZ
MILTON VERA TORRES
JUAN CARLOS ROMERO VARGAS
Raw
ptrcolores.c
#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;
}
Raw
pulsaciones.c
#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;
}
Raw
pulsaciones.h
#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