Herramientas de Apoyo

DESCARGAS

 

PRIMARIA

• Code Enseñe a sus niños a programar jugando, y desarrolle su inteligencia lógica.

Desarrolle sus Juegos e Historietas Jugando

• Scratch, Herramienta para aprender a programar y desarrollar tus propios juegos e historietas.

ADOLESCENTES 

Desarrolle Aplicaciones Móviles

•  AppInventor. para jóvenes y adolescentes, crear aplicaciones móviles es fácil.

UNIVERSITARIOS Y SECUNDARIA

Diseño de Algoritmos

• Pseint Excelente herramienta para el diseño de Algoritmos.

Programación

• Codeblocks, Entorno de programación para C, C++.
• Eclipse, Herramienta para programar en Java.
• Pycharm, Herramienta para programar en Python.

CADENAS

Cadenas de caracteres

^

Antes de entrar en el tema de los arrays también conocidos como arreglos, tablas o matrices, veremos un caso especial de ellos. Se trata de las cadenas de caracteres, frecuentemente nombrados en inglés como strings.

Nota: en informática es frecuente usar términos en inglés, sobre todo cuando la traducción puede inducir a errores, como en este caso, en que string se suele traducir como cuerda o cadena.
Aunque array también se puede traducir como ristra o sarta, que en este caso parece más apropiado, en ningún texto de programación verás que se hable jamás de ristras o sartas de caracteres o enteros.

Una cadena en C++ es un conjunto de caracteres, o valores de tipo char, terminados con el carácter nulo, es decir el valor numérico 0. Internamente, en el ordenador, se almacenan en posiciones consecutivas de memoria. Este tipo de estructuras recibe un tratamiento muy especial, ya que es de gran utilidad y su uso es continuo.
La manera de definir una cadena es la siguiente:

char <identificador> [<longitud máxima>];

Nota: En este caso los corchetes no indican un valor opcional, sino que son literalmente corchetes, por eso están en negrita.

Cuando se declara una cadena hay que tener en cuenta que tendremos que reservar una posición para almacenar el carácter nulo terminador, de modo que si queremos almacenar la cadena "HOLA", tendremos que declarar la cadena como:

char Saludo[5];

Las cuatro primeras posiciones se usan para almacenar los caracteres "HOLA" y la posición extra, para el carácter nulo.
También nos será posible hacer referencia a cada uno de los caracteres individuales que componen la cadena, simplemente indicando la posición. Por ejemplo el tercer carácter de nuestra cadena de ejemplo será la 'L', podemos hacer referencia a él como Saludo[2].
Es muy importante tener presente que en C++, los índices tomarán valores empezando siempre en cero, así el primer carácter de nuestra cadena sería Saludo[0], que es la letra 'H'.
En un programa C++, una cadena puede almacenar informaciones en forma de texto, como nombres de personas, mensajes de error, números de teléfono, etc.
La asignación directa sólo está permitida cuando se hace junto con la declaración.
El siguiente ejemplo producirá un error en el compilador, ya que una cadena definida de este modo se considera una constante, como veremos en el capítulo de "arrays" o arreglos.

char Saludo[5]; 
Saludo = "HOLA"

La manera correcta de asignar una cadena es:

char Saludo[5]; 
Saludo[0] = 'H'; 
Saludo[1] = 'O'; 
Saludo[2] = 'L'; 
Saludo[3] = 'A'; 
Saludo[4] = 0;

O bien:

char Saludo[5] = "HOLA";

Si te parece un sistema engorroso, no te preocupes, existen funciones que facilitan la manipulación de cadenas.
De hecho, existen muchas de tales funciones, que permiten compararlas, copiarlas, calcular su longitud, imprimirlas, visualizarlas, guardarlas en disco, etc. Además, frecuentemente nos encontraremos a nosotros mismos creando nuevas funciones que básicamente hacen un tratamiento de cadenas.
En C existe una biblioteca estándar (disponible en todos los compiladores), llamada precisamente string. En C++ también existe una biblioteca para manipular cadenas, aunque en este caso se trata de una biblioteca de clases.

ARREGLOS MULTIDIMENSIONALES

Arreglos bidimensionales en C++

