UNIVERSIDAD TECNOLOGICA NACIONAL

FACULTAD REGIONAL GENERAL PACHECO

ANEXO JOSÉ CLEMENTE PAZ

TECNICO SUPERIOR
EN PROGRAMACION

LABORATORIODE COMPUTACIÓN I
Prof. Rubén A. Calabuig

GUIA DE TRABAJOS PRACTICOS

Nº 1
EJERCICIOS INTRODUCTORIOS AL LENGUAJE
C/C++
 LABORATORIO DE COMPUTACIÓN I
UTN
GUÍA DE TRABAJOS PRÁCTICOS Nº 1
FRGP EJERCICIOS SIMPLES RESUELTOS

Ejercicios simples.....................................................................................................1
Una operación muy simple. ...........................................................................................................................................................................1
Una operación muy simple utilizando constantes.....................................................................................................................................1
Una operación muy simple utilizando constantes y cartel.......................................................................................................................1
Una operación muy simple utilizando constantes, una variable y cartel. ..............................................................................................1
Una operación muy simple utilizando sólo variables y cartel. ................................................................................................................1
Una operación muy simp le utilizando variables ingresadas y cartel......................................................................................................1
Ejercicios simples con cadenas de caracteres (strings) ....................................1
Mostrar un cartel simple. ...............................................................................................................................................................................1
Mostrar un cartel cargado en una constante...............................................................................................................................................2
Mostrar un cartel ingresado por el usuario.................................................................................................................................................2
Dos funciones específicas para cadenas: gets() y puts(). .........................................................................................................................2
Ejercicios simples con estructuras de decisión ..................................................2
Un ejercicio simple con una estructura de decisión..................................................................................................................................2
Un ejercicio simple con estructuras de decisión anidadas.......................................................................................................................2
Un ejercicio simple con estructuras de decisión y utilizando el operador &&. ...................................................................................2
Un ejercicio simple con estructuras de decisión........................................................................................................................................2
Un ejercicio simple con estructuras de decisión y utilizando el operador ||..........................................................................................2
Un ejercicio simple con estructuras de decisión múltiple. .......................................................................................................................2
Ejercicios simples con estructuras cíclicas. ........................................................2
Un ejercicio simple con un ciclo for. ...........................................................................................................................................................2
Un ejercicio simple con un ciclo for y con un if.......................................................................................................................................2
Otro ejercicio simple con un ciclo for y con un if. ....................................................................................................................................2
Un ejercicio simple con un ciclo while y un contador..............................................................................................................................3
Un ejercicio simple con un ciclo while, un contador y un sumador.......................................................................................................3
Un ejercicio simple con ciclo while, contador, sumador y cálculo de promedio.................................................................................3
Ejercicios simples con funciones de cadenas de la librería “string.h”..........3
Un ejercicio simple de copia de cadenas (utiliza la función “strcpy()”)................................................................................................3
Un ejercicio simple de medición de cadenas (utiliza la función “strlen()”)..........................................................................................3
Un ejercicio simple de comparación de cadenas (utiliza la función “strcmp()”).................................................................................3
Un ejercicio simple de concatenación de cadenas (utiliza la función “strcat()”).................................................................................3

I
 LABORATORIO DE COMPUTACIÓN I
UTN
GUÍA DE TRABAJOS PRÁCTICOS Nº 1
FRGP EJERCICIOS SIMPLES RESUELTOS

En todos los ejercicios siguientes deberán cumplirse las consignas que se mencionan abajo:

a) Diseñe los algoritmos, y realice los diagramas de flujo.

b) Codifique los diagramas utilizando el lenguaje C/C++
c) Todos los programas deben llevar un encabezado del autor como el siguiente:

//////////////////////////////////////////////////////////////////////////
// ARCHIVO : nombre del archivo (ejemplo: SUMAENT.CPP)
// PROGRAMA : nombre completo del programa (ejemplo: SUMA DE ENTEROS).
// AUTOR : nombre completo del autor.
// VERSION : numero de version (ejemplo: “1.0 estable” o “Sin version”
// CREADO : fecha de creación (ejemplo: 28/02/2008)
// IDE : Code::Blocks.
// COMPILADOR : GNU GCC Compiler (Mingway).
//------------------------------------------------------------------------
// DESCRIPCION: una breve explicacion de lo que hace el programa.
//========================================================================

d) Todos los programas deberán llevar comentarios aclaratorios en los casos que sea necesario.

Ejercicios simples
Una operación muy simple.
1) Realizar la suma 7 + 3.y mostrar el resultado por pantalla. (Ver SIMPLE01.CPP)

Una operación muy simple utilizando constantes.

2) Asignar los valores 7 y 3 a dos constantes, y mostrar el resultado d e la suma de ellas. (Ver SIMPLE02.CPP)

Una operación muy simple utilizando constantes y cartel.

3) Mejorar el ejercicio anterior agregando un mensaje aclaratorio. (Ver SIMPLE03.CPP)

Una operación muy simple utilizando constantes, una variable y cartel.

4) Asignar los valores 7 y 3 a dos constantes, guardar el resultado de la suma en una variable y mostrarlo. (Ver SIM -
PLE04.CPP)

Una operación muy simple utilizando sólo variables y cartel.

5) Modificar el ejercicio anterior reemplazando las constantes por dos variables asignadas por programa. (Ver SIM -
PLE05.CPP)

