Documente online.
Zona de administrare documente. Fisierele tale
Am uitat parola x Creaza cont nou
 HomeExploreaza
upload
Upload




Algoritmos en seudolenguaje

Spaniola


Unidad I: Algoritmos en seudolenguaje

1.                                     Algoritmos y Programas



1.1                   Concepto de Algoritmo ..............................4

1.2                   Características de los Algoritmos ............................4

1.3                   Datos, Tipos de Datos, Operaciones primitivas ....................5

1.3.1                                            Datos Numéricos ..............................5

1.3.2                                            Datos Lógicos (Booleanos) ......................5

1.3.3                                            Datos de Tipo Carácter y del Tipo Cadena ....................5

1.4                   Constantes y Variables .............................6

1.5                   Expresiones  .......... ..... ...... ......6

1.5.1                                            Expresiones Aritméticas ...........................7

1.5.1.1                                      Reglas de Precedencia de Operadores .........................8

1.5.2                                            Expresiones Lógicas o Booleanas ...........................8

1.5.2.1                                      Operadores de Relación .......... ..... ...... .8

1.5.2.2                                      Operadores Lógicos .......... ..... ...... .8

1.6                   Operación de Asignación .......... ..... ...... ......9

1.6.1                                            Asignación Aritmética .......... ..... ...... .9

1.6.2                                            Asignación Lógica .......... ..... ...... .9

1.6.3                                            Asignación de Strings .......... ..... ...... .9

1.7                   Entrada y Salida de Datos/Información ..........................10

2.                                     Resolución de Problemas

2.1                   Diseño del Algoritmo .......... ..... ...... .....11

2.1.1                                            Escritura inicial del Algoritmo .............................11

2.1.2                                            Seudocódigo  .......... ..... ...... ...13

3.                                     Estructura General de un Programa y Programación Estructurada

3.1                   Instrucciones  .......... ..... ...... .....14

3.2                   Tipos de Instrucciones .......... ..... ...... ...14

3.3                   Escritura de Algoritmos / Programas ..........................14

3.3.1                                            Encabezado del Algoritmo o del Programa ........................14

3.3.2                                            Declaración de Variables .......... ..... ...... 14

3.3.3                                            Declaración de Constantes Numéricas ........................15

3.3.4                                            Declaración de Variables y Constantes del Tipo Carácter .................15

3.3.5                                            Comentarios  .......... ..... ...... ...16

3.3.6                                            Estilo de Escritura de los Algoritmos / Programas ...................16

3.4                   Técnicas de Programación ..............................17

3.4.1                                            Estructuras Básicas de Control .........................17

3.4.1.1                                      Estructuras Secuenciales ...........................17

3.4.1.2                                      Estructuras de Decisión o Selección ....................18

3.4.1.2.1         Decisión Simple: Si - entonces .........................18

3.4.1.2.2         Decisión Doble : Si - entonces - si_no .........................18

3.4.1.2.3         Decisión Múltiple: Según_sea - hacer - si_no ......................19

3.4.1.2.4         Estructuras de Decisión Anidadas ........................19

3.4.1.3                                      Estructuras de Repetición ...........................21

3.4.1.3.1              Estructura de Repetición Mientras - hacer ......................24

3.4.1.3.2              Estructura de Repetición Repetir - hasta_que ......................26

3.4.1.3.3              Estructura de Repetición Desde / Para ........................27

3.4.1.3.4              Estructuras de Repetición Anidadas ........................29

Ejercicios Capítulo 1: Algoritmos y Programas - generalidades - .................30

Ejercicios Capítulo 2: Estructura general de un Programa, Programación Estructurada: Estructuras de Control:

Ejercicios Resueltos  .......... ..... ...... 33

Ejercicios Propuestos  .......... ..... ...... 41

Ejercicios Resueltos  .......... ..... ...... 42

Ejercicios Propuestos  .......... ..... ...... 56

Unidad II: Estructuras de Control

Estructuras de Control .......... ..... ...... ......62

1.                                      Estructuras Secuenciales .............................62

2.                                      Estructura de Selección .............................63

2.1                                  Selección Simple: if .......... ..... ...... .63

2.2                                  Selección Doble: if - else.............................63

2.3                                  Selección Múltiple: switch / case  ........................64

3.                                      Estructuras de Repetición ........................65

3.1                                  Estructura de repetición while  .............................65

3.2                                  Estructura de repetición do while  ...................65

3.3                                  Estructura de repetición for .............................66

Ejercicios resueltos .......... ..... ...... ....67

Ejercicios propuestos .......... ..... ...... ....80

Unidad III: Arreglos Unidimensionales

1.                                      Introducción  .......... ..... ...... ..86

2.                                      Arreglos lineales o unidimensionales .....................86

Ejercicios resueltos .......... ..... ...... 89

Ejercicios propuestos .............................106

Bibliografía .......... ..... ...... ..109

UNIDAD I: Algoritmos en seudocódigo

1.        ALGORITMOS Y PROGRAMAS.

CONCEPTO DE ALGORITMO

·            La palabra algoritmo proviene de Mohammed al-Khowârizmî, matemático persa (s. IX dC).

·            Euclides, matemático griego (s. IV aC) inventó un algoritmo para encontrar Máximo Común Divisor entre dos números

Resolución de problemas:

·            Se necesita el diseño de un algoritmo que resuelva el problema

Problema

 

Diseño del algoritmo

 

Programa (computadora)

 


Pasos para resolver un Problema:

1.     Definir (analizar) el problema

2.     Diseñar el algoritmo

3.     "Traducir" el algoritmo a un programa

4.     Ejecutar y validar el programa.

·            Los algoritmos son independientes tanto del lenguaje de programación en que se implementen como de la computadora que ejecute el programa.

·            Un lenguaje de programación es un medio para expresar un algoritmo.

·            La solución de un problema se puede representar por medio de un algoritmo

CARACTERÍSTICAS DE LOS ALGORITMOS.

Definición:

·            Procedimiento detallado,

·            se ejecuta secuencialmente (en orden),

·            para resolver un problema.

·            Es un método para resolver un problema.

Características: todo algoritmo debe ser

·            Preciso: debe indicar el orden en que se realiza cada paso,

·            Definido: "fidelidad de respuesta" la ejecución del algoritmo debe conducir siempre al mismo resultado,

·            Finito: al seguir (rutear) un algoritmo, debe terminarse en algún momento.

Composición general: todo algoritmo tiene

·            Entrada: información que alimenta al algoritmo,

·            Proceso: operaciones o cálculos necesarios para encontrar la solución,

·            Salida: respuesta (solución) al problema.

DATOS, TIPOS DE DATOS, OPERACIONES PRIMITIVAS.

·            Los algoritmos y los programas correspondientes operan sobre datos.

·            Los datos de entrada son procesados (transformados) en datos de salida (solución).

1.3.1.       DATOS NUMÉRICOS

·            Valores numéricos, o simplemente números.

·            Pueden representarse de dos formas: enteros o reales.

Enteros: (Integer)

·          También se denominan números de punto o coma fija.

·          Son un subconjunto (finito) de los números enteros (Z),

·          No tienen componentes fraccionarios ni decimales,

·          Pueden ser negativos o positivos.

·          Ejemplo: 4, 6, 12, 23, 0, -2, -35, -1200, .........

·          El rango de números enteros que maneja una computadora de 16 bits es desde -32768 a +32767.

·          En general, el rango dependerá del lenguaje de programación en que se codifique el algoritmo.

Reales: (Real)

·          También se denominan números de punto o coma flotante.

·          Son un subconjunto de los números reales (R),

·          Tienen un componente decimal (punto decimal),

·          Pueden ser negativos o positivos.

·          Todo número real consta de una parte entera y una parte decimal.

·          Ejemplo: 0.03, 3.0, 7.3456, -0

1.3.2.       DATOS LÓGICOS (BOOLEANOS)

·            Sólo puede tomar uno de dos valores: verdadero (true), falso (false).

·            Se usan para representar las alternativas sí / no frente a determinadas condiciones.

1.3.3.       DATOS DEL TIPO CARÁCTER Y DEL TIPO CADENA

·            El tipo carácter es el conjunto (finito) de caracteres que reconoce y opera la computadora,

·            Un dato tipo carácter consiste en un solo carácter.

·            Las computadoras por lo general reconocen los siguientes caracteres:

·            Caracteres alfabéticos: (A, B, C,....., Z), (a, b, c,......, z).

·            Caracteres numéricos: (1, 2, 3, ........., 0).

·            Caracteres especiales: (¿, ?, ¡, !, ", $, (, +, -, /, *, <,.............).

·            Una cadena o string de caracteres es una sucesión de caracteres delimitados por una comilla simple, o por comillas dobles (depende del lenguaje de programación).

·            La longitud del string es el número de caracteres entre comillas.

·            Ejemplo 'Buenos días', "Buenos días", '31 de diciembre', "20 de marzo", etc.

1.4.            CONSTANTES Y VARIABLES.

Constante:

·            Son un conjunto de datos (valores) que permanecen sin cambios durante todo el desarrollo del algoritmo o durante la ejecución de un programa.

·            En general las constantes pueden ser del tipo: enteras, reales, booleanas, caracteres, string.

Variables:

·            Dato o conjunto de datos cuyo valor puede variar durante el desarrollo del algoritmo o durante el programa.

·            En general las variables pueden ser del tipo: enteras, reales, booleanas, caracteres, string.

·            Una variable definida de un tipo, sólo puede tomar valores de ese tipo de datos.

·            Si se trata de asignar a una variable un tipo de dato que no corresponde, hay error de tipo.

·            Una variable se define (declara) de la siguiente manera:

Tipo Nombre_de_variable
 


·            Los nombres deben ser significativos.

1.5.            EXPRESIONES.

·            La misma idea matemática.

·            Combinaciones de constantes, variables, símbolos de operación, paréntesis, funciones especiales.

·            Ejemplo:

·            Consta de operandos y operadores.

1.5.1.       EXPRESIONES ARITMÉTICAS.

·            Análogas a las fórmulas matemáticas.

·            Los operandos son numéricos, los operadores son aritméticos, el resultado es numérico.

·            Ejemplo:

Operandos: 2, 3, 5, a, b, c


Operadores ,


el valor de la expresión es el resultado

·            Operadores aritméticos

Operador

Significado

Tipo Operando

Tipo Resultado

Exponenciación

Entero o Real

Entero o Real

Suma

Entero o Real

Entero o Real

Resta

Entero o Real

Entero o Real

Multiplicación

Entero o Real

Entero o Real

División

Real

Real

Div

División entera

Entero

Entero

Mod

Módulo (resto)

Entero

entero

Ejemplos:

·          8 x 12 se representa 8 * 12

·         

·          se representa 5 ^ 3

·            Operador /:

·          División entera o real

·          El resultado de A / B, depende del tipo de los operandos: si A y B son reales, el resultado es real; si A y B son enteros, el resultado es entero.

·          43 / 22 = 1; 1 / 10 = 0; 19.0 / 3.0 = 6. 3; 43..0 / 22.0 = 1. 954; 1.0 / 10.0 = 0.1

·            Operador %:

·          Módulo o resto,

·          A % B, se usa sólo si A y B son enteros; se obtiene el resto de A / B,

·          43 % 22 = 21; 1 % 10 = 1

·            Ejemplo:

21 : 5 = 4 parte entera 21 / 5 = 4

1

resto 21 % 5 = 1

REGLAS DE PRECEDENCIA DE OPERADORES.

·            Determinan el orden en que se ejecutan las operaciones:

Primero se evalúan las expresiones encerradas entre paréntesis. Si hay paréntesis anidados, se evalúan desde dentro hacia fuera.

Las operaciones aritméticas siguen el siguiente orden de precedencia:

·     Operador exponencial.

·     Operadores *, /.

·     Operadores div, mod,

·     Operadores +, -.

Si en una expresión hay varios operadores de igual nivel de precedencia, se evalúan de izquierda a derecha.

·     Ejemplo: 8 * 2 - 4 * (2 ^ 3) + 5 * 4 / 2

1.        

2.        

3.        

4.        

5.        

1.5.2.       EXPRESIONES LÓGICAS O BOOLEANAS.

·            Su valor siempre será verdadero o falso. (Ley del tercero excluido).

·            Se forman por la combinación de constantes lógicas, variables lógicas, utilizando operadores lógicos (not, and, or), y operadores relacionales (=, <>. <, >, <=, >=).

OPERADORES DE RELACIÓN.

·            Permiten realizar comparaciones de valores de tipo numérico o carácter.

·            Expresan condiciones.

·            Operadores de Relación

Operador

Significado

<

Menor que

>

Mayor que

Igual que

< =

Menor o igual que

>=

Mayor o igual que

< >

Distinto de

·            Formato para las comparaciones

Expresión 1 OPERADOR DE RELACIÓN Expresión 2

El resultado de la operación será verdadero o falso

·            Ejemplos: Si A = 2, y B = 6, entonces

·            A < B es verdadero

·            A * 3) > (B - 3) es verdadero

·            Los operadores de relación se pueden emplear a los tipos de datos enteros, real, lógico, carácter.

·            Los valores de los caracteres numéricos están en su orden natural: '0'  '1'  '2'  '3'.. '9'.

·            Los valores de los caracteres alfabéticos siguen el orden alfabético: ('A' < 'B' < 'C', etc.) ('a' < 'b' < 'c', etcétera1.)

1.5.2.2.       OPERADORES LÓGICOS.

·            Los básicos son not (no), and (y), or (o).

·            Tablas de verdad.

P

no p

p

q

p y q

p o q

V

F

V

V

V

V

F

V

V

F

F

V

F

V

F

V

F

F

F

F

·            Ejemplo:

·          < 3) y (6 < tiene valor de verdad verdadero

·          > 7) o ('C' < 'D') tiene valor de verdad verdadero

1.6.            OPERACION DE ASIGNACION.

·          Es el modo de darle (asignarle) valores a una variable.

·          Símbolo (operador):

·          Formato general de la operación de asignación:

Nombre_de_variable expresión
 


·          La asignación se hace de derecha a izquierda.

·          Ejemplo: S 23 significa que a la variable S se le asignó el valor 23.

·          El símbolo = se usa para el operador de igualdad.

·          Al asignar un valor a una variable, se destruye el valor que tenía antes dicha variable.

1.6.1.       ASIGNACIÓN ARITMÉTICA

·          En la asignación, las expresiones que se evalúan son aritméticas.

·          Ejemplos:

·          S // La expresión 5 + 6 + 2 se evalúa y su resultado se asigna a S (13).

·          A // Se asigna 22,5 a A

B // Se asigna 2.55 a B

TOTAL A / B // se asigna 22.5 / 2.55 a TOTAL.

// TOTAL

1.6.2.       ASIGNACIÓN LÓGICA

·          En la asignación, las expresiones que se evalúan son lógicas.

·          Ejemplos:

·          X < // Valor de verdad falso