Un arreglo de una dimensión es usado para representar  elementos en una lista o secuencia de valores. En algunos casos la relación entre elementos del arreglo no pueden representarse en forma de lista. Un arreglo de 2 dimensiones es usado para representar elementos en una tabla con columnas y filas, se puede acceder a cualquier elemento dentro del arreglo indicando el indice de la columna y la fila del arreglo.
La siguiente figura muestra un arreglo con 4 filas y 4 columnas. Las filas se acceden integrando un rango desde 0 hasta el 3 y las columnas con un rango del 0 al 3. Un arreglo bi-dimensional se declara de la misma manera que un arreglo unidimensional, exceptuando que su tamaño debe ser declarado.

1 2 3 4 5

const int NUMFIL=4;                                //numero de filas   const int NUMCOL=4;                             //numero de columnas   float  caja[NUMFIL][NUMCOL]         //arreglo creado con las constantes anteriores.  [NUMFIL]=primera dimension. [NUMCOL] =segunda dimension.

Este ejemplo declara caja como un arreglo de 2 dimensiones cuyos elementos son variables del tipo float. Para acceder a un elemento individual del arreglo debe de especificar 2 expresiones (una por cada dimensión) ejemplo: caja[0][2] donde [0] es fila y [2] columna.

Ejemplos de declaración de arreglos bidimensionales en C++

Necesitamos un arreglo que muestre  el clima de cada día de año indicando la semana y el día (un arreglo de 52*7=364)

1	int clima[52][7];

Nuestro arreglo clima consta de 52 filas y 7 columnas partiendo del 0 al 51 y el 0 al 6, cada espacio de este contiene un valor int. Nuestra intención es que el arreglo guarde los datos de cada día del año. Si usamos la expresión clima[2][6], nos dará el clima del día 7 de la tercer semana..

Procesando arreglos bidimensionales en C++ para dos dimensiones

Procesar los datos de un arreglo de 2 dimensiones generalmente significa acceder al arreglo en uno o 4 patrones: aleatorio, a través de columna, a través de filas o a través del arreglo entero. Por ejemplo un usuario ingresa las coordenadas de un mapa a través de un indice en el arreglo nombre_calle para llegar a la dirección  que desea, este proceso es conocido como aleatorio.
Hay veces que necesitamos utilizar una operación en cada elemento de una fila o columna en el arreglo. Suponiendo en el caso anterior del clima que queremos sacar un promedio de la temperatura de una semana debemos sumar lo valores en la fila semana y dividirlo entre 7, este caso accede al arreglo a través de las filas, si por el contrario lo que queremos es el promedio de un día de la semana en especifico (ejemplo promedio de todos lunes del año) debemos sumar los elementos de la columna días y dividirlo entre 52, este caso accede al arreglo a través de las columnas, un ejemplo mas, si queremos sacar el promedio del clima del año entero debemos acceder a cada elemento del arreglo (en este caso el orden para acceder a las filas o columnas no tiene relevancia) y dividirlo entre 364, esto accede a todo el arreglo.
Considerando los 4 ejemplos comunes para procesar los arreglos echemos un vistazo a los siguientes patrones para acceder a ellos.

1. sumar las filas.
2. sumar las columnas.
3. inicializar el arreglo en 0 (o algún valor especifico)
4. mostrar el arreglo.

Primero definimos algunas constantes y variables usando identificadores generales como fila y columna.

1 2 3 4 5 6 7 8

const int NUMCOL=10;   const int NUMFIL=10;   int arreglo[NUMFIL][NUMCOL];      //arreglo bidimensional int columna                                   //indice de columna int fila                                            //indice de fila int total                                          //la variable para la suma

Sumando filas de arreglos bidimensionales en C++

Suponiendo que queremos sumar la fila numero 3 (cuarta fila) en el arreglo y queremos mostrarlo. Lo haremos fácilmente con la función for

1 2 3 4 5 6 7

total=0;   for(columna=0;columna<NUMCOL;col++){     total=total+arreglo[3][columna]; }   cout<<"la suma es "<<total<<endl;

El for suma cada columna mientras mantienes fija la fila con el indice 3, sumando cada valor que hay en ella.
Ahora supongamos que queremos sumar la fila 2 y 3, anidamos un for al que ya teníamos ejemplo:

1 2 3 4 5 6 7 8