Una operación muy simple utilizando variables ingresadas y cartel.

6) Modificar el ejercicio anterior para que los valores de A y B sean ingresados por el usuario. (Ver SIMPLE06.CPP)

Ejercicios simples con cadenas de caracteres (strings)

Mostrar un cartel simple.
7) Mostrar el cartel “HOLA MUNDO”. (Ver SIMPLE07.CPP)

Autor: Prof. Rubén A. Calabuig LAB1_TP01_Ejercicios_simples_2008.doc Página 1

Mostrar un cartel cargado en una constante.
8) Asignar el cartel “HOLA MUNDO” a una constante y mostrarlo. (Ver SIMPLE08.CPP)

Mostrar un cartel ingresado por el usuario.

9) Pedir al operador el ingreso de un cartel y mostrarlo. (Ver SIMPLE09.CPP)

Dos funciones específicas para cadenas: gets() y puts().

10) Modificar el ejercicio utilizando las funciones gets() y puts().(Ver SIMPLE10.CPP)

Ejercicios simples con estructuras de decisión

Un ejercicio simple con una estructura de decisión.
11) Pedir al usuario que ingrese dos números. Si su suma es menor o igual a 10 mostrar el cartel “INGRESO CORREC-
TO”, en caso contrario mostrar el cartel “¡ERROR!... Valores fuera de rango.” (Ver SIMPLE11.CPP)

Un ejercicio simple con estructuras de decisión anidadas.

12) Pedir 3 números enteros positivos y mostrar el mayor de ellos. (Ver SIMPLE12.CPP)

Un ejercicio simple con estructuras de decisión y utilizando el operador &&.

13) Modificar el ejercicio anterior utilizando el operador && (AND). (Ver SIMPLE13.CPP)

Un ejercicio simple con estructuras de decisión.

14) Determinar si un numero ingresado se encuentra fuera del rango 10..30. (Ver SIMPLE14.CPP)

Un ejercicio simple con estructuras de decisión y utilizando el operador ||.

15) Modificar el ejercicio anterior utilizando e l operador || (OR) (Ver SIMPLE15.CPP)

Un ejercicio simple con estructuras de decisión múltiple.

16) Pedir un número entre 1 y 7, y mostrar un cartel con el nombre del día de la semana. Hipótesis: se considera al día lu -
nes como el primero de la semana. En caso que el número no pertenezca al rango deberá mostrarse un cartel informan -
do el error. (Ver SIMPLE16.CPP)

Ejercicios simples con estructuras cíclicas.

Un ejercicio simple con un ciclo for.
17) Mostrar los números impares que se encuentren entre los primeros 20 enteros positivos. (Ver SIMPLE17.CPP)

Un ejercicio simple con un ciclo for y con un if.

18) Pedir 10 pares de números enteros positivos, y en cada caso mostrar cual es el mayor de cada par. (Ver SIM -
PLE18.CPP)

Otro ejercicio simple con un ciclo for y con un if.

19) Modificar el ejercicio anterior, pero pidiéndole al usuario que informe previamente qué cantidad de pares va a ingresar.
(Ver SIMPLE19.CPP)
 LABORATORIO DE COMPUTACIÓN I
UTN
GUÍA DE TRABAJOS PRÁCTICOS Nº 1
FRGP EJERCICIOS SIMPLES RESUELTOS

Un ejercicio simple con un ciclo while y un contador.

20) Ingresar números positivos hasta que se ingrese un negativo o cero. Luego mostrar la cantidad de números ingresados.
(Ver SIMPLE20.CPP)

Un ejercicio simple con un ciclo while, un contador y un sumador.

21) Ingresar números positivos hasta que se ingrese un negativo o cero. Luego mostrar la cantidad de números ingresados y
la suma de ellos. (Ver SIMPLE21.CPP)

Un ejercicio simple con ciclo while, contador, sumador y cálculo de prome-

dio.
22) Ingresar números positivos hasta que se ingrese un negativo o cero. Luego mostrar la cantidad de números ingresados,
la suma de ellos y el promedio. (Ver SIMPLE22.CPP)
.

Ejercicios simples con funciones de cadenas de la librería

“string.h”.
Un ejercicio simple de copia de cadenas (utiliza la función “strcpy()”)
23) Pedir una cadena, copiarla en otra y mostrar la copia. (Ver SIMPLE23.CPP)

Un ejercicio simple de medición de cadenas (utiliza la función “strlen()”)

24) Pedir una cadena e informar por cuántos caracteres está formada. (Ver SIMPLE24.CPP)

Un ejercicio simple de comparación de cadenas (utiliza l a función

“strcmp()”)
25) Pedir el ingreso de una palabra clave de un máximo de 10 caracteres y asignar el valor VERDADERO a una variable si
la palabra ingresada es igual a otra almacenada en un archivo oculto. En caso contrario deberá informarse el error y
asignar el valor FALSO a la misma variable. (Ver SIMPLE25.CPP)

Un ejercicio simple de concatenación de cadenas (utiliza la función

“strcat()”)
26) Pedir al usuario que ingrese su nombre, y concatenarlo con un saludo, luego mostrar la concatenación. (Ver SIM -
PLE26.CPP)

Autor: Prof. Rubén A. Calabuig LAB1_TP01_Ejercicios_simples_2008.doc Página 3