·          Y X o (3 < // Valor de verdad verdadero

·          Z > // Valor de verdad verdadero

1.6.3.       ASIGNACIÓN DE STRINGS.

·          En la asignación, las expresiones que se evalúan son del tipo string (cadena).

·          X '12 de noviembre de 1985'.  // a X se le asigna el string '12 de noviembre de 1985'.

1.7.            ENTRADA Y SALIDA DE DATOS / INFORMACIÓN.

·            Todo algoritmo requiere una entrada de datos sobre los que opera, y muestra una salida de resultados.

·            Las operaciones de entrada leen los datos y los asignan a las variables: lectura (read).

·            Las operaciones de salida muestran los resultados: escritura (write).

·            Formato general de las operaciones de lectura y escritura:

Leer (variables de entrada)

Escribir (expresiones de salida)
 


·            Ejemplo:

·            Leer (A, B, C) representa la lectura de 3 valores de entrada asignados a las variables A, B, C.

·            Escribir ('Buenos días mundo') muestra por pantalla, o escribe 'Buenos días mundo'.

·            Si los dispositivos desde los cuales se leen o escriben datos no son especificados, por defecto se asume que los dispositivos de E/S son el teclado y la pantalla.

2.        RESOLUCIÒN DE PROBLEMAS.

·            La resolución de problemas por medio de computador se divide en 3 fases::

·            Análisis del problema,

·            Diseño del algoritmo,

·            Implementación del algoritmo en el computador.

2.1.                  DISEÑO DEL ALGORITMO.

·            Por norma general, los problemas se descomponen en "piezas pequeñas" que sean más fáciles de solucionar.

·            "Dividir para vencer"

·            Así se obtiene un algoritmo claro, preciso, completo.

·            Fases del diseño del algoritmo:

1.         Diseño descendente: el problema se descompone en sub-problemas más simples, y estos a su vez en otros más simples que puedan implementarse.

Ventajas:

El problema es descompuesto en piezas o módulos, más fáciles de comprender.

Es más fácil modificar y corregir cada módulo.

El problema global se verifica más fácilmente.

2.         Refinamiento por pasos: El diseño final del algoritmo se logra a través de sucesivos pasos, en los que aumentan los detalles.

3.         Representación del algoritmo: seudocódigo, diagrama de flujo.

·            Ejemplo: Leer el lado de un cuadrado, calcular e imprimir su área y su perímetro.

Subproblema

Refinamiento

Leer lado

Leer radio

Calcular área

Área = lado ^ 2

Calcular perímetro

Perímetro = lado * 4

Imprimir resultados

Escribir lado, área, perímetro.

2.1.1.       ESCRITURA INICIAL DEL ALGORITMO.

·            "Reglas básicas" de todo algoritmo:

·            secuencialidad (orden) de los pasos

·            Un proceso (operación) a la vez

·            Ejemplo: Almuerzo en el casino

·           

Diseño descendente: problema dividido en pasos
Ir al casino

·            Comprar el almuerzo

·            Almorzar

·            Volver a clases.

Se debe hacer un refinamiento del algoritmo:

Inicio

Verificar si hay dinero suficiente para el almuerzo

Si no alcanza el dinero entonces

3.1.Pensar en comprar un chicle en el kiosco de la estación

3.2.Ir a 7

si_no

3.3     Ir al casino

Fin_si

Si hay fila entonces

4.1.                  Ponerse en la fila

4.2.                  Mientras haya personas delante hacer

4.2.1.             Avanzar en le fila

4.3.                  Fin mientras

Fin_si

Si hay algo que quiere comer entonces

5.1.                  Hacerle el pedido a la cajera

5.2.                  Pagar el pedido

5.3.                  Recibir la boleta

5.4.                  Esperar a que los cocineros le pasen el almuerzo

5.5.                  Ubicar una mesa desocupada

5.6.                  Mientras come su almuerzo hacer

5.6.1.1.       disfrute el almuerzo

Fin_mientras

5.7.                  Salir del casino

Si_no

5.8.                  Salir enojado y hambriento del casino

Fin_si

Ir al patio

Fin

Refinamiento del punto 5.5. Ubicar una mesa desocupada.

1.                       Inicio

2.                       Repetir

Caminar con la bandeja en las manos hasta una mesa desocupada

Hasta_que ubique la mesa desocupada

3.                       Sentarse a la mesa

4.                       Fin

Notas:

·            En negritas se han resaltado las palabras "reservadas".

·            Estas palabras reservadas se usan para describir las estructuras de control del algoritmo.

·            Estructuras de control básicas:

·            Estructuras de selección: si - entonces - si_no (if - then - else)

Permiten elegir una alternativa de acción a seguir.

·            Estructuras de repetición: mientras - hacer; repetir - hasta; iterar - fin_iterar. (while - do; repeat - until)

Permiten repetir una acción.

·            Se ha empleado la indentación, para facilitar la lectura y seguimiento del algoritmo. Como norma, se empleará siempre el indentado cuando se escriba un algoritmo, y cuando se escriba el código fuente de él.

2.1.2.       SEUDOCÓDIGO.

·            Lenguaje de especificación o descripción de algoritmos.

·            Facilita la "traducción" del algoritmo a un lenguaje de programación específico.

·            El seudocódigo debe ser traducido a un lenguaje programación.

·            Si hay errores, es fácil modificar el seudocódigo.

·            El seudocódigo presenta dos ventajas evidentes sobre el diagrama de flujo: es más rápido de crear, y es más fácil de modificar.

·            Originalmente el seudocódigo representa las acciones por medio de una serie de palabras reservadas, en inglés: start, end, stop, if-then-else, while-end, repeat-until, etc.

·            Se pueden usar palabras reservadas en castellano: inicio, fin, leer, escribir, parar, si-entonces-en_caso_contrario, mientras-hacer, fin-mientras, repetir-hasta_que, etc.

·            Al escribir un algoritmo en seudocódigo, se debe usar la indentación (sangría en el margen izquierdo) de diferentes líneas.

Inicio

Comienzo del seudocódigo
Fin

Término del seudocódigo

Comentarios de una sola línea.

No realizan acción, y sólo sirven para documentar el código.

Si los comentarios abarcan más de una línea
Leer (lista_de_variables)

Para introducir valores y asignarlos a una o varias variables
Escribir (lista_de_expresiones)

Para imprimir en un dispositivo estándar
Nombre_variable expresión

Asignación de una expresión
Si condición entonces

Acciones 1

Fin_si

Estructura de decisión simple
Si condición entonces

Acciones 1

Si_no

Acciones 2

Fin_si

Estructura de decisión doble
Según_sea expresión ordinal hacer

Lista_de valores_ordinales: acciones 1

..............

[si_no acciones N]

fin_según

Estructura de decisión múltiple

// el corchete indica opcionalidad.
Mientras condición hacer

Acciones

Fin_mientras

Estructuras repetitivas, o ciclos

Repetir

Acciones

Hasta_que condición
Desde variable v_inicial hasta v_final

[incremento | decremento incremento]

hacer acciones

Fin_desde

3.        ESTRUCTURA GENERAL DE UN PROGRAMA. Y PROGRAMACIÓN ESTRUCTURADA.

3.1                   INSTRUCCIONES

Acciones o instrucciones

·            Primero se deben escribir,

·            Luego se almacenan en memoria

·            Se ejecutan en el mismo orden (secuencia) en que fueron escritas

·            Si las instrucciones se ejecutan secuencialmente, sin bifurcaciones, decisiones ni comparaciones, se dice que el programa es lineal.

3.2                   TIPOS DE INSTRUCCIONES

·            Las instrucciones básicas, independientes del lenguaje son:

1)        Instrucciones de inicio / fin,

2)        Instrucciones de asignación,

3)        Instrucciones de lectura,

4)        Instrucciones de escritura,

5)        Instrucciones de bifurcación.

3.3                   ESCRITURA DE ALGORITMOS / PROGRAMAS

·            La escritura de un algoritmo debe ser lo más clara posible, y estructurada.

·            Esto facilita su entendimiento y traspaso a un lenguaje de programación.

·            Todo algoritmo consta de:

a)        Encabezado: comienza con la palabra algoritmo, seguida por el nombre del programa,

b)        Bloque algoritmo: resto del programa. Consta de 2 componentes (secciones):

·          Declaraciones: definen o declaran variables y constantes que tengan nombres.

·          Acciones ejecutables: son las que realizará el programa ya implementado.

3.3.1              ENCABEZADO DEL ALGORITMO O DEL PROGRAMA

·            Todos los algoritmos y programas deben tener un identificador,

·            Se usa la palabra reservada algoritmo

·            Ejemplo: algoritmo SUMATORIA

3.3.2              DECLARACIÓN DE VARIABLES

·            Se definen o declaran TODAS las variables usadas en el algoritmo.

·            Se deben listar sus nombres, y especificar sus tipos

·            Palabra reservada var

·           

Var

Tipo_1: lista_de_variables_1

Tipo_2: lista_de_variables_2

Tipo_n: lista_de_variables_n
 
Formato:

Tipo: tipo de dato básico (entero, real, carácter, lógico)

Lista de variables: variable simple, o lista de variables separadas por coma

·           

var

Entero: número_trabajador

Real: horas, sueldo, imposiciones
Ejemplo : var

Entero: número_trabajador

Real: horas

Real: sueldo

Real: imposiciones

·            Buena práctica:

·            Utilizar nombres significativos para las variables.

·            Incluir comentarios que indiquen cómo se usa la variable.

·            Ejemplo: var

Entero: número_trabajador // identificación del empleado

Real: horas // nº de horas trabajadas

Real: sueldo // líquido a recibir

Real: imposiciones // % del sueldo no imponible

3.3.3              DECLARACIÓN DE CONSTANTES NUMÉRICAS

·            Se definen o declaran TODAS las constantes que tengan nombre.

·            Formato:

Const

Pi = 3.141592

Altura = 23

Tiempo = 8.38
 


Los valores de estas constantes no varían en el transcurso del algoritmo.

3.3.4              DECLARACIÓN DE VARIABLES Y CONSTANTES DEL TIPO CARÁCTER

·            Las variables de caracteres se declaran de 2 maneras:

1)        Almacenar un solo valor:

Var carácter : nombre, inicial, nota, letra

·            nombre, inicial, nota, letra, almacenarán sólo un carácter.

2)        Almacenar múltiples caracteres (string):

Var cadena [20] : nombre

·            Las constantes de un solo carácter, y las de string, se pueden declarar de igual forma que las constantes numéricas

Const

Asterisco = ' * '

Fecha = '12 de noviembre'

 


3.3.5              COMENTARIOS

·            Los comentarios que se hacen respecto al código fuente del programa constituyen la documentación interna.

esto es un comentario

 


3.3.6              ESTILO DE ESCRITURA DE LOS ALGORITMOS / PROGRAMAS

·            Formato:

Algoritmo Nombre del programa // encabezado

// Declaraciones

var tipo de datos : lista de variables

const lista de constantes = valor

inicio // cuerpo del algoritmo

< sentencia 1 >

<Sentencia 2>

<sentencia n>

fin

·            Los string se encierran entre comillas simples,

·            Usar sangría para indentar, facilita la legibilidad del algoritmo.

3.4                   TÉCNICAS DE PROGRAMACIÓN

·            Los problemas medianos y grandes son eficientemente resueltos, empleando técnicas de programación modular y programación estructurada.

·            Programación Modular: El problema de descompone en módulos independientes, cada modulo ejecuta una sola tarea

·            Programación Estructurada: Cada módulo se programa mediante métodos estructurados, utilizando estructuras de control que minimizan la complejidad de los problemas

·            Posteriormente se ensamblan los módulos.

3.4.1              ESTRUCTURAS BÁSICAS DE CONTROL:

·            Todo algoritmo / programa se puede escribir usando sólo 3 tipos de estructuras de control:

·            Secuenciales,

·            De selección,

·            Repetitivas.

3.4.1.1         ESTRUCTURAS SECUENCIALES

·            Una acción (instrucción) sigue en secuencia a otra.

·            La salida de una acción es la entrada para otra acción, y así sucesivamente.

acción 1

acción 2

acción n

Inicio

<acción 1>

<acción 2>

Fin
 


·            Ejemplo: calcular la suma y el producto de dos números.

Inicio

Leer ( x )

Leer ( y )

Suma x + y

Producto x * y

Escribir (suma, producto)

Fin

3.4.1.2         ESTRUCTURAS DE DECISIÓN O DE SELECCIÓN

·            Se usan para tomar decisiones lógicas (estructuras de decisión o alternativas),

·            Se evalúa una condición, y según sea el resultado, se ejecuta una opción u otra,

·            Las condiciones se especifican usando expresiones lógicas,

·            Palabras reservadas: si, entonces, si_no, (if, then, else). Gráficamente se usa el rombo.

·            Las estructuras de selección pueden ser:

·            Simples,

·            Dobles,

·            Múltiples.

3.4.1.2.1                  DECISIÓN SIMPLE

·                         Si - entonces

·                         Ejecuta una determinada acción cuando se cumple una determinada condición.

·                         Si la condición es V, entonces se ejecuta la acción A (o acciones),

·                         Si la condición es F, entonces no hacer algo.

·                         Formato:

condición

acciones

Si <condición> entonces

<acción 1>

<acción 2>

<acción n>

Fin_si

 


falsa

verdadera

3.4.1.2.2                  DECISIÓN DOBLE

·            Si - entonces - si_no

·            La selección simple es muy limitada.

·            Habitualmente se necesita una estructura que permita elegir entre dos alternativas posibles, en función del cumplimiento o no de una determinada condición.

·            Si la condición es V, se ejecuta la acción A1, si es F, se ejecuta la acción A2.

·            Formato:

¿condición?

acción 1

acción 2

Si <condición> entonces

<acción 11>

<acción 12>

<acción 1n>

si_no

<acción 21>

<acción 22>

<acción 2n>

Fin_si
 


Si No

3.4.1.2.3                  DECISIÓN MÚLTIPLE

·            Según_sea - hacer - si_no

·            A veces es necesario que existan más de 2 elecciones posibles,

·            Se podría resolver mediante estructuras de selección simples o dobles, anidadas o en cascada, PERO si el número de alternativas es grande, se dificulta su manejo.

·            La estructura de decisión múltiple evaluará una expresión que podrá tomar n valores distintos. Según elija uno de estos valores en la condición, se ejecutará una de las n posibles acciones, es decir, el algoritmo seguirá un determinado camino entre n posibles.

·            Formato:

condición

Acción 1

Acción 2

Acción 3

Acción n

n


·            Formato:

expresión (E) hacer

e1: acción 11

acción 12

acción 1n

e2: acción 21

acción 22

acción 2n

en: acción n1

acción n2

acción nn

si_no: acción X

Fin_según
 

Según E hacer

Fin_según
 

Caso_de E hacer

Fin_hacer
 


·            En el caso de sentencias compuestas, también se puede usar

Según_sea expresión (E) hacer

e1: inicio

acción 11

acción 12

acción 1n

fin

e2: inicio

acción 21

acción 22

acción 2n

fin

en: inicio

acción n1

acción n2

acción nn

fin

si_no: acción X

Fin_según
 


3.4.1.2.4                  ESTRUCTURAS DE DECISIÓN ANIDADAS

·            Las estructuras de selección si - entonces y si - entonces - si_no, involucran la selección de una o dos alternativas.

·            Una estructura si - entonces puede contener otra estructura si - entonces, y ésta a su vez otra, y así sucesivamente. Es decir, la estructura si puede llegar a contener más de dos alternativas.

·            Las estructuras si internas están anidadas.

·            Es importante mantener la indentación para que el algoritmo sea claro.

·           

Condición 1

Acción 1

Condición 2

Acción 2

Condición n

Acción ni

Acción nj
Formato:

Si <condición 1> entonces

<acciones>

Si_no

Si <condición 2> entonces

<acciones>

Si_no

Si <condición 3> entonces

<acciones>

Si_no

Fin_si

Fin_si

Fin_si

3.4.1.3         ESTRUCTURAS DE REPETICIÓN

·            Generalmente los programas se diseñan para que una operación (o un conjunto de ellas) se repitan muchas veces.

·            Es común que un algoritmo repita acciones un número determinado de veces.

·            Estas estructuras se denominan bucles o ciclos, y la repetición de sentencias se llama iteración.

·            Ejemplo: se requiere sumar una lista de números ingresados por teclado:

·            Se declara una variable suma, y se inicializa en cero (suma

·            Los números se leen desde teclado y sus valores se añaden a la variable suma,

·            La variable suma, almacena las sumas parciales.

·            Posible algoritmo:

Algoritmo suma_números

Var Entero: núm, suma.

Inicio

suma

Leer (num)

suma suma + num

Leer (num)

suma suma + num

Leer (num)

Fin

Y se repite para cada número de la lista

·            Es decir, este algoritmo repite n veces las acciones:

Bucle, ciclo, lazo
 
Leer (num)

suma suma + num

·            Para diseñar un ciclo, hay que considerar:

·            ¿Qué contiene el ciclo?, es decir, cómo está estructurado,

·            ¿Cuántas veces se debe repetir el ciclo?

·            Al usar un ciclo para sumar una lista de números, se debe saber cuántos números se han de sumar. Esto es necesario para detener el ciclo.

·            Si el usuario ingresa la cantidad de números a sumar, por ejemplo N, existen 2 formas para contar las iteraciones:

1.         Usar una variable total que se inicializa con valor N, y se va decrementando su valor en 1 cada vez que el ciclo se repite (total total - 1), hasta llegar a 0,

Algoritmo suma_números

Var Entero: N, total

Entero: num, suma.

Inicio

Leer (N)

total N

Mientras total > 0 hacer

Leer (num)

suma suma + num

total total - 1

Fin_mientras

 
suma

Repetir

Leer (num)

suma suma + num

total total - 1

Hasta_que total = 0

Escribir ('La suma de los', N, 'números es', suma)

Fin

2.         Usar una variable total que se inicializa en 0 ó 1, y se va incrementando en 1 cada vez que el ciclo se repite

(total total + 1), hasta llegar a N.

Algoritmo suma_números

Var Entero: N, total

Entero: num, suma.

Inicio

Leer (N)

total

Mientras total < N hacer

Leer (num)

suma suma + num

total total + 1

Fin_mientras

 
suma

Repetir

Leer (num)

suma suma + num

total total + 1

Hasta_que total = N

Escribir ('La suma de los', N, 'números es', suma)

Fin

·            La condición de salida del ciclo se indica al comienzo o al final del bucle.

·            Condición de salida al comienzo del ciclo, estructura Mientras - hacer - Fin_mientras

Algoritmo suma

Inicio

K

S

Leer (n)

Mientras K < n hacer

K K + 1

S S + K

Fin_mientras

Escribir (S)

Fin

El ciclo se repite mientras se cumple la condición (K < n)

·            Condición de salida al final del ciclo, estructura Repetir - hasta_que

Repetir

K K + 1

S S + K

Hasta_que K > n

El ciclo se repite hasta que se cumple la condición (K > n)

·            Condición de salida se realiza con un contador que cuenta el número de iteraciones

Desde i = Vi hasta Vf hacer

S S + i

Fin_desde

i es un contador que cuenta desde el valor inicial (Vi) hasta el valor final (Vf)

3.4.1.3.1                  ESTRUCTURA DE REPETICIÓN Mientras (while)

·            El ciclo se repite mientras se cumple una determinada condición.

·            Lo primero que se hace es evaluar la condición,

·            Si es F, no se ejecuta el ciclo, y el programa sigue en la siguiente instrucción,

·            Si es V, se ejecuta el ciclo ("se entra al ciclo"), evaluándose la condición en cada iteración. El proceso se repite mientras la condición sea V.

·            Formato:

no
 

si
 

acciones

condición hacer

<Acción 1>

<Acción 2>

<Acción n>

Fin_mientras
 

condición


·            Ejemplo: contar los números enteros positivos, ingresados por teclado.

Análisis: se usan 2 variables: número, contador. El ciclo se detiene cuando se lee un número negativo o cero.

Algoritmo cuenta_enteros

Var Entero: número, contador

Inicio

Contador

Leer (número)

Mientras número > 0 hacer

Contador contador +1

Leer (número)

Fin_mientras

Escribir (contador)

Fin

·            Regla: las pruebas en las condiciones (expresiones booleanas) deben ser del tipo >, <, > =, < =. No se recomiendan las pruebas de igual a (=) o diferente a (< >).

·            Terminación de los bucles con los datos de entrada: si el algoritmo lee una lista de valores, es necesario incluir algún mecanismo que permita terminar el ciclo. En general se consideran 4 métodos para terminar un bucle:

1.        Preguntar antes de la iteración: se solicita mediante un mensaje al usuario si existen más entradas:

suma

Escribir ('Hay más valores en la lista S/N')

Leer (resp) // Var Char: resp

Mientras ((resp = 's') o (resp = 'S')) hacer

Escribir ('Valor')

Leer (n)

suma suma + n

Escribir ('Hay más valores en la lista S/N')

Leer (resp)

Fin_mientras

Este método es bueno siempre y cuando la lista de valores no sea grande

2.        Encabezar la lista de datos con su tamaño (Variable N que representa el total, cuyo valor se decrementa)

3.        Finalizar la lista con cierto valor de entrada: uso del centinela

·          Es el método más correcto.

·          Centinela: valor especial que se usa para indicar el final de una lista.

·          Ejemplo: una lista de notas (escala 1 - 7) tiene como centinela un valor fuera de este rango.

·          Ejemplo: suma de todos los números positivos, introducidos por teclado:

Suma

Leer (num)

Mientras num >= 0 hacer

Suma suma + num

Leer (num)

Fin_mientras

El centinela leído no se añade a la suma, pues se sale del bucle,

Debe existir una instrucción Leer ( ) dentro del bucle, pues debe leerse (y detectarse) el centinela.

4.        Agotar los datos de entrada:

·          Se comprueba si no hay más datos para ingresar,

·            Ejemplo: analice los algoritmos. ¿Qué se muestra?, ¿Cuántas veces se repite el ciclo?

a)                       i

Mientras i < 6 hacer

Escribir (i)

i i +1

Fin_mientras

Se muestran los valores de la variable de control i : 0, 1, 2, 3, 4, 5; el ciclo se repite 6 veces

b)                      i

Mientras i < 6 hacer

i i +1

Escribir (i)

Fin_mientras

La salida es: 1, 2, 3, 4, 5, 6; el ciclo se repite 6 veces

3.4.1.3.2                  ESTRUCTURA DE REPETICIÓN Repetir (repeat)

·            Muchas veces es conveniente que un ciclo se ejecute al menos una vez. Con la estructura repetir-hasta_que, el cuerpo del bucle se ejecuta siempre al menos una vez ya que la condición se evalúa al final del proceso.

·                         Esto no se puede hacer con el ciclo mientras si la condición es F.

·                         Formato:

acciones


<Acciones>

Hasta_que <condición>

 


falsa
 

condición

verdadera
 

·            La estructura repetir se ejecuta hasta que se cumpla una determinada condición, que se comprueba al final del bucle.

·            Lo primero que hace la estructura es ejecutar acciones, luego se evalúa la condición,

·            Si es F, se ejecuta el ciclo ("se vuelve a entrar al ciclo"),

·            Si es V, no se ejecuta el ciclo, y el programa sigue en la siguiente instrucción.

·            Es decir, es lo opuesto de lo que sucede con la estructura mientras.

·            Ejemplo 3.21:

Algoritmo total_números_ingresados

Var Entero: num, contador

Inicio

Mientras contador < 4 hacer

Leer (num)

cont cont + 1

Fin_mientras
 
Contador

Repetir

Leer (num)

contador contador + 1

Hasta_que contador > = 4

Escribir ('Total de números', contador)

Fin

El ciclo se repite en tanto la condición sea F
 

El ciclo se repite en tanto la condición sea V
 


·            Diferencias entre las estructuras mientras - hacer - fin_mientras y repetir - hasta_que :

·            La estructura repetir termina cuando la condición es V,

·            La estructura mientras termina cuando la condición es F,

·            En la estructura repetir el cuerpo del bucle se ejecuta siempre al menos una vez,

·            La estructura mientras es más general y tiene la posibilidad de que el bucle no se ejecute.

3.4.1.3.3                  ESTRUCTURA DE REPETICIÓN Desde / Para (for)

·            Se usa cuando se conoce anticipadamente el número de veces que se repetirá el ciclo.

·            Cuando el número de iteraciones es fijo, se usa la estructura desde / para.

·            La estructura desde ejecuta las acciones del cuerpo del bucle un número especificado de veces, y controla automáticamente el número de iteraciones (pasos por el bucle).

·            Formato:

calcular

valor inicial y

valor final

Inicialización

del Contador
 

V Vi
 


variable índice

al valor inicial

 


variable

índice > valor final

Acciones

V V + 1


verdadero
 


V > Vf

acciones

incrementar

variable índice


falso
 


a)

Desde v vi hasta vf [ incremento | decremento <valor> ] hacer

<acciones>

Fin_desde

b)

Para v vi hasta vf [ incremento | decremento <valor> ] hacer

<acciones>

Fin_para

// v : variable índice

// vi : valor inicial de la variable

// vf : valor final de la variable

·            Ejemplo:

Algoritmo suma

Var entero: i, n, s

Inicio

s

leer (n)

Desde i 1 hasta n con incremento 2 hacer

s s + i

Fin_desde

Escribir ('Suma = ', s)

Fin

·            Si Vi (v Vi) < Vf : Se debe incrementar

·            Si Vi (v Vi) > Vf : Se debe decrementar

Ejemplo: desde i 20 hasta 10 hacer

<acciones>

fin_desde

no se ejecuta, pues el vi es 20y el vf es 10, y se supone un incremento positivo de 1

Ejemplo: desde i 20 hasta 10 decremento 1 hacer

<acciones>

fin_desde

·            Hacer una estructura desde con una estructura mientras:

a)        Estructura desde con incrementos positivos de la variable índice:

V vi

Mientras v < = vf hacer

<acciones>

v v + incremento

Fin_mientras

b)        Estructura desde con incrementos negativos de la variable índice:

V vi

Mientras v > vf hacer

<acciones>

v v - decremento

Fin_mientras

·            La estructura desde se puede realizar con algoritmos basados en la estructuras mientras y repetir. Esto significa que se pueden intercambiar.

Las estructuras equivalentes a desde son:

b) inicio

i n

mientras i > 0 hacer

<acciones>

i i - 1

fin_mientras

fin
a) inicio

i

mientras i < = n hacer

<acciones>

i i + 1

fin_mientras

fin

d) inicio

i

repetir

<acciones>

i i + 1

hasta_que i > n

fin
c) inicio

i

repetir

<acciones>

i i + 1

hasta_que i = n

fin

f) inicio

i n

repetir

<acciones>

i i - 1

hasta_que i < 1

fin
e) inicio

i n + 1

repetir

<acciones>

i i - 1

hasta_que i = 1

fin

3.4.1.3.4                  ESTRUCTURAS DE REPETICIÓN ANIDADAS

·            Se hace de igual manera que la anidación de estructuras de selección,

·            Se usa la misma regla que para las estructuras de selección anidadas: la estructura interna debe estar totalmente incluida dentro de la estructura externa.

EJERCICIOS: Algoritmos en seudocódigo

CAPÍTULO 1: Algoritmos y programas - generalidades -

Ejercicio 1.1: Diseñar un algoritmo que determine si un número cualquiera es primo.

(Un número primo sólo es divisible por sí mismo y por uno)

1.         Inicio

2.         Se definen las variables N (nº estudiado), X (divisores de N)

3.         Poner X = 2 // X

4.         N / X // Dividir N por X

5.         Si N / X es entero N no es primo

Ir al paso 8

Caso contrario seguir (paso 6)

6.         Sumar 1 a X // X X + 1

7.         Si X = N N es primo

Caso contrario ir al paso 3

8.         Fin

Ejercicio 1.2: Diseñar un algoritmo que determine la suma de todos los números pares entre 2 y 1000.

1.         Inicio

2.         Se definen las variables N (número), S (suma);

3.         S // a S se le asigna el valor 0 (se deja S = 0)

4.         N // a N se le asigna el valor 2

5.         S S + N // sumar S a N, asignar el resultado a S

6.         N N + 2 // Incrementar N en 2 unidades

7.         Si N <= 1000 ir al paso 5

Caso contrario escribir último valor de S

8.         Fin.

Ejercicio 1.3: Usos de División entera y Módulo (resto)

Operador / (división):

·            División entera, o real

·            El resultado de A / B, depende del tipo de los operandos: si A y B son reales, el resultado es real; si A y B son enteros, el resultado es entero.

·            43 / 22 = 1; 1 / 10 = 0; 19.0 / 3.0 = 6. 3; 43..0 / 22.0 = 1. 954; 1.0 / 10.0 = 0.1

Operador % (módulo o resto):

·            A % B, se usa sólo si A y B son enteros; se obtiene el resto de A / B,

·           

Ejemplo:

parte entera 21 / 5 = 4

resto 21 % 5 = 1

Ejercicio 1.4:

S // La expresión 5 + 6 + 2 se evalúa y su resultado se asigna a S (13).

A // Se asigna 22,5 a A

B // Se asigna 2.55 a B

TOTAL A / B  // se asigna 22.5 / 2.55 a TOTAL.

// TOTAL

Ejercicio 1.5:

X 8 < 5 // Valor de verdad falso

Y X o (3 < = 7) // Valor de verdad verdadero

Z 15 > 9 // Valor de verdad verdadero

Ejercicio 1.6: ¿Qué valores toman A, B, C, después de la ejecución de las siguientes operaciones?

A Resp. // A toma valor 3

B // B toma valor 4

C A + 2 * B // C toma valor 3 + 2 * 4 = 11

C C + B // C toma valor 11 + 4 = 15

B C - A // B toma valor 15 - 3 = 12

A B * C // A toma valor 12 * 15 = 180

Ejercicio 1.7: ¿Valor que toma X después de las operaciones?

X Resp. // X toma valor 2

X cuadrado (X + X)  // X toma valor cuadrado (4) = 16

X raíz2 (X + raíz2(X) + 5) // X toma valor raíz2 (16 + raíz2 (16) + 5) = raíz2 (25) = 5

Ejercicio 1.8: ¿Valor que toma la variable X después de las operaciones?

Y 3 * cuadrado (3)  Resp. // Y

A 2 * Y // A

B A +3  // B

X A - (2(B - Y)) // X

X X + 1 // X

Ejercicio 1.9: ¿Cómo intercambiar los valores de las variables A y B?

Se deben definir las variables A, B, y una variable Temporal (AUX):

A

B

A

B
 

B

A
 
AUX A

A B

B AUX

AUX

A


Ejemplo:

A

B

AUX A // AUX

A B // A

B AUX // B

Ejercicio 1.10: Algoritmo que determine el mayor de tres números

1.         Inicio

2.         Definir las variables NUM1, NUM2, NUM3, MAYOR

3.         NUM1 primer número ingresado

4.         NUM2 segundo número ingresado

5.         SI (NUM1 > NUM2 o NUM1 = NUM2)

MAYOR NUM1

Caso contrario MAYOR NUM2

6.         NUM3 tercer número ingresado

7.         SI (NUM3 > MAYOR o NUM3 = MAYOR)

MAYOR NUM3

Imprimir MAYOR

Caso contrario imprimir MAYOR

Ejercicio 1.11: Obtener el valor de cada una de las siguientes expresiones aritméticas

a)           

b)         

c)           

d)         

e)           

f)            

g)         

h)         

CAPÍTULO 2: Estructura general de un Programa, Programación Estructurada: Estructuras de Control.

Ejercicios Resueltos

Ejercicio 2.1: algoritmo para calcular sueldo líquido de un trabajador en función del número de horas trabajadas, valor de la hora de trabajo y, considerando unos descuentos fijos, calcular el sueldo bruto en concepto de impuestos (21 %)

Inicio

Leer ( nombre, horas, valor_hora)

Sueldo_bruto horas * valor_hora

Impuesto 0.21 * Sueldo_bruto

Sueldo_neto Sueldo_bruto - impuesto

Escribir (nombre, sueldo_bruto, sueldo_neto)

Fin

Ejercicio 2.2: determinar el precio del pasaje ida-vuelta en bus, conociendo la distancia a recorrer, y sabiendo que si el número de días de viaje es superior a 7 y la distancia superior a 800 km el pasaje tiene un descuento del 30 %. El precio por km. es de $ 900