total=0;   for(fila=2;fila<4;fila++){     for(columna=0;columna<NUMCOL;columna++){         total=total+arreglo[fila][columna];     } } cout<<"el total es "<<total<<endl;

el for de afuera controla las filas y el de adentro las columnas.
En la primera iteración se accede a la posición del arreglo: arreglo[2][0], arreglo[2][1], arreglo[2[2] … arreglo[2][NUMCOL-1];
En la segunda accede a: arreglo[3][0], arreglo[3][1], arreglo[3][2] …. arreglo[3][NUMCOL-1];
Si queremos acceder a una porción del arreglo declararemos las siguientes variables (subarreglo)

1 2	int filaFilled         //dato esta en 0.....filaFilled int colFilled          //datos esta en 0 ....colFilled

Entonces escribimos el fragmento de código siguiente

1 2 3 4 5 6 7 8

total=0;   for(fila=2;fila<filaFilled;fila++){     for(columna=0;columna<columnaFilled;columna++){         total=total+arreglo[fila][columna];     } } cout<<"el total es "<<total<<endl;

Sumar columnas de arreglos bidimensionales en C++

Supongamos que queremos sumar cada columna y mostrarlas.

Una vez mas generalizamos el código sumando solo la porción del arreglo que contiene datos validos.

1 2 3 4 5 6 7 8

total=0;   for(columna=0;columna<columnaFilled;columna++){     for(fila=2;fila<filaFilled;fila++){         total=total+arreglo[fila][columna];     } } cout<<"el total es "<<total<<endl;

En este caso el primer for controla las columnas y el interior las filas.

Inicializando arreglos bidimensionales en C++

Como con los arreglos unidimensionales podemos inicializar los arreglos bidimensionales en su declaración o usando declaración de asignaciones.
Si el arreglo es corto es simple iniciarlo en su declaración, para iniciar un arreglo de 2 flas y 3 columnas como este
14 4 -5
0  46 7
podemos usar la siguiente declaración

1 2 3 4 5

int arreglo[2][3]= {     {14, 3, -5},     {0, 46, 7} };

En esta declaración la lista consiste en dos elementos, siendo cada uno una lista de inicialización: la primera guarda los valores 14, 3, -5 en la fila 0 del arreglo; la segunda guarda los valores 0, 46 y 7 en la fila 1.
Inicializar un arreglo en su declaración es impractico si el arreglo es largo por ejemplo uno de 100*100, no necesariamente tienes que listar 10,000 elementos. Si los valores son todos distintos deberías guardarlos en un archivo y entrarlos en el arreglo al mismo tiempo que corre el programa. Si los valores son iguales lo usual es anidar iteraciones en su declaración de asignaciones, el siguiente ejemplo inicializa todos los arreglos en 0.

1 2 3

for(fila=0;fila<NUMFIL;fila++)     for(columna=0;columna<NUMCOL;columna++)         arreglo[fila][columna]=0;

en este caso no importa si accedemos por las filas primero o las columnas, mientras accedamos a todos los elementos del arreglo.

Mostrar arreglos bidimensionales en C++

Si queremos mostrar el arreglo con una fila por fila entonces tendremos otro caso de procesamiento por fila:

1 2 3 4 5 6 7 8 9 10

#include <iomanip>           //para el setw(); . . . for(fila=0;fila<NUMFIL;fila++) {     for(columna=0;columna<NUMCOL;columna++)         cout<<setw(15)<<arreglo[fila][columna];     cout<<endl; }

Este fragmento de código imprime valores del arreglo en columnas de 15 caracteres.
No hay regla que diga que tenemos que imprimir cada fila en una linea, podemos voltear el arreglo e imprimir cada columna en una linea, simplemente cambiando los dos for.
Cuando imprimes un arreglo bidimensional, debes considerar cual orden de presentación tiene mas sentido y como el arreglo encaja en la pagina. Por ejemplo un arreglo de 6 columnas y 100 filas, seria mejor presentado como 6 columnas y 100 lineas de largo.

ARRERGLOS UNIDIMENSIONALES

Arreglos unidimensionales en C++

Los arreglos (array) son un conjunto de valores que se relacionan por medio de un nombre en común. También se puede decir que son datos que se almacenan bajo el mismo nombre y para diferenciarlos se utiliza un índice.
En el lenguaje C++ un arreglo puede tener varias dimensiones, en esta ocasión hablaremos de los arreglos unidimensionales (una dimensión).

Arreglos Unidimensionales

Un arreglo unidimensional es una lista de valores guardados bajo el mismo nombre y del mismo tipo. Cada valor dentro del arreglo se le conoce como elemento del arreglo.
Para declarar un arreglo unidimensional en C++ se utiliza la siguiente línea de código:
tipo_dato identificador[tamaño];
En “tipo de dato” introduciremos que tipo de dato queremos (int, char, float.. etc) , luego en “identificador” introducimos como llamaremos a nuestro arreglo para ubicarlo e identificarlo de manera rápida. Y entre los corchetes colocaremos el tamaño que le demos a nuestro array. Quedando de esta manera:

1	int arreglo[3];

Ya que tenemos declarado nuestro arreglo necesitamos declarar cada uno de los elementos que lo conforman, para esto utilizamos lo siguiente:

1	arreglo[1]=valor;

Iniciamos con el nombre de nuestro arreglo en el apartado que dice arreglo, entre los corchetes colocaremos que parte del array utilizaremos, en C++ los valores se inician en 0, esto quiere decir que si nuestro arreglo es de tamaño 3, al hacer nuestro índice hay que tomar el 0 como valor inicial quedando [0] , [1] y [2] completando así nuestros 3 valores del tamaño antes mencionado.
En la parte “valor” asignaremos el valor que le daremos a ese elemento quedando de la siguiente manera:

1	arreglo[1]=100;

Ejemplo: el siguiente programa carga el arreglo sqrs con los cuadrados de los números del 1 al 10 y luego los visualiza

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

#include <iostream> using namespace std; int main() {     int sqrs[10];// forma un arreglo de tamaño 10     int i;     for (i=1;i<11;i++) {         sqrs[i-1]=i*i;     }// un ciclo for para ir aumentando el numero que elevaremos al cuadrado y definir la operación.     for (i=0;i<10;i++) {         cout<<sqrs[i]<<endl;     }//aumento de posición del índice del arreglo.          return 0; }

La forma como se almacenan los valores en el arreglo es la siguiente:
sqrs[0] = 1*1
sqrs[1] = 2*2
sqrs[2] = 3*3
sqrs[3] = 4*4
sqrs[4] = 5*5
sqrs[5] = 6*6
sqrs[6] = 7*7
sqrs[7] = 8*8
sqrs[8] = 9*9
sqrs[9] = 10*10
y muestra en pantalla:


Como vimos los arreglos  son de mucha utilidad cuando manejamos una lista de información y así elaborarla de manera rápida y óptima para nuestros programas.
Referencias

• Schildt Herbert, C++ Para programadores. McGraw-Hill. 1996
• Lenguaje C++ Arreglos unidimensionales y multidimensionales. Prof. Elías Cisneros República Bolivariana de Venezuela Aldea Universitaria Fray Pedro de Agreda PNFSI 2009

ESTRUCTURA DE CONTROL

¿Qué es un ciclo while?

Los ciclos while es otra forma de hacer repeticiones de condiciones permitiéndonos ejecutarla de manera repetitiva sin tener un valor inicial o final ya que este no depende de valores numéricos y mas bien depende de condiciones otorgadas de verdadero o falso y por este motivo son diferentes y más efectivos a diferencia de los ciclos for.
La sentencia o grupo de sentencias que se repite en un bloque se denomina cuerpo del ciclo y cada repetición del cuerpo del ciclo se llama iteración del ciclo.

¿Cómo funciona un ciclo while?

Necesitamos comprender que en un ciclo while se utiliza cuando queremos o necesitamos repetir una sentencia un numero indefinido de veces, por ejemplo, podemos pedirle al usuario que introduzca una cantidad deseada de latas de refresco a comprar las veces que el desee por lo que podrá poner “2, 4, 7, etc” y el programa seguirá corriendo e ingresando nombres y solo dejara de hacerlo cuando se pida una condición especifica que en este caso seria cuando el usuario ingrese una cantidad mayor a “7”.
A continuación la sintaxis del ciclo while en c++

Sintaxis ciclo while en c++

Esta es muy sencilla ya que solo requerimos tener bien clara una condición de parada.

https://es.wikipedia.org/wiki/Bucle_while
en este caso nuestra sintaxis del pseudocodigo quedaría de este modo

1 2 3 4 5 6

while(numero <= 7) { cout <<  "Ingrese una cantidad "; cin >> numero; cout<<" No puede adquirir mas de 7 latas a la vez, "; } system("pause");

Aquí tenemos lo esencial del ciclo, como es la condicional en la linea una que nos dice que si el numero es mayor a 7 el ciclo debe terminar ahí, las otras lineas son meramente guía para que el usuario realice los pasos dichos en ella como son el ingresar una cantidad y en caso de ingresar mas de 7, avisarle que no puede hacer esa función y terminar el ciclo.
Cuando el usuario ejecute el programa tendrá que verse así

Diagrama de ciclo while

A continuación presentaremos en manera de diagrama como se vería el código

Código de ciclo while

Este seria el código funcional del ciclo while

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

#include "iostream"   using namespace std; int main() { int numero; //declaramos la variable numero//         cout <<  "Ingrese la cantidad de latas de refresco que desea comprar "; //le pedimos al usuario que ingrese una cantidad"         cin >> numero; //guardamos la cantidad en la variable// while(numero <= 7) //while nos ayuda para ver si la cantidad es mayor a 7// { cout <<  "Ingrese una cantidad "; //le pedimos que ingrese cantidad, si es menor a 7 se termina// cin >> numero; cout<<" No puede adquirir mas de 7 latas a la vez, "; //si es mayor a 7 le saldra este mensaje// }         system ("pause"); //termina programa// return 0; }

SALIDA DE DATOS

Algoritmo del programa Hola mundo “C++”

Conjunto de pasos para la solución de un problema o de un proceso.
Ejemplo:

1. Usuario ejecute el Programa.
2. Mostrar en Pantalla un Mensaje de “Hola Mundo”.
3. Finalizar el Programa.

Pseudocódigo del programa Hola mundo

Es una descripción de alto nivel la cual esta enfocada en un lenguaje humano en lugar de lenguaje en maquina.

1 2 3 4 5

<strong>Inicio:   Mostrar "Hola Mundo"   Fin </strong>

Diagrama de Flujo del programa Hola mundo

Es la representación gráfica de un algoritmo o Control de Flujos al momento de un Proceso.

Código en C ++ del programa “Hola Mundo”

Bibliotecas
En Primer Lugar las Librerías (O Bibliotecas) son archivos que podemos incluir en nuestro programa.
Estos archivo ya programados por lo tanto solo tienes que agregarlos para realizar diferentes tareas dentro de tu programa como mostrar texto en pantalla.
Conclusión : Las librearías son archivos externos (No siempre) que nos permiten llevar un cabo diferentes tareas dentro de un Programa.
#include <iostream>
Using namespace std
“La instrucción using namespace especifica que los miembros van a utilizarse frecuentemente en un Programa.
Como resultado al usarlo ya no tienes que estar repitiendo lo mismo al momento de escribir alguna instrucción para mostrar un mensaje en pantalla.
using namespace std;
Ejemplo al no declarar el using namespace:

1	std :: cout << "Hola Mundo" << endl;

Función  int main ()
“La Línea int main ().  Es La Que Indica Que El código Que Viene un Continuación, Entre los Paréntesis o llaves ( { y } ) es parte de la Función principal.”
Cuando la Función Principal regresa  un valor de cero, entonces el programa se termina.
Conclusión: por regla general, una Función principal  siempre dębe de tener un  retorno 0  .
Cout en C ++
Mostrar texto por Pantalla en C ++ es muy simple. Para imprimir una salida de texto en C ++ se Hace uso de la instrucción cout << y Entre comillas el texto que quieras mostrar en la pantalla al momento de la ejecución del programa.
Nota: Es Importante tener en cuenta que la instrucción cout siempre va acompañada de 2 menor que << en cada párrafo sobre todo para controlar el flujo de datos de salida.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

/ * Programa: Hola Mundo Autor: Oscar Martínez González Carrera: Ing. Informatica 2016B Materia: Programacion Seccion: D24 * /   // Definir las librerias Que Vamos a Como utilizar en Nuestro Programa #include <iostream>   / * Definir el USO de epacios párrafo sin declerarlo En Cada linea de Nuestro codigo * / using namespace std;   int main () { // Mensaje Que se va mostra en Pantalla cout << "Hola Mundo" << endl; // Instrucción para Finalizar y salir del Programa return 0; }

ENTRADA DE DATOS

Entrada de datos

Canal de Entrada

La entrada de datos consiste en recoger datos para incorporarlos al programa. Es decir, una serie de datos externos se recogen, y entran a formar parte del programa. La forma de recoger los datos que veremos aqu, es hacer que estos nos los proporcione el usuario.
Para eso al escribir el código fuente indicamos que el programa debe pararse y esperar a que el usuario introduzca un dato. una vez introducido el dato, el programa debe ser capaz de recogerlo, y seguir con el resto de instrucciones.
Otras formas de recoger datos sera extraerlos de un fichero o de una base de datos, e incorporarlos al programa, pero esto es algo más complicado, por lo que de momento veremos cómo incorporar los datos que nos proporciona directamente el usuario.

Instrucciones de entrada

Par poder recoger un dato, lo primero que tenemos que tener es un recipiente o contenedor en donde guardar el dato, y esto lo conseguimos con una variable. Por lo tanto lo primero que debemos hacer es declarar una variable.
Vamos a poner un ejemplo, en el que pedimos al usuario su nombre, y después lo sacamos en pantalla. lo primero que haremos será declarar una variable de tipo string:

string nombre;

Tal como hemos explicado en páginas anteriores, tanto esta sentencia como las siguientes las pondremos siempre dentro de la función int main().
Aquí hemos declarado una variable de tipo "texto" (string), pero no la hemos inicializado, es decir al crearla no le hemos dado un valor. En esta variable guardaremos el dato que nos proporcione el usuario.
El siguiente paso es pedirle al usuario que nos proporcione el dato, es decir, que nos diga su nombre. Esto, siguiendo nuestro ejemplo, lo pondremos con el siguiente código:

cin >> nombre;

Cuando el programa llega a este punto se para y espera que el usuario escriba con el teclado algo, y que una vez que lo ha escrito pulse la tecla "Enter".
Una vez que el usuario ha pulsado la tecla "Enter", el dato que ha introducido el usuario, es decir, el nombre, es guardado como el valor de la variable nombre.
Analicemos un momento el código. Así como la instrucción cout indica que vamos a sacar algo en pantalla , cin de C (lenguaje c) y in (dentro en inglés), indica que recogemos algo de la pantalla.
Los dos signos de >> (menor que) indican que va a haber una entrada de datos. Recordemos que para la salida de datos se ponen los signos << (mayor que), es decir los signos contrarios.
Ahora para comprobar que el dato se ha guardado, lo sacaremos en pantalla, mediante una salida de datos, por lo que la siguiente línea podría ser:

cout << nombre << endl;

Como ya hemos visto la salida en pantalla en la página anterior, no debe tener ninguna dificultad entender este código.
Con las líneas que hemos puesto hasta ahora tenemos el siguiente programa:

1 2 3 4 5 6 7 8

#include<iostream>
using namespace std;

int main() {
    string nombre;
    cin >> nombre;
    cout << nombre << endl;
}

Si compilamos y ejecutamos este programa sale la consola de windows sin nada y esperando a que nosotros escribamos algo. Si escribimos un nombre y pulsamos después "Intro", el programa sigue, y escribira otra vez el nombre que le hemos dicho, para luego acabar.

Mejorar el programa

Aunque este es un programa muy sencillo, podemos mejorarlo, incluyendo unas cuantas instrucciones de salida, que le digan al usuario que tiene que escribir un nombre, y después el programa le saluda con su nombre, Para ello modificamos el código fuente, el cual quedara así:

1 2 3 4 5 6 7 8 9 10

#include<iostream>
using namespace std;

int main() {
    cout << "Escribe tu nombre :" << endl;
    string nombre;
    cin >> nombre;
    cout << "Hola " << nombre
         << " encantado de conocerte." << endl;
}

Ahora al compilar y ejecutar el programa primero nos pregunta el nombre, y una vez que lo escribimos y pulsamos intro, nos saluda con nuestro nombre.
El programa ha mejorado respecto al del principio, ya que aquí le indicamos al usuario lo que tiene que hacer, es decir, introducir su nombre. Igualmente en la salida de datos añadimos un saludo, para que esta resulte un poco más amable.