ESTRUCTURA IF -ELSE

Mayoria de edad:
Digitas tu edad y identifica si estas en la mayoria de edad.
Pseint
Numero Mayor:
Escribe dos numeros y te digitara cual es el mayor.

Pseint
Identificando positivo y negativo:
Escribe un numero diferente o igual a 0 siempre y cuando
sea real lo procesará y te digitada si es positivo negativo o
neutro.

Pseint
Identificando número par o impar:
Colocas un numero positivo real y te dará como respuesta si es
par o impar.

Pseint
 ESTRUCTURA SWITCH

Capital del paises:

Con el pseudocodigo generlizado se puede implementar mas paises y sus
capitales para tener mas rapuestas.
Vacantes disponibles por sección para 3ro de
secundaria
Precio de cuadernos según sus marcas
En una librería se emplea para dar un resultado mas rápido
Sedes para una Barberia
Has un ejercicio de selección múltiple para ubicar las sedes de una
Barberia.
Pseint
 BUCLE WHILE - DO WHILE

Ejercicio 1: Crear un programa que determine la cantidad de materias aprobadas y

desaprobadas. Calcular el promedio.

#include<stdio.h>
#include<conio.h>

int main()
{
int N, cont,cant_aprobadas;
float nota,suma,promedio;
cont=1;
cant_aprobadas=0;
suma=0;
promedio=0;
print(“Ingrese la cantidad de materias”);
scanf("%d",&N);

while(cont<=N){ //COMIENZO DEL BUCLE MIENTRA

printf (“Ingrese la nota de la materia %d”, cont);
scanf("%f",&nota);
if (nota>=12)
{
cant_aprobadas=cant_aprobadas+1;
}
suma=suma+nota;
cont=cont+1;}//FIN DEL BUCLE MIENTRAS
promedio=suma/N;

if(promedio>=12){
printf (“El alumno esta APROBADO\n”);
}
else//SINO {
printf (“El alumno esta DESAPROBADO\n”);
}
printf("El promedio es %f:", promedio);
}
return 0;
}

Ejercicio 2: Crear un programa que determine la tabla de multiplicar

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

int main() { //Comienzo del programa principal

system("Color F1");

int
contador, num, tabla ,v_ final, cin, cout;//Declaracion de variables
contador=1; //inicializar las variables

cout<<"Ingresar el numero para realizar la tabla de multiplicar:";

cin>>num ;
cout<<"Ingresar el valor final: ";
cin>>v_final ;

while(contador< = v_final){//Comienza for- repetir para

tabla =num*contador;
cout<< " "<<num<<"x"<<contador<<"="<<tabla<<"\n";
contador = contador+1;

}//TERMINA WHILE

}RETURN 0;//Fin del programa principal

Ejercicio 3: Determinar la cantidad de vocales, consonantes de un de N letras leídas.

#include <stdlib.h>
#include<iostream>
using namespace std;

int main(){// COMIENZO DEL PROGRAMA PRINCIPAL

system ("Color F1");
int contador, N, cont_vocales, cont_consonantes, cont_caracteres;//DECLARACION DE VARIABLES
char letra;
contador=1;//INICIALIZAR LAS VARIABLES
cont_vocales=0;
cont_consonantes=0;
cont_caracteres=0;
cout<<"Ingrese la cantidad de letras:";
cin>>N; //N representa la cantidad de letras ingresados

while (contador<=N){//COMIENZA WHILE - REPETIR MIENTRAS

cout<< "Ingrese la letra" <<contador<<":";
cin>>letra;

swicth(letra){

case "a" : case "e" :case "i" :case "o": case"u":

cont_vocales=cont_vocales+1;
break;
case "b": case "c":case"d":case"f":
case "g": case "h":case"j":case"k":
case "l": case "ll":case"m":case"n":
case "ñ": case "p":case"q":case"r":
case "s": case "t":case"v":case"w":
case "x": case "y":case"z":
cont_caracteres=cont_caracteres+1;
break;

default:
cont_caracteres = cont_caracteres+1;

}//FIN SWICHT contador=contador + 1;

}//TERMINA WHILE
cout<<"\n La cantidad de vocales es: "<<cont_vocales;
cout<<"\n La cantidad de consonantes es: "<<cont_consonantes;
cout<<"\n La cantidad de caracteres es: "<<cont_caracteres;

}//FIN DEL PROGRAMA PRINCIPAL

Ejercicio 3: Determinar la contraseña de la clave de acceso e indicar si es valido o
invalido

#include<iostream>
Main ()
{
int valida= 948
int clave;

do
{
printf (“Introduzca su calve numerica:”);
scanf("%d",&clave);
if (clave! = valida)
printf("clave no valida\n");

}
while(clave!=valida);
printf("Clave valida\n")-,
}

BUCLE FOR
 Ejercicio 16

Transformar en código el pseudocódigo que se muestra a continuación, relativo a un programa que pide
un número del 1 al 10 y nos muestra la tabla de multiplicar correspondiente.

Psdocodigo