Algoritmo pasaje

Var entero: día_viaje

real: distancia, precio

Inicio

Leer (día_viaje, distancia)

precio 900 * distancia

Si (distancia > 800) y (día_viaje > 7) entonces

precio precio - (precio * 30 / 100)

Fin_si

Escribir ('Precio del pasaje', precio)

Fin

·            Ejemplo 2.3: algoritmo que calcule el área de un triángulo, conociendo sus lados.

Clave: primero se debe verificar si los lados pueden formar un triángulo

Algoritmo área_triángulo

Var

Real: a, b, c, p, área

Inicio

Escribir ('Ingrese los lados')

Leer (a, b, c)

p (a + b + c) / 2

Si (p > a) y (p > b) y (p > c) entonces // es o no triángulo

Área raíz2 (p * (p - a) * (p - b) (p - c))

Escribir (área)

Si_no

Escribir ('No es un triángulo')

Fin_si

Fin

Ejercicio 2.4: Calcular el promedio de un conjunto de números positivos. Los datos se leen desde pantalla. Una entrada de valor 0 indica el fin de la serie de números positivos.

Solución: metodología: descomponer el problema (diseño descendente). Para calcular el promedio, se requiere: sumar y contar los valores de entrada.

Var real : número, contador, suma, promedio

Inicio

Contador

Suma

Leer (número)

Si número = 0 entonces

promedio suma / contador

escribir (promedio)

Fin_si

Si número < > 0 entonces

suma suma + número

contador contador + 1

ir a 1

Fin_si

Fin

·            Ejemplo 2.5: emplear la estructura de selección para saber si un año es o no bisiesto

Algoritmo bisiesto

Var

Entero: año

Inicio

Leer (año)

Si (año % 4 = 0) y (año % 100 < > ) o (año % 400 = 0) entonces

Escribir ('El año', año, 'es bisiesto')

Si_no

Escribir ('El año', año, 'no es bisiesto')

Fin_si

Fin

Ejercicio 2.6: algoritmo que escriba los nombres de los días de la semana en función del valor de la variable día, introducida por teclado, que representa su posición dentro de la semana.

Análisis: los días de la semana son 7 (1,..., 7), y si día toma un valor fuera de rango, se debe emitir un mensaje de error

Algoritmo nombre_día

Var Entero: día

Inicio

Leer (día)

Según_sea día hacer

1: escribir ('LUNES')

2: escribir ('MARTES')

3: escribir ('MIÉRCOLES')

4: escribir ('JUEVES')

5: escribir ('VIERNES')

6: escribir ('SÁBADO')

7: escribir ('DOMINGO')

si_no

escribir ('ERROR')

Fin_según

Fin

Ejercicio 2.7: leída una fecha (por ejemplo 27), decir el día de la semana, suponiendo que el día 1 de dicho mes es lunes.

Algoritmo día_semana

Var

Entero: día

Inicio

Escribir ('Cuál es el día ?')

Leer (día)

Según_sea (día % 7) hacer

1: escribir ('Lunes')

2: escribir ('Martes')

3: escribir ('Miércoles')

4: escribir ('Jueves')

5: escribir ('Viernes')

6: escribir ('Sábado')

0: escribir ('Domingo')

Fin_según

Fin

Ejercicio 2.8: se lee por teclado un número entre 1 y 10 (inclusive), y se desea saber si ese número es par o impar.

Algoritmo Par_impar

Var entero: número

Inicio

Leer (número)

Si ((número >=1) y (número <=10)) entonces

Según_sea número hacer

1, 3, 5, 7, 9 : escribir ('Par')

2, 4, 6, 8, 10 : escribir ('Impar')

Fin_según

Fin_si

Fin

Ejercicio 2.9: Algoritmo que permita leer 2 números; si son iguales que los multiplique, si el primero es mayor que el segundo que los reste y si no que los sume.

Var real :x, y, z

Inicio

Leer (x, y)

Si x = y entonces

z x * y

Si_no

Si x > y entonces

z x - y

Si_no z x + y

Fin_si

Fin_si

Escribir (z)

Fin

Ejercicio 2.10: algoritmo para calcular las soluciones de una ecuación general de segundo grado:


Algoritmo raíces // solución a ecuación de 2º grado

Var real: a, b, c, d

Inicio

Leer (a, b, c)

d b ^2 - 4 * a * c

Si d < 0 entonces

escribir ('raíces complejas')

Si_no

Si d = 0 entonces

Escribir (- b / 2 * a)

Si_no

Escribir ((- b - raíz2 (d)) / (2 * a))  //raíz2 = raíz cuadrada

Escribir ((- b + raíz2 (d)) / (2 * a))

Fin_si

Fin_si

Fin

Ejercicio 2.11: Obtener el listado semanal con el sueldo líquido, de los empleados de una fábrica, cuyo trabajo se paga por horas, de la siguiente manera:

·            la cantidad de horas iguales o inferiores a 35 (normales) se paga a un valor determinado que se introduce por teclado. Por teclado también se ingresa el número de horas y el nombre del trabajador.

·            Si la cantidad de horas es mayor a 35, se pagan como extras, al valor de 1,5 horas normales.

·            Los impuestos que se le descuentan a los trabajadores varían en función de su sueldo semanal:

-            sueldo < = $ 100.000, libre de impuestos,

-            los siguientes $ 75.000, tienen un descuento del 10 %,

-            el resto, descuento de 30 %.

Algoritmo listado semanal

Var

String (cadena): nombre

Real: horas, impuestos, sbruto, sliquido.

Inicio

Leer (nombre, horas, valor_hora)

Si horas < = 35 entonces

Sbruto horas * valor_hora

Si_no

Sbruto 35 * valor_hora + (horas - 35) * 1.5 * valor_hora

Fin_si

Si sbruto < = 100.000 entonces

Impuestos

Si_no

Si (sbruto >100.000) y (sbruto < = 175.000) entonces

Impuestos (sbruto - 100.000) * 0.10

Si_no

Impuestos (75.000 * 0.10) + (sbruto - 175.000) * 0.30

Fin_si

Fin_si

Sliquido sbruto - impuestos

Escribir (nombre, sbruto, impuestos, sliquido)

Fin

Ejercicio 2.12: algoritmo que lea tres números, y muestre por pantalla el mayor. Suponer que los tres números son distintos.

Algoritmo mayor

Var real: i, j, k, mayor

Inicio

Leer (i, j, k)

Si (i > j) entonces

Si (i > k) entonces

Mayor i // i < j, i > k

Si_no

Mayor k // k >= i > j

Fin_si

Si_no

Si (j > k) entonces

Mayor j // j >= i, j > k

Si_no

Mayor k // k >= j >= i

Fin_si

Fin_si

Fin

Ejercicio 2.13: algoritmo que lea tres números diferentes, y muestre por pantalla los números ordenados de mayor a menor.

Algoritmo mayor_menor

Var real: i, j, k

Inicio

Leer (i, j, k)

Si (i > j) entonces // se ordenan los dos primeros

Si (j > k) entonces

Escribir (a, b, c)

Si_no

Si (k > i) entonces

Escribir (k, i, j)

Si_no

Escribir (i, k, j)

Fin_si

Fin_si

Si_no

Si (i > k) entonces

Escribir (j, i, k)

Si_no

Si (k > j) entonces

Escribir (k, j, i)

Si_no

Escribir (j, k, i)

Fin_si

Fin_si

Fin_si

Fin

Ejercicio 2.14: algoritmo que permita calcular las soluciones de una ecuación de segundo grado, incluyendo los valores imaginarios.

Algoritmo Solución_ecuación_grado2

Var Real: a, b, c, d, X1, X2, r, i

Inicio

Escribir ('Ingrese los coeficientes')

Leer (a, b, c)

Si (a = 0) entonces

Escribir ('No corresponde a una ecuación de grado 2')

Si_no

d b ^ 2 - 4 * a * c

Si (d = 0) entonces

X1 b / (2 * a)

X2 X1

Escribir (X1, X2)

Si_no

Si (d > 0) entonces

X1 b + raíz2 (d)) / (2 * a)

X2 b - raíz2 (d)) / (2 * a)

Escribir (X1, X2)

Si_no

r b) / (2 * a)

i raíz2 (abs(d)) / (2 * a)

Escribir (r, '+', i, 'i')

Escribir (r, '-', i, 'i')

Fin_si

Fin_si

Fin_si

Fin

Ejercicio 2.15: algoritmo al que ingresándole la hora (hh, mm, ss), calcule la hora dentro de 5 segundos. Las horas, minutos y segundos se leerán como enteros.

Algoritmo reloj_5_seg_después

Var Entero: hh, mm, ss

Inicio

Escribir ('Ingrese hh, mm, ss')

Leer (hh, mm, ss)

Si ((hh < 24) y (mm < 60) y (ss < 60)) entonces

ss ss + 5

Si (ss > = 60) entonces

ss ss - 60

mm mm + 1

Si (mm = 60) entonces

mm

hh hh + 1

Si (hh = 24) entonces

hh

Fin_si

Fin_si

Fin_si

Escribir (hh, ':', mm, ':', ss)

Fin_si

Fin

Ejercicio 2.16: los empleados de una fábrica trabajan en dos turnos: diurno y nocturno. Se desea calcular el salario diario de acuerdo a los siguientes puntos:

1.         la tarifa de las horas diurnas es de $ 4500

2.         la tarifa de las horas nocturnas es de $ 6300

3.         si es domingo, la tarifa se incrementa en $ 1200 el turno diurno y $ 2300 el turno nocturno

Algoritmo salario

Var

Real: HT, salario  //HT = horas trabajadas

String: día, turno

Inicio

Leer (HT, día, turno)

Si día < > domingo entonces

Si turno = 'diurno' entonces

salario 4500 * HT

Si_no

salario 6300 * HT

Fin_si

Si_no

Si turno = 'diurno' entonces

salario 5700 * HT

Si_no

salario 8600 * HT

Fin_si

Fin_si

Escribir (salario)

Fin

Ejercicio 2.17: Un palíndrome es un número o una frase que se lee lo mismo hacia adelante que hacia atrás. Por ejemplo, los siguientes números de cinco dígitos son palíndromes: 12321, 61916, etc. Escriba un programa que lea un entero de 5 dígitos y permita determinar si tal número es o no un palíndrome.

Algoritmo palíndrome

Var int (entero): num, p, u, cabeza, cola;

Inicio

Escribir ('Ingrese un Numero de 5 dígitos: ');

Leer (num);

p num / 10000; // p= primer dígito

u num % 10 // u= último dígito

Si (p = u) entonces // Si el primero es igual al quinto

Inicio

cabeza num / 1000; // Dos primeros dígitos

cola num % 100; // Dos últimos dígitos

cabeza cabeza % 10; // Segundo dígito

cola cola / 10; // Cuarto dígito

Si (cabeza = cola) entonces

Escribir ('Palindrome')

Si_no

Escribir ('No Palindrome');

Fin_si

Fin

Si_no

Escribir ('No palíndrome');

Fin.

Ejercicios Propuestos

Ejercicio 2.18: Algoritmo que calcule la superficie de un triángulo en función de la base y la altura.

Ejercicio 2.19: algoritmo que permita calcular el perímetro y el área de un cuadrado dada la longitud de su lado

Ejercicio 2.20: algoritmo que permita calcular el perímetro y el área de un rectángulo. Se deben ingresar las dimensiones de sus lados mayor y menor.

Ejercicio 2.21: las equivalencias entre las unidades inglesas de longitud son las siguientes

1 yarda (yard) = 3 pies (foot)

1 pie  = 12 pulgadas (inch)

1 milla (mile) = 5280 pies

Desarrollar un algoritmo que realice las siguientes conversiones:

a)        leer una cantidad en yardas e imprimir el equivalente en pulgadas

b)        leer una cantidad en pies e imprimir el equivalente en yardas

c)        una cantidad en millas e imprimir el equivalente en pulgadas

Ejercicios Resueltos

Ejercicio 2.22: Contar los números enteros positivos, ingresados por teclado.

Análisis: se usan 2 variables: número, contador. El ciclo se detiene cuando se lee un número negativo o cero.

Algoritmo cuenta_enteros

Var Entero: número, contador

Inicio

Contador

Leer (número)

Mientras número > 0 hacer

Contador contador +1

Leer (número)

Fin_mientras

Escribir (contador)

Fin

Observaciones:

Terminación de los bucles con los datos de entrada: si el algoritmo lee una lista de valores, es necesario incluir algún mecanismo que permita terminar el ciclo. En general se consideran 4 métodos para terminar un bucle:

5.         Preguntar antes de la iteración: se solicita mediante un mensaje al usuario si existen más entradas:

suma

Escribir ('Hay más valores en la lista S/N')

Leer (resp) // Var Char: resp

Mientras ((resp = 's') o (resp = 'S')) hacer

Escribir ('Valor')

Leer (n)

suma suma + n

Escribir ('Hay más valores en la lista S/N')

Leer (resp)

Fin_mientras

Este método es bueno siempre y cuando la lista de valores no sea grande

6.         Encabezar la lista de datos con su tamaño (ver ejercicio 3.29): se conoce a priori el tamaño de la lista

7.         Finalizar la lista con cierto valor de entrada: uso del centinela

·          Es el método más correcto.

·          Centinela: valor especial que se usa para indicar el final de una lista.

·          Ejemplo: una lista de notas (escala 1 - 7) tiene como centinela un valor fuera de este rango.

Ejercicio 2.23: suma de todos los números positivos, introducidos por teclado:

Suma

Leer (num)

Mientras num >= 0 hacer

Suma suma + num

Leer (num)

Fin_mientras

·          El centinela leído no se añade a la suma, pues se sale del bucle,

·          Debe existir una instrucción Leer ( ) dentro del bucle, pues debe leerse (y detectarse) el centinela.

Ejercicio 2.24: analice los algoritmos. ¿Qué se muestra?, ¿Cuántas veces se repite el ciclo? Rutéelos.

c)                       i

Mientras i < 6 hacer

Escribir (i)

i i +1

Fin_mientras

Se muestran los valores de la variable de control i : 0, 1, 2, 3, 4, 5; el ciclo se repite 6 veces

d)                      i

Mientras i < 6 hacer

i i +1

Escribir (i)

Fin_mientras

La salida es: 1, 2, 3, 4, 5, 6; el ciclo se repite 6 veces

Ejercicio 2.25: Algoritmo: dado un número entero n, se debe mostrar la suma de los dígitos que lo componen. Por ejemplo, si el número es 123, se debe mostrar 6.

Var: Entero: n, x, suma

Inicio

Leer (n)

Mientras n >= 1 hacer

x n % 10

Suma suma + x

n n / 10

Fin_mientras

Escribir (suma)

Fin

Ejercicio 2.26: calcular la media de un conjunto de notas de alumnos. Valor centinela: - 99

Inicio

total

n // nº de alumnos

Leer (nota) // primera nota debe ser < > - 99

Mientras nota < > - 99 hacer

total total + nota

n n + 1

Leer (nota)

Fin_mientras

media total / n

Escribir ('La media es', media)

Fin

Ejercicio 2.27 (ciclo controlado por centinela)

Calcular el sueldo de una serie de trabajadores, cuyos datos serán leídos desde teclado. Sabiendo que las horas normales se pagan a $2000, y las extraordinarias a $2500, mientras no pasen de 10. Si las horas extraordinarias sobrepasan las 10, el exceso se pagará a $2350. La introducción de datos termina cuando se teclea '*' como nombre para un trabajador.

Algoritmo calcular_sueldo

Var

String (Cadena): nombre

Real : hnormal, hextra, sueldo

Inicio

Escribir ('Nombre (* para ningún ingreso más)')

Leer (nombre)

Mientras (nombre < > '*') hacer

Escribir ('Nº horas normales')

Leer (hnormal)

Escribir (Nº horas extras)

Leer (hextra)

Sueldo hnormal * 2000

Si (hextra < = 10) entonces

Sueldo sueldo + hextra * 2500

Si_no

Sueldo sueldo + (10 * 2500) + ((hextra - 10) * 2350)

Fin_si

Escribir (nombre, sueldo)

Escribir ('Nombre (* para ningún ingreso más)')

Leer (nombre)

Fin_mientras

Fin

Ejercicio 2.28: (ciclo controlado por flag)

Determinar si un número leído por teclado es primo o no. Un número es compuesto cuando tiene algún divisor distinto de sí mismo o de la unidad.

Algoritmo primo_o_no

Var

Entero: n, divisor

Booleano: primo

Inicio

Escribir ('Ingrese número')

Leer (n)

Primo Verdadero

Divisor

Mientras (divisor < = n / 2) y primo hacer // la variable primo controla

Si (n % divisor = 0) entonces

Primo falso

Si_no

Divisor divisor + 1

Fin_si

Fin_mientras

Si primo entonces

Escribir (n, 'es primo')

Si_no

Escribir (n, 'es divisible por', divisor)

Fin_si

Fin

Ejemplo 2.29: (ciclo controlado por contador)

Introducir las notas de un curso de 20 alumnos por teclado, calcular el porcentaje de reprobados.

Algoritmo porcentaje_reprobados

Var

Entero: cont_alumnos, cont_reprobados

Real : porcent, n

Inicio

Cont_alumnos

Cont_reprobados

Mientras cont_alumnos < = 20 hacer

Escribir ('Nota alumno: ')

Leer (n)

Si (n < 4) entonces

Cont_reprobados Cont_reprobados + 1

Fin_si

Cont_alumnos cont_alumnos + 1

Fin_mientras

Porcent (cont_reprobados * 100) / 20

Escribir ('El % de alumnos reprobados es', porcent)

Fin

Ejercicio 2.30: algoritmo para calcular el factorial de un número N, según la fórmula:

N ! = N (N - 1) (N - 2)

Por ejemplo: 4 ! = 4

Restricción: N debe ser mayor o igual a 0


a)

Algoritmo factorial

Var Entero: N, fact

Inicio

Leer (N) // N >= 0

fact

Repetir

Fact fact * N

N N - 1

Hasta_que N = 1

Escribir ('El factorial de', N, '=', fact)

Fin

b)

Algoritmo factorial

Var Entero: N, i, fact

Inicio

Leer (N) // N >= 0

fact

i

Repetir

Fact fact * i

i i + 1

Hasta_que i = N + 1

Escribir ('El factorial de', N, '=', fact)

Fin

Ejercicio 2.31: Escribir los números 1 a 100

Algoritmo uno_cien

Var Entero: num

Inicio

num

Repetir

Escribir (num)

num num + 1

Hasta_que num > 100

Fin

Ejercicio 2.32: Validar entrada de datos: Algoritmo que detecte cualquier entrada comprendida entre 1 y 12, rechazando las otras. Se trata de leer los números correspondientes a los meses.

Algoritmo validar_mes

Var Entero: mes

Inicio

Escribir ('Número del mes'')

Repetir

Leer (mes)

Si ((mes < 1) o (mes > 12)) entonces

Escribir ('Valores entre 1 y 12')

Fin_si

Hasta_que ((mes >= 1) y (mes <= 12))

Fin

Ejercicio 2.33: Algoritmo que determine el mayor de 3 números positivos ingresados.

Solución: mostrar las diferentes formas de implementar el algoritmo en seudocógigo, desde la más ineficiente a la más eficiente. Recalcar las diferentes formas de solución empleando diferentes estructuras de repetición. Los alumnos deben deducir cuál es la mejor estructura que resuelve el problema.

a)        Var Entero: número1, número2, número3, mayor

Inicio

Mayor

Leer (número1, número2)

Si número 1 >= número 2 entonces

mayor número1

Si_no mayor número2

Fin_si

Leer (número3)

Si número3 >= mayor entonces

mayor número3

Escribir (mayor)

Fin

b)        Var Entero: número, mayor, contador

Mayor

Contador

Repetir

Leer (número)

Si número >= mayor entonces

mayor número

Si_no mayor mayor

Fin_si

contador contador + 1

Hasta_que contador > 3

Escribir (mayor)

Fin

 


Inicio

Mayor

Contador

Repetir

Leer (número)

Si número >= mayor entonces

mayor número

Fin_si

contador contador + 1

Hasta_que contador > 3

Escribir (mayor)

Fin

c)        Var Entero: número, mayor, contador

Inicio

mayor

contador

Mientras contador < 3 hacer

Leer (número)

Si número >= mayor entonces

Mayor número

Si_no mayor mayor

Fin_si

contador contador + 1

Fin_mientras

Escribir (mayor)

Fin

 

Inicio

mayor

contador

Mientras contador < 3 hacer

Leer (número)

Si número >= mayor entonces

Mayor número

Fin_si

contador contador + 1

Fin_mientras

Escribir (mayor)

Fin

Ejercicio 2.34 Algoritmo que determine el mayor de una serie de números positivos ingresados. El ingreso de números se detiene cuando se lee el número 0.

Var Entero: número, mayor

Inicio

mayor

Mientras número <>0 hacer

Leer (número)

Si número >= mayor entonces

Mayor número

Fin_si

Fin_mientras

Escribir (mayor)

Fin

Inicio

mayor

Repetir

Leer (número)

Si número >= mayor entonces

mayor número

Fin_si

Hasta_que número = 0

Escribir (mayor)

Fin

Nota: Deben fijarse en la ubicación de la condición en las estructuras de repetición:

·         

Mientras condición hacer

Acciones

Fin_mientras
 


ü        El proceso no se realiza (ninguna vez) si la condición NO se cumple.

ü        El proceso se repite mientras la condición se cumpla

·         

Repetir

Acciones

Hasta_que condición

 


ü        Permite realizar el proceso al menos una vez, ya que la condición se evalúa al final del proceso.

ü        El proceso se repite hasta que la condición no se cumpla o cambie.

Ejercicio 2.35: Algoritmo que determine el mayor y el menor de una serie de 12 números ingresados.

Var Entero: número, mayor, menor, contador

Inicio

Mayor

Menor

Contador

Mientras contador < 12 hacer

Leer (número)

Si número > mayor entonces

Mayor número

Fin_si

Si número < menor entonces

Menor número

Fin_si

Contador contador + 1

Fin_mientras

Escribir (mayor, menor)

Fin

Inicio

Mayor

Menor

Contador

Repetir

Leer (número)

Si número > mayor entonces

Mayor número

Fin_si

Si número < menor entonces

Menor número

Fin_si

Contador contador + 1

Hasta_que contador > 12

Escribir (mayor, menor)

Fin

Ejercicio 2.36: Algoritmo que determine cuántas cifras tiene un entero n

Var Entero: n, contador

Inicio

Contador

Leer (n)

Repetir

n n / 10

contador contador + 1

Hasta_que n = 0

Escribir (contador)

Fin

Inicio

Contador

Leer (n)

Mientras n >= 1 hacer

n n / 10

contador contador + 1

Fin_mientras

Escribir (contador)

Fin

Ejercicio 2.37: Algoritmo que determine cuántas cifras tiene un entero n. Si la cantidad de cifras es par, calcular el producto de ellas, si no, es decir, si es impar, imprimir 'La suma es impar.'

Var Entero: n, aux, X, prod, contador

Inicio

Contador

Prod

Leer (n)

Aux n

Repetir

n n / 10

contador contador + 1

Hasta_que n = 0

Si contador % 2 = 0 entonces

Repetir

X aux % 10

prod prod * X

aux aux / 10

Hasta_que aux = 0

Escribir (prod)

Si_no

Escribir ('La suma es impar')

Fin_si

Fin

Inicio

Contador

Prod

Leer (n)

Aux n

Mientras n >= 1 hacer

n n / 10

contador contador + 1

Fin_mientras

Si contador % 2 = 0 entonces

Mientras aux >= 1 hacer

X aux % 10

prod prod * X

aux aux / 10

Fin_mientras

Escribir (prod)

Si_no

Escribir ('La suma es impar')

Fin_si

Fin

Ejercicio 2.38: Algoritmo que lea un entero positivo, y lo escriba invertido.

Var: Entero: n, resto

Leer (n)

Repetir

resto n % 10

Escribir (resto)

n n / 10

Hasta_que n = 0

Fin

 

Inicio

Leer (n)

Mientras n > 0 hacer

resto n % 10

Escribir (resto)

n n / 10

Fin_mientras

Fin

Ejercicio 2.39: Algoritmo para sumar una lista de números ingresados por teclado:

·            Si el usuario ingresa la cantidad de números a sumar, por ejemplo N, existen 2 formas para contar las iteraciones:

a)            Usar una variable total que se inicializa con valor N, y se va decrementando (disminuyendo) su valor en 1 cada vez que el ciclo se repite (total total - 1), hasta llegar a 0,

Algoritmo suma_números

Var Entero: N, total

Real: num, suma.

Inicio

Leer (N)

total N

Mientras total > 0 hacer

Leer (num)

suma suma + num

total total - 1

Fin_mientras

 
suma

Repetir

Leer (num)

suma suma + num

total total - 1

Hasta_que total = 0

Escribir ('La suma de los', N, 'números es', suma)

Fin

b)          Usar una variable total que se inicializa en 0 ó 1, y se va incrementando (aumentando) en 1 cada vez que el ciclo se repite (total total + 1), hasta llegar a N.

Algoritmo suma_números

Var Entero: N, total

Real: num, suma.

Inicio

Leer (N)

total

Mientras total < N hacer

Leer (num)

suma suma + num

total total + 1

Fin_mientras

 
suma

Repetir

Leer (num)

suma suma + num

total total + 1

Hasta_que total = N

Escribir ('La suma de los', N, 'números es', suma)

Fin

Observaciones:

·            Condición de salida al comienzo del ciclo, estructura Mientras (Condición) - hacer - Fin_mientras

Algoritmo suma

Inicio

K

S

Leer (n)

Mientras K < n hacer

K K + 1

S S + K

Fin_mientras

Escribir (S)

Fin

El ciclo se repite mientras se cumple la condición (K < n)

·            Condición de salida al final del ciclo, estructura Repetir - hasta_que (Condición)

Repetir

K K + 1

S S + K

Hasta_que K > n

El ciclo se repite hasta que se cumple la condición (K > n)

·            Ejercicio 2.40: imprimir todos los números primos entre 2 y 100 inclusive

Algoritmo primos

Var

entero: i, divisor

booleano: primo

Inicio

Desde i 2 hasta 200 hacer

Primo V

Divisor