Ejercicio 17
Crea un programa que muestre todos los enteros comprendidos entre un número definido por el usuario y
100. Razonar la lógica del programa y valorar si es correcta o no.
 ARRAYS
Ejercicio 18

Crear un programa que pira una cadena al usuario y muestre por pantalla la cadena
invertida.

#include <stdlib.h>

int main () {
char texto [ 200];
int a;
printf (”\n Escribiste el texto”);
obtiene (texto);
printf (”\n Escribiste:%s”, texto”);
int len = strlen (texto);
printf ( ”\n\n Texto al revés:”);
para (a = len; a > 0 ; a - ) {
printf (“%c”, texto [a - 1 ]);
}
printf (“\n”);
obtiene (texto);

Ejercicio 19

Nos piden un array con los números impares del 1 – 50 y los muestre en pantalla de
forma ascendente.

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

int main () {
int x, cont, z, i, tabla [ 50 ];
i=0;
para (x = 1 ; x <= 50 ; x ++ ) {
cont = 0 ;
si (x % 2 == 1 ) {
tabla [i] = x;
i ++ ;
}
}
para (x = 0 ; x < i; x ++ ) {
printf ( “%d\n”, tabla [x]);
}
return 0 ;
}

Ejercicio 20

Una profesora tiene 5 números que desea dividir, multiplicar, sumar y restar en ellos.
#include <stdio.h>
#include <stdlib.h>

int main () {
int x, tabla [ 5 ];
int suma, res, mul, div;

para (x = 0 ; x < 5 ; x ++ ){
printf (“Introduzca un numero\n”);
scanf ( "% d" , & tabla [x]);
}
suma = tabla [ 0 ];
res = tabla [ 0 ];
mul = tabla [ 0 ];
div = tabla [ 0 ];

para (x = 1 ; x < 5 ; x ++ {
suma = suma + tabla [x];
res = res - tabla [x];
mul = mul * tabla [x];
div = div / tabla [x];
}
printf (”Suma:%d\n, suma);
printf (”Resta:%d\n, res);
printf (”Multiplicacion:%d\n, mul);
printf (”Division:%d\n, div);

return 0 ;
}

Ejercicio 21

5 números escrito por teclado, los copie a otro array multiplicados por 5 y muestre el segundo
array.

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

int main () {
int aux, numeros1 [ 5 ], numeros2 [ 5 ];
int i, j;

para (i = 0 ; i < 5 ; i ++ ) {
printf (“Escriba un numero”);
scanf ( "% d" , & numeros1 [i]);
}

para (i = 0 ; i < 5 ; i ++ )
{
numeros2 [i] = numeros1 [i] * 5 ;
}
para (i = 0 ; i < 5 ; i ++ ) {
printf ( "% d \ n " , numeros2 [i]);
}
return 0 ;
}

PUNTERO
Definir un tipo de datos que represente a una persona, siendo sus campos: el nombre (char *),
el apellido (char *), el nif (char [10]) y la edad (int). Llamar PERSONA a este tipo de datos.
Escribir un programa que pida por pantalla esos datos y rellene una variable de tipo PERSONA.
Prestar atención al hecho de que los miembros nombre y apellido deben alocarse
dinámicamente, y liberarse posteriormente. Escribir una función auxiliar de prototipo void
LiberarPersona(PERSONA); que libere dichos punteros.

// Este programa pide los datos por pantalla de una estructura en la

que se guardaran: nombre, apellido, nif y edad. El nombre y el
apellido son alocados dinamicamente y posteriormente liberados//

#include <stdio.h>
#include <alloc.h>
#include <stdlib.h>
#include <string.h>
#define MAX_LONG_NIF 10/* Longitud maxima del NIF */
#define MAXLEN 80/* Longitud maxima de las cadenas que leemos */

typedef struct
{
char *nombre;
char *apellido;
char nif[MAX_LONG_NIF];
int edad;
} PERSONA;

PERSONA persona, *pPersona=NULL;

typedef enum { OK = 1, ERR = 0} status;

status LeerDatos(PERSONA *pp);

void MostrarDatos(PERSONA *);

status EsDigito(char *caracter);
status CadenaVacia(char caracter[]);

int PasaAEntero(char caracter[], int maximo);

LiberarPersona(PERSONA *);

int main(void)
{
pPersona = &persona;

if (LeerDatos(pPersona) == ERR)
{
LiberarPersona(pPersona);
return ERR;
}

MostrarDatos(pPersona);
LiberarPersona(pPersona);

return OK;
}

A partir de una lista de calificaciones de los alumnos de primer grado, acceder y mostrar la
información correspondiente a dicha lista mediante el acceso de un apuntador. Uso de
punteros, estructuras de control repetitiva y el arreglo inicia con diez calificaciones.
#include <stdio.h>

#include <stdlib.h>

//Inicializo mi arreglo con las calificaciones

int mi_arreglo[] = {5, 5, 6, 6, 7, 8, 5, 5, 9, 9};//creo mi puntero

int *ptr;

int main ()

int i=0; //Mi indice

ptr = &mi_arreglo[0];

//le asigno la dirección

Escribir un programa (es decir una función main) que lea el contenido de un
archivo de texto en el que cada línea contenga los datos que definen a una
persona, y rellene de esa forma una tabla de variables de tipo
PERSONA. El programa debe recibir el nombre del archivo como argumento,
no teniendo que introducirse éste por pantalla. Para ello la función main debe
tener el prototipo estándar int main(int argc, char *argv[]). El programa debe
comprobar que el número de líneas que se van leyendo no supera la dimensión
 de la tabla definida. Una vez terminado de leer el archivo debe imprimirse por
pantalla los datos de todas las personas (una por línea), y liberarse toda la
memoria alocada dinámicamente.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <conio.h>
#define MAX_LEN 80
#define MAX_PERS 200
#define MAX_LONG_NIF 10

typedef struct
{
char *nombre;
char *apellido;
char nif[MAX_LONG_NIF];
int edad;
} PERSONA;
PERSONA persona[MAX_PERS], *pPersona=NULL;
typedef enum { OK = 1, ERR = 0} status;
void ayuda(void);
status LeerArchivo(char *archivo[], PERSONA *pp, int *pTop);
status ControlErrores(char *pNombre, char *pApellido, char *pNif, char *pEdad);
status CadenaVacia(char *caracter);
status EsDigito(char *caracter, int longitud);
int PasaAEntero(char *caracter, int maximo, PERSONA *pDatos);
void MostrarDatos(PERSONA *pp, int linea);
int main(int argc, char *argv[])
{
int top=0; /* Numero de personas leidas */

pPersona = persona; /* Puntero que apunta a una estructura de tipo PERSONA */

/* Se debe introducir: <nombre del ejecutable> <nombre del archivo> */
if (argc != 2){
ayuda(); /* Mensaje de ayuda para el usuario */
return ERR; }
if (LeerArchivo(&argv[1], pPersona, &top) == ERR)
{
printf("\nRevise el fichero, se produjo un fallo al intentar leerle.\n");

return ERR;
}
return OK;
}

Escriba un programa que encuentre el cuadrado mágico para cualquier n donde 3< n< 10 de
orden impar. Un cuadrado mágico es una cuadrícula en general de n x n, en la que se
acomodan ciertos números que cumplen que la suma de cualquier renglón, la suma de
cualquier columna y la suma de cualquiera de cualquiera de las dos diagonales es siempre la
misma. Si el cuadrado es de 3 x 3, entonces tendrá 9 casillas y los números que se acomodan
en él son todos los números del 1 al 9. Si el cuadrado es de 4 x 4, entonces tendrá 16 casillas y
los números que se acomodan en él son del 1 al 16. En general, si el cuadrado es de n x n,
 entonces tendrá n cuadrada casillas y los números que acomodaremos en él serán del 1 a n².
El orden de un cuadrado mágico es el número de renglones o el número de columnas que
tiene. Así un cuadrado de 3 x 3 se dice que es de orden 3.

#include <stdio.h>
}
#include <conio.h>
/*limitar rango (limita los valores de x al rango [0, N] )*/
#define lr( x, N ) ( (x)<0 ? N+(x)%N : ( (x)>=N ? (x)%N : (x)
))
int main()
{ int cuadrado[17][17],x,y,n,N;/*restricción del orden a los impares entre 3 y 17, por
motivos de dar mayor facilidad para entender el código*/
do{
printf( "nIngrese el orden ( impar entre 3 y 17 ): " );
scanf( "%i", &N );

}while( !(N%2) );
printf( "nCuadrado Mágico de orden %ix%i :nn", N, N);
/*Se inicia los elementos del cuadrado mágico con
ceros*/

for(x=0;x<N;x++)
for(y=0;y<N;y++)cuadrado[x][y]=0; /*Se aplica el algoritmo general para obtener
cuadrados magicos de orden impar*/
for( x=N/2,y=0,n=1; n<=N*N; ) /*se hace N*N iteraciones...*/

if ( !cuadrado[x][y] ) /*si el elemento seleccionado es cero*/

cuadrado[x][y] = n++, /*se inserta un número natural*/
x=lr(x+1,N), /*se incrementa x en 1 */
y=lr(y-1,N); /*se decrementa y en 1 */

else x=lr(x-1,N), /*se decrementa x en 1 */

y=lr(y+2,N); /*se incrementa y en 2 *//*se imprime el cuadrado magico en pantalla*/

for(y=0;y<N;y++){
printf("n");

for(x=0;x<N;x++)
printf ("%4i", cuadrado[x][y] );
}
printf ("nn Suma = %inn", (N*(N*N+1))/2 );/*se imprime la suma*/

getch ();

return 0;
}
EJERCICIO 01

EJERCICIO 02
EJERCICIO 03

EJERCICIO 04
 EJERCICIO 05

EJERCICIO 06

EJERCICIO 07
EJERCICIO 08
EJERCICIO 09
EJERCICIO 10
EJERCICIO 11
EJERCICIO 12
EJERCICIO 13

EJERCICIO 14

EJERCICIO 15
EJERCICIO 15
EJERCICIO 16

EJERCICIO 17
EJERCICIO 18