Mientras ((divisor < = i / 2) y ( primo) hacer

Si (i % divisor = 0) entonces

Primo F

Si_no

Divisor divisor + 1

Fin_si

Fin_mientras

Si primo entonces

Escribir (i, ' ')

Fin_si

Fin_desde

Fin

Ejercicio 2.41: Se conoce el número de habitantes que hay en cada una de las 7 ciudades más grandes de las 13 regiones de Chile (se incluye la Región Metropolitana). Identificar y visualizar la ciudad con mayor cantidad de habitantes de cada región.

Algoritmo ciudad_más_grande

Var

entero: i // contador de regiones

entero: j // contador de ciudades

entero: mayor  // mayor población

entero: ciudad  // población de una ciudad

Inicio

i

Mientras i < = 13

mayor

j

Mientras j < = 7

Leer (ciudad)

Si ciudad > mayor entonces

mayor ciudad

j j + 1

Fin_si

Fin_mientras

Escribir (`La mayor población tiene', mayor, 'habitantes.')

i i + 1

Fin_mientras

Fin

Ejercicio 2.42: (Certamen 1, semestre 1, 2001) Para estudiar el efecto de inversión térmica, una estación meteorológica proporciona todos los días un par de temperaturas (mínima, máxima). El laboratorio que procesa dichos datos desecha el par de temperaturas correspondientes, si una o ambas son de 9 grados. Es decir, el par (mínima, máxima) de ese día no se considera para el estudio.

Se le pide al departamento de Informática del laboratorio PC 1 que diseñe un algoritmo que sea capaz de entregar mensualmente la siguiente información:

·            Número de días cuyas temperaturas han sido estudiadas,

·            Las temperaturas media mínima y media máxima,

·            Número de días cuyas máxima o mínima fueron 0 (cero) grados,

·            Porcentaje que representan los días con una máxima o mínima de 0 (cero) grados, sobre el total de días estudiados

Algoritmo Temperatura

Var

Entero: día, cero

Real: min, max, suma_min, suma_max, media_min, media_max, porcent_cero

Carácter: resp

Inicio

día

cero

suma_min

suma_max

Escribir ('Ingresar temperaturas [S/N]')

Leer (resp)

Mientras ((resp = 'S') o (resp = 's')) hacer

Escribir ('Ingresar temperaturas Mínima y Máxima')

Leer (min, max)

Si ((min < > 9) y (max < > 9)) entonces

día día + 1

suma_min suma_min + min

suma_max suma_max + max

Si ((min = 0) o (max = 0)) entonces

cero cero + 1

Fin_si

Fin_si

Escribir ('Ingresar temperaturas [S/N]')

Leer (resp)

Fin_mientras

media_min suma_min / día

media_max suma_max / día

porcent_cero cero / día * 100

Escribir ('Número de días estudiados: ', día)

Escribir ('Media Mínima: ', media_min)

Escribir ('Media Máxima: ', media_max)

Escribir ('Número de días con Mínima o Máxima de cero grados: ', cero)

Escribir ('Porcentaje de días cuyas Mínimas o Máximas fueron cero grados: ', porcent_cero)

Fin

Variación del mismo:

Día

cero

suma_min

suma_max

Escribir ('Ingresar temperaturas [s/n]')

Leer (resp)

Si ((resp = 'S') o (resp = 's')) entonces

Repetir

Escribir ('Ingresar temperaturas min y max')

Leer (min,max)

Si ((min < >9)) y ((max < > 9)) entonces

suma_min suma_min + min

suma_max suma_max + max

Si ((min=0) o (max=0)) entonces

cero cero + 1

Si_no

Dia dia + 1

Fin_si

Fin_si

Escribir ('Ingresar temperaturas [s/n]')

Leer (resp)

Hasta_que (resp = 'N' o resp = 'n')

Ejercicios Propuestos

Ejercicio 2.43: (Certamen 1, semestre 2, 2001) Una empresa conservera envasa sus conservas de frutas mediante una máquina totalmente automática, que es guiada por medio de señales digitales, enviadas una vez al día desde un computador central.

La máquina permite envasar según las siguientes categorías:

·          Cajas de 30 unidades (30 tarros).

·          Cajas de 60 unidades (60 tarros).

·          Cajas de 80 unidades (80 tarros).

Además, los tarros pueden pesar 400 [gr], ó 1.000 [gr].

Es decir, puede haber cajas de 30 unidades, conteniendo tarros de 400 [gr], y/o cajas de 30 unidades, conteniendo tarros de 1.000 [gr], etc.

Los códigos que envía el computador son los siguientes:

·          0000 : no funciona

·          1111 : envasa cajas de 30 u conteniendo tarros de 400 [gr]

·          1110 : envasa cajas de 30 u conteniendo tarros de 1.000 [gr]

·          1101 : envasa cajas de 60 u conteniendo tarros de 400 [gr]

·          1100 : envasa cajas de 60 u conteniendo tarros de 1.000 [gr]

·          1011 : envasa cajas de 80 u conteniendo tarros de 400 [gr]

·          1010 : envasa cajas de 80 u conteniendo tarros de 1.000 [gr]

Diseñe un algoritmo que permita contabilizar el total de cajas procesadas, según su categoría y según el peso de los tarros que contienen. Se requiere que se contabilicen estas cajas en períodos de 15 días efectivamente trabajados (si un día la máquina recibió la señal 0000, no trabajó).

Ejercicio 2.44: (Certamen 2, semestre 2, 2001) En una maestranza hay una máquina que fabrica aleatoriamente tanto tornillos como tuercas. Dependiendo de la cantidad de acero fundido que pasa al molde, la pieza que sale puede ser o un tornillo o una tuerca. Si la cantidad de acero es de 22 gramos, se fabrica un tornillo, y si es de 17 gramos se fabrica una tuerca.

Si la cantidad de acero fundido que sale es menor a 17 gramos, se fabrica una pieza defectuosa del tipo A, y si es mayor a 22 gramos es una pieza defectuosa del tipo B.

La máquina funciona a base de un "centinela" electrónico conectado a un computador. Mientras el valor del centinela es 1 se fabrican piezas, en cambio cuando el centinela toma el valor 0 (cero), se detiene la producción.

Se pide diseñar un algoritmo que permita:

·          Contabilizar el número de tornillos,

·          Contabilizar el número de tuercas,

·          Contabilizar el número de piezas tipo A,

·          Contabilizar el número de piezas tipo B,

·          Calcular el porcentaje de piezas tipo A, sobre el total de piezas (buenas y malas) fabricadas,

·          Calcular el número total de piezas defectuosas,

·          Calcular el porcentaje total de piezas defectuosas, sobre el total de piezas fabricadas.

Ejercicio 2.45: algoritmo que indique si un número, leído de teclado, tiene 1, 2, 3, o más de 3 dígitos. Se deben considerar los negativos.

Ejercicio 2.46: leer las notas de un curso de Programación, y mostrar aquellas que sean iguales o superiores a 6

Ejercicio 2.47: Leer 100 números. Determinar el promedio de los números positivos, y el promedio de los números negativos.

Ejercicio 2.48: (Certamen 1, semestre 2, 2001) Realizar un algoritmo que calcule e imprima el valor de la siguiente serie:

S= 1 - 4 + 9 - 16 + 25 - ................ n * n.

Se debe ingresar n

Ejercicio 2.49: Rutear el siguiente código. ¿Qué se muestra (Escribe) en pantalla?

Var Entero: X1, X2, X3, cont

Inicio

Leer (X2)

X1 X2

X3 X2

cont

Mientras cont < = 10 hacer

Leer (X2)

Si X2 < X1 entonces

X1 X2

Fin_si

Si X2 > X3 entonces

X3 X1

Fin_si

cont cont + 1

Fin_mientras

X2 X1

Repetir

Si X2 % 3 = 0 entonces

Escribir (X2)

Fin_si

X2 X2 + 1

Hasta_que X2 < = X3

Escribir (X1, X3)

Fin

Ejercicio 2.50: (Certamen 1, semestre 2, 2001) Para el siguiente programa:

Var Real: X, Y, F, R

Inicio

Escribir ('Ingrese el Primer número')

Leer ( X )

Escribir ('Ingrese el Segundo número')

Leer ( Y )

R

F Y

Mientras (X < > 0) hacer

Si (X % 2 = 0) entonces

X X / 2

F raíz2 (F) // raíz cuadrada

R R + F

Fin_si

Fin_mientras

Escribir ('El resultado es', R)

Fin

a)                       Hacer el ruteo para X = 6, Y = 25

b)                      Explicar qué hace el programa.

Ejercicio 2.51: Se desea llevar una estadística de los pesos de los alumnos de un curso, según los siguientes criterios:

·            Alumnos de menos de 40 kg

·            Alumnos entre 40 kg y 50 kg

·            Alumnos de más de 50 kg y menos de 60 kg

·            Alumnos de 60 kg o más

La entrada de datos terminará cuando se introduzca el valor centinela - 99.

Determinar cuántos alumnos hay en cada categoría.

Ejercicio 2

Var

Real: real

Entero: km, prod, fact, tot_prod, x, y, pot

Inicio

Escribir ( Ingrese el peso: ' );

Leer ( peso );

Escribir ( 'Ingrese los kilómetros: ' );

Leer ( km );

Si (peso % 2 = 0) entonces

inicio

suma

Desde x 1 hasta km hacer

inicio

pot

Desde y 1 hasta x hacer

pot pot * (1 + x)

fin_desde

suma suma + ( pot / x );

fin

fin_desde

Escribir ( 'Suma vale: ', suma );

fin

si_no

inicio

tot_prod

Desde x 1 hasta kms hacer

inicio

prod

Desde y 1 hasta ( x - 1) hacer

prod prod * y;

fin_desde

tot_prod tot_prod * prod;

fin

fin_desde

Escribir ( 'Cantidad es: ', tot_prod );

fin

End.

Realice el ruteo del programa, para los casos a) y b), especificando los valores que van tomando las variables, y lo que se muestra en pantalla. Suponer los siguientes valores:

a)                       peso = 1562 kms = 3

b)                      peso = 451 kms = 2.

Ejercicio 2.53: (Quiz 2, año 2001) Una empresa de diversiones que fabrica máquinas que "adivinan el futuro" tiene una nueva idea para uno de sus dispositivos: por sólo $100 Ud. puede saber cómo le irá el resto del día. La empresa encarga que se fabrique el software que usarán tales máquinas.

Las características que debe cumplir el SW, son las siguientes:

·            Se debe ingresar la fecha de nacimiento en el formato DDMMAA, por ejemplo, 201285 equivale al día 20, del mes 12, del año 1985.

·            Se deben sumar cada uno de los dígitos de la fecha de nacimiento; en el ejemplo, la suma es 18.

·            Si de esta suma, el resultado es mayor a 10, se debe volver a sumar cada uno de los dígitos resultantes, en el ejemplo, la primera suma dio 18, entonces la suma de ellos da 9.

·            Dependiendo del resultado de la o las sumas, se debe hacer lo siguiente:

·            Si el resultado es 1, 2, ó 3: sumar los dígitos correspondientes al año de nacimiento.

Si el resultado de esta suma es impar debe mostrar el mensaje: "Día incierto", en caso contrario, "Suerte".

·            Si el resultado es 4, 5, ó 6: sumar los dígitos correspondientes al mes.

Si el resultado de esta suma es menor que 7, debe mostrar el mensaje "No se desespere", en caso contrario, "Hoy será un gran día para Ud."

·            Si el resultado es 7, 8, ó 9: sumar los dígitos correspondientes al día.

Si el resultado de esta suma es menor que 16, debe mostrar el mensaje "Juegue, tendrá suerte", de lo contrario, "Mañana será mejor".

·            Si el resultado es mayor que 9, mostrar el mensaje "Hoy logrará todo lo que se proponga".

Ejercicio 2.54: Calcular el valor de n facturas de una empresa de electricidad. El tráfico se define de la siguiente manera :

·            Los primeros 90 KWH tienen un costo de $20 por KWH

·            Los segundos 90 KWH tienen un costo de $30 por KWH

·            A partir del 181 KWH tienen un costo de $ 36 por KWH

Por cada factura, se debe ingresar el consumo en KWH y se debe imprimir el total a pagar. Finalmente se debe imprimir el total a pagar por las n facturas

Ejercicio 2.55: Realizar un algoritmo que ingrese n números y con ellos genere e imprima las siguientes estadísticas:

·            Suma total

·            Cantidad de números mayores a num.

·            Suma de números pares.

Se debe ingresar n y num.

Ejercicio 2.56: Realizar un algoritmo que permita calcular e imprimir el resultado de la siguiente suma:

S = x / (x + 1) + (x + 1) / (x + 2) + (x + 2)/(x + 3) + ...........+ (x + n) / (x + n + 1).

Se debe ingresar x, n.

Ejercicio 2.57: La comisión sobre las ventas totales de un vendedor se calcula de la siguiente manera:

·            Si las ventas son menores que $40.000, entonces la comisión corresponde al 4% de las ventas.

·            Si las ventas están comprendidas entre $40.000 y $200.000 (ambos inclusive), hay una comisión del 8% sobre las ventas.

·            Si las ventas son superiores a $200.000, entonces la comisión corresponde a $30.000 más el 9% de las ventas.

Calcular la comisión a pagar a n vendedores. Se deben ingresar las ventas totales por cada vendedor.

Ejercicio 2.58 Se desea conocer una serie de datos de una empresa que tiene 50 empleados:

a)        ¿Cuántos empleados ganan más de $ 500.000 al mes (sueldos altos)?

b)        ¿Cuántos empleados ganan entre $ 250.000 y $ 500.000 al mes (sueldos medios)?

c)        ¿Cuántos empleados ganan menos de $ 250.000 al mes (sueldos bajos)

Ejercicio 2.59 escribir un algoritmo que permita convertir una determinada cantidad de segundos ingresada desde teclado, en su equivalente en minutos y segundos. Por ejemplo, si se ingresa 75 segundos, debe mostrar 1 minuto y 15 segundos.

UNIDAD II: Estructuras de Control en C

Estructuras de Control

Todo programa se puede escribir usando 3 tipos de estructuras de control:

·            Secuenciales,

·            de Selección,

·            Repetitivas.


Estr. Secuenciales

If

Estructuras de Control Estr. Selección  If / else

switch


while

Estr. Repetición  do / while

for


Estr. Control Apiladas (Lineales)

Combinación de estructuras de Control

Estr. Control Anidadas

1.        Estructuras Secuenciales:

·            Cada instrucción sigue en secuencia a otra.

·            Cada sentencia se ejecuta una sola vez y en el mismo orden en que figura en el texto del programa.

instrucción 1

instrucción 2

instrucción 3
 


2.        Estructuras de Selección (Decisión)

·            Se usan para tomar decisiones. Se evalúa una condición, y según sea el resultado, se ejecuta una acción.

·            Las estructuras de selección pueden ser:

·            Simples

·          Dobles

·          Múltiples

Selección Simple: if

·            Ejecuta una acción cuando se cumple una determinada condición.

·            Si la condición es V, se ejecuta la acción 1.

·            Si la condición es F, se continúa con la siguiente instrucción.

V

F

condición

acción 1

if <condición>

<acción 1>

 


Selección Doble: if - else

·            Permite elegir entre dos alternativas posibles o cursos de acción a seguir, en función del cumplimiento o no de una determinada condición.

·            Si la condición es V, se ejecuta la acción 1, si es F, se ejecuta la acción 2.

condición

acción 1

acción 2

if <condición>

<acción 1>

else <acción 2>
 


V F

Selección Múltiple: switch / case

·            La instrucción switch permite seleccionar una entre varias alternativas.

·            La estructura de decisión múltiple evaluará una expresión que podrá tomar n valores distintos. Al coincidir uno de estos valores con la condición, se ejecutará una de las n posibles acciones.

·            Al cumplirse una condición, no se ejecutan las demás, gracias a la instrucción break asociada a cada una de ellas.

·            Default permite especificar una acción a seguir en caso de que no exista correspondencia con ningún valor previamente especificado.


case a


break
 

acción

 
V


F

case b


break
 

acción

 
V


F

case z


break
 

acción

 
V


F

default

switch expresión

 


3.        Estructuras de Repetición (Ciclos, Bucles)

Estructura de repetición while

·          El ciclo se repite mientras se cumple una determinada condición (mientras la condición sea verdadera).

·          La estructura while, se ejecuta cero o más veces, debido a que se evalúa en primer termino la condición y luego se ejecuta la acción.

F
 

V
 

acción

<condición>

<acción>

 

condición


Estructura de repetición do while

·          El ciclo se repite mientras se cumple una determinada condición (mientras la condición sea verdadera).

·          La estructura do while ejecuta el ciclo siempre al menos una vez, debido a que se ejecuta en primer termino la acción y luego se evalúa la condición.

acción

<condición>

 


condición

V
 

F
 

Estructura de repetición for

·            Se usa cuando se conoce anticipadamente el número de veces que se repetirá el ciclo.

·            La estructura for controla automáticamente el número de iteraciones.

Asignación

inicial

Condición


incremento
 

acción

 
V


F

Su estructura general es:

for (expresión1; expresión2; expresión3)

<acción>

donde:

expresión1: inicializa la variable de control (Asignación inicial)

expresión2: condición que regula la repetición.

expresión3 : incrementa la variable de control.

EJERCICIOS: Estructuras de Control

Ejercicios resueltos

1.         Muestra en pantalla los números entre el 1 y el 10.

#include <iostream.h>

main()

while (i < = 10);

return 0;

2.         Suma los pares entre 2 y 10.

#include <iostream.h>

main()

3.         Muestra en pantalla los números entre el 1 y el 10, utilizando distintos tipos de for.

#include <iostream.h>

int main()

4.         Programa que suma 2 números

#include <iostream.h>

main()

5.         Programa que intercambia 2 números

# include <iostream.h>

main()

6.         Calcula el promedio de 3 notas

#include <iostream.h>

main()

promedio = total / 3;

cout << promedio << endl;

return 0;

7.         Ingresa 100 enteros. Calcula suma de los números pares y la suma de los números impares

# include <iostream.h>

main()

cout << "Suma de los números pares: " << suma_par << endl;

cout << "Suma de los números impares: " << suma_impar << endl;

return 0;

8.         Programa que cuenta los vendedores que se encuentran en cada una de las 3 categorías existentes, en base a las ventas realizadas. Para calcular el sueldo, $200.000 base mas un 5% de las ventas. Asuma que existen 100 vendedores.

#include <iostream.h>

main()

cout << "Categoria 1: " << cat1;

cout << "Categoria 2: " << cat2;

cout << "Categoria 3: " << cat3;

return 0;

9.         Haga un programa que determine la cantidad de divisores primos que tiene un numero N ingresado por el usuario.

//divisores primos

#include <iostream.h>

main()

if (cont == 0) // es primo

divprimos++;

cout << "los divisores primos son : " << divprimos << endl;

return 0;

10.     A base del siguiente lazo repetitivo se pide:

for (x=1; x<=10; x+=2)

a)        señalar que escribe en pantalla.

Escribe: 1 3 7 9

b)        Reescribirlo utilizando la sentencia while.

x=1;

while (x <= 10)

cout <<x<<" ";

x+=2;

11.     Para el siguiente programa:

a)         Indique si hay errores sintácticos. Corrija los que encuentre.

#include <iostream.h>

main()

cout << "Su resultado es : " r << endl; 

debe ser: cout << "Su resultado es : " << r << endl;

return 0;

b)         Rutearlo para x = 5, e y = 3.

x = 5 2 1 0

y = 3

r = 1 3 243

f = 3 9 81 6561

su resultado es 6561

c)         Señale una manera alternativa de escribir la instrucción: x = x / 2;

x /= 2

d)         Es posible lograr el mismo resultado usando menos variables? En caso que sí, indique cuántas variables necesita y que modificaciones haría.

Si es posible. No es necesario declarar la variable f. La variable y puede usarse directamente.

e)         Explicar que hace el programa.

yx

12.     Programa que indica que día de la semana es, basándose en que el primer día del mes es un lunes.

# include <iostream.h>

main ()

return 0;

13.     Determinar cuantas cifras componen a un entero n.

# include <iostream.h>

main ()

cout << "La suma de las cifras es: " << cont;

return 0;

14.     Determina el mayor y el menor entre 10 números ingresados.

#include<iostream.h>

main()

cout << "El menor es: " << menor << endl;

cout << "El mayor es: " << mayor << endl;

return

15.     Lee un entero positivo y lo escribe invertido.

#include <iostream.h>

main()

while (n <= 0);

while (n > 0)

return 0;

Un palíndrome es un número o una frase que se lee lo mismo hacia adelante que hacia atrás. Por ejemplo, los siguientes números de 5 dígitos son palíndromes: 12321, 61916, etc. Escriba un programa que lea un entero de 5 dígitos y permita determinar si tal número es o no un palíndrome

# include <iostream.h>

main ()

else

cout << "No es un Palíndrome" << endl;

return 0;

17.     Imprime los numero primos entre 1 y 100 inclusive.

#include<iostream.h>

main()

if (primo)

cout << i << endl;

i++;

}

return 0;

18.     Programa que ingresa n números y con ellos genera las siguientes estadísticas:

·          suma total

·          cantidad de números mayores a num

·          suma de números pares

se debe ingresar n y num.

#include<iostream.h>

int main()

cout << "Suma total: " << sumtot << endl;

cout << "mayores a " << num << ":" << mayores << endl;

cout << "suma de pares: " << sumpares << endl;

return

19.     Programa que pide una cierta cantidad de números positivos, mientras el usuario lo desee, y entrega como resultado la cantidad de números ingresados y el mayor valor ingresado.

#include<iostream.h>

main()

cout << "Cantidad de numeros ingresados: " << cont << endl;

cout << "El numero mayor es: " << mayor << endl;

return

20.     Hacer un programa que calcule la siguiente suma:

Se debe ingresar x , n.

#include<iostream.h>

int main()

cout << "la suma es: " << s << endl;

return

21.     Escriba un programa que permita calcular el valor de en la siguiente serie:


# include <iostream.h>

int main ()

cout << suma << endl;

return 0;

22.     El satélite Uranos que orbita la tierra envía 24 lecturas al día a base del tipo de terreno que está mostrando en un determinado momento. Los códigos posibles a ser enviados al computador son:

·          0: zona desértica

·          1: río

·          2: océano

·          3: terreno urbano

·          4: zona no identificada

Hacer un programa que lea las lecturas enviadas por el satélite y a base de a ellas realice los siguientes cálculos:

a)        porcentaje de zonas no identificadas con respecto al total de lecturas.

b)       Cantidad de lecturas de terreno urbano

c)        Cantidad de lecturas que identifican agua

#include<iostream.h>

int main()

cout << "No identificado = " << noidentif*100/24 << endl;

cout << "Terreno urbano = " << terrenourbano << endl;

cout << "Agua = " << agua;

return 0;

23.     Programa que lee 3 números enteros y determina si estos se encuentran o no ordenados ascendentemente.

#include<iostream.h>

int main()

24.     ¿Qué imprime el siguiente fragmento de código?

# include <iostream.h>

int main ()

cout << endl;

return 0;

Imprime por pantalla lo siguiente:

Ejercicios Propuestos

1.         Hacer un programa que permita calcular la siguiente expresión:

x = 1! + 2! + 3! + 4! + ... + n!

2.         Para cada uno de los 35 alumnos que están tomando el ramo de "Introducción a la Informática" se desea obtener el promedio final obtenido. Asuma que cada alumno tiene 4 notas. El programa debe:

·          mostrar el promedio final individual.

·          contar los alumnos aprobados

·          calcular el promedio general del curso.

3.         Calcular el valor de la factura de electricidad si el trafico se define de la siguiente manera:

·          los primeros 90 KWH tiene un costo de $100/KWH.

·          sobre 90 KWH se tiene un costo de $150/KWH adicional.

Ej. Si una persona consumió 100 KWH debería cobrársele $10.500.

El programa debe permitir ingresar tantos datos de clientes como lo desee el usuario, además de validar que el consumo ingresado sea mayor que cero

4.         La comisión para las ventas totales mensuales de un vendedor es como sigue:

a)                                      Si las ventas son menores que $100.000, su comisión es de un 5%.

b)                                     Si las ventas son entre $100.001 y 300.000, su comisión es de un 8%.

c)                                      Si las ventas son superiores a $300.000, su comisión es de un 10%.

Asuma que el sueldo base es de 100.000.

Se pide determinar cuanto debe pagar la compañía en sueldo, si se sabe que son 5 los vendedores. (El programa debe solicitar el ingreso de las ventas realizadas por cada uno de los vendedores.) Tuvo ganancias la empresa?

5.         Haga un programa que imprima todos los números primos menores que N. Un número primo es aquel que solo es divisible por uno y por si mismo.

6.         Calcular la siguiente serie: x = 1/3 + 2/4 + 3/5 + 4/6 + .... + n / n+2

7.         Se ha realizado una encuesta callejera para determinar el grado de cesantía en la región. A cada persona se le consulto: edad (entre15 y 100), sexo (F, M) y si trabaja(S, N). Hacer un programa que determine lo siguiente:

·          cantidad de personas que pertenecen a la tercera edad (sobre 60 anos).

·          Promedio de edad de los encuestados.

·          Cantidad de personas de sexo masculino que están cesantes.

·          % de damas menores de 30 años que no trabajan con respecto al total de damas encuestadas.

Se debe validar que los datos de entrada estén dentro de los rangos señalados. Asuma que se encuestaran 200 personas.

8.         Escriba un programa que para un valor real calcule el valor de la función dada por:


6 + 2x2 si x>=1

f(x)=  3 + 6x3 si 0<x<1

2 +3x3+5x2 si x<=0

9.         Calcule la siguiente sumatoria:


donde N es un valor entre 5 y 10.

10.     Determine que escribe en pantalla el siguiente programa para x = 17 e y = 8

#include <iostream.h>

int main()

cout << "cont = " << cont << endl;

return 0;

11.     Considerando los datos de cada uno de los 40 empleados que tiene una empresa se desean obtener las siguientes estadísticas:

·          mostrar el promedio de sueldos.

·          contar los empleados con sueldo mayor a $300.000

·          determinar cuanto se gastaría en bonificación si a los empleados con sueldo menor a $300.000 se les bonifica con un 10% de su sueldo y a los de sueldo mayor o igual a $300.000 una bonificación de un 5%.

12.    


Calcular:

13.     Para un curso de 40 alumnos se desea saber el código del alumno que tuvo la mejor y la peor nota en la primera prueba. Para ello se ingresara para cada alumno su código y su correspondiente nota obtenida.

14.     Hacer un programa que muestre en pantalla todos los divisores que tiene un número N. Debe validarse que N sea mayor que 300.

15.     Se ha realizado una encuesta callejera con el fin de determinar el grado de escolaridad de la población. A cada persona se le consulto: edad (entre 10 y 100), sexo (F,M), escolaridad (b = básica, m = media, t = técnica, u = universitaria).

Hacer un programa que determine lo siguiente, después de encuestar a 200 personas tomadas en forma aleatoria:

a)        Cantidad de personas de sexo femenino con edad mayor que 20.

b)       Promedio de edad de los encuestados.

c)        Existen más mujeres u hombres con escolaridad técnica?

d)       Porcentaje de universitarios con respecto al total de encuestados.

16.     Hacer un programa que permita procesar los resultados del censo que se realizó el pasado 24 de abril en la ciudad de Valparaíso. Para cada una de las 500 casas encuestadas se registró:

·          cantidad de habitantes de la casa

·          cantidad de personas mayores de 65 años

·          ¿tiene televisor? (s/n)

·          ingreso familiar (sueldo)

·          número de estudiantes

Basándose en los antecedentes recopilados, se pide generar los siguientes resultados:

·          Cantidad de personas residentes en Valparaíso.

·          Ingreso familiar promedio en la ciudad.

·          Porcentaje de hogares que no tienen personas mayores de 65 años en sus casas.

·          Cantidad de hogares que no tienen televisor.

·          Porcentaje de estudiantes en la ciudad con respecto al total de habitantes.

17.     Hacer un programa que lea una serie de letras del alfabeto y que determine:

·          Cantidad total de elementos ingresados.

·          Porcentaje de letras 'a' con respecto al total de vocales ingresadas.

·          Cantidad de consonantes ingresadas.

18.     Determinar la mejor nota promedio en un curso de 40 alumnos, considerando que cada alumno tiene 10 notas.

19.     Se está haciendo un estudio de costos en una empresa, para determinar cuánto más se debería cancelar por concepto de sueldos mensualmente, si se decidiera subir el sueldo a sus empleados. El sueldo se subirá en un:

·          20% si el empleado es casado y lleva mas de 10 años en la empresa.

·          10% si el empleado no es casado y lleva mas de 10 años en la empresa.

·          5% en cualquier otra situación.

El programa deberá solicitar a cada uno se sus 20 empleados: el sueldo actual, cantidad de años trabajando en la empresa y si es casado o no, y deberá entregar como resultado el monto que le implicaría pagar a la empresa mensualmente en forma adicional en caso de que decidiera aprobar el aumento de sueldo.

20.     Cambie todas las estructuras de control while por do-while, y viceversa, de modo que se haga exactamente lo mismo.

int main()

while (condicion_3 || condicion_4);

accion_3;

while (condicion_5 || condicion_6)

while (condicion_7 && condicion_8);

accion_6;

accion_7;

return 0;

21.     Dado el siguiente programa en C:

int main ()

while ( c < 0 );

d = c;

e = c;

while ( c > = )

cout << "a = " << a;

cout << "El resultado es: " << b / a << endl;

cout << "d = " << d << "e = " << e;

return 0;

a)        Rutee el programa para los siguientes valores de c: -4, 3, 0, -8, 25

b)        Explique brevemente cuál es el objetivo del programa.

c)        Cambie el nombre de las variables a, b, c, d, e, f, de modo que reflejen lo que hacen realmente (dar nombres significativos a las variables).

22.     Rutear el siguiente algoritmo que determina el cuociente y el resto de una división entera entre p y q

a) Usar: p = q, y q = 3

b) Usar: p = 7, y q = 2

# include < iostream.h >

int main ()

cout << "Cuociente = " << cuociente << endl;

cout << "Resto = " << resto << endl;

return 0;

Unidad III: Arreglos

1.         Introducción:

·          Los arreglos son estructuras de datos que consisten en elementos del mismo tipo que están relacionados.

·          Los arreglos son entidades "estáticas": conservan el mismo tamaño durante todo el programa.

2.         Arreglos lineales o unidimensionales:

·          Definición: conjunto de variables del mismo tipo (homogéneas), que tienen un nombre común, y ocupan posiciones contiguas de memoria.

·          En memoria, los elementos de un arreglo están uno al lado del otro.

·          Ejemplo: arreglo de enteros, de nombre mi_arreglo, que contiene 7 elementos.

Nombre del arreglo

(todos los elementos del arreglo

tienen el mismo nombre: mi_arreglo)


 

 

 


mi_arreglo [ 0 ]

 


mi_arreglo [ 1 ]

mi_arreglo [ 2 ]

 


mi_arreglo [ 3 ]

 


mi_arreglo [ 4 ]

 


mi_arreglo [ 5 ]

 


mi_arreglo [ 6 ]


memoria

Número de posición del elemento

en el arreglo mi_arreglo (subíndice)

·          Declaración de arreglos:

Tipo Nombre_arreglo [Tamaño];

Tipo: de qué tipo son los elementos del arreglo

Nombre_arreglo: cualquier identificador que sea válido.

Tamaño: número de elementos que componen el arreglo.

·          Ejemplo

int mi_arreglo [7];

·            declara un arreglo de enteros de 7 elementos

·            desde mi_arreglo[0] hasta mi_arreglo[6]

·            Los arreglos se deben declarar de manera explícita, para que el compilador asigne los espacios de memoria.

·            El número de bytes de memoria que requiere un arreglo se calcula:

total bytes = sizeof (tipo base) * número de elementos

Ej: cout << sizeof (int) * 4;

·            El número de posición de un elemento del arreglo va encerrado entre corchetes, es el subíndice.

·            El primer elemento de cualquier arreglo tiene subíndice cero.

·            Si un arreglo tiene n elementos, las posiciones (subíndices) van desde 0 hasta (n - 1)

·            Es importante notar la diferencia entre el "tercer elemento de un arreglo", y el "elemento tres del arreglo". Puesto que los subíndices comienzan en 0, el "tercer elemento de un arreglo" tiene un subíndice 2, mientras que el "elemento tres del arreglo" tiene un subíndice 3, y es el cuarto elemento.

·            Para acceder a un elemento del arreglo:

·            nombre del arreglo

·            número de posición del elemento, encerrándolo entre corchetes ([ ]), es decir, el subíndice.

·            Ej.: cout << mi_arreglo[4];

muestra el quinto elemento del arreglo


·            Por lo tanto se debe especificar: Nombre_arreglo [nº_elemento - 1]

·            Para acceder al i-ésimo elemento del arreglo, se especifica: mi_arreglo [i - 1];

·           

subíndice
Esquemáticamente:

1 2 3 4 5 6

Orden del elemento
 

Elemento o contenido
 

2º 3º 4º 5º 6º 7º

·            Si algún problema usa como subíndice una expresión, ésta se evalúa para determinar el subíndice.

Ejemplo:

Si a = 3 y b = 2:

mi_arreglo [a + b] = mi_arreglo [a + b] + 3

suma 3 al elemento mi_arreglo [5]

EJERCICIOS: Arreglos lineales en C

Ejercicios resueltos

1.         Inicializar o "cargar" con ceros los elementos de un arreglo

#include <iostream.h>

#include <conio.h>

int main()

2.         Inicializar los elementos de un arreglo, con números de 0 a 6

// Primero se carga el arreglo, y luego se muestran sus elementos

#include <iostream.h>

#include <conio.h>

int main()

3.         Ídem al ejercicio 2, pero optimizando código

// Los elementos se muestran a medida que van siendo cargados.

#include <iostream.h>

#include <conio.h>

int main()

return 0;

4.         Variación usando un manipulador de flujos de datos

// Uso de setw(): manipulador de flujos

#include <iostream.h>

#include <conio.h>

#include <iomanip.h>

int main()

// Setw() es un manipulador de flujos (sirve para "direccionar").

5.         Inicializar un arreglo mediante una declaración: usar listas de inicialización

// int arreglo[6] = es igual a int arreglo[ ] =

#include <iostream.h>

#include <conio.h>

int main()

clrscr();

int arreglo[6] = ; // Lista de inicialización

int i;

for (i = 0; i < 6; i++)

cout << arreglo[i] << " ";

return 0;

6.         Definir el tamaño del arreglo mediante el uso de variables constantes:

Obsérvese el uso de las llamadas variables constantes (¿?), variables de sólo lectura, o constantes nombradas.

# include <iostream.h>

int main()

// (1), (2), (3) cambian automáticamente al cambiar fila.

// Si no se usa la variable constante fila, se deberían hacer 3 cambios en distintos lugares del programa.

// Facilidad para mantener el código

7.         Inicializar un arreglo con los pares del 2 al 20

Obsérvese el uso de las llamadas variables constantes (¿?), variables de sólo lectura, o constantes nombradas.

# include <iostream.h>

int main ()

8.         Cargar un arreglo de tamaño 10, con números aleatorios entre 1 y 50

// Cargar un arreglo con números aleatorios entre 1 - 50

#include <iostream.h>

# include <conio.h>

# include <stdlib.h>

int main()

9.         Calcular el promedio de los elementos de un arreglo de tamaño 10. Llenar el arreglo desde teclado.

# include <iostream.h>

# include <conio.h>

int main()

promedio = suma / fila;

cout << "\nPromedio: " << promedio;

return 0;

10.     Dado un arreglo cualquiera, mostrar un elemento según subíndice elegido. Validar Subíndices

# include <iostream.h>

# include <conio.h>

int main()

cout << "\nMostrar elemento de subíndice ";

cin >> subind;

if (subind > fila)

cout << "arreglo[" << subind << "]: " << arreglo[subind];

return 0;

11.     Encontrar los elementos mayor y menor de un arreglo, mostrarlos junto con sus subíndices respectivos.

Arreglo de tamaño 15, llenado con números aleatorios entre 1 y 100

# include <iostream.h>

# include <conio.h>

# include <stdlib.h>

int main()

if (arreglo[i] < menor)

cout << "\nElemento mayor: " << mayor

<< " ==> arreglo[" << subindmax << "]";

cout << "\nElemento menor: " << menor

<< " ==> arreglo[" << subindmin << "]";

return 0;

12.     Llenar un arreglo de tamaño 10 con números aleatorios. Buscar un elemento del arreglo, indicar si está o no. En caso de estar, mostrar el elemento y su subíndice.

# include <iostream.h>

# include <conio.h>

# include <stdlib.h>

int main()

cout << "NO ESTÁ";

return 0;

13.     Leer los elementos de un arreglo, y mostrar la información en forma de gráfico de barras o Histograma. Cada número se imprime seguido de una barra que consiste en la misma cantidad de asteriscos.

// Histograma

# include <iostream.h>

# include <conio.h>

# include <stdlib.h>

int main()

return 0;

14.     Entregar el bit de paridad de un arreglo de tamaño 8 (8 bits), que contiene sólo 1 y 0. El bit de paridad es 1 si la cantidad de unos (1) en el arreglo es par, y es 0 en caso contrario.

A)

# include <iostream.h>

# include <conio.h>

int main()

if (suma % 2 = = 0 && suma != 0)

cout << "PARIDAD PAR, bit de paridad 1";

else

cout << "PARIDAD IMPAR, bit de paridad 0";

return 0;

B)

# include <iostream.h>

# include <conio.h>

# include <stdlib.h>

int main()

if (cont % 2 == 0 && cont !=

cout << "\nPARIDAD PAR (1)";

else

cout << "\nPARIDAD IMPAR (0)";

return 0;

15.     Se desea manipular dos arreglos de 20 enteros cada uno. Escribir un programa que permita realizar las siguientes operaciones

a)            Llenar los dos arreglos, arreglo_1 y arreglo_2, con números aleatorios entre 1 y 50

b)          Mostrar por pantalla todos los elementos del arreglo_1, que son mayores que el máximo valor del arreglo_2.

c)            Mostrar por pantalla todos los elementos del arreglo_1, que son menores que el promedio de los valores del arreglo_2.

# include <iostream.h>

# include <conio.h>

# include <stdlib.h>

int main()

cout << "a)\n";

for (i = 0; i < fila; i++)  // Mostrar arreglo_1

cout << arreglo1[i] << " ";

cout << endl;

for (i = 0; i < fila; i++)  // Mostrar arreglo_2

cout << arreglo2[i] << " ";

max2 = arreglo2[0]; // Mayor elemento de arreglo_2

for (i = 1; i < fila; i++)

if (max2 < arreglo2[i])

max2 = arreglo2[i];

cout << "\n\nb) Mayor elemento arreglo_2: "

<< max2 << "\n";

cout << "Elementos de arreglo_1 mayores que " << max2 << ":\n";

for (i = 0; i < fila; i++)

if(arreglo1[i] > max2)

cout << arreglo1[i] << " ";

promedio2 = suma2 / fila;

cout << "\n\nc) Promedio de elementos de arreglo_2: " << promedio2;

cout << "Elementos de arreglo_1 menores que " << promedio2 << ":\n";

for (i = 0; i < fila; i++)

if (arreglo1[i] < promedio2)

cout << arreglo1[i] << " ";

return 0;

16.     Dado un arreglo de N números enteros, calcular (y mostrar):

·            la suma de los subíndices de aquellos elementos pares.

·            promedio de los elementos impares.

Por ejemplo, considere el siguiente arreglo:

Debería mostrar lo siguiente:

·           

·           

# include <iostream.h>

# include <conio.h>

# include <stdlib.h>

int main()

for (i = 0; i < fila; i++)

cout << arreglo[i] << " ";

promedio = suma_elem / fila;

cout << "\nSuma ¡ndices de elementos pares: " << suma_ind;

cout << "\nPromedio elementos impares: " << promedio;

return 0;

17.     Llenar un arreglo de enteros de tamaño 10 (desde teclado, o con números generados aleatoriamente), y mostrar sus elementos ordenados de menor a mayor.

Algoritmo de Ordenamiento (Bubble Sort)

# include <iostream.h>

# include <conio.h>

# include <stdlib.h>

int main()

cout << "\nOrden de SALIDA : ";

for (i = 0; i < fila; i++)

cout << arreglo[i] << " ";

return 0;

18.     Programa que trabaja con arreglos unidimensionales.

# include <iostream.h>

int main()

while ((a[i] < 1) || (a[i]>100));

// Números bajo el promedio

int cont=0, prom, sum=0;

for (i = 0; i < 5; i++)

sum = sum + a[i];

prom = sum / 5;

cout << "Promedio= " << prom << endl;

for (i = 0; i < 5; i++)

if (a[i] < prom)

cont++;

cout << "cantidad numeros bajo el promedio: ";

cout << cont << endl;

// Posición del elemento mayor

int pos=0, mayor=a[0];

for (i = 0; i < 5; i++)

cout << "Posición: " << pos;

// Mostrar el arreglo en forma inversa

cout << "Arreglo en forma inversa: ";

for (i = 4; i >= 0; i- -)

cout << a[i];

cout << endl;

// Mostrar elementos posiciones pares y cuyo valor es impar

cout << "posiciones pares, valor impar: ";

for (i = 0; i < 5; i++)

// Generar arreglo b con los elementos que sean mayores que 10.

pos=0;

for (i = 0; i < 5; i++)

return 0;

19.     Programa en C que permita realizar lo que indica el dibujo:

Arreglo1 Arreglo2

Arreglo3

Desde arreglo_3[5] hasta arreglo3_[9], se llena con la suma de arreglo_1[i] + arreglo_2[i]

# include <iostream.h>

# include <conio.h>

# include <stdlib.h>

int main()

for (i = 0; i < fila; i++)

cout << arreglo_1[i] << " ";

cout << endl;

for (i = 0; i < fila; i++)

cout << arreglo_2[i] << " ";

cout << endl;

for (i = 0; i < fila * 3; i++)

cout << arreglo_3[i] << " ";

return 0;

20.     Se almacenan las edades de un grupo de personas en un arreglo de largo 35: (Ud.debe llenar el arreglo)

a)        Mostrar la edad de una persona determinada (la persona con subíndice 0 tiene su edad en la casilla 0, etc)

b)        Mostrar el subíndice de la persona de menor edad

c)        Mostrar la mayor edad, y su posición (subíndice)

d)        Determinar cuántas personas son mayores a 19 años

# include <iostream.h>

# include <conio.h>

int main()

cout << "Mostrar edad de persona [?]: "; // a)

cin >> i;

cout << mi_arr[i];

mayor = menor = mi_arr[0];  //b) y c)

for (i = 0; i < fila; i++)

if (mayor < mi_arr[i])

cout << "\nSubíndice de persona menor edad: " << subind_edad_menor;

cout << "\nMayor edad: " << mayor;

cout << "\nSubíndice de mayor edad: " << subind_edad_mayor;

for (i = 0; i < fila; i++)  // d)

if (mi_arr[i] > 19)

cont_19 = cont_19 + 1;

cout << "\nMayores a 19 años: " << cont_19;

// e) se hace un CAST

calculo = float((mayor + subind_edad_menor)) / (menor + subind_edad_mayor);

cout << "\nC lculo: " << calculo;

for (i = 0; i < fila; i++)  // f)

if (mi_arr[i] % 2 == 0)

suma_par = suma_par + mi_arr[i];

cout << "\nSuma de edades pares: " << suma_par;

return 0;

Ejercicios propuestos

1.         Invertir los elementos de un arreglo.

2.         Determinar la suma de los elementos positivos de un arreglo.

3.         Encontrar la posición de un elemento e en un arreglo V.

4.         Contar en un arreglo los números iguales a x.

5.         Determinar la cantidad de valores mayores que X, en un arreglo A, de N elementos decimales.

6.         Llenar 2 arreglos de largo 10 cada uno con números enteros y a partir de estos datos generar:

a)        Un arreglo de largo 20 con todos los elementos del primer arreglo y luego los del segundo.

b)        Un arreglo de largo 20 llamado D con los elementos de A y B pero intercalados.

c)        Un arreglo llamado E de largo 10 con la suma de los elementos de A y B (E[i]=A[i]+B[i])

d)        Un arreglo F con los números que se encuentren dentro de cierto rango ingresado por el usuario, en el arreglo A.

e)        Un arreglo G con el factorial de cada elemento almacenado en A (G[i]=A[i]!).

f)         Un arreglo H con la multiplicación del elemento por su índice del arreglo B (H[i]=B[i]*i)

g)        Un arreglo I con los elementos de A en orden inverso (I[i]=A[n-i]).

7.         Dado un arreglo A de largo 20 de números enteros:

a)        Llenar el arreglo con valores que estén dentro del rango de 1 a 1000.

b)        Mostrar en pantalla los elementos ingresados en forma inversa.

c)        Calcular el porcentaje de elementos que son mayores que 50.

d)        Mostrar en pantalla todos elementos que se encuentran en las posiciones pares y luego aquellos que estén en las posiciones impares.

e)        Aumentar al doble todos los elementos menores que 15.

f)         Intercalar los elementos de manera de que los que estaban en una posición par se almacenen ahora en una posición impar (aux=A[i]; A[i]=A[i+1]; A[i+1]=aux).

8.         Dado un arreglo M de 8 elementos enteros. Cree un arreglo A que contenga los elementos de M y agregue antes y después de cada numero '10' una casilla con un numero 1 y otra con un numero 0. El programa debe mostrar finalmente en pantalla ambos arreglos creados y la cantidad de elementos almacenados en el arreglo M.

Ejemplo:

M= 4 6 10 3 10 5 7 12

A= 4 6 1 10 0 3 1 10 0 5 7 12

Total de elementos de A: 12

9.         Diseñe un programa que permita almacenar los diez primeros números primos en un arreglo.

10.     Para un arreglo de largo 50, de números enteros:

a)        Llenar el arreglo sólo con números entre -100 y 100

b)        Contar los números mayores que 50 existentes en el arreglo

c)        Determinar el porcentaje de números ceros con respecto al total de números ingresados

d)        Multiplicar cada elemento positivo del arreglo por 2

e)        Intercambiar el primer elemento con el segundo, el tercero con el cuarto, y así sucesivamente.

11.     Para un arreglo de tamaño 30, de números enteros, mostrar el promedio de los elementos almacenados en el arreglo. Generar además, otro arreglo pero sólo con los elementos que se encuentran bajo el promedio calculado.

12.     Se tiene un arreglo A, de largo 200, lleno con números enteros.

a)        Generar el arreglo B que sea una copia exacta de A

b)        Generar el arreglo C que sea una copia invertida de A

c)        Generar el arreglo D que contenga sólo a aquellos elementos mayores que 50

d)        Generar el arreglo E que contenga el factorial de cada uno de los elementos almacenados en A

13.     Diseñar un programa que traspase desde un arreglo A de largo 30, lleno con números enteros, a un arreglo B, de largo 10, sólo los 10 primeros valores pares que encuentre en el primer arreglo.

14.     Hacer un programa que copie desde un arreglo de largo 30, lleno con enteros, a un arreglo B, los factoriales de los valores almacenados originalmente en A.

15.     Las notas de un curso de 40 alumnos están almacenadas en un arreglo de largo 40.

a)        Mostrar la nota individual para un alumno determinado (el alumno con código 0 tendrá su nota en el casillero 0, y así sucesivamente).

b)        Determinar cuál es la mejor nota

c)        Determinar el código del alumno con la peor nota

d)        Indicar cuántos alumnos tuvieron nota inferior a 4.0

16.     Suponga que un supermercado almacena los precios de sus productos en un arreglo de largo 50, en donde los productos perecibles están almacenados en las localizaciones pares, y los no perecibles en las impares. Hacer un programa que:

a)        Llene el arreglo.

b)        Calcule la suma de los precios de los alimentos no perecibles.

c)        Aumente en un 10% el precio de todos los productos que valen menos de $1.000 y que son perecibles.

d)        Muestre por pantalla todos los códigos de los productos cuyo precio es mayor que el precio promedio de todos los productos del supermercado.

17.     Un club deportivo - social cuenta con 80 socios, casualmente 40 de ellos practican taca-taca, y los otros 40 yo-yo. Los pesos de estos 80 "deportistas" se almacenan en un arreglo, donde los del taca-taca ocupan las posiciones pares, y los del yo-yo las posiciones impares.

Cree un programa en C que:

a)        Llene el arreglo

b)        Encuentre el mayor peso y muestre a qué tipo de deportista corresponde (yoyocero o tacataquero)

c)        Determine el promedio del peso de los tacataqueros

d)        Muestre cuántos practicantes de yo-yo están bajo el promedio de peso de los practicantes de taca-taca.

18.     Se tiene el arreglo A, de tamaño 100, lleno con números enteros. Calcular y mostrar lo siguiente:

e)        (elemento mayor + subíndice elemento menor) / (elemento menor + subíndice del elemento mayor).

f)         Factorial de los elementos de subíndice impar

g)        Suma de los elementos pares

h)        Producto de los elementos de subíndice impar.

19.     Se tienen 3 arreglos:

·          Arreglo1, de enteros, de largo 20,

·          Arreglo2, de enteros, de largo 10,

·          Arreglo3, de enteros, de largo 10

Se pide llenar el Arreglo1. Una vez lleno se debe hacer lo siguiente:

a)        Llenar el Arreglo2 con los elementos 11 - 20 (últimos 10 elementos) ordenados, del Arreglo1.

b)        Llenar el Arreglo3 con los elementos 1 - 10 (primeros 10 elementos) del Arreglo1, pero en orden inverso.

20.     Una sala de juegos del casino de Tilcoco, tiene un total de 60 mazos de naipes; cada uno de ellos se identifica con un número positivo (número de inventario). Los mazos que se emplean en una sesión de juego son aquellos cuyo número de inventario es divisible por un entero K (K > 1), que debe ser ingresado y validado. Desarrollar un programa que:

a)        Llene el arreglo "mazos" con el número correspondiente del inventario de los mazos.

b)        Verifique la divisibilidad de cada número de inventario, asignando un 0 (cero) si la condición se cumple, o un 1 (uno) en caso contrario, guardando esta información en el arreglo "divisible".

c)        Imprimir el número de mazos a usar en una sesión para un K dado.

Además el programa debe imprimir el número de veces que se repite la secuencia 1 0 1 en el arreglo "divisible" (la secuencia 1 0 1 0 1 son dos secuencias 1 0 1)

BIBLIOGRAFÍA

·            Schildt, H., Turbo C/C++: Manual de Referencia, McGRAW-HILL, 1992.

·            Schildt, H., Borland C++: Manual de Referencia, McGRAW-HILL, 1997

·            Joyanes A., L., Borland C++ 4/4.5 Iniciación y Referencia, McGRAW-HILL,1996.

·            Davis, S.R., C++ for Dummies, IDG Books, 1994.

·            Deitel, H.M., Deitel, P.J., C++ Cómo Programar, PRENTICE HALL, 1998. Segunda edición.

·            Sedgewick, Robert, Algoritmos en C++, ADDISON - WESLEY / DÍAZ DE SANTOS, 1995

·            Manuales de C/C++ de diversas direcciones electrónicas:

·            www.elrincondelc.com

·            www.programación.com

·            www.manualesgratis.com

·            www.programmersheaven.com

·            https://c.conclase.net/curso/indice.html

Document Info


Accesari: 6750
Apreciat: hand-up

Comenteaza documentul:

Nu esti inregistrat
Trebuie sa fii utilizator inregistrat pentru a putea comenta

Creaza cont nou

A fost util?

Daca documentul a fost util si crezi ca merita
sa adaugi un link catre el la tine in site


in pagina web a site-ului tau.



eCoduri.com - coduri postale, contabile, CAEN sau bancare

Politica de confidentialitate | Termenii si conditii de utilizare




Copyright © Contact (SCRIGROUP Int. 2024 )