├── .gitignore ├── README.md ├── Tipos de datos.md ├── archivos ├── Productos.cpp ├── README.md ├── agregar_texto.cpp ├── crud_cpp.cpp ├── escribir.cpp ├── lectura.cpp ├── probando.txt ├── productos.dat └── programacion.txt ├── aritmeticos.cpp ├── asignacion.cpp ├── bool.cpp ├── char.cpp ├── clases.cpp ├── comparacion.cpp ├── comparar_cadenas.cpp ├── condicionales ├── condicionales.cpp ├── constantes.cpp ├── decremento.cpp ├── definicionTipos.cpp ├── double.cpp ├── ejercicios ├── 1.perimetro.cpp ├── 2.area_isosceles.cpp ├── 3.volumen_cilindro.cpp ├── 4.triangulo-equilatero.cpp ├── 5.triangulo-escaleno.cpp ├── 6.triangulo-rectangulo.cpp ├── comparacionFunciones.cpp ├── ejercicios-finales │ ├── ejercicio_1.cpp │ ├── ejercicio_10.cpp │ ├── ejercicio_11.cpp │ ├── ejercicio_2.cpp │ ├── ejercicio_3.cpp │ ├── ejercicio_4.cpp │ ├── ejercicio_5.cpp │ ├── ejercicio_6.cpp │ ├── ejercicio_7.cpp │ ├── ejercicio_8.cpp │ ├── ejercicio_9.cpp │ └── readme.md ├── estanque.cpp ├── funciones_1.cpp ├── funciones_2.cpp ├── funciones_potencia.cpp ├── opreacionesFuncion.cpp └── recursividadEjercicio1.cpp ├── enteros.cpp ├── estructuras-2.cpp ├── estructuras.cpp ├── float.cpp ├── for.cpp ├── funcion-parametros.cpp ├── funciones.cpp ├── funciones ├── Factorial_Recursividad.cpp ├── Fibonacci_Recursividad.cpp ├── Potencia_Recursividad.cpp ├── arrays.cpp └── readme.md ├── images ├── math-functions1.png ├── math-functions2.png └── operadores-asignacion.png ├── incremento.cpp ├── logicos.cpp ├── main.cpp ├── namespace.cpp ├── pescadosEnEstanque.cpp ├── poo ├── README.md ├── Rectangulo.cpp └── clases.cpp ├── proyectos ├── Dogs_and_cat │ ├── .vscode │ │ └── settings.json │ ├── Dogs_and_cat.zpr │ ├── Producto.cpp │ ├── Producto.h │ ├── dbProductos.csv │ └── main.cpp └── tienda_veterinaria.cpp ├── puntero-estructura.cpp ├── punteros-2.cpp ├── punteros.cpp ├── switch.cpp ├── taller_programacion ├── ciclos │ ├── ciclo_do_while.cpp │ ├── ciclo_do_while_printf.cpp │ ├── ciclo_while.cpp │ ├── ciclo_while_printf.cpp │ ├── ejercicio_1.cpp │ ├── ejercicio_1_cout.cpp │ ├── ejercicio_2.cpp │ ├── ejercicio_2_cout.cpp │ ├── ejercicio_3.cpp │ ├── ejercicio_3_cout.cpp │ ├── ejercicio_4.cpp │ ├── ejercicio_4_printf.cpp │ ├── intervalo.cpp │ ├── intervalo_impar.cpp │ ├── intervalo_impares_while_cout.cpp │ ├── intervalo_impares_while_printf.cpp │ ├── intervalo_pares_while.cpp │ ├── intervalo_pares_while_printf.cpp │ ├── intervalo_printf.cpp │ ├── intervalor_impar_printf.cpp │ ├── numeros_impares.cpp │ ├── numeros_impares_printf.cpp │ ├── numeros_pares.cpp │ ├── numeros_pares_printf.cpp │ ├── usco_while_cout.cpp │ └── usco_while_printf.cpp ├── condicionales │ ├── condicionales_cout.cpp │ └── condicionales_printf.cpp ├── ejercicio_1.cpp ├── ejercicio_2.cpp ├── incio_1.cpp ├── inicio_2.cpp ├── operadores_logicos_cout.cpp ├── operadores_logicos_printf.cpp ├── taller_1 │ ├── ejercicio_10_cout.cpp │ ├── ejercicio_10_printf.cpp │ ├── ejercicio_11_cout.cpp │ ├── ejercicio_11_printf.cpp │ ├── ejercicio_12_cout.cpp │ ├── ejercicio_12_printf.cpp │ ├── ejercicio_13_cout.cpp │ ├── ejercicio_13_printf.cpp │ ├── ejercicio_14_cout.cpp │ ├── ejercicio_14_printf.cpp │ ├── ejercicio_15_cout.cpp │ ├── ejercicio_15_printf.cpp │ ├── ejercicio_1_cout.cpp │ ├── ejercicio_1_printf.cpp │ ├── ejercicio_2_cout.cpp │ ├── ejercicio_2_printf.cpp │ ├── ejercicio_3_cout.cpp │ ├── ejercicio_3_printf.cpp │ ├── ejercicio_4_cout.cpp │ ├── ejercicio_4_printf.cpp │ ├── ejercicio_5_cout.cpp │ ├── ejercicio_5_printf.cpp │ ├── ejercicio_6_cout.cpp │ ├── ejercicio_6_printf.cpp │ ├── ejercicio_7_cout.cpp │ ├── ejercicio_7_printf.cpp │ ├── ejercicio_8_cout.cpp │ ├── ejercicio_8_printf.cpp │ ├── ejercicio_9_cout.cpp │ ├── ejercicio_9_printf.cpp │ └── readme.md ├── taller_2 │ ├── ejercicio_10_cout.cpp │ ├── ejercicio_10_printf.cpp │ ├── ejercicio_1_cout.cpp │ ├── ejercicio_1_printf.cpp │ ├── ejercicio_2_cout.cpp │ ├── ejercicio_2_printf.cpp │ ├── ejercicio_3_cout.cpp │ ├── ejercicio_3_printf.cpp │ ├── ejercicio_4_cout.cpp │ ├── ejercicio_4_printf.cpp │ ├── ejercicio_5_cout.cpp │ ├── ejercicio_5_printf.cpp │ ├── ejercicio_6_cout.cpp │ ├── ejercicio_6_printf.cpp │ ├── ejercicio_7_cout.cpp │ ├── ejercicio_7_printf.cpp │ ├── ejercicio_8_cout.cpp │ ├── ejercicio_8_printf.cpp │ ├── ejercicio_9_cout.cpp │ ├── ejercicio_9_printf.cpp │ └── readme.md ├── taller_3 │ ├── ejercicio_1_cout.cpp │ ├── ejercicio_1_printf.cpp │ ├── ejercicio_2_cout.cpp │ ├── ejercicio_2_printf.cpp │ ├── ejercicio_3_cout.cpp │ ├── ejercicio_3_printf.cpp │ ├── ejercicio_4_cout.cpp │ ├── ejercicio_4_printf.cpp │ ├── ejercicio_5_cout.cpp │ ├── ejercicio_5_printf.cpp │ ├── ejercicio_6_cout.cpp │ ├── ejercicio_6_printf.cpp │ ├── ejercicio_7_cout.cpp │ ├── ejercicio_7_printf.cpp │ ├── ejercicio_8_cout.cpp │ └── ejercicio_8_printf.cpp ├── taller_5 │ ├── ejercicio_10_cout.cpp │ ├── ejercicio_10_printf.cpp │ ├── ejercicio_1_cout.cpp │ ├── ejercicio_1_printf.cpp │ ├── ejercicio_2_cout.cpp │ ├── ejercicio_2_printf.cpp │ ├── ejercicio_3_cout.cpp │ ├── ejercicio_3_printf.cpp │ ├── ejercicio_4_cout.cpp │ ├── ejercicio_4_printf.cpp │ ├── ejercicio_5_cout.cpp │ ├── ejercicio_5_printf.cpp │ ├── ejercicio_6_cout.cpp │ ├── ejercicio_6_printf.cpp │ ├── ejercicio_7_cout.cpp │ ├── ejercicio_7_printf.cpp │ ├── ejercicio_8_cout.cpp │ ├── ejercicio_8_printf.cpp │ ├── ejercicio_9_cout.cpp │ └── ejercicio_9_printf.cpp ├── taller_6 │ ├── ejercicio_10_cout.cpp │ ├── ejercicio_10_printf.cpp │ ├── ejercicio_1_cout.cpp │ ├── ejercicio_1_printf.cpp │ ├── ejercicio_2_cout.cpp │ ├── ejercicio_2_printf.cpp │ ├── ejercicio_3_cout.cpp │ ├── ejercicio_3_printf.cpp │ ├── ejercicio_4_cout.cpp │ ├── ejercicio_4_printf.cpp │ ├── ejercicio_5_cout.cpp │ ├── ejercicio_5_printf.cpp │ ├── ejercicio_6_cout.cpp │ ├── ejercicio_6_printf.cpp │ ├── ejercicio_7_cout.cpp │ ├── ejercicio_7_printf.cpp │ ├── ejercicio_8_cout.cpp │ ├── ejercicio_8_printf.cpp │ ├── ejercicio_9_cout.cpp │ └── ejercicio_9_printf.cpp ├── taller_7 │ ├── ejercicio_10_cout.cpp │ ├── ejercicio_10_printf.cpp │ ├── ejercicio_11_cout.cpp │ ├── ejercicio_11_printf.cpp │ ├── ejercicio_12_cout.cpp │ ├── ejercicio_12_printf.cpp │ ├── ejercicio_13_cout.cpp │ ├── ejercicio_13_printf.cpp │ ├── ejercicio_14_cout.cpp │ ├── ejercicio_14_printf.cpp │ ├── ejercicio_15_cout.cpp │ ├── ejercicio_15_printf.cpp │ ├── ejercicio_16_cout.cpp │ ├── ejercicio_16_printf.cpp │ ├── ejercicio_1_cout.cpp │ ├── ejercicio_1_printf.cpp │ ├── ejercicio_2_cout.cpp │ ├── ejercicio_2_printf.cpp │ ├── ejercicio_3_cout.cpp │ ├── ejercicio_3_printf.cpp │ ├── ejercicio_4_cout.cpp │ ├── ejercicio_4_printf.cpp │ ├── ejercicio_5_cout.cpp │ ├── ejercicio_5_printf.cpp │ ├── ejercicio_6_cout.cpp │ ├── ejercicio_6_printf.cpp │ ├── ejercicio_7_cout.cpp │ ├── ejercicio_7_printf.cpp │ ├── ejercicio_8_cout.cpp │ ├── ejercicio_8_printf.cpp │ ├── ejercicio_9_cout.cpp │ ├── ejercicio_9_printf.cpp │ └── readme.md ├── taller_8 │ ├── clase │ │ ├── ejercicio_2_printf.cpp │ │ ├── ejercicio_do_while_cout.cpp │ │ ├── ejercicio_do_while_printf.cpp │ │ ├── ejercicio_for_cout.cpp │ │ ├── ejercicio_for_printf.cpp │ │ ├── ejercicio_while_cout.cpp │ │ └── ejercicio_while_printf.cpp │ ├── ejercicio_1_cout.cpp │ ├── ejercicio_1_printf.cpp │ ├── ejercicio_2_cout.cpp │ ├── ejercicio_2_printf.cpp │ ├── ejercicio_3_cout.cpp │ ├── ejercicio_3_printf.cpp │ ├── ejercicio_4_cout.cpp │ ├── ejercicio_4_printf.cpp │ ├── ejercicio_5_cout.cpp │ ├── ejercicio_5_printf.cpp │ ├── ejercicio_6_cout.cpp │ ├── readme.md │ └── taller │ │ ├── ejercicio_10_cout.cpp │ │ ├── ejercicio_10_printf.cpp │ │ ├── ejercicio_1_cout.cpp │ │ ├── ejercicio_1_printf.cpp │ │ ├── ejercicio_2_cout.cpp │ │ ├── ejercicio_2_printf.cpp │ │ ├── ejercicio_3_cout.cpp │ │ ├── ejercicio_3_printf.cpp │ │ ├── ejercicio_4_cout.cpp │ │ ├── ejercicio_4_printf.cpp │ │ ├── ejercicio_5_cout.cpp │ │ ├── ejercicio_5_printf.cpp │ │ ├── ejercicio_6_cout.cpp │ │ ├── ejercicio_6_printf.cpp │ │ ├── ejercicio_7_cout.cpp │ │ ├── ejercicio_7_printf.cpp │ │ ├── ejercicio_8_cout.cpp │ │ ├── ejercicio_8_printf.cpp │ │ ├── ejercicio_9_cout.cpp │ │ └── ejercicio_9_printf.cpp └── taller_9 │ ├── ejercicio_1.cpp │ ├── ejercicio_10.cpp │ ├── ejercicio_11.cpp │ ├── ejercicio_2.cpp │ ├── ejercicio_3.cpp │ ├── ejercicio_4.cpp │ ├── ejercicio_5.cpp │ ├── ejercicio_6.cpp │ ├── ejercicio_7.cpp │ ├── ejercicio_8.cpp │ ├── ejercicio_9.cpp │ └── readme.md └── while.cpp /.gitignore: -------------------------------------------------------------------------------- 1 | # Prerequisites 2 | *.d 3 | 4 | # Compiled Object files 5 | *.slo 6 | *.lo 7 | *.o 8 | *.obj 9 | 10 | # Precompiled Headers 11 | *.gch 12 | *.pch 13 | 14 | # Compiled Dynamic libraries 15 | *.so 16 | *.dylib 17 | *.dll 18 | 19 | # Fortran module files 20 | *.mod 21 | *.smod 22 | 23 | # Compiled Static libraries 24 | *.lai 25 | *.la 26 | *.a 27 | *.lib 28 | 29 | # Executables 30 | *.exe 31 | *.out 32 | *.app 33 | *.bin 34 | 35 | ### VisualStudioCode ### 36 | .vscode/* 37 | !.vscode/settings.json 38 | !.vscode/tasks.json 39 | !.vscode/launch.json 40 | !.vscode/extensions.json 41 | 42 | ### VisualStudioCode Patch ### 43 | # Ignore all local history of files 44 | .history 45 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Curso de C++ Básico 2 | 3 | C++ es un lenguaje de programación, es uno de los más utilizados en todo el mundo. 4 | Para programar en C++, se necesita un compilador y un editor. 5 | El **compilador** traduce el código fuente a código máquina (Código Binario), y el **editor** es el programa que nos colorea la sintaxis del lenguaje para poder escribir el código cómodamente, 6 | 7 | Hay algunos programas que son compiladores y editores, se conocen como IDE (Entorno de desarrollo Integrado). por ejemplo. 8 | - Dev C++ 9 | - CodeBlocks 10 | - [Zinja](http://zinjai.sourceforge.net/). Es un programa similar a PSeint en la interfaz. 11 | 12 | Cualquiera que se escoja se debe descargar e instalar. 13 | 14 | En el caso de usar **Dev C++**, al crear un nuevo proyecto debemos ir a *Menu -> Nuevo -> Proyecto* y allí escogemos el tipo de aplicación que queramos escoger. 15 | 16 | Para ejecutar el programa, debemos previamente haberlo compilado. También podemos usar el botón de **compilar y ejecutar** 17 | 18 | 19 | > Para ignorar archivos por git, podemos usar la herramienta [gitignore](https://www.gitignore.io/), que genera el archivo para usarlo, dependiendo del lenguaje o entorno en el que se trabaje. 20 | 21 | 22 | ## Hola Mundo 23 | 24 | Primero, debemos crear un nuevo proyecto, y luego crear un archivo llamado **main.cpp**, o el nombre que se desee. 25 | Luego de eso, debemos incluir las librerías, que son un conjunto de código que viene predefinido y que nos facilita el trabajo. 26 | 27 | Para incluir una librería usamos la sentencia 28 | ```cpp 29 | #include 30 | 31 | int main(){ 32 | printf("Hola Mundo \n"); 33 | std::cout << "Hi everyone" << std::endl; 34 | return 0; 35 | } 36 | ``` 37 | *stdio.h* **`.h`** porque es una cabecera. 38 | *`\n`* Es un operador de escape, el compilador lo detecta como un salto de línea. 39 | 40 | - **Librería** Conjunto de herramientas que viene con código predefinido, lo que nos permite facilitar el trabajo. 41 | 42 | 43 | ## Variables enteras (`int`) 44 | 45 | **iostream** Es una librería que nos permite escribir y leer información por consola. 46 | ```cpp 47 | #include 48 | ``` 49 | 50 | Para declarar un variable en *C++¨*, debemos primero colocar el tipo de dato. Por ejemplo: 51 | ```cpp 52 | int num = 31; 53 | // Otra forma de delcarar y asignar valor es 54 | int num{23}; 55 | ``` 56 | 57 | Para evitar colocar prefijos a las funciones, es necesario especificar los espacios de nombre que vamos a utilizar, por ejemplo: 58 | ```cpp 59 | using namespace std; 60 | 61 | // Si no usaramos los espacios de nombre, nos tocaría usar 62 | std::cout << "Hola mundo \n Hola universo " << endl; 63 | ``` 64 | 65 | Si queremos que haya salto de línea, podemos usar el operador de escape `\n`, y así colocamos texto en una nueva línea. 66 | 67 | ## Variables `bool` y `char` 68 | 69 | - **char** Esta tipo de dato almacena caracteres 70 | - **bool** Este tipo de dato almacena valores booleanos (false o verdadero), `true` `false` 71 | 72 | ### Variable de tipo `char` 73 | 74 | Si por ejemplo colocamos una palabra en una variable de tipo **char**, el compilador, sólo tomará el último caracter. En este caso usamos *comillas simples* 75 | ```cpp 76 | char letra = 'Hola mundo'; 77 | ``` 78 | 79 | Para mostrar varios caracteres usamos comillas dobles y colocamos un __`*`__, al final de la palabra reservada `char` . 80 | 81 | ### Variable de tipo `bool` 82 | Es un tipo de variable lógico, 0 - 1, ó verdadero y falso. 83 | 0 == false 84 | 1 == true 85 | 86 | Para declarar una variable booleana, indicamos el tipo de dato `bool` 87 | ```cpp 88 | bool variable = true; // false | true 89 | ``` 90 | 91 | 92 | ## Variable de tipo `float` 93 | 94 | Son variables que guardar números de coma flotante de baja precisión, son como decimales que no tienen muchos decimales (No tiene tanto espacio en la memoria). 95 | 96 | En algunos casos, el compilador redondea el número a un valor superior o inferior. 97 | 98 | ```cpp 99 | float num = 5.23478; 100 | ``` 101 | 102 | ## Variable de tipo `double` 103 | 104 | Son tambien números de punto flotante que tienen más precisión ó espacio que memoria que los float. Funciona para números con más caracteres. 105 | ```cpp 106 | double num = 12.3479835; 107 | ``` 108 | 109 | ## Constantes 110 | 111 | Son variables que no pueden ser modificadas durante la ejecución del programa. Lo valores que le asignemos no se pueden cambiar. 112 | 113 | ```cpp 114 | // Es una constante, su valor no se puede cambiar 115 | const int numero = 11; 116 | ``` 117 | 118 | 119 | ## Operadores Aritméticos 120 | 121 | Son los que nos permiten realizar operaciones matemáticas. 122 | 123 | ```cpp 124 | int num1 = 2; 125 | int num2 = 6; 126 | int suma = num1 + num2; 127 | ``` 128 | 129 | - Suma `+` 130 | - Resta `-` 131 | - Multiplicación `*` 132 | - División `/` 133 | - Módulo (Residuo de la división) `%` 134 | 135 | 136 | ## Operadores de Asignación 137 | 138 | El operador de asignación general es `=`. Exiten otros como: 139 | - **Asigna una suma** `+=` Suma un valor a la variable 140 | - **Asigna una resta** `-=` Resta un valor a la variable 141 | - **Asigna una multiplicación** `*=` Resta un valor a la variable 142 | 143 | ```cpp 144 | // Declaración; 145 | int operacion; 146 | // Asignación 147 | operacion = 12; 148 | // Operador de asignación 149 | operacion *= 3; 150 | ``` 151 | 152 | Algunos ejemplos de operadpres de asignación son: 153 | ![Operadores de Asignación](images/operadores-asignacion.png) 154 | 155 | ## Operadores de Comparación 156 | 157 | - *Operador de comparación* `==` 158 | - *Distinto o diferente* `!=` 159 | - *Mayor que* `>` 160 | - *Mayor o igual que* `>=` 161 | - *Menor que* `<` 162 | - *Menor o igual que* `<=` 163 | 164 | Estos operadores son usamos en los condicionales y ciclos, donde comparamos dos valores para realizar una determinada acción. 165 | 166 | ## Operadores lógicos 167 | 168 | - *and* `&&` 169 | Si ambas condiciones se cumplen, retorna true 170 | - *or* `||` 171 | Si alguna de las dos condiciones se cumple, retorna true. 172 | - *Negación* `!` 173 | Niega una condición. Si es true, lo vuelve false y viciversa. 174 | 175 | ## Funciones matemáticas 176 | 177 | La librería header Standard `cmath`define un rango de funciones trigonométricas y numéricas que puede usar en todos sus programas. A continuación se presenta una tabla con las funciones más útiles. 178 | 179 | ![Funciones matemáticas 1](images/math-functions1.png) 180 | ![Funciones matemáticas](images/math-functions2.png) 181 | *Img. Referencia Beginning C++ Ivor Horton (Pag. 40)* 182 | ## Sentencias `if` (Condicionales) 183 | 184 | Permiten comparar dos variables para ejecutar una acción determinada. La condición se cumple siempre y cuando la condición sea verdadera. 185 | 186 | ```cpp 187 | if (numero1 < numero2){ 188 | cout << "Es menor" << endl; 189 | } else if (numero1==numero2){ 190 | cout<<"Son iguales"<< endl; 191 | } else { 192 | cout << "Es mayor" << endl; 193 | } 194 | ``` 195 | 196 | ## Sentencia `switch` 197 | 198 | Es un tipo de condicional que dado un valor introducido los compara con los casos que tiene definido. Un ejemplo de switch en `C++` es el siguiente 199 | 200 | ```cpp 201 | switch (c){ 202 | case 'a': 203 | case 'e': 204 | case 'i': 205 | case 'o': 206 | case 'u': 207 | cout << "El una vocal." << endl; 208 | break; 209 | default: 210 | cout << "Es una consonante" << endl; 211 | break; 212 | } 213 | ``` 214 | 215 | ## Comentarios 216 | 217 | Son útiles para ordenar el código y explicar el código. Cuando se compila el programa, el compilador ignora estas líneas y nos las lee. 218 | 219 | ```cpp 220 | /** 221 | * Comentario multilínea 222 | */ 223 | 224 | // Comentario de una sola línea 225 | ``` 226 | 227 | ## Ciclos o Bucles 228 | 229 | Estas estructuras nos permiten ejecutar bloques de códigos dada una condición. 230 | 231 | ## Ciclo `while` 232 | 233 | Ejecuta las sentencia siempre que la condición sea verdadera. La expresión se verfica en cada inicio de la iteración. 234 | 235 | ```cpp 236 | int i = 0; 237 | while (i <= 5) { 238 | cout << "Valor de i: " << i << endl; 239 | // Aumentamos el valor de la variable 240 | i++; 241 | } 242 | ``` 243 | 244 | ## Ciclo `do while` 245 | 246 | El bucle do-while es una variante del ciclo while. Este ciclo evalúa la expresión al final de cada iteración. Por lo que se garantiza que el ciclo se ejecute al menos una vez. 247 | 248 | ```cpp 249 | int a = 10; 250 | do { 251 | cout << "Valor de a: " << a << endl; 252 | // Aumentamos el valor de la variable 253 | a++; 254 | } while (a <= 5); 255 | ``` 256 | 257 | ## Ciclo `for` 258 | 259 | El ciclo for ejecuta la primera expresión al iniciar el ciclo. Luego al inicio de cada iteración (Repetición) evalúa la segunda expresion y al final de cada iteración ejecuta la tercera expresion. 260 | 261 | ```cpp 262 | // Declaración de un array 263 | char array[5]; 264 | array[0] = 'A'; 265 | array[1] = 'B'; 266 | array[2] = 'C'; 267 | array[3] = 'D'; 268 | array[4] = 'E'; 269 | 270 | // Ciclo for 271 | for (unsigned int i = 0; i < sizeof(array) ; i++){ 272 | cout << array[i] << endl; 273 | } 274 | ``` 275 | 276 | En este ejemplo, vemos algo llamado arreglo. Los arreglos son variables que tienen varias posiciones en memoria, lo que permiten almacenar más de un valor en una sóla referencia. 277 | 278 | Para declarar un arreglo, lo hacemos igual que en una variable, colocando al final corchetes angulares indicando el tamaño del arreglo. 279 | 280 | ```cpp 281 | // Arreglo de tipo entero con 5 posiciones 282 | int variable[5]; 283 | ``` 284 | 285 | Para asignar valores al arreglo, debemos acceder a la posición y en ella colocar el valor que deseemos (Debe ser del mismo tipo de dato). 286 | ```cpp 287 | // Asignamos un valor al arreglo, en la posición 0 288 | variable[0] = 12; 289 | ``` 290 | 291 | ## Operadores del Preprocesaor 292 | 293 | ### Operador `include` 294 | 295 | Es un operador del preprocesador, el preprocesador es una parte del compilador que verifica qué librerías se están importando en el código fuente. (`#`). 296 | 297 | El operador `#include`, permite incluir librerías. Hay dos formas de incluir las librerías 298 | 299 | - `#include ` Busca los archivos en los recursos del compilador 300 | - `#include "iostream"` Busca los archivos en la propia carpeta 301 | 302 | 303 | ### Operador `define` 304 | 305 | `#define` crea una macro, que es la asociación de un identificador o identificador parametrizado con una cadena de token. Una vez definida la macro,el compilador puede sustituir la cadena de token para cada aparición del identificador del archivo de código fuente. 306 | 307 | ```cpp 308 | #define suma(a,b) a+b 309 | ... 310 | int valor = suma(2,5); 311 | ``` 312 | En este ejemplo, el compilador evalúa el identificador y al utilizarse, sustituye la cadena con la aparición del identificador. 313 | 314 | 315 | ## Funciones 316 | 317 | Las funciones son una manera de encapsular una funcionalidad que quieres reutilizar, de manera que puedes llamar esa función con un solo nombre, y no tendrás que escribir el código entero cada vez que la utilices. 318 | 319 | La declaración de una función en c++, va de la siguiente manera. 320 | *tipo-dato-devolver nombre-funcion(){ //Código a ejecutar }* 321 | 322 | ```cpp 323 | // Funcion suma 324 | int sumar(int a, int b){ 325 | return a+b; 326 | } 327 | 328 | // Funcion que no retorna nada 329 | void miFuncion(){ 330 | cout << "Yo no retorno nada" << endl; 331 | } 332 | ``` 333 | 334 | Hay dos tipos de funciones 335 | - Las que no retornan valor `void` 336 | - Las que retornan un valor `int`, etc. 337 | 338 | También podemos definir parámetros por defecto a la función, de la siguiente manera. 339 | ```cpp 340 | void funcion(int a = 10){ 341 | cout << a+3 << endl; 342 | } 343 | ``` 344 | 345 | De esta manera, ya el valor de a tiene predefinido 10, sin embargo este valor puede ser cambiado al pasar por parámetro un nuevo valor en la llamada de la función. 346 | ```cpp 347 | int main(){ 348 | function(); 349 | function(12); 350 | return 0; 351 | } 352 | ``` 353 | 354 | ## Estructuras 355 | 356 | Son un tipo de variable estructurada, donde se puede almacenar varios datos sin importar del tipo que sea y que tenga relación entre ellas. 357 | 358 | Haciendo relación con otros lenguajes, vendría siendo lo que se conoce como objetos. 359 | 360 | ```cpp 361 | // Definición de la estructura 362 | struct Personaje { 363 | int edad; 364 | int telefono; 365 | string nombre; 366 | }; 367 | 368 | // Declaración y asignación de valores 369 | Personaje juan; 370 | juan.nombre = "Juan Marruecos"; 371 | juan.edad = 100; 372 | juan.telefono = 3123; 373 | 374 | cout << juan.nombre << endl; 375 | ``` 376 | 377 | En las estructuras también podemos declarar funciones y constructores. Los **constructores** son funciones que se inicializan al ser inicializadas las variables. 378 | 379 | *Ver ejemplo* [estructuras-2.cpp](estructuras-2.cpp) 380 | 381 | ## Espacios de Nombres (`namespace`) 382 | 383 | Es una funcionalidad de C++ que permite crear encapsular a las variables para evitar conflictos cuando tienen el mismo nombre. 384 | 385 | ```cpp 386 | // Declaración de un espacio de nombre 387 | namespace pueblo { 388 | int calle = 10; 389 | } 390 | 391 | // Utilización del espacio de nombre 392 | using namespace ciudad; 393 | ``` 394 | 395 | ## Punteros 396 | 397 | Son herramientas que nos permiten gestionar la memoria. Los punteros son variables que guardan la dirección en memoria. 398 | 399 | **`&`** *Operador de referencia*, nos permite saber la dirección en memoria de las variables. 400 | 401 | `*` Es un operador de indirección, es decir cambia el valor de memoria por el valor que contiene esa dirección. 402 | 403 | ```cpp 404 | cout << &numero << endl; 405 | ``` 406 | 407 | Cuando accedemos al puntero en un array, se accede a la posición 0. Los demás items están en las posiciones siguientes de la memoria. Para acceder a las direcciónes siguientes de memoria, sólo dando `p++` 408 | 409 | ```cpp 410 | int array[5]; 411 | int *p; 412 | 413 | int main(){ 414 | 415 | p = array; 416 | cout << "Direccion array[0] " << &array << endl; 417 | cout << "Puntero " << p << endl; 418 | 419 | cin.get(); 420 | return 0; 421 | } 422 | ``` 423 | 424 | ## Punteros a estructuras 425 | 426 | Se pueden tener tambien referencias a las estructuras `struct`, el funcionamiento de los punteros es igual como en los ejemplos anteriores. 427 | 428 | ## Definición de tipos `tipedef` 429 | 430 | Permite colocarle alias o sobrenombre a los tipos de datos que estemos utilizando. 431 | 432 | ```cpp 433 | // Define una tipo de dato entero sin signo como `uint` 434 | typedef unsigned int uint; 435 | ``` 436 | 437 | ## Clases 438 | 439 | Una clase es un modelo que define las propiedades y métodos de un objeto. 440 | - **Atributos o propiedades**: Variables 441 | - **Métodos**: Son las funciones que haré con esos atributos 442 | 443 | *Las clases son plantillas que agrupan comportamiento (métodos) y estados (atributos) de los futuros objetos.* 444 | 445 | Las clases se definen usando la palabra reservada `class`, seguido del nombre de la clase. 446 | ```cpp 447 | class nombreClase { //Código a definir }; 448 | ``` 449 | 450 | Cada clase tiene modificadores de acceso, como son: 451 | 452 | **public**: Pueden ser accedidos desde cualquier instancia de la clase 453 | **private**: Pueden ser accedidos sólo en la misma clase 454 | **protected**: Pueden ser accedidos desde las clases heredadas. 455 | 456 | 457 | *Ejemplo de clases* [clases.cpp](clases.cpp) -------------------------------------------------------------------------------- /Tipos de datos.md: -------------------------------------------------------------------------------- 1 | # Tipos de dato 2 | 3 | El sistema operativo asigna memoria y selecciona lo que será almacenado en la memoria reservada basado en el **tipo de dato** de la variable. 4 | 5 | El tipo de dato define el uso apropiado de un identificador, qué tipo d dato puede ser almacenado, y qué tipos de operaciones puedes ser realizadas. 6 | 7 | > En C++, las comillas simples indican un **carácter**; las comillas dobles definen una cadena de texto. Mientras que 'a' es un carácter individual, "a" es una cadena de texto. 8 | 9 | ## Enteros 10 | 11 | Almacena números no fraccionados, los cuales pueden ser positivos o negativos. 12 | 13 | > El tamañp del tipo entero varía de acuerdo a la arquitectura del sistema en el cual el programa es ejecutado, aunque 4 Bytes es el tamaño mínimo en la mayoría de los sistemas modernos. 14 | 15 | Se usa la palabra **int** para definir un entero 16 | ```c++ 17 | int a = 42; 18 | ``` 19 | 20 | Los enteros pueden modificarse usando los **modificadores** 21 | - **signed** Entero cn signo, puede almacenar valores negativos y positivos. 22 | - **unsigned** Sin signo, puede almacenar sólo valores positivos 23 | - **short** La mitad del tamaño por defecto 24 | - **long** El doble del tamaño por defecto 25 | 26 | ```c++ 27 | unsigned long int a; 28 | ``` 29 | 30 | ## Números de punto Flotante 31 | 32 | Puede almacenar un número real, es decir con decimales. 33 | Hay tres tipos diferentes de datos de punto flotante: 34 | - **float** Generalmente de 4 Bytes 35 | - **double** Generalmente 8 bytes 36 | - **long double** Puede ser de 8 bytes o 16 bytes 37 | 38 | ```c++ 39 | double myVar = 3.11; 40 | ``` 41 | 42 | > Los tipos de datos de punto flotante, siempre serán **signed** (Con signo), lo que significa que tienen la capacidad de almacenar tanto valores positivos como negativos. 43 | 44 | 45 | ## Cadenas de texto 46 | 47 | Una cadena de texto (*string*), es una secuencia ordenada de caracteres, encerrados dento de **comillas dobles**. 48 | 49 | Son parte de la librería estándar. Necesita incluit la librería **** para utilizar el tipo de dato *string* 50 | 51 | ```c++ 52 | #include 53 | using namespace std; 54 | 55 | int main(){ 56 | string cadena = "Hola, soy una cadena de texto"; 57 | return 0; 58 | } 59 | ``` 60 | 61 | > La librería es incluida en la librería **, así que de ser incluida, no necesario llamarla por aparte 62 | 63 | 64 | ## char 65 | 66 | Una variable **char** almacena un entero de 1 byte. No se interpreta como un entero, sino como un caracter ASCII. 67 | 68 | El carácter es colocado dentro de comillas simples ('a', 'x') 69 | 70 | ```c++ 71 | char caracter = 'A'; 72 | ``` 73 | 74 | 75 | ## booleanos 76 | 77 | Las variables booleanas (**bool**) sólo tienen dos valores posibles: 78 | - **true** (1) 79 | - **false** (0) 80 | 81 | ```c++ 82 | bool study = true; 83 | bool love = false; 84 | ``` 85 | 86 | > Si un valor booleano es asignado a un entero, **true (verdadero)** es 1, y** false (false)** es 0 87 | 88 | 89 | ## Nombrar variables 90 | 91 | Para nombrar variables en C++, sigue las siguientes instrucciones: 92 | - Deben empezar con una letra del alfabeto o guión bajo ( \_ ) 93 | - Después de la letra inicial, los nombres de variables pueden contener letras adicionales. 94 | 95 | **Importante** 96 | * Los espacios en blanco o caracteres especiales no son permitidos 97 | * Las palabras reservadas no pueden ser incluidas como nombres de variables, por ejemplo int, float, bool 98 | 99 | Hay dos tipos de convenciones para nombrar variables 100 | - **Pascal Case** (Tipo pascal), se usa la primera letra de cada palabra en Mayúscula (**MyVariable**) 101 | - **Camel Case** (Tipo camel) Se deja la primera letra en minúscula y luego, la primera letra de cada palabra en Mayúsculas (**miVariable**) 102 | 103 | 104 | > C++ es sensible a mayúsculas, lo que significa que una variable escrita en mayúsculas no es las misma que escritas en minúsculas (miVariable != MyVariable) 105 | 106 | 107 | 108 | ## :fire: Punteros 109 | 110 | Una variable es un una ubicación en memoria que tiene diección definida. 111 | 112 | Ésta direccción puede ser accedida usando el operador **&** (Conocido como *dirección de*) el cuál indica la dirección en memoria. 113 | 114 | ```c++ 115 | int puntaje = 5; 116 | cout << &puntaje << endl; 117 | // Muestra 0x29fee8 118 | ``` 119 | 120 | Lo que hace es mostrar la **direccción en memoria** de la variable. 121 | 122 | *Un puntero es una variable que almacena el valor de la dirección de otra variable* 123 | Nos ayudan a realizaar más fácilmente ciertas tareas 124 | 125 | Un puntero es una variable, y al igual que cualquier otra variable, debe ser declarada antes de trabajar con ella. 126 | 127 | El signo **asterisco** es usado para declarar un **puntero** (el mismo asterisco que se usa para la multiplicación), en este caso se usa para designar una variable como un puntero. 128 | 129 | ```c++ 130 | int *entero; // Puntero a un entero 131 | double *flotante; // Punetro a un double 132 | ``` 133 | 134 | Ejemplo de uso de punteros 135 | 136 | ```c++ 137 | int puntaje = 5; 138 | int *puntajePuntero; 139 | puntajePuntero = &puntaje; 140 | 141 | cout << puntajePuntero << endl; 142 | // Muestra la dirección (hexadecimal) de la variable 143 | ``` 144 | 145 | Se declara un puntero entero, llamado puntajePuntero, y se le asigna la dirección de memoria de la variable puntaje usando el operador **&** (*Dirección de*) 146 | 147 | - [ ] **Operaciones con punteros** 148 | 149 | Los operadores para punteros son: 150 | - **&** (Dirección de), devuelve la direccción de memoria 151 | - __*__ (Contenido de), devuelve el valor de la variable localizada 152 | 153 | ```c++ 154 | int var = 11; 155 | int *pointer; 156 | pointer = &var; 157 | 158 | cout << var << endl; // Muestra 11 159 | cout << pointer << endl; // Muestra la ubicación en memoria (hexadecimal) 160 | cout << *pointer << endl; // Muestra el valor de la variable almacenada en el puntero, es decir 11 161 | ``` -------------------------------------------------------------------------------- /archivos/Productos.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | 8 | typedef struct { 9 | int codigo; 10 | char descripcion[41]; 11 | float precio; 12 | } tproducto; 13 | 14 | 15 | void continuar() 16 | { 17 | printf("Presione una tecla para continuar\n\n"); 18 | getch(); 19 | } 20 | 21 | void crear() 22 | { 23 | FILE *arch; 24 | arch=fopen("productos.dat","wb"); 25 | if (arch==NULL) 26 | exit(1); 27 | fclose(arch); 28 | continuar(); 29 | } 30 | 31 | 32 | void cargar() 33 | { 34 | FILE *arch; 35 | arch=fopen("productos.dat","ab"); 36 | if (arch==NULL) 37 | exit(1); 38 | tproducto producto; 39 | printf("Ingrese el codigo del producto:"); 40 | scanf("%i",&producto.codigo); 41 | fflush(stdin); 42 | printf("Ingrese el nombre del producto:"); 43 | gets(producto.descripcion); 44 | printf("Ingrese precio:"); 45 | scanf("%f",&producto.precio); 46 | fwrite(&producto, sizeof(tproducto), 1, arch); 47 | fclose(arch); 48 | continuar(); 49 | } 50 | 51 | void listado() 52 | { 53 | FILE *arch; 54 | arch=fopen("productos.dat","rb"); 55 | if (arch==NULL) 56 | exit(1); 57 | tproducto producto; 58 | fread(&producto, sizeof(tproducto), 1, arch); 59 | while(!feof(arch)) 60 | { 61 | printf("%i %s %0.2f\n", producto.codigo, producto.descripcion, producto.precio); 62 | fread(&producto, sizeof(tproducto), 1, arch); 63 | } 64 | fclose(arch); 65 | continuar(); 66 | } 67 | 68 | void consulta() 69 | { 70 | FILE *arch; 71 | arch=fopen("productos.dat","rb"); 72 | if (arch==NULL) 73 | exit(1); 74 | printf("Ingrese el codigo de producto a consultar:"); 75 | int cod; 76 | scanf("%i", &cod); 77 | tproducto producto; 78 | int existe=0; 79 | fread(&producto, sizeof(tproducto), 1, arch); 80 | while(!feof(arch)) 81 | { 82 | if (cod==producto.codigo) 83 | { 84 | printf("%i %s %0.2f\n", producto.codigo, producto.descripcion, producto.precio); 85 | existe=1; 86 | break; 87 | } 88 | fread(&producto, sizeof(tproducto), 1, arch); 89 | } 90 | if (existe==0) 91 | printf("No existe un producto con dicho codigo\n"); 92 | fclose(arch); 93 | continuar(); 94 | } 95 | 96 | void modificacion() 97 | { 98 | FILE *arch; 99 | arch=fopen("productos.dat","r+b"); 100 | if (arch==NULL) 101 | exit(1); 102 | printf("Ingrese el codigo de producto a modificar:"); 103 | int cod; 104 | scanf("%i", &cod); 105 | tproducto producto; 106 | int existe=0; 107 | fread(&producto, sizeof(tproducto), 1, arch); 108 | while(!feof(arch)) 109 | { 110 | if (cod==producto.codigo) 111 | { 112 | printf("%i %s %0.2f\n", producto.codigo, producto.descripcion, producto.precio); 113 | printf("Ingrese nuevo precio:"); 114 | scanf("%f",&producto.precio); 115 | int pos=ftell(arch)-sizeof(tproducto); 116 | fseek(arch,pos,SEEK_SET); 117 | fwrite(&producto, sizeof(tproducto), 1, arch); 118 | printf("Se modifico el precio para dicho producto.\n"); 119 | existe=1; 120 | break; 121 | } 122 | fread(&producto, sizeof(tproducto), 1, arch); 123 | } 124 | if (existe==0) 125 | printf("No existe un producto con dicho codigo\n"); 126 | fclose(arch); 127 | continuar(); 128 | } 129 | 130 | int main() 131 | { 132 | int opcion; 133 | do { 134 | printf("1 - Crear un archivo binario llamado \"productos.dat\"\n"); 135 | printf("2 - Carga de registros de tipo tproducto\n"); 136 | printf("3 - Listado completo de productos.\n"); 137 | printf("4 - Consulta de un producto por su codigo.\n"); 138 | printf("5 - Modificacion del precio de un producto. \n"); 139 | printf("6 - Finalizar\n\n"); 140 | printf("Ingrese su opcion:"); 141 | scanf("%i",&opcion); 142 | switch (opcion) { 143 | case 1:crear(); 144 | break; 145 | case 2:cargar(); 146 | break; 147 | case 3:listado(); 148 | break; 149 | case 4:consulta(); 150 | break; 151 | case 5:modificacion(); 152 | break; 153 | } 154 | } while (opcion!=6); 155 | return 0; 156 | } 157 | -------------------------------------------------------------------------------- /archivos/README.md: -------------------------------------------------------------------------------- 1 | # Trabajo con archivos en C++ 2 | 3 | ## :clapper: **123 ATS** Escribir en un archivo de texto 4 | 5 | Para trabajar con ficheros utilizamos la librería **fstream**. Para más información visitar [files - cplusplus reference](http://www.cplusplus.com/doc/tutorial/files/) 6 | 7 | ```c++ 8 | // basic file operations 9 | #include 10 | #include 11 | using namespace std; 12 | 13 | int main () { 14 | ofstream myfile; 15 | myfile.open ("example.txt"); 16 | myfile << "Writing this to a file.\n"; 17 | myfile.close(); 18 | return 0; 19 | } 20 | ``` 21 | 22 | *Ver ejemplo [escribir.cpp](escribir.cpp)* 23 | 24 | 25 | ## Lectura de un archivo de texto 26 | 27 | Para leer un archivo se usa el objeto *ifstream*, donde **_i_** indica input, es decir datos que van a ser leídos. 28 | 29 | ```cpp 30 | #include 31 | #include 32 | #include 33 | #include 34 | using namespace std; 35 | 36 | void lectura(); 37 | 38 | int main() { 39 | 40 | lectura(); 41 | system("pause"); 42 | return 0; 43 | } 44 | 45 | 46 | void lectura(){ 47 | ifstream archivo; 48 | string texto; 49 | 50 | archivo.open("programacion.txt", ios::in); // Abriendo el archivo en modo lectura 51 | 52 | if (archivo.fail()){ 53 | cout << "Error al abrir el archivo :("; 54 | exit(1); 55 | } 56 | 57 | // Recorremos todo el archivo de texto con el bucle while 58 | while (!archivo.eof()){ 59 | getline(archivo, texto); 60 | cout << texto << endl; 61 | } 62 | 63 | archivo.close(); // Cerramos el archivo 64 | } 65 | ``` 66 | 67 | 68 | > **`ios::app`** escribe justo en el lugar donde ha quedado el cursor. 69 | -------------------------------------------------------------------------------- /archivos/agregar_texto.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | void agregar(); 8 | 9 | int main() { 10 | 11 | agregar(); 12 | system("pause"); 13 | return 0; 14 | } 15 | 16 | 17 | void agregar(){ 18 | // Queremos escribir sin borrrar lo que se tenia 19 | ofstream archivo; 20 | string texto; 21 | 22 | archivo.open("programacion.txt", ios::app); // Abrimos el archivo en modo append 23 | 24 | if (archivo.fail()){ 25 | cout << "NO se pudo abrir el archivo "; 26 | exit(1); 27 | } 28 | 29 | cout << "Digite el texto que quiere agregar: "; 30 | getline(cin, texto); 31 | 32 | archivo << texto << endl; 33 | 34 | archivo.close(); // Cerramos el archivo. 35 | } 36 | 37 | -------------------------------------------------------------------------------- /archivos/crud_cpp.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/archivos/crud_cpp.cpp -------------------------------------------------------------------------------- /archivos/escribir.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | using namespace std; 7 | 8 | // Funcion que escribira dentro de un archivo de texto plano 9 | void escribir(); 10 | 11 | int main() 12 | { 13 | escribir(); 14 | system("pause"); 15 | return 0; 16 | } 17 | 18 | void escribir() 19 | { 20 | // Instanciamos la librería 21 | ofstream archivo; 22 | string nombreArchivo, frase; 23 | 24 | cout << "Digite el nombre del archivo: "; 25 | getline(cin, nombreArchivo); 26 | 27 | // file.open(ubicacion, modo[]) 28 | // archivo.open("d://prueba//pruebass.txt", ios::out); 29 | archivo.open(nombreArchivo.c_str(), ios::out); // Abriendo el archivo. Si el archivo no existe lo crea 30 | 31 | if (archivo.fail()) 32 | { 33 | cout << "No se puedo arbir el archivo :("; 34 | system("pause"); 35 | exit(1); // Gracias a Stdlib.h 36 | } 37 | 38 | /* 39 | archivo << "Hola que tal?. Mi nombre en Johan" << endl; // Copia algo en el bloc de notas 40 | archivo << "Agregando mas texto"; 41 | */ 42 | 43 | cout << "\nDigite el texto del archivo: "; 44 | getline(cin, frase); 45 | 46 | archivo << frase; 47 | archivo.close(); 48 | } 49 | -------------------------------------------------------------------------------- /archivos/lectura.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | void lectura(); 8 | 9 | int main() { 10 | 11 | lectura(); 12 | system("pause"); 13 | return 0; 14 | } 15 | 16 | 17 | void lectura(){ 18 | ifstream archivo; 19 | string texto; 20 | 21 | archivo.open("programacion.txt", ios::in); // Abriendo el archivo en modo lectura 22 | 23 | if (archivo.fail()){ 24 | cout << "Error al abrir el archivo :("; 25 | exit(1); 26 | } 27 | 28 | // Recorremos todo el archivo de texto con el bucle while 29 | while (!archivo.eof()){ 30 | getline(archivo, texto); 31 | cout << texto << endl; 32 | } 33 | 34 | archivo.close(); // Cerramos el archivo 35 | } 36 | -------------------------------------------------------------------------------- /archivos/probando.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/archivos/probando.txt -------------------------------------------------------------------------------- /archivos/productos.dat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/archivos/productos.dat -------------------------------------------------------------------------------- /archivos/programacion.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/archivos/programacion.txt -------------------------------------------------------------------------------- /aritmeticos.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | int uno = 11; 7 | int dos = 06; 8 | int suma, resta, multiplicacion, division, modulo; 9 | 10 | int main(){ 11 | suma = uno + dos; 12 | resta = uno - dos; 13 | multiplicacion = uno * dos; 14 | division = uno / dos; 15 | modulo = uno % dos; 16 | 17 | cout << "La suma es: " << suma << endl; 18 | cout << "La resta es: " << resta << endl; 19 | cout << "La multiplicacion es: " << multiplicacion << endl; 20 | cout << "La división es: " << division << endl; 21 | cout << "El residio de la división es: " << division << endl; 22 | getch(); 23 | return 0; 24 | } 25 | -------------------------------------------------------------------------------- /asignacion.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | int main(){ 7 | // Declaración; 8 | int operacion; 9 | // Asignación 10 | operacion = 12; 11 | // Operador de asignación 12 | operacion *= 3; // Multiplica el valor por 3 13 | 14 | cout << "La operación fué: " << operacion << endl; 15 | 16 | getch(); 17 | 18 | return 0; 19 | } -------------------------------------------------------------------------------- /bool.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | bool verdadero = true; 6 | bool falso = false; 7 | 8 | int main(){ 9 | cout<<"Valor de la variable Verdadero: " << verdadero << endl; 10 | cout<<"Valor de la variable Falso: " << false << endl; 11 | return 0; 12 | } -------------------------------------------------------------------------------- /char.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | // Esta variable solo muestra el último caracter 6 | char letra = 'Johan Mosquera'; 7 | // Esta variable, muestra el texto completo [char* - ""] 8 | char* palabra = "Johan Mosquera"; 9 | 10 | int main(){ 11 | cout << "Letra: "<< letra << endl; 12 | return 0; 13 | } 14 | -------------------------------------------------------------------------------- /clases.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | // Definicion de la clase 5 | class Cuentas { 6 | public: 7 | int sumaDos(int arg); 8 | int sumaTres(int arg); 9 | 10 | private: 11 | int resultado; 12 | }; 13 | 14 | int Cuentas::sumaDos(int arg){ 15 | resultado = arg+2; 16 | return resultado; 17 | } 18 | 19 | int Cuentas::sumaTres(int arg){ 20 | resultado = arg+3; 21 | return resultado; 22 | } 23 | 24 | int main(){ 25 | // Intancia de la clase (Creacion del objeto) 26 | Cuentas cuentas; 27 | cout << "+2 = " << cuentas.sumaDos(2) << endl; 28 | cout << "+3 = " << cuentas.sumaTres(2) << endl; 29 | cin.get(); 30 | return 0; 31 | } 32 | -------------------------------------------------------------------------------- /comparacion.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | bool verificar; 7 | int numeroUno = 12; 8 | int numeroDos = 12; 9 | 10 | int main(){ 11 | verificar = (numeroUno == numeroDos); 12 | cout << verificar << endl; 13 | getch(); 14 | return 0; 15 | } -------------------------------------------------------------------------------- /comparar_cadenas.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/comparar_cadenas.cpp -------------------------------------------------------------------------------- /condicionales: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/condicionales -------------------------------------------------------------------------------- /condicionales.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int numero1 = 12; 6 | int numero2 = 14; 7 | 8 | bool booleana = true; 9 | int main(){ 10 | if (numero1 < numero2){ 11 | cout<<"Es menor"< 2 | #include 3 | 4 | using namespace std; 5 | 6 | // Es una constante, su valor no se puede cambiar 7 | const int numero = 11; 8 | 9 | int main(){ 10 | cout << numero << endl; 11 | getch(); 12 | return 0; 13 | } -------------------------------------------------------------------------------- /decremento.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main(){ 6 | 7 | int total {0}; 8 | int count {5}; 9 | 10 | cout << "Valor de decremento final count--" << endl; 11 | total = count-- + 6; 12 | 13 | cout << "Total = " << total; 14 | cout << " Count = " << count << endl << endl; 15 | 16 | cout << "Valor de decremento inicial --count" << endl; 17 | total = count-- + 6; 18 | 19 | cout << "Total = " << total; 20 | cout << " Count = " << count; 21 | 22 | return 0; 23 | } -------------------------------------------------------------------------------- /definicionTipos.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | typedef unsigned int uint; 5 | 6 | int main(){ 7 | uint numero = 10; 8 | cout << numero << endl; 9 | 10 | cin.get(); 11 | return 0; 12 | } -------------------------------------------------------------------------------- /double.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | // Librería que usamos para que el programa no se cierre 3 | #include 4 | 5 | using namespace std; 6 | 7 | int main(){ 8 | double num = 12.69419616; 9 | cout << num << endl; 10 | getch(); 11 | return 0; 12 | } 13 | -------------------------------------------------------------------------------- /ejercicios/1.perimetro.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * 1. Dado el perímetro de una circunferencia imprima en pantalla su área, su diámetro y su radio. 3 | */ 4 | #include 5 | #include 6 | using namespace std; 7 | 8 | int main(){ 9 | const double pi = 3.14169; 10 | double perimetro; 11 | double area; 12 | double radio; 13 | 14 | cout << "Ingrese el perimetro de la circunferencia: "; 15 | cin >> perimetro; 16 | 17 | // Perimetro = 2*pi*radio 18 | radio = perimetro/(2*pi); 19 | 20 | // Area = pi * radio^2 21 | area = pi * pow(radio, 2); 22 | 23 | cout << "El area del circulo es: " << area << endl; 24 | cout << "El radio del circulo es: " << radio << endl; 25 | 26 | cin.get(); 27 | return 0; 28 | } 29 | -------------------------------------------------------------------------------- /ejercicios/2.area_isosceles.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/ejercicios/2.area_isosceles.cpp -------------------------------------------------------------------------------- /ejercicios/3.volumen_cilindro.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/ejercicios/3.volumen_cilindro.cpp -------------------------------------------------------------------------------- /ejercicios/4.triangulo-equilatero.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | Dada la longitud de un lado de un triángulo equilátero imprimir en pantalla su área y el valor en radianes y en grados de cada ángulo. 3 | */ 4 | #include 5 | #include 6 | using namespace std; 7 | 8 | const double pi = 3.14159265359; 9 | 10 | double rad_to_grades(double angulo){ 11 | double angle = angulo*(180/pi); 12 | return angle; 13 | } 14 | 15 | int main(){ 16 | 17 | double longitud, angulo; 18 | cout << "Ingrese la longitud del triangulo equilatero: "; 19 | cin >> longitud; 20 | 21 | angulo = acos((longitud/2)/longitud); 22 | 23 | cout << "Como es un triangulo equilatero, todos sus angulos son iguales." << endl; 24 | cout << "El angulo del triangulo es: " << angulo << " radianes <=> " << rad_to_grades(angulo) << " grados."; 25 | 26 | cin.get(); 27 | return 0; 28 | } 29 | 30 | -------------------------------------------------------------------------------- /ejercicios/5.triangulo-escaleno.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Dadas las logitudes de los ángulos de un triángulo escaleno, imprimir en pantalla su área y el valor en radianes y en grados de cada uno de sus ángulos. 3 | * 4 | * Un triángulo escaleno es un triángulo en el cual los tres lados tienen longitudes diferentes. 5 | */ 6 | #include 7 | #include 8 | using namespace std; 9 | 10 | const double pi = 3.14159265359; 11 | 12 | double rad_to_grades(double angulo){ 13 | double angle = angulo*(180/pi); 14 | return angle; 15 | } 16 | 17 | /* 18 | Se calcula el angulo a partir del teorema del coseno 19 | a^2 = b^2 + c^2 - 2bc cosA 20 | */ 21 | double angulo_a(double a, double b, double c){ 22 | double angulo; 23 | angulo = acos((pow(b,2) + pow(c,2) - pow(a,2))/(2*b*c)); 24 | return angulo; 25 | } 26 | /* 27 | Se calcula el angulo a partir del teorema del coseno 28 | b^2 = a^2 + c^2 - 2ac cosB 29 | */ 30 | double angulo_b(double a, double b, double c){ 31 | double angulo; 32 | angulo = acos((pow(a,2) + pow(c,2) - pow(b,2))/(2*a*c)); 33 | return angulo; 34 | } 35 | 36 | int main(){ 37 | double a, b, c, ang_a, ang_b, ang_c; 38 | cout << "Ingrese la longitud A del triangulo escaleno: "; 39 | cin >> a; 40 | cout << "Ingrese la longitud B del triangulo escaleno: "; 41 | cin >> b; 42 | cout << "Ingrese la longitud C del triangulo escaleno: "; 43 | cin >> c; 44 | 45 | ang_a = angulo_a(a, b, c); 46 | ang_b = angulo_b(a, b, c); 47 | ang_c = pi - ang_a - ang_b; 48 | 49 | cout << "El angulo estre B y C es: " << ang_a << " radianes = " << rad_to_grades(ang_a) << " grados." << endl; 50 | cout << "El angulo estre A y C es: " << ang_b << " radianes = " << rad_to_grades(ang_b) << " grados." << endl; 51 | cout << "El angulo estre A y B es: " << ang_c << " radianes = " << rad_to_grades(ang_c) << " grados." << endl; 52 | 53 | cin.get(); 54 | return 0; 55 | } 56 | -------------------------------------------------------------------------------- /ejercicios/6.triangulo-rectangulo.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | Dadas las logitudes de los lados (no la hipotenusa) de un triaángulo rectángulo imprimir en pantalla su área y el valor en radianes y en grados de cada uno de sus ángulos 3 | */ 4 | #include 5 | #include 6 | using namespace std; 7 | 8 | const double pi = 3.14159265359; 9 | 10 | double rad_to_grades(double angulo){ 11 | double angle = angulo*(180/pi); 12 | return angle; 13 | } 14 | 15 | int main(){ 16 | double a, b, c, area, ang_a, ang_b, ang_c; 17 | 18 | cout << "Ingrese la longitud del lado A (Base): "; 19 | cin >> a; 20 | cout << "Ingrese la longitud del lado B: "; 21 | cin >> b; 22 | 23 | // Hallo la hipotenusa usando el teorema de pitagoras 24 | c = pow( (pow(a, 2) + pow(b, 2)), 0.5 ); 25 | 26 | // Calculo el area 27 | area = (a*b)/2; 28 | // Calculo el angulo entre a y c 29 | ang_a = acos(a/c); 30 | // Calculo el angulo entre b y c 31 | ang_b = acos(b/c); 32 | 33 | ang_c = pi - ang_a - ang_b; 34 | 35 | cout << "El area del triangulo es: " << area << endl; 36 | cout << "El angulo entre A (Base) y C (Hipotenusa) es: " << ang_a << " radianes = " << rad_to_grades(ang_a) << " grados." << endl; 37 | cout << "El angulo entre B y C (Hipotenusa) es: " << ang_b << " radianes = " << rad_to_grades(ang_b) << " grados." << endl; 38 | cout << "El angulo entre A y B es: " << ang_c << " radianes = " << rad_to_grades(ang_c) << " grados." << endl; 39 | 40 | 41 | cin.get(); 42 | return 0; 43 | } 44 | -------------------------------------------------------------------------------- /ejercicios/comparacionFunciones.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/ejercicios/comparacionFunciones.cpp -------------------------------------------------------------------------------- /ejercicios/ejercicios-finales/ejercicio_1.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/ejercicios/ejercicios-finales/ejercicio_1.cpp -------------------------------------------------------------------------------- /ejercicios/ejercicios-finales/ejercicio_10.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/ejercicios/ejercicios-finales/ejercicio_10.cpp -------------------------------------------------------------------------------- /ejercicios/ejercicios-finales/ejercicio_11.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/ejercicios/ejercicios-finales/ejercicio_11.cpp -------------------------------------------------------------------------------- /ejercicios/ejercicios-finales/ejercicio_2.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/ejercicios/ejercicios-finales/ejercicio_2.cpp -------------------------------------------------------------------------------- /ejercicios/ejercicios-finales/ejercicio_3.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/ejercicios/ejercicios-finales/ejercicio_3.cpp -------------------------------------------------------------------------------- /ejercicios/ejercicios-finales/ejercicio_4.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/ejercicios/ejercicios-finales/ejercicio_4.cpp -------------------------------------------------------------------------------- /ejercicios/ejercicios-finales/ejercicio_5.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/ejercicios/ejercicios-finales/ejercicio_5.cpp -------------------------------------------------------------------------------- /ejercicios/ejercicios-finales/ejercicio_6.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/ejercicios/ejercicios-finales/ejercicio_6.cpp -------------------------------------------------------------------------------- /ejercicios/ejercicios-finales/ejercicio_7.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/ejercicios/ejercicios-finales/ejercicio_7.cpp -------------------------------------------------------------------------------- /ejercicios/ejercicios-finales/ejercicio_8.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/ejercicios/ejercicios-finales/ejercicio_8.cpp -------------------------------------------------------------------------------- /ejercicios/ejercicios-finales/ejercicio_9.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/ejercicios/ejercicios-finales/ejercicio_9.cpp -------------------------------------------------------------------------------- /ejercicios/ejercicios-finales/readme.md: -------------------------------------------------------------------------------- 1 | ## Ejercicios finales C++ 2 | 3 | 1. Escriba un programa en c++, usando funciones, que pida un número y devuelva el cubo de dicho número. [Ejercicio_1](ejercicio_1.cpp) 4 | 5 | 2. Escriba un programa en c++, usando funciones, que reciba un valor de distancia en metros y/o cm y la devuelva en yardas, pies y pulgadas [Ejercicio_2](ejercicio_2.cpp) 6 | 7 | 3. Escriba un programa en c++, usando funciones,que lea un entero positivo de dos dígitos y determinar si sus dígitos son números primos. [Ejercicio_3](ejercicio_3.cpp) 8 | 9 | 4. Escriba un programa en c++, usando funciones,que lea dos números x e y, luego hacer la diferencia x - y; si la diferencia es menor o igual a 10, entonces escribir todos los número comprendidos entre y y x. [ejercicio_4](ejercicio_4.cpp) 10 | 11 | 5. Escriba un programa en c++, usando funciones, que solicite al usuario que ingrese una fecha y calcule el día correspondiente del año. Ejemplo, si se ingresa la fecha 31 12 1998, el número que se visualizará será 365. [ejercicio_5](ejercicio_5.cpp) 12 | 13 | 6. Escriba un programa en c++, usando funciones, que convierta centímetros a pulgadas y libras a kilogramos. [ejercicio_6](ejercicio_6.cpp) 14 | 15 | 7. Escriba un programa en c++, usando funciones, que calcule el área y el perímetro de un rectángulo dada la base y la altura. [ejercicio_7](ejercicio_7.cpp) 16 | 17 | 8. Escriba un programa en c++, usando funciones, que reciba un numero entrero y devuelva la suma de sus digitos [ejercicio_8](ejercicio_8.cpp). 18 | 19 | 9. Escriba un programa en c++, usando funciones, que reciba una lista de hasta 10 números reales y devuelva, su promedio, moda, varianza y desviación estándar. [ejercicio_9](ejercicio_9.cpp) 20 | 21 | 10. Escriba un programa en c++, usando funciones, que reciba su día, mes y año de nacimiento y devuelva su edad [ejercicio_10](ejercicio_10.cpp) 22 | 23 | 11. Escriba un programa en c++, usando funciones, que reciba una lista de hasta 20 números y los ordene de menor a mayor y de mayor a menor [ejercicio_11](ejercicio_11.cpp) -------------------------------------------------------------------------------- /ejercicios/estanque.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Escriba un programa para calcular cuántas cajas cuadradas pueden contenerse en una sola capa en un estante rectangular, sin voladizo. 3 | Las dimensiones del estante en pies y la dimensión de un lado de la caja en pulgadas se leen desde el teclado. 4 | Use variables de tipo double para la longitud y profundidad del estante y 5 | escriba int para la longitud del lado de un recuadro. 6 | Defina e inicialice una constante entera para convertir de pies a pulgadas. 7 | Calcule el número de cajas que puede contener el estante en una sola capa y escriba el resultado. 8 | */ 9 | #include 10 | using namespace std; 11 | 12 | int main(){ 13 | 14 | // 1 pie = 12 pulgadas 15 | const int pulgadas_por_pies = 12; 16 | double longitud; 17 | double profundidad; 18 | double tamanio; 19 | 20 | cout << "Ingrese la longitud del estanque, en pies: "; 21 | cin >> longitud; 22 | cout << "Ingrese la profundidad del estanque, en pies: "; 23 | cin >> profundidad; 24 | 25 | cout << "Ingrese el tamanio de la caja en pulgadas "; 26 | cin >> tamanio; 27 | 28 | long cajas = static_cast((longitud*pulgadas_por_pies)/tamanio)* 29 | static_cast((profundidad*pulgadas_por_pies)/tamanio); 30 | 31 | cout << "El numero de cajas que puede contener es: " << cajas << endl; 32 | 33 | cin.get(); 34 | return 0; 35 | } 36 | -------------------------------------------------------------------------------- /ejercicios/funciones_1.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/ejercicios/funciones_1.cpp -------------------------------------------------------------------------------- /ejercicios/funciones_2.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | 2. Escriba un programa en c++, usando funciones, que reciba un valor de distancia en metros y/o cm y la devuelva en yardas, pies y pulgadas 3 | */ 4 | 5 | #include 6 | using namespace std; 7 | 8 | long double 9 | 10 | int main() { 11 | 12 | return 0; 13 | } 14 | 15 | -------------------------------------------------------------------------------- /ejercicios/funciones_potencia.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | double potencia(double number, double exponente); 5 | 6 | int main() { 7 | double a, b; 8 | cout << "Ingrese la base: "; 9 | cin >> a; 10 | cout << "Ingrese el exponente: "; 11 | cin >> b; 12 | 13 | cout << "La potencia de 2 es: " << potencia(a, b); 14 | return 0; 15 | } 16 | 17 | 18 | double potencia(double number, double exponente){ 19 | double resultado = 1; 20 | for (int i = 1; i <= exponente; i++){ 21 | resultado *= number; 22 | } 23 | return resultado; 24 | } 25 | 26 | 27 | 28 | -------------------------------------------------------------------------------- /ejercicios/opreacionesFuncion.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/ejercicios/opreacionesFuncion.cpp -------------------------------------------------------------------------------- /ejercicios/recursividadEjercicio1.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/ejercicios/recursividadEjercicio1.cpp -------------------------------------------------------------------------------- /enteros.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/enteros.cpp -------------------------------------------------------------------------------- /estructuras-2.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main(){ 6 | 7 | struct Persona { 8 | string nombre; 9 | int edad; 10 | int genero; 11 | string color; 12 | //Funcion constructora 13 | Persona(){ 14 | nombre = "None"; 15 | edad = 0; 16 | genero = 1; 17 | color = "No se sabe"; 18 | } 19 | 20 | int sumar(int a, int b){return a+b;} 21 | }; 22 | 23 | Persona carlos; 24 | cout << carlos.nombre << endl; 25 | cout << carlos.sumar(12,3) << endl; 26 | cin.get(); 27 | 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /estructuras.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | int main(){ 5 | struct Personaje { 6 | int edad; 7 | int telefono; 8 | string nombre; 9 | }; 10 | 11 | Personaje juan; 12 | juan.nombre = "Juan Marruecos"; 13 | juan.edad = 100; 14 | juan.telefono = 3123; 15 | 16 | cout << juan.nombre << endl; 17 | 18 | cin.get(); 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /float.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | // Librería que usamos para que el programa no se cierre 3 | #include 4 | 5 | using namespace std; 6 | 7 | int main(){ 8 | float num = 5.23478; 9 | float num2 = 1.324; 10 | 11 | cout << num+num2 << endl; 12 | // Esta función evita que se cierre el programa 13 | getch(); 14 | return 0; 15 | } 16 | -------------------------------------------------------------------------------- /for.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main(){ 5 | 6 | // Declaración de un array 7 | char array[5]; 8 | array[0] = 'A'; 9 | array[1] = 'B'; 10 | array[2] = 'C'; 11 | array[3] = 'D'; 12 | array[4] = 'E'; 13 | 14 | // Ciclo for 15 | for (unsigned int i = 0; i < sizeof(array) ; i++){ 16 | cout << array[i] << endl; 17 | } 18 | 19 | cin.get(); 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /funcion-parametros.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Funciones con parámetros 3 | */ 4 | #include 5 | using namespace std; 6 | 7 | // Declaracion de la funcion 8 | void funcion(int a = 10){ 9 | cout << a+3 << endl; 10 | } 11 | 12 | int main(){ 13 | // Llamada a la funcion 14 | funcion(); 15 | funcion(0); 16 | cin.get(); 17 | return 0; 18 | } -------------------------------------------------------------------------------- /funciones.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int suma; 5 | int num1 = 5; 6 | int num2 =6; 7 | 8 | // Funcion suma 9 | int sumar(int a, int b){ 10 | return a+b; 11 | } 12 | 13 | // Funcion que no retorna nada 14 | void miFuncion(){ 15 | cout << "Yo no retorno nada" << endl; 16 | } 17 | 18 | // Funcion principal 19 | int main(){ 20 | suma = sumar(num1, num2); 21 | cout << suma << endl; 22 | miFuncion(); 23 | cin.get(); 24 | return 0; 25 | } 26 | 27 | 28 | -------------------------------------------------------------------------------- /funciones/Factorial_Recursividad.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/funciones/Factorial_Recursividad.cpp -------------------------------------------------------------------------------- /funciones/Fibonacci_Recursividad.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/funciones/Fibonacci_Recursividad.cpp -------------------------------------------------------------------------------- /funciones/Potencia_Recursividad.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/funciones/Potencia_Recursividad.cpp -------------------------------------------------------------------------------- /funciones/arrays.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/funciones/arrays.cpp -------------------------------------------------------------------------------- /funciones/readme.md: -------------------------------------------------------------------------------- 1 | # Funciones 2 | 3 | Una función es un grupo de declaraciones que realizan una tarea en particular. En C++, podemos definir nuestras propias funciones. 4 | 5 | Los beneficios de usar funciones son: 6 | * Reutilizar código dentro de una función 7 | * Validar fácilmente funciones individuales 8 | * Hacer modificación al código de la función sin alterar la estructura del programa 9 | * Utilizar la función con diferentes parámetros 10 | 11 | > Todo programa de C++ tiene al menos la función **main()** 12 | 13 | ## Tipo de Retorno 14 | 15 | El tipo de retorno, es declarado antes del nombre de la función, éste indica el tipo de dato que devolverá la función. 16 | 17 | Algunas funciones realizan operaciones sin devolver un valor. Éstas funciones son definidas con la palabra clave **void** 18 | 19 | - **void** Es un tipo de dato básico que define un estado sin valor. 20 | 21 | 22 | ## Definción de una función 23 | 24 | Para definir una función en C++, usamos la siguientes sintaxis: 25 | 26 | ```c++ 27 | tipo_retorno nombre_funcion(lista de parametros){ 28 | // cuerpo de la función 29 | return valor_retorno; 30 | } 31 | ``` 32 | 33 | - **tipo_retorno** Tipo de valor que devolverá la función 34 | - **nombre_funcion** Nombre de la función 35 | - **lista de parametros** Cuando la función es llamada, y ésta posee argumentos, se le pasan el valor como parámetro. Éstos nos permiten hacer operaciones dentro de la función. 36 | - **cuerpo de la función** Es la colección de declaraciones que define lo que hace la función. 37 | 38 | > Los parámetros son **opcionales** lo que significa que se puede tener una función sin parámetros. 39 | 40 | En resumen, una función de forma por: 41 | - Tipo de retorno 42 | - Nombre de la función 43 | - Parámetros 44 | - Cuerpo de la función 45 | 46 | 47 | > Para **llamar** una función, simplemente se escribe el nombre de la función y le escribes los parámetros que necesita. 48 | 49 | ```c++ 50 | // LLamar a una función 51 | void miFuncion(){ 52 | cout << "Hola mundo, desde mi función"; 53 | } 54 | 55 | int main(){ 56 | // Esta función no tiene argumentos, ni retorna ningún tipo de valor. 57 | miFuncion(); 58 | return 0; 59 | } 60 | ``` 61 | 62 | ## :warning: Importante 63 | 64 | Siempre se debe **declarar** una función **antes de llamarla**, por ejemplo: 65 | 66 | ```c++ 67 | #include 68 | using namespace std; 69 | 70 | void miFuncion(){ 71 | cout << "Hola mundo, desde mi función"; 72 | } 73 | 74 | int main(){ 75 | miFuncion(); 76 | return 0; 77 | } 78 | ``` 79 | 80 | Si se declara después de la función **main**, resulta en un error. 81 | 82 | **Pero para ello hay una solución** :blush: 83 | 84 | La declaración de una función o **prototipo**, le indica al compilador acerca del nombre de la función y cómo llamar a la función. El cuerpo real de la función puede ser definido aparte. Por ejemplo: 85 | 86 | ```c++ 87 | #include 88 | using namespace std; 89 | 90 | // Declaración de la función 91 | void miFuncion(); 92 | 93 | int main(){ 94 | miFuncion(); 95 | return 0; 96 | } 97 | 98 | // Definición de la función 99 | void miFuncion(){ 100 | cout << "Hola mundo, desde mi función"; 101 | } 102 | ``` 103 | 104 | 105 | ## Parámetros de Función 106 | 107 | Los parámetros son variables que aceptam valores de los argumentos. 108 | Los parámetros formales se comportan de manera similar a otras variables locales. Son creadas al entrar en la función, y son destruidas al salir de la función. 109 | 110 | Podemos pasar diferentes argumentos a la función, siempre y cuando ésta sea llamada. 111 | 112 | ```c++ 113 | int dosVeces(int x){ 114 | return x*2; 115 | } 116 | ``` 117 | 118 | ```c++ 119 | int main(){ 120 | cout << dosVeces(3); // Muestra 6 121 | cout << dosVeces(7); // Muestra 14 122 | } 123 | ``` 124 | 125 | > Cada parámetro debe estar definido con un **tipo de dato** y **nombre** 126 | 127 | ## Múltiples parámetros 128 | 129 | Se puede definir varios parámetros a una función, deparandolos por comas. 130 | 131 | ```c++ 132 | int main(int param1, int param2){} 133 | ``` 134 | 135 | ## Números aleatorios 136 | 137 | 138 | ### Función rand() 139 | 140 | La librería estándar de C++, tiene acceso a una función que genera números aleatorios, se llama **rand()**. Para usarla, debemos incluir el encabezado *__cstdlib__* 141 | 142 | ```c++ 143 | int main(){ 144 | cout << rand(); // Imprimirá un número aleatorio 145 | } 146 | ``` 147 | 148 | Al utilizar el operador **módulo (%)** genera números aleatorios dentro de un rango específico. Por ejemplo: 149 | 150 | ```c++ 151 | int main(){ 152 | for (int x = 0; x <= 10; x++){ 153 | cout << 1 + (rand()%6); 154 | } 155 | } 156 | ``` 157 | 158 | 159 | - Función **time()** 160 | 161 | La función time opciotne el número de segundos del reloj del sistema. Para eso se tiene que incluir el encabezado `` 162 | 163 | ```c++ 164 | time(0); // Devolverá el conteo de segundos actual 165 | ``` 166 | 167 | 168 | ## Valores por defecto para los parámetros 169 | 170 | Se puede especificar un valor por defecto a los parámtros, en caso de que sea omitido al llamar la función. 171 | 172 | ```c++ 173 | int suma(int a, int b=42){ 174 | int result = a + b; 175 | return (result); 176 | } 177 | ``` 178 | 179 | ## Sobrecarga de funciones 180 | 181 | Sobrecargar funciones nos permite crear múltiples funciones con el mismo nombre, siempre y cuando tengan diferentes parámetros. 182 | 183 | Por ejemplo, la función siguiente, recibe parámetros flotantes y enteros 184 | ```c++ 185 | void imprimirNumero(int number){ 186 | cout << number; 187 | } 188 | void imprimirNumero(float number){ 189 | cout << number; 190 | } 191 | ``` 192 | 193 | La función sobrecargada debe diferir de todas las demás por los tipos y/o el número de argumentos. 194 | 195 | No se puede sobrecargar funciones declarados que sean diferentes en el tipo de retorno. 196 | 197 | 198 | 199 | ## :fire: Recursión 200 | 201 | Una función recursiva en C++ es una función que se llama a sí misma. 202 | 203 | > **Importante** Para evitar que la recursión se llame indefinidamente, se debe incluir una condición terminación. 204 | 205 | *La recursión es un método para resolver un problema cuando la solución depende de las solución depende de las soluciones de instancias menores del mismo problema* 206 | 207 | Por ejemplo. La función factorial 208 | 209 | ```c++ 210 | int factorial(int n){ 211 | if (n==1) 212 | return 1; 213 | else 214 | return n * factorial(n-1); 215 | } 216 | ``` 217 | 218 | > La función factorial se llama a sí misma, y luego continúa haciéndolo hasta que el argumento sea 1. 219 | > Un **caso base** es necesario para la recursión real. Sin él, la recursión seguirá ejecutándose por siempre. 220 | 221 | 222 | ## Arreglos y funciones 223 | 224 | También se puede pasar un arreglo a una función como argumento. Al declarar una función, el parámetro debe definirse como un arreglo utilizando corchetes. 225 | 226 | ```c++ 227 | void printArray(int arr[], int size){ 228 | for (int x = 0; x < size; x++){ 229 | cout << arr[x]; 230 | } 231 | } 232 | ``` 233 | 234 | ## Argumentos de función 235 | 236 | Hay dos formas para pasar argumentos a una función mientras la función es llamada. 237 | 238 | - **Por valor:** Este método copia el valor actual del argumento al parámetro formal de la función. En este caso, podemos hacer cambios al parámetro dentro de la función sin tener ningún efecto sobre el argumento. 239 | 240 | - **Por referencia** Este método copia la referencia del argumento al parámetro formal. En la función, la referencia es utilizada para acceder el argumento original utilizado en la llamada. Esto significa que cualquier cambio realiado al parámetro afectará al argumento. 241 | 242 | > Por defecto C++ utiliza llamada por valor para pasar argumentos. 243 | 244 | Ejemplo de pasar por referencia 245 | 246 | ```c++ 247 | void myFunc(int *x){ 248 | *x = 100; 249 | } 250 | 251 | int main(){ 252 | int var = 20; 253 | myFunc(&var); 254 | cout << var; 255 | } 256 | ``` -------------------------------------------------------------------------------- /images/math-functions1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/images/math-functions1.png -------------------------------------------------------------------------------- /images/math-functions2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/images/math-functions2.png -------------------------------------------------------------------------------- /images/operadores-asignacion.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/images/operadores-asignacion.png -------------------------------------------------------------------------------- /incremento.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main(){ 6 | 7 | int total {0}; 8 | int count {5}; 9 | 10 | cout << "Valor de incremento final count++" << endl; 11 | total = count++ + 6; 12 | 13 | cout << "Total = " << total; 14 | cout << " Count = " << count << endl << endl; 15 | 16 | cout << "Valor de incremento inicial ++count" << endl; 17 | total = ++count + 6; 18 | 19 | cout << "Total = " << total; 20 | cout << " Count = " << count; 21 | 22 | return 0; 23 | } -------------------------------------------------------------------------------- /logicos.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | bool comprobador; 5 | 6 | int num1, num2, num3, num4; 7 | 8 | int main(){ 9 | num1 = 12; 10 | num2 = 20; 11 | num3 = 4; 12 | num4 = 13; 13 | 14 | comprobador = (num4 > num1 && num3 < num2); 15 | 16 | cout << comprobador << endl; 17 | // Evitamos que se cierre el programa, usando la librería `iostream` 18 | cin.get(); 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /main.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/main.cpp -------------------------------------------------------------------------------- /namespace.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | // Declaracion del espacio de nombre 5 | namespace ciudad{ 6 | int calle; 7 | } 8 | 9 | namespace pueblo { 10 | int calle = 10; 11 | } 12 | 13 | // Usamos el espacio de nombre ciudad 14 | using namespace ciudad; 15 | 16 | int main(){ 17 | calle = 12; 18 | cout << "Pueblo: " << pueblo::calle << endl; 19 | cout << "Calle: " << pueblo::calle << endl; 20 | cin.get(); 21 | return 0; 22 | } -------------------------------------------------------------------------------- /pescadosEnEstanque.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include // Libería de funciones matemáticas 3 | 4 | using namespace std; 5 | 6 | int main(){ 7 | 8 | // Superficie del estanque de 2 pies cuadrados por cada 6 pulgadas de peces 9 | const double fish_factor {2.0/0.5}; 10 | const double inches_per_foot {12.0}; // Area po unidad de largo del pescado 11 | const double pi {3.14159265}; 12 | 13 | double fish_count {}; // Número de pescados 14 | double fish_length {}; // Promedio de largo del pescado 15 | 16 | cout << "Ingrese el numero de pescados que quiere guardar"; 17 | cin >> fish_count; 18 | cout << "Ingrese el promedio de largo del pescado en pulgadas"; 19 | cin >> fish_length; 20 | fish_length /=inches_per_foot; // Convertir a pulgadas 21 | 22 | // Calcula la superficie de área requerida 23 | double pond_area {fish_count * fish_length * fish_factor}; 24 | // Calcule el diámetro del estanque desde el área 25 | double pond_diameter {2.0 * sqrt(pond_area/pi)}; 26 | cout << "\nEl diametro requrido para " << fish_count << " pescados es " 27 | << pond_diameter << " pies.\n"; 28 | 29 | return 0; 30 | } 31 | -------------------------------------------------------------------------------- /poo/README.md: -------------------------------------------------------------------------------- 1 | # Conceptos básicos de Programación Orientada a Objetos (POO) 2 | 3 | - **Clase** 4 | 5 | Es una _abstracción_ que hacemos de nuestra experiencia sensible. El ser humano tiende a agrupar seres o cosas -objetos- con características similares en grupos -clases-. 6 | 7 | - **Objeto** 8 | 9 | Es un conjunto de *atributos* y *métodos*, un objeto se deriva de una clase. 10 | 11 | - **Abstracción** 12 | 13 | Es un proceso mental de extracción de las características esenciales de alfo ignorando los detalles superflúos. 14 | 15 | - **Encapsulación** 16 | 17 | Proceso por el que se ocultan los detalles del soporte de las características de una abstracción. 18 | 19 | - **Herencia** 20 | 21 | Es donde una clase nueva se crea a partir de una clase ya existente, heredando todos sus atributos y métodos. 22 | 23 | > Todas las clases deben ser en singular. 24 | 25 | - **Polimofismo** 26 | 27 | Es aquella cualidad que poseen los objetos para responder del mismo modo ante el mismo mensaje. 28 | 29 | El método constructor inicializa los atributos de la clase y tienen el mismo nombre de la clase. 30 | 31 | Los *__::__* se puede leer como pertenece, se le conoce como _**operador de resolución de alcance**_ 32 | 33 | ```cpp 34 | // Clases en C++ 35 | #include 36 | #include 37 | #include 38 | using namespace std; 39 | 40 | class Persona { 41 | 42 | // Atributos 43 | private: 44 | string nombre; 45 | int edad; 46 | 47 | 48 | // Métodos 49 | public: 50 | Persona(int, string); // Constructor 51 | void leer(); 52 | void correr(); 53 | }; 54 | 55 | 56 | // Implementación del constructor. Sirve para inicializar los atributos de la clase 57 | Persona::Persona(int _edad, string _nombre){ 58 | edad = _edad; 59 | nombre = _nombre; 60 | } 61 | 62 | 63 | void Persona::leer(){ 64 | cout << "Estoy leyendo los hábitos de la gente altamente efectiva (" << nombre << ")"; 65 | } 66 | 67 | void Persona::correr(){ 68 | cout << "Soy " << nombre << " y tengo " << edad; 69 | } 70 | 71 | int main(){ 72 | system("pause"); 73 | return 0; 74 | } 75 | ``` 76 | 77 | 78 | :star2: Dentro de **header** se inluyen los prototipos de todas la funciones y atributos de la clases. En el archivo **`.cpp`** se escribe el código fuente. :sunny: 79 | 80 | Incluir las bibliotecas necesarias en el código fuente como: 81 | 82 | ```cpp 83 | #include 84 | using namespace std; 85 | ``` -------------------------------------------------------------------------------- /poo/Rectangulo.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/poo/Rectangulo.cpp -------------------------------------------------------------------------------- /poo/clases.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/poo/clases.cpp -------------------------------------------------------------------------------- /proyectos/Dogs_and_cat/.vscode/settings.json: -------------------------------------------------------------------------------- 1 | { 2 | "files.associations": { 3 | "iosfwd": "cpp", 4 | "iostream": "cpp", 5 | "fstream": "cpp", 6 | "sstream": "cpp", 7 | "type_traits": "cpp" 8 | } 9 | } -------------------------------------------------------------------------------- /proyectos/Dogs_and_cat/Dogs_and_cat.zpr: -------------------------------------------------------------------------------- 1 | # generated by ZinjaI-w32-20191006 2 | [general] 3 | files_to_open=4 4 | project_name=Dogs_and_cat 5 | help_page= 6 | autocodes_file= 7 | macros_file= 8 | default_fext_source=cpp 9 | default_fext_header=h 10 | autocomp_extra= 11 | active_configuration=Debug 12 | version_saved=20191006 13 | version_required=20140318 14 | tab_width=4 15 | tab_use_spaces=0 16 | explorer_path=. 17 | inherits_from= 18 | current_source=Producto.cpp 19 | path_char=\ 20 | [source] 21 | path=main.cpp 22 | cursor=78:5 23 | open=true 24 | [source] 25 | path=Producto.cpp 26 | cursor=57:2 27 | open=true 28 | [header] 29 | path=Producto.h 30 | cursor=37:14 31 | open=true 32 | [config] 33 | name=Debug 34 | toolchain= 35 | working_folder= 36 | always_ask_args=0 37 | args= 38 | exec_method=0 39 | exec_script= 40 | env_vars= 41 | wait_for_key=2 42 | temp_folder=Debug 43 | output_file=${TEMP_DIR}\Dogs_and_cat.exe 44 | icon_file= 45 | manifest_file= 46 | compiling_extra= 47 | macros=_DEBUG 48 | warnings_level=2 49 | warnings_as_errors=0 50 | pedantic_errors=0 51 | std_c= 52 | std_cpp=c++14 53 | debug_level=2 54 | optimization_level=0 55 | enable_lto=0 56 | headers_dirs= 57 | linking_extra= 58 | libraries_dirs= 59 | libraries= 60 | libs_to_use= 61 | strip_executable=0 62 | console_program=1 63 | dont_generate_exe=0 64 | [config] 65 | name=Release 66 | toolchain= 67 | working_folder= 68 | always_ask_args=0 69 | args= 70 | exec_method=0 71 | exec_script= 72 | env_vars= 73 | wait_for_key=2 74 | temp_folder=Release 75 | output_file=${TEMP_DIR}\Dogs_and_cat.exe 76 | icon_file= 77 | manifest_file= 78 | compiling_extra= 79 | macros= 80 | warnings_level=2 81 | warnings_as_errors=0 82 | pedantic_errors=0 83 | std_c= 84 | std_cpp=c++14 85 | debug_level=0 86 | optimization_level=2 87 | enable_lto=0 88 | headers_dirs= 89 | linking_extra= 90 | libraries_dirs= 91 | libraries= 92 | libs_to_use= 93 | strip_executable=2 94 | console_program=1 95 | dont_generate_exe=0 96 | [custom_tools] 97 | [end] 98 | -------------------------------------------------------------------------------- /proyectos/Dogs_and_cat/Producto.cpp: -------------------------------------------------------------------------------- 1 | #include "Producto.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | /** 12 | * Se inicializa el archivo dbProductos 13 | * */ 14 | Producto::Producto() 15 | { 16 | dbProductos.open("dbProductos.csv", ios::app); 17 | if (dbProductos.fail()) 18 | { 19 | cout << "Error al abrir el archivo "; 20 | } 21 | dbProductos.close(); 22 | } 23 | 24 | /* 25 | Funcion para gurdar los productos 26 | */ 27 | bool Producto::guardar() 28 | { 29 | 30 | dbProductos.open("dbProductos.csv", ios::app); 31 | 32 | if (dbProductos.fail()) 33 | { 34 | estado = false; 35 | cout << "NO se pudo abrir el archivo "; 36 | exit(1); 37 | return false; 38 | } 39 | printf("\t\t Ingrese el nombre del producto: "); 40 | cin >> nombre; 41 | printf("\t\t Ingrese el precio del producto ($): "); 42 | cin >> precio; 43 | printf("\t\t Ingrese la cantidad del producto: "); 44 | cin >> cantidad; 45 | 46 | dbProductos << codigo << "," << nombre << "," << precio << "," << cantidad << endl; 47 | dbProductos.close(); 48 | 49 | cout << "\n\t\t..:: El registro fue almacenado correctamente ::..\n\n"; 50 | 51 | return true; 52 | } 53 | 54 | /** 55 | * Mostrar todos los productos de la tienda. 56 | */ 57 | void Producto::listarProductos() 58 | { 59 | string linea; 60 | 61 | dbProductos.open("dbProductos.csv", ios::in); // Abriendo el archivo en modo lectura 62 | 63 | if (dbProductos.fail()) 64 | { 65 | cout << "No hay informacion para mostrar :(" << endl; 66 | } 67 | 68 | printf(" ------------------------------------------------------------------------------\n"); 69 | printf("%18s %18s %18s %18s\n", "CODIGO", "NOMBRE", "PRECIO $", "CANTIDAD"); 70 | printf(" ------------------------------------------------------------------------------\n"); 71 | 72 | // Recorremos todo el archivo de texto con el bucle while 73 | while (!dbProductos.eof()) 74 | { 75 | getline(dbProductos, linea); // Se imprime cada celda del texto. 76 | for (auto data : split(linea, ',')) 77 | printf("%18s", data.c_str()); 78 | cout << endl; 79 | } 80 | printf(" ------------------------------------------------------------------------------\n"); 81 | 82 | dbProductos.close(); // Cerramos el archivo 83 | } 84 | 85 | /** 86 | * Busca el producto por código. 87 | */ 88 | void Producto::buscar() 89 | { 90 | string search_codigo; 91 | string linea; 92 | bool encontrado = false; 93 | dbProductos.open("dbProductos.csv", ios::in); 94 | 95 | cout << "El codigo a buscar: " << endl; 96 | cin >> search_codigo; 97 | 98 | while (!dbProductos.eof()) 99 | { 100 | getline(dbProductos, linea); 101 | // Se imprime cada celda del texto. 102 | for (auto data : split(linea, ',')) 103 | { 104 | if (data == search_codigo) 105 | { 106 | encontrado = true; 107 | goto theEnd; 108 | } 109 | } 110 | } 111 | theEnd: 112 | 113 | if (!encontrado) 114 | cout << "\n ..:: El producto no Existe ::.. " << endl; 115 | else 116 | for (auto data : split(linea, ',')) 117 | cout << data << "\t"; 118 | 119 | dbProductos.close(); 120 | 121 | cout << endl; 122 | system("PAUSE"); 123 | } 124 | 125 | /** 126 | * Busca si el registro existe 127 | **/ 128 | bool Producto::existe(string cod) 129 | { 130 | string linea; 131 | vector product; 132 | bool encontrado = false; 133 | dbProductos.open("dbProductos.csv", ios::in); 134 | 135 | while (!dbProductos.eof()) 136 | { 137 | getline(dbProductos, linea); 138 | product = split(linea, ','); 139 | for (auto data : split(linea, ',')) 140 | { 141 | if (data == cod) 142 | encontrado = true; 143 | break; 144 | } 145 | } 146 | dbProductos.close(); 147 | return encontrado; 148 | } 149 | 150 | /** 151 | * Modifica los productos almacenados 152 | * */ 153 | bool Producto::modificar(string search_code) 154 | { 155 | string linea; 156 | vector product; 157 | estado = false; 158 | 159 | dbProductos.open("dbProductos.csv", ios::in); 160 | tempProductos.open("dbProductosTemp.csv", ios::out); 161 | 162 | while (!dbProductos.eof()) 163 | { 164 | getline(dbProductos, linea); 165 | product = split(linea, ','); 166 | 167 | for (auto item : split(linea, ',')) 168 | { 169 | if (item == search_code) 170 | { 171 | printf("\n\t\t------------------------------------"); 172 | printf("\n\t\t Codigo: %s", product[0].c_str()); 173 | printf("\n\t\t Nombre: %s", product[1].c_str()); 174 | printf("\n\t\t Precio $: %s", product[2].c_str()); 175 | printf("\n\t\t Cantidad: %s", product[3].c_str()); 176 | printf("\n\t\t------------------------------------\n"); 177 | 178 | printf("\n\n\t\t ...Ingrese los nuevos valores...\n\n"); 179 | 180 | printf("\t\t Ingrese el nombre del producto: "); 181 | cin >> nombre; 182 | printf("\t\t Ingrese el precio del producto ($): "); 183 | cin >> precio; 184 | printf("\t\t Ingrese la cantidad del producto: "); 185 | cin >> cantidad; 186 | 187 | tempProductos << product[0].c_str() << "," << nombre << "," << precio << "," << cantidad << endl; 188 | estado = true; 189 | } 190 | else 191 | { 192 | tempProductos << linea << endl; 193 | } 194 | 195 | break; // Para que salte a la siguiente iteracion (Si no lo hago asi da error) 196 | } 197 | } 198 | 199 | dbProductos.close(); 200 | tempProductos.close(); 201 | 202 | remove("dbProductos.csv"); 203 | rename("dbProductosTemp.csv", "dbProductos.csv"); 204 | 205 | return estado; 206 | } 207 | 208 | bool Producto::eliminar(string search_code) 209 | { 210 | string linea; 211 | vector product; 212 | estado = false; 213 | 214 | cout << "\t\t Esta segur@ que deseas eliminar el registro? [S/N]: "; 215 | cin >> respuesta; 216 | 217 | if (respuesta == 'S' || respuesta == 's') 218 | { 219 | 220 | dbProductos.open("dbProductos.csv", ios::in); 221 | tempProductos.open("dbProductosTemp.csv", ios::out); 222 | 223 | while (!dbProductos.eof()) 224 | { 225 | getline(dbProductos, linea); 226 | product = split(linea, ','); 227 | 228 | for (auto item : split(linea, ',')) 229 | { 230 | // Se guardar todos lo registros menos el que se va a borrar 231 | if (item == search_code) 232 | estado = true; 233 | else 234 | { 235 | tempProductos << linea << endl; 236 | } 237 | 238 | break; // Para que salte a la siguiente iteracion (Si no lo hago asi da error) 239 | } 240 | } 241 | 242 | dbProductos.close(); 243 | tempProductos.close(); 244 | 245 | remove("dbProductos.csv"); 246 | rename("dbProductosTemp.csv", "dbProductos.csv"); 247 | } 248 | 249 | return estado; 250 | } 251 | 252 | /** 253 | * Menu para realizar las operaciones de Producto 254 | */ 255 | void Producto::menuInsertar() 256 | { 257 | 258 | bool repeat = true; 259 | 260 | do 261 | { 262 | system("cls"); 263 | printf("\n ======================================================================\n"); 264 | printf("\t\t\t ..:: LISTADO DE PRODUCTOS ::.."); 265 | printf("\n ======================================================================\n\n"); 266 | listarProductos(); 267 | printf("\n\t\t Escoge una opcion \n\n"); 268 | printf("\t\t[1]. Agregar Producto\n"); 269 | printf("\t\t[2]. Modificar Producto\n"); 270 | printf("\t\t[3]. Eliminar Producto\n"); 271 | printf("\t\t[0]. Volver al menu principal\n"); 272 | printf("\n\t\tIngrese su opcion: [ ]\b\b"); 273 | 274 | // Opciones 275 | scanf("%d", &opcion); 276 | 277 | switch (opcion) 278 | { 279 | 280 | case 0: 281 | repeat = false; 282 | break; 283 | 284 | case 1: 285 | // Validaciones para registrar producto 286 | do 287 | { 288 | cout << "\n\t\t Ingrese el codigo del producto: "; 289 | cin >> strCode; 290 | 291 | if (!existe(strCode)) 292 | { 293 | codigo = stoi(strCode); 294 | guardar(); 295 | } 296 | else 297 | cout << "\n\t\t ..:: El codido del producto YA Existe ::.. " << endl; 298 | 299 | cout << "\n\t\t Deseas agregar mas productos [S/N]?: "; 300 | cin >> respuesta; 301 | 302 | } while (respuesta == 'S' || respuesta == 's'); 303 | break; 304 | 305 | // Modificar 306 | case 2: 307 | do 308 | { 309 | cout << "\n\t\t Ingrese el codigo del producto a modificar: "; 310 | cin >> strCode; 311 | if (!existe(strCode)) 312 | { 313 | cout << "\n\t\t ..:: El producto NO Existe ::.. " << endl; 314 | } 315 | else 316 | { 317 | modificar(strCode); 318 | } 319 | 320 | cout << "\n\t\t Deseas modificar mas productos [S/N]?: "; 321 | cin >> respuesta; 322 | } while (respuesta == 'S' || respuesta == 's'); 323 | break; 324 | 325 | // Eliminar 326 | case 3: 327 | cout << "\n\t\t Ingrese el codigo del producto a eliminar: "; 328 | cin >> strCode; 329 | if (existe(strCode)) 330 | { 331 | eliminar(strCode); 332 | } 333 | else 334 | { 335 | cout << "\n\t\tEl producto NO existe"; 336 | system("\n\t\tPAUSE"); 337 | } 338 | break; 339 | } 340 | 341 | } while (repeat); 342 | } 343 | 344 | /** 345 | * Función que extrae cada campo del registro (Producto) 346 | * */ 347 | vector Producto::split(const string &s, char delim) 348 | { 349 | vector result; 350 | stringstream ss(s); 351 | string item; 352 | 353 | while (getline(ss, item, delim)) 354 | { 355 | result.push_back(item); 356 | } 357 | 358 | return result; 359 | } 360 | -------------------------------------------------------------------------------- /proyectos/Dogs_and_cat/Producto.h: -------------------------------------------------------------------------------- 1 | #ifndef PRODUCTO_H 2 | #define PRODUCTO_H 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | using namespace std; 9 | 10 | class Producto 11 | { 12 | 13 | private: 14 | // Atributo de la clase 15 | int codigo; 16 | string nombre; 17 | double precio; 18 | int cantidad; 19 | 20 | // Estados y respuestas del usuario 21 | char respuesta; 22 | bool estado = false; // operacion true|false (Correcta o incorrecta) 23 | int opcion; 24 | 25 | // Instancias para los archivos 26 | fstream dbProductos; 27 | fstream tempProductos; 28 | 29 | public: 30 | // Datos 31 | string strCode; 32 | // Metodos 33 | bool guardar(); 34 | bool modificar(string); 35 | bool eliminar(string); 36 | bool existe(string); 37 | 38 | Producto(); 39 | void buscar(); 40 | void listarProductos(); 41 | vector split(const string &s, char delim); 42 | 43 | // Menus 44 | void menuInsertar(); 45 | }; 46 | 47 | #endif 48 | -------------------------------------------------------------------------------- /proyectos/Dogs_and_cat/dbProductos.csv: -------------------------------------------------------------------------------- 1 | 1,Shampoo,13250,88 2 | 2,Laptop,12500,12 3 | -------------------------------------------------------------------------------- /proyectos/Dogs_and_cat/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include /* system */ 5 | #include /* setlocale */ 6 | 7 | #include "Producto.h" 8 | using namespace std; 9 | 10 | // Objetos 11 | Producto producto; 12 | 13 | // Menus y submenus 14 | void menuPrincipal(); 15 | void headerTienda(); 16 | void menuVentas(); 17 | void menuProductos(); 18 | void menuProveedores(); 19 | 20 | int main() 21 | { 22 | setlocale(LC_ALL, "spanish"); /* Permite imprimir caracteres con tilde */ 23 | menuPrincipal(); 24 | return 0; 25 | } 26 | 27 | void menuPrincipal() 28 | { 29 | 30 | int opcion, repetir = 1; 31 | 32 | do 33 | { 34 | system("cls"); 35 | headerTienda(); 36 | printf("\t\t\t\t ..:: MENU PRINCIPAL ::.. \n\n"); 37 | printf("\t\t[1]. Ventas\n"); 38 | printf("\t\t[2]. Productos\n"); 39 | printf("\t\t[3]. Proveedores\n"); 40 | printf("\t\t[0]. Salir\n"); 41 | printf("\n\t\tIngrese su opcion: [ ]\b\b"); 42 | 43 | scanf("%d", &opcion); 44 | 45 | switch (opcion) 46 | { 47 | case 0: 48 | repetir = 0; 49 | break; 50 | 51 | case 1: 52 | break; 53 | 54 | case 2: 55 | producto.menuInsertar(); 56 | break; 57 | 58 | case 3: 59 | break; 60 | } 61 | 62 | } while (repetir); 63 | } 64 | 65 | /** 66 | El encabezao que se muestra en el programa. 67 | */ 68 | void headerTienda() 69 | { 70 | printf("\n ======================================================================\n"); 71 | printf("\t\t\t Dogs and Cat Shop \n"); 72 | printf("\t\t Tu tienda favorita para mascotas\n"); 73 | printf(" ======================================================================\n\n"); 74 | } 75 | -------------------------------------------------------------------------------- /proyectos/tienda_veterinaria.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/proyectos/tienda_veterinaria.cpp -------------------------------------------------------------------------------- /puntero-estructura.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | struct miEstructura { 5 | int a; 6 | } estructura, *puntero; 7 | 8 | 9 | int main(){ 10 | estructura.a = 12; 11 | puntero = &estructura; 12 | 13 | cout << puntero << endl; 14 | cout << puntero->a << endl; 15 | 16 | cin.get(); 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /punteros-2.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int array[5]; 5 | int *p; 6 | 7 | int main(){ 8 | 9 | p = array; 10 | cout << "Direccion array[0] " << &array << endl; 11 | cout << "Puntero " << p << endl; 12 | 13 | cin.get(); 14 | return 0; 15 | } -------------------------------------------------------------------------------- /punteros.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int numero = 3; 5 | int *puntero = № // Guardamos la dirección en memoria en la variable `puntero` 6 | 7 | int main(){ 8 | 9 | // Con & mostramos la dirección de memoria de la variable 10 | cout << &numero << endl; 11 | 12 | // Mostrar la dirección en memoria con puntero 13 | cout << puntero << endl; 14 | 15 | // Muestra el valor de la dirección en memoria 16 | cout << *puntero << endl; 17 | 18 | // `*` Es un operador de indirección 19 | 20 | cin.get(); 21 | return 0; 22 | } -------------------------------------------------------------------------------- /switch.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main(){ 6 | char c; 7 | 8 | cout << "Escribe una letra" << endl; 9 | cin >> c; 10 | 11 | switch (c){ 12 | case 'a': 13 | case 'e': 14 | case 'i': 15 | case 'o': 16 | case 'u': 17 | cout << "El una vocal." << endl; 18 | break; 19 | default: 20 | cout << "Es una consonante" << endl; 21 | break; 22 | } 23 | 24 | // Evita que se cierre el programa 25 | system("pause"); 26 | return 0; 27 | } 28 | -------------------------------------------------------------------------------- /taller_programacion/ciclos/ciclo_do_while.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main(){ 7 | system("color ba"); 8 | float tercera, cuarta, num; 9 | cout << "Digite 10 numeros. " << endl; 10 | int i = 0; 11 | 12 | do { 13 | i = i+1; 14 | cin >> num; 15 | tercera = pow(num, 3); 16 | cuarta = (tercera * num); 17 | cout << "Su cubo es " << tercera << endl; 18 | cout << "Su cuarta es " << cuarta << endl << endl; 19 | } while(i < 10); 20 | 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /taller_programacion/ciclos/ciclo_do_while_printf.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main(){ 7 | system("color ba"); 8 | float tercera, cuarta, num; 9 | printf("Digite 10 numeros.\n"); 10 | int i = 0; 11 | 12 | do { 13 | i = i+1; 14 | scanf("%f", &num); 15 | tercera = pow(num, 3); 16 | cuarta = (tercera * num); 17 | printf("Su cubo es %.2f\n",tercera); 18 | printf("Su cuarta es %.2f\n\n", cuarta); 19 | } while(i < 10); 20 | 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /taller_programacion/ciclos/ciclo_while.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main(int argc, char *argv[]) { 6 | 7 | int i = 1; 8 | 9 | while (i <= 10){ 10 | cout << i << endl; 11 | i++; 12 | } 13 | 14 | getch(); 15 | 16 | return 0; 17 | } 18 | 19 | -------------------------------------------------------------------------------- /taller_programacion/ciclos/ciclo_while_printf.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main(int argc, char *argv[]) { 7 | 8 | int i = 1; 9 | 10 | while (i <= 10){ 11 | printf("%d \n", i); 12 | i++; 13 | } 14 | 15 | getch(); 16 | 17 | return 0; 18 | } 19 | 20 | -------------------------------------------------------------------------------- /taller_programacion/ciclos/ejercicio_1.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main(int argc, char *argv[]) { 6 | 7 | int x = 0; 8 | 9 | for (x=1; x <= 10; x++){ 10 | printf("%d Usco \n", x); 11 | } 12 | 13 | return 0; 14 | } 15 | 16 | -------------------------------------------------------------------------------- /taller_programacion/ciclos/ejercicio_1_cout.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main(int argc, char *argv[]) { 6 | 7 | int x = 0; 8 | 9 | for (x=1; x <= 10; x++){ 10 | cout << x << " Usco " << endl; 11 | } 12 | 13 | return 0; 14 | } 15 | 16 | -------------------------------------------------------------------------------- /taller_programacion/ciclos/ejercicio_2.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main(int argc, char *argv[]) { 6 | 7 | int x = 0; 8 | 9 | for (x=1; x <= 20; x++){ 10 | printf("%d-", x); 11 | } 12 | 13 | return 0; 14 | } 15 | 16 | -------------------------------------------------------------------------------- /taller_programacion/ciclos/ejercicio_2_cout.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main(int argc, char *argv[]) { 6 | 7 | int x = 0; 8 | 9 | for (x=1; x <= 20; x++){ 10 | cout << x << "-"; 11 | } 12 | 13 | return 0; 14 | } 15 | 16 | -------------------------------------------------------------------------------- /taller_programacion/ciclos/ejercicio_3.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main(int argc, char *argv[]) { 6 | 7 | int x = 0; 8 | 9 | for (x=1; x <= 20; x++){ 10 | printf("%d\n", x); 11 | } 12 | 13 | return 0; 14 | } 15 | 16 | -------------------------------------------------------------------------------- /taller_programacion/ciclos/ejercicio_3_cout.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main(int argc, char *argv[]) { 6 | 7 | int x = 0; 8 | 9 | for (x=1; x <= 20; x++){ 10 | cout << x << endl; 11 | } 12 | 13 | return 0; 14 | } 15 | 16 | -------------------------------------------------------------------------------- /taller_programacion/ciclos/ejercicio_4.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/ciclos/ejercicio_4.cpp -------------------------------------------------------------------------------- /taller_programacion/ciclos/ejercicio_4_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/ciclos/ejercicio_4_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/ciclos/intervalo.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/ciclos/intervalo.cpp -------------------------------------------------------------------------------- /taller_programacion/ciclos/intervalo_impar.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/ciclos/intervalo_impar.cpp -------------------------------------------------------------------------------- /taller_programacion/ciclos/intervalo_impares_while_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/ciclos/intervalo_impares_while_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/ciclos/intervalo_impares_while_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/ciclos/intervalo_impares_while_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/ciclos/intervalo_pares_while.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/ciclos/intervalo_pares_while.cpp -------------------------------------------------------------------------------- /taller_programacion/ciclos/intervalo_pares_while_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/ciclos/intervalo_pares_while_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/ciclos/intervalo_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/ciclos/intervalo_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/ciclos/intervalor_impar_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/ciclos/intervalor_impar_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/ciclos/numeros_impares.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/ciclos/numeros_impares.cpp -------------------------------------------------------------------------------- /taller_programacion/ciclos/numeros_impares_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/ciclos/numeros_impares_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/ciclos/numeros_pares.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/ciclos/numeros_pares.cpp -------------------------------------------------------------------------------- /taller_programacion/ciclos/numeros_pares_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/ciclos/numeros_pares_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/ciclos/usco_while_cout.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main(int argc, char *argv[]) { 7 | 8 | int x = 0; 9 | while ( x <= 10){ 10 | cout << "Usco " << x << endl; 11 | x++; 12 | } 13 | getch(); 14 | return 0; 15 | } 16 | -------------------------------------------------------------------------------- /taller_programacion/ciclos/usco_while_printf.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main(int argc, char *argv[]) { 7 | 8 | int x = 0; 9 | while ( x <= 10){ 10 | printf("%d Usco \n", x); 11 | x++; 12 | } 13 | getch(); 14 | return 0; 15 | } 16 | -------------------------------------------------------------------------------- /taller_programacion/condicionales/condicionales_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/condicionales/condicionales_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/condicionales/condicionales_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/condicionales/condicionales_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/ejercicio_1.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main(int argc, char *argv[]) { 7 | 8 | int cantidad = 0; 9 | float total_iva = 0, subtotal = 0, total = 0; 10 | float precio = 12500; 11 | const float IVA = 0.19; 12 | printf("\nIngrese la cantidad de Tarros de pintura: "); 13 | scanf("%i", &cantidad); 14 | 15 | // Procesos 16 | subtotal = precio * cantidad; 17 | total_iva = subtotal*IVA; 18 | total = subtotal + total_iva; 19 | 20 | printf("\nLa cantidad de tarros comprados es: %i\nEl valor del impuesto es de: $%.2f \nEl total a pagar es de $%.2f",cantidad, total_iva, total); 21 | 22 | return 0; 23 | } 24 | 25 | -------------------------------------------------------------------------------- /taller_programacion/ejercicio_2.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main(int argc, char *argv[]) { 6 | 7 | int cantidad = 0; 8 | float total_iva = 0, subtotal = 0, total = 0; 9 | float precio = 12500; 10 | const float IVA = 0.19; 11 | 12 | cout << "Ingrese la cantidad de Tarros de pintura: "; 13 | cin >> cantidad; 14 | 15 | // Procesos 16 | subtotal = precio * cantidad; 17 | total_iva = subtotal*IVA; 18 | total = subtotal + total_iva; 19 | 20 | cout << "\nLa cantidad de tarros comprados es: " << cantidad << endl; 21 | cout << "El valor del impuesto es de: $" << total_iva << endl; 22 | cout << "El total a pagar es de: $" << total << ends; 23 | 24 | 25 | return 0; 26 | } 27 | 28 | -------------------------------------------------------------------------------- /taller_programacion/incio_1.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main(){ 6 | system("color z1"); 7 | double dolares, conversion, tasa_conversion; 8 | cout << "\nIngrese la cantidad de dolares USD$: "; 9 | cin >> dolares; 10 | cout << "Ingrese la tasa actual en pesos colombianos $ "; 11 | cin >> tasa_conversion; 12 | conversion = dolares * tasa_conversion; 13 | cout << "\nSus dolares en pesos colombianos son: $ " << conversion << ends; 14 | 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /taller_programacion/inicio_2.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main(int argc, char *argv[]) { 7 | system("color FF"); 8 | float dolares, pesos_colombianos, tasa_cambio; 9 | printf("\nIngrese la cantidad de dolares $ "); 10 | scanf("%f", &dolares); 11 | printf("\nIngrese la tasa actual $ "); 12 | scanf("%f", &tasa_cambio); 13 | pesos_colombianos = dolares * tasa_cambio; 14 | printf("\nSus solares en pesos son: $%.2f", pesos_colombianos); 15 | 16 | return 0; 17 | } 18 | 19 | -------------------------------------------------------------------------------- /taller_programacion/operadores_logicos_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/operadores_logicos_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/operadores_logicos_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/operadores_logicos_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_1/ejercicio_10_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_1/ejercicio_10_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_1/ejercicio_10_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_1/ejercicio_10_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_1/ejercicio_11_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_1/ejercicio_11_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_1/ejercicio_11_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_1/ejercicio_11_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_1/ejercicio_12_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_1/ejercicio_12_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_1/ejercicio_12_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_1/ejercicio_12_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_1/ejercicio_13_cout.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | 7 | /** 8 | * 13. Tres personas deciden invertir su dinero para fundar una empresa. 9 | * Cada una de ellas invierte cantidades distintas. Obtener el porcentaje 10 | * que cada quien invierte con respecto a la cantidad total invertida. 11 | */ 12 | 13 | float inversion_1, inversion_2, inversion_3, inversion_total; 14 | 15 | int main(int argc, char *argv[]) { 16 | system("color 06"); 17 | 18 | cout << "Ingrese el valor invertido por la persona 1: "; 19 | cin >> inversion_1; 20 | cout << "Ingrese el valor invertido por la persona 2: "; 21 | cin >> inversion_2; 22 | cout << "Ingrese el valor invertido por la persona 3: "; 23 | cin >> inversion_3; 24 | 25 | inversion_total = inversion_1 + inversion_2 + inversion_3; 26 | 27 | cout << endl << ends; 28 | cout << "El porcentaje invertido por la persona 1 es de: " << (inversion_1*100/inversion_total) << "%" << endl; 29 | cout << "El porcentaje invertido por la persona 2 es de: " << (inversion_2*100/inversion_total) << "%" << endl; 30 | cout << "El porcentaje invertido por la persona 3 es de: " << (inversion_3*100/inversion_total) << "%" << endl; 31 | 32 | return 0; 33 | } 34 | 35 | -------------------------------------------------------------------------------- /taller_programacion/taller_1/ejercicio_13_printf.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | 7 | /** 8 | * 13. Tres personas deciden invertir su dinero para fundar una empresa. 9 | * Cada una de ellas invierte cantidades distintas. Obtener el porcentaje 10 | * que cada quien invierte con respecto a la cantidad total invertida. 11 | */ 12 | 13 | float inversion_1, inversion_2, inversion_3, inversion_total; 14 | 15 | int main(int argc, char *argv[]) { 16 | system("color 06"); 17 | 18 | printf("Ingrese el valor invertido por la persona 1: "); 19 | scanf("%f", &inversion_1); 20 | printf("Ingrese el valor invertido por la persona 2: "); 21 | scanf("%f", &inversion_2); 22 | printf("Ingrese el valor invertido por la persona 3: "); 23 | scanf("%f", &inversion_3); 24 | 25 | inversion_total = inversion_1 + inversion_2 + inversion_3; 26 | 27 | printf("\n\nEl porcentaje invertido por la persona 1 es de: %.2f%%", (inversion_1*100/inversion_total)); 28 | printf("\nEl porcentaje invertido por la persona 2 es de: %.2f%%", (inversion_2*100/inversion_total)); 29 | printf("\nEl porcentaje invertido por la persona 3 es de: %.2f%%", (inversion_3*100/inversion_total)); 30 | 31 | return 0; 32 | } 33 | 34 | -------------------------------------------------------------------------------- /taller_programacion/taller_1/ejercicio_14_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_1/ejercicio_14_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_1/ejercicio_14_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_1/ejercicio_14_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_1/ejercicio_15_cout.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | /** 7 | 15. Calcular el nuevo salario de un obrero si obtuvo un incremento del 30% sobre un salario anterior 8 | */ 9 | 10 | float salario; 11 | 12 | int main(int argc, char *argv[]) { 13 | system("color 02"); 14 | 15 | cout << "\nIngrese el salario anterior del obrero: "; 16 | cin >> salario; 17 | 18 | cout << "\nEl nuevo salario del Obrero con incremento del 30% es de: $"<< (salario*1.3) << ends; 19 | 20 | return 0; 21 | } 22 | 23 | -------------------------------------------------------------------------------- /taller_programacion/taller_1/ejercicio_15_printf.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | /** 7 | 15. Calcular el nuevo salario de un obrero si obtuvo un incremento del 30% sobre un salario anterior 8 | */ 9 | 10 | float salario; 11 | 12 | int main(int argc, char *argv[]) { 13 | system("color 02"); 14 | printf("\nIngrese el salario anterior del obrero: "); 15 | scanf("%f", &salario); 16 | 17 | printf("\nEl nuevo salario del Obrero con incremento del 30%% es de: $%.2f", (salario*1.3) ); 18 | 19 | return 0; 20 | } 21 | 22 | -------------------------------------------------------------------------------- /taller_programacion/taller_1/ejercicio_1_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_1/ejercicio_1_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_1/ejercicio_1_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_1/ejercicio_1_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_1/ejercicio_2_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_1/ejercicio_2_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_1/ejercicio_2_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_1/ejercicio_2_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_1/ejercicio_3_cout.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | /** 7 | 3. Una tienda ofrece un descuento del 15% sobre el total de la compra y un cliente desea saber cuanto debera 8 | pagar finalmente por su compra 9 | */ 10 | 11 | float descuento, precio, total; 12 | const float PER_DESCUENTO = 15; 13 | 14 | int main(int argc, char *argv[]) { 15 | system("color 02"); 16 | 17 | cout << "Ingrese el precio de la compra: "; 18 | cin >> precio; 19 | 20 | descuento = precio * (PER_DESCUENTO/100); 21 | 22 | cout << "\nEl precio total de la compra es de: $" << precio; 23 | cout << "\nEl descuento es de: $" << descuento; 24 | cout <<"\nEl total a pagar es de: $" << (precio-descuento); 25 | 26 | return 0; 27 | } 28 | 29 | -------------------------------------------------------------------------------- /taller_programacion/taller_1/ejercicio_3_printf.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | /** 7 | 3. Una tienda ofrece un descuento del 15% sobre el total de la compra y un cliente desea saber cuanto debera 8 | pagar finalmente por su compra 9 | */ 10 | 11 | float descuento, precio, total; 12 | const float PER_DESCUENTO = 15; 13 | 14 | int main(int argc, char *argv[]) { 15 | system("color 02"); 16 | 17 | printf("Ingrese el precio de la compra: "); 18 | scanf("%f", &precio); 19 | 20 | descuento = precio * (PER_DESCUENTO/100); 21 | 22 | printf("\nEl precio total de la compra es de: $%.2f", precio); 23 | printf("\nEl descuento es de: $%.2f", descuento); 24 | printf("\nEl total a pagar es de: $%.2f", (precio-descuento)); 25 | 26 | return 0; 27 | } 28 | 29 | -------------------------------------------------------------------------------- /taller_programacion/taller_1/ejercicio_4_cout.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | /** 7 | * 4. Un alumno desea saber cual sera su calificacion final en la materia de Algoritmos. Dicha calificacion se compone de los siguientes porcentajes: 8 | - 55% del promedio de sus tres calificaciones 9 | - 30% de la calificacion del examen final 10 | - 15% de la calificacion de un trabajo final 11 | */ 12 | 13 | float nota, promedio_notas = 0; 14 | float examen, trabajo, nota_final; 15 | 16 | int main(int argc, char *argv[]) { 17 | system("color F0"); 18 | 19 | for (int i = 1; i <= 3; i++){ 20 | cout << "Ingrese la nota " << i << " : "; 21 | cin >> nota; 22 | promedio_notas += nota; 23 | } 24 | 25 | cout << "\nIngrese la calificacion del examen final: "; 26 | cin >> examen; 27 | cout << "\nIngrese la calificacion del trabajo final: "; 28 | cin >> trabajo; 29 | 30 | promedio_notas = (promedio_notas/3); 31 | nota_final = (promedio_notas*0.55) + (examen*0.3) + (trabajo*0.15); 32 | 33 | cout << "\nLa nota final del estudiante es de: " << nota_final; 34 | 35 | return 0; 36 | } 37 | 38 | -------------------------------------------------------------------------------- /taller_programacion/taller_1/ejercicio_4_printf.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | /** 7 | * Un alumno desea saber cual sera su calificacion final en la materia de Algoritmos. Dicha calificacion se compone de los siguientes porcentajes: 8 | - 55% del promedio de sus tres calificaciones 9 | - 30% de la calificacion del examen final 10 | - 15% de la calificacion de un trabajo final 11 | */ 12 | 13 | float nota, promedio_notas = 0; 14 | float examen, trabajo, nota_final; 15 | 16 | int main(int argc, char *argv[]) { 17 | system("color F0"); 18 | 19 | for (int i = 1; i <= 3; i++){ 20 | printf("Ingrese la nota %i: ", i); 21 | scanf("%f", ¬a); 22 | promedio_notas += nota; 23 | } 24 | 25 | printf("\nIngrese la calificacion del examen final: "); 26 | scanf("%f", &examen); 27 | printf("\nIngrese la calificacion del trabajo final: "); 28 | scanf("%f", &trabajo); 29 | 30 | promedio_notas = (promedio_notas/3); 31 | nota_final = (promedio_notas*0.55) + (examen*0.3) + (trabajo*0.15); 32 | 33 | printf("\nLa nota final del estudiante es de: %.2f", nota_final); 34 | 35 | return 0; 36 | } 37 | 38 | -------------------------------------------------------------------------------- /taller_programacion/taller_1/ejercicio_5_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_1/ejercicio_5_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_1/ejercicio_5_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_1/ejercicio_5_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_1/ejercicio_6_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_1/ejercicio_6_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_1/ejercicio_6_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_1/ejercicio_6_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_1/ejercicio_7_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_1/ejercicio_7_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_1/ejercicio_7_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_1/ejercicio_7_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_1/ejercicio_8_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_1/ejercicio_8_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_1/ejercicio_8_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_1/ejercicio_8_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_1/ejercicio_9_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_1/ejercicio_9_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_1/ejercicio_9_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_1/ejercicio_9_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_1/readme.md: -------------------------------------------------------------------------------- 1 | # Taller 1 2 | 3 | Algoritmos realizados en C++ usando la sentencia `cout` y `printf` 4 | 5 | 1. Suponga que un individuo desea invertir su capital en un banco y desea saber cuánto dinero ganará después de un mes si el banco paga a razón del 2% mensual. 6 | - [Ejercicio 1 - printf](ejercicio_1_printf.cpp) 7 | - [Ejercicio 1 - cout](ejercicio_1_cout.cpp) 8 | 9 | 10 | 2. Un vendedor recibe un sueldo base, más un 10% extra por comisión de sus ventas, el vendedor desea saber cuánto dinero obtendrá por concepto de comisiones por las tres ventas que realiza en el mes y el total que recibirá en el mes tomando en cuenta su sueldo base y comisiones. 11 | - [Ejercicio 2 - printf](ejercicio_2_printf.cpp) 12 | - [Ejercicio 2 - cout](ejercicio_2_cout.cpp) 13 | 14 | 15 | 3. Una tienda ofrece un descuento del 15% sobre el total de la compra y un cliente desea saber cuánto deberá pagar finalmente por su compra. 16 | - [Ejercicio 3 - printf](ejercicio_3_printf.cpp) 17 | - [Ejercicio 3 - cout](ejercicio_3_cout.cpp) 18 | 19 | 20 | 4. Un alumno desea saber cuál será su calificación final en la materia de Algoritmos. Dicha calificación se compone de los siguientes porcentajes: 21 | - 55% del promedio de sus tres calificaciones 22 | - 30% de la calificación del examen final 23 | - 15% de la calificación de un trabajo final 24 | - [Ejercicio 4 - printf](ejercicio_4_printf.cpp) 25 | - [Ejercicio 4 - cout](ejercicio_4_cout.cpp) 26 | 27 | 28 | 5. Un maestro desea saber qué porcentaje de hombres y mujeres hay en un grupo de estudiantes. 29 | - [Ejercicio 5 - printf](ejercicio_5_printf.cpp) 30 | - [Ejercicio 5 - cout](ejercicio_5_cout.cpp) 31 | 32 | 33 | 6. Realizar un algoritmo que calcule la edad de una persona. 34 | - [Ejercicio 6 - printf](ejercicio_6_printf.cpp) 35 | - [Ejercicio 6 - cout](ejercicio_6_cout.cpp) 36 | 37 | 38 | 7. Dada una cantidad en pesos, obtener la equivalencia en dólares, asumiendo que la unidad cambiaría y es un dato desconocido.. 39 | - [Ejercicio 7 - printf](ejercicio_7_printf.cpp) 40 | - [Ejercicio 7 - cout](ejercicio_7_cout.cpp) 41 | 42 | 43 | 8. Leer un número y escribir el valor absoluto del mismo 44 | - [Ejercicio 8 - printf](ejercicio_8_printf.cpp) 45 | - [Ejercicio 8 - cout](ejercicio_8_cout.cpp) 46 | 47 | 48 | 9. La presion, el volumen y la temperatura de una masa de aire se relaciona por la fórmula `masa = (presión*volumen)/(0.37 * (temperatura + 460))` 49 | - [Ejercicio 9 - printf](ejercicio_9_printf.cpp) 50 | - [Ejercicio 9 - cout](ejercicio_9_cout.cpp) 51 | 52 | 53 | 10. La presión, el volumen y la temperatura de una masa de aire se relaciona por la fórmula `num_pulsaciones = (220 - edad)/10` 54 | - [Ejercicio 10 - printf](ejercicio_10_printf.cpp) 55 | - [Ejercicio 10 - cout](ejercicio_10_cout.cpp) 56 | 57 | 58 | 11. El dueño de una tienda compra un artículo a un precio determinado. Obtener el precio en que lo debe vender para obtener una ganancia del 35%. 59 | - [Ejercicio 11 - printf](ejercicio_11_printf.cpp) 60 | - [Ejercicio 11 - cout](ejercicio_11_cout.cpp) 61 | 62 | 63 | 12. Todos los lunes, miércoles y viernes, una persona recorre la misma ruta y cronometra los tiempos obtenidos. Determinar el tiempo promedio que la persona tarda en recorrer la ruta en una semana cualquiera. 64 | - [Ejercicio 12 - printf](ejercicio_12_printf.cpp) 65 | - [Ejercicio 12 - cout](ejercicio_12_cout.cpp) 66 | 67 | 68 | 13. Tres personas deciden invertir su dinero para fundar una empresa. Cada una de ellas invierte cantidades distintas. Obtener el porcentaje que cada quien invierte con respecto a la cantidad total invertida. 69 | - [Ejercicio 13 - printf](ejercicio_13_printf.cpp) 70 | - [Ejercicio 13 - cout](ejercicio_13_cout.cpp) 71 | 72 | 73 | 14. Un alumno desea saber cuál será su promedio general de las cuatro calificaciones más difíciles que cursa y cual será el promedio que obtendrá en cada una de ellas. Estas materias se evalúan como se muestran a continuación: 74 | 75 | * La calificación de matemáticas se obtiene de la sig. Manera: 76 | - Examen 80% 77 | - Promedio de tareas 20% 78 | - En esta materia se pidió un total de tres tareas. 79 | 80 | * La calificación de física se obtiene de la sig. Manera: 81 | - Examen 70% 82 | - Promedio de tareas 30% 83 | - En esta materia se pidió un total de tres tareas. 84 | 85 | * La calificación de química se obtiene de la sig. Manera: 86 | - Examen 60% 87 | - Promedio de tareas 40% 88 | - En esta materia se pidió un total de tres tareas. 89 | 90 | * La calificación de variables complejas se obtiene de la sig. Manera: 91 | - Examen 90% 92 | - Promedio de tareas 10% 93 | - En esta materia se pidió un total de dos tareas. 94 | 95 | 96 | - [Ejercicio 14 - printf](ejercicio_14_printf.cpp) 97 | - [Ejercicio 14 - cout](ejercicio_14_cout.cpp) 98 | 99 | 100 | 15. Calcular el nuevo salario de un obrero si obtuvo un incremento del 30% sobre un salario anterior. 101 | - [Ejercicio 15 - printf](ejercicio_15_printf.cpp) 102 | - [Ejercicio 15 - cout](ejercicio_15_cout.cpp) -------------------------------------------------------------------------------- /taller_programacion/taller_2/ejercicio_10_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_2/ejercicio_10_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_2/ejercicio_10_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_2/ejercicio_10_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_2/ejercicio_1_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_2/ejercicio_1_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_2/ejercicio_1_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_2/ejercicio_1_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_2/ejercicio_2_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_2/ejercicio_2_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_2/ejercicio_2_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_2/ejercicio_2_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_2/ejercicio_3_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_2/ejercicio_3_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_2/ejercicio_3_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_2/ejercicio_3_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_2/ejercicio_4_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_2/ejercicio_4_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_2/ejercicio_4_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_2/ejercicio_4_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_2/ejercicio_5_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_2/ejercicio_5_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_2/ejercicio_5_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_2/ejercicio_5_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_2/ejercicio_6_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_2/ejercicio_6_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_2/ejercicio_6_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_2/ejercicio_6_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_2/ejercicio_7_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_2/ejercicio_7_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_2/ejercicio_7_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_2/ejercicio_7_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_2/ejercicio_8_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_2/ejercicio_8_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_2/ejercicio_8_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_2/ejercicio_8_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_2/ejercicio_9_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_2/ejercicio_9_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_2/ejercicio_9_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_2/ejercicio_9_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_2/readme.md: -------------------------------------------------------------------------------- 1 | # Taller 2 - Condicionales 2 | 3 | 1. Un hombre desea saber cuánto dinero se genera por concepto de intereses sobre la cantidad que tiene en inversión en el banco. El decidirá reinvertir los interese siempre y cuando estos excedan a $7000. Y en ese caso desea saber cuánto dinero tendrá finalmente en su cuenta. 4 | - [ejercicio 1 - cout](ejercicio_1_cout.cpp) 5 | - [ejercicio 1 - printf](ejercicio_1_printf.cpp) 6 | 7 | 8 | 2. Determinar si un alumno apruena o reprueba un curso, sabiendo que aprobará si su promedio de 3 calificaciones es mayor o igual a 3.0 y reprueba en caso contrario 9 | - [ejercicio 2 - cout](ejercicio_2_cout.cpp) 10 | - [ejercicio 2 - printf](ejercicio_2_printf.cpp) 11 | 12 | 13 | 3. En un almacen se hace un 20% de descuento a los clientes cuya compra supere los $1000 ¿Cuál será la cantidad que pagará la persona por su compra? 14 | - [ejercicio 3 - cout](ejercicio_3_cout.cpp) 15 | - [ejercicio 3 - printf](ejercicio_3_printf.cpp) 16 | 17 | 18 | 4. Un obrero necesita calcular su salario semanal, el cual se obtiene de la siguiente manera. 19 | - Si trabaja 40 horas o menos, se le paga $16 por hora. 20 | - Si trabaja más de 40 horas, se le paga %16 por cada una de las primeras 40 horas y $20 por cada hora extra. 21 | - [ejercicio 4 - cout](ejercicio_4_cout.cpp) 22 | - [ejercicio 4 - printf](ejercicio_4_printf.cpp) 23 | 24 | 25 | 5. Haga un programa que lea 2 numeros y los imprima de forma ascencente 26 | - [ejercicio 5 - cout](ejercicio_5_cout.cpp) 27 | - [ejercicio 5 - printf](ejercicio_5_printf.cpp) 28 | 29 | 30 | 6. Una persona enferma que pesa 70kg, se encuentra en reposo y desea saber cuántas calorías consume su cuerpo durante todo el tiempo que realiza una misma actividad. Las actividades que tiene permitido realizar son únicamente dormir o estar sentado en reposo. 31 | Los datos que tiene son, que estando dormido consume 1.08 calorias por minuto y estando sentado en reposo consume 1.66 calorias por minuto 32 | - [ejercicio 6 - cout](ejercicio_6_cout.cpp) 33 | - [ejercicio 6 - printf](ejercicio_6_printf.cpp) 34 | 35 | 36 | 7. Hacer un algoritmo que imprima el nombre de un artículo, clave, precio original y su precio con descuento. 37 | El descuento lo hace en base a la clave, si la clave es 01 el descuento es del 10% y si la clave es 02 el descuento es del 20% (Solo existen 2 claves) 38 | - [ejercicio 7 - cout](ejercicio_7_cout.cpp) 39 | - [ejercicio 7 - printf](ejercicio_7_printf.cpp) 40 | 41 | 42 | 8. Hacer un algoritmo que calcule el total a pagar por la compra de camisas. 43 | Si se compran tres camisas o más se aplica un descuento del 20% sobre el total de la compra y si son menos de 3 camisas un 10% 44 | - [ejercicio 8 - cout](ejercicio_8_cout.cpp) 45 | - [ejercicio 8 - printf](ejercicio_8_printf.cpp) 46 | 47 | 48 | 9. Una empresa quiere hacer una compra de varias piezas de la misma clase a una fábrica de refreacciones. 49 | La empresa, dependiendo del monto total de la compra, decidirá qué hacer para pagar al fabricante. 50 | Si el monto total de la compra excede de $500.000 la empresa tendrá la capacidad de invertir de su propio dinero en un 55% del monto de la compra, pedir prestado al banco un 30% y el resto lo pagará solicitando un crédito al fabricante. 51 | Si el monto total de la compra no excede de $500.000 la empresa tendrá la capacidad de invertir de su propio dinero un 70% y el restante 30% lo pagará solicitando crédito al fabricante. 52 | El fabricante cobra por concepto de interés un 20% sobre la cantidad que se pague a crédito. 53 | - [ejercicio 9 - cout](ejercicio_9_cout.cpp) 54 | - [ejercicio 9 - printf](ejercicio_9_printf.cpp) 55 | 56 | 57 | 10. Calcular el total que una persona debe pagar en una llantera, si el precio de cada llanta es de $800 si se compran menos de 5 y de $700 si se compran 5 o más. 58 | - [ejercicio 10 - cout](ejercicio_10_cout.cpp) 59 | - [ejercicio 10 - printf](ejercicio_10_printf.cpp) 60 | -------------------------------------------------------------------------------- /taller_programacion/taller_3/ejercicio_1_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_3/ejercicio_1_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_3/ejercicio_1_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_3/ejercicio_1_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_3/ejercicio_2_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_3/ejercicio_2_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_3/ejercicio_2_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_3/ejercicio_2_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_3/ejercicio_3_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_3/ejercicio_3_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_3/ejercicio_3_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_3/ejercicio_3_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_3/ejercicio_4_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_3/ejercicio_4_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_3/ejercicio_4_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_3/ejercicio_4_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_3/ejercicio_5_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_3/ejercicio_5_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_3/ejercicio_5_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_3/ejercicio_5_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_3/ejercicio_6_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_3/ejercicio_6_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_3/ejercicio_6_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_3/ejercicio_6_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_3/ejercicio_7_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_3/ejercicio_7_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_3/ejercicio_7_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_3/ejercicio_7_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_3/ejercicio_8_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_3/ejercicio_8_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_3/ejercicio_8_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_3/ejercicio_8_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_5/ejercicio_10_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_5/ejercicio_10_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_5/ejercicio_10_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_5/ejercicio_10_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_5/ejercicio_1_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_5/ejercicio_1_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_5/ejercicio_1_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_5/ejercicio_1_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_5/ejercicio_2_cout.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | /** 8 | 2. Leer 10 numero y obtener su cubo y su cuarta 9 | */ 10 | int main(int argc, char *argv[]) { 11 | 12 | float numero; 13 | 14 | for (int i = 1; i <= 10; i++){ 15 | cout << "Ingrese el " << i << " numero: "; 16 | cin >> numero; 17 | 18 | cout << "La tercera es: " << pow(numero, 3) << "\nLa cuarta es: " << pow(numero, 4) << endl << endl; 19 | } 20 | 21 | return 0; 22 | } 23 | 24 | -------------------------------------------------------------------------------- /taller_programacion/taller_5/ejercicio_2_printf.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | /** 8 | 2. Leer 10 numero y obtener su cubo y su cuarta 9 | */ 10 | int main(int argc, char *argv[]) { 11 | 12 | float numero; 13 | 14 | for (int i = 1; i <= 10; i++){ 15 | printf("Ingrese el %d numero: ", i); 16 | scanf("%f", &numero); 17 | 18 | printf("La tercera es: %.2f \nLa cuarta es: %.2f \n\n", pow(numero, 3), pow(numero, 4) ); 19 | } 20 | 21 | return 0; 22 | } 23 | 24 | -------------------------------------------------------------------------------- /taller_programacion/taller_5/ejercicio_3_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_5/ejercicio_3_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_5/ejercicio_3_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_5/ejercicio_3_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_5/ejercicio_4_cout.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | /** 6 | 4. Leer 20 numeros e imprimir cuantos con positivos, cuantos negativos y cuantos neutros 7 | */ 8 | int main(int argc, char *argv[]) { 9 | system("color 30"); 10 | int positivos = 0, negativos = 0, neutros = 0; 11 | float numero; 12 | 13 | for (int i = 1; i <= 20; i++){ 14 | cout << "Ingrese el " << i << " numero: "; 15 | cin >> numero; 16 | 17 | if (numero > 0){ 18 | positivos++; 19 | } else if (numero == 0){ 20 | neutros++; 21 | } else { 22 | negativos++; 23 | } 24 | } 25 | 26 | cout << "\nPositivos: " << positivos; 27 | cout << "\nNegativos: " << negativos; 28 | cout << "\nNeutros: " << neutros; 29 | 30 | return 0; 31 | } 32 | 33 | -------------------------------------------------------------------------------- /taller_programacion/taller_5/ejercicio_4_printf.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | /** 7 | 4. Leer 20 numeros e imprimir cuantos con positivos, cuantos negativos y cuantos neutros 8 | */ 9 | int main(int argc, char *argv[]) { 10 | system("color 30"); 11 | 12 | int positivos = 0, negativos = 0, neutros = 0; 13 | float numero; 14 | 15 | for (int i = 1; i <= 20; i++){ 16 | printf("Ingrese el %d numero: ", i); 17 | scanf("%f", &numero); 18 | 19 | if (numero > 0){ 20 | positivos++; 21 | } else if (numero == 0){ 22 | neutros++; 23 | } else { 24 | negativos++; 25 | } 26 | } 27 | 28 | printf("\n\nPositivos: %d", positivos); 29 | printf("\nNegativos: %d", negativos); 30 | printf("\nNeutros: %d", neutros); 31 | 32 | return 0; 33 | } 34 | 35 | -------------------------------------------------------------------------------- /taller_programacion/taller_5/ejercicio_5_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_5/ejercicio_5_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_5/ejercicio_5_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_5/ejercicio_5_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_5/ejercicio_6_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_5/ejercicio_6_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_5/ejercicio_6_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_5/ejercicio_6_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_5/ejercicio_7_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_5/ejercicio_7_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_5/ejercicio_7_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_5/ejercicio_7_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_5/ejercicio_8_cout.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | /** 6 | 8. Simular el comportamiento de un reloj digital, imprimiendo la hora, minutos y segundos de un dia 7 | desde las 0:00:00 horas hasta las 23:59:59 horas 8 | */ 9 | 10 | int main(int argc, char *argv[]) { 11 | system("color 30"); 12 | 13 | for (int hora = 0; hora <= 23; hora++){ 14 | for (int minutos = 0; minutos < 60; minutos++){ 15 | for (int segundos = 0; segundos < 60; segundos++){ 16 | cout << hora << ":" << minutos << ":" << segundos << endl; 17 | } 18 | } 19 | } 20 | 21 | return 0; 22 | } 23 | 24 | -------------------------------------------------------------------------------- /taller_programacion/taller_5/ejercicio_8_printf.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | /** 7 | 8. Simular el comportamiento de un reloj digital, imprimiendo la hora, minutos y segundos de un dia 8 | desde las 0:00:00 horas hasta las 23:59:59 horas 9 | */ 10 | 11 | int main(int argc, char *argv[]) { 12 | system("color 30"); 13 | 14 | for (int hora = 0; hora <= 23; hora++){ 15 | for (int minutos = 0; minutos < 60; minutos++){ 16 | for (int segundos = 0; segundos < 60; segundos++){ 17 | printf("%d:%d:%d\n", hora, minutos, segundos); 18 | } 19 | } 20 | } 21 | 22 | return 0; 23 | } 24 | 25 | -------------------------------------------------------------------------------- /taller_programacion/taller_5/ejercicio_9_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_5/ejercicio_9_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_5/ejercicio_9_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_5/ejercicio_9_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_6/ejercicio_10_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_6/ejercicio_10_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_6/ejercicio_10_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_6/ejercicio_10_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_6/ejercicio_1_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_6/ejercicio_1_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_6/ejercicio_1_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_6/ejercicio_1_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_6/ejercicio_2_cout.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | /** 8 | 2. Leer 10 numero y obtener su cubo y su cuarta 9 | */ 10 | int main(int argc, char *argv[]) { 11 | 12 | float numero; 13 | 14 | int i = 1; 15 | while (i <= 10){ 16 | cout << "Ingrese el " << i << " numero: "; 17 | cin >> numero; 18 | 19 | cout << "La tercera es: " << pow(numero, 3) << "\nLa cuarta es: " << pow(numero, 4) << endl << endl; 20 | i++; 21 | } 22 | 23 | return 0; 24 | } 25 | 26 | -------------------------------------------------------------------------------- /taller_programacion/taller_6/ejercicio_2_printf.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | /** 8 | 2. Leer 10 numero y obtener su cubo y su cuarta 9 | */ 10 | int main(int argc, char *argv[]) { 11 | 12 | float numero; 13 | 14 | int i = 1; 15 | while (i <= 10){ 16 | printf("Ingrese el %d numero: ", i); 17 | scanf("%f", &numero); 18 | 19 | printf("La tercera es: %.2f \nLa cuarta es: %.2f \n\n", pow(numero, 3), pow(numero, 4) ); 20 | i++; 21 | } 22 | 23 | return 0; 24 | } 25 | 26 | -------------------------------------------------------------------------------- /taller_programacion/taller_6/ejercicio_3_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_6/ejercicio_3_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_6/ejercicio_3_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_6/ejercicio_3_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_6/ejercicio_4_cout.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | /** 6 | 4. Leer 20 numeros e imprimir cuantos con positivos, cuantos negativos y cuantos neutros 7 | */ 8 | int main(int argc, char *argv[]) { 9 | system("color 30"); 10 | int positivos = 0, negativos = 0, neutros = 0; 11 | float numero; 12 | 13 | int i = 1; 14 | while (i <= 20){ 15 | cout << "Ingrese el " << i << " numero: "; 16 | cin >> numero; 17 | 18 | if (numero > 0){ 19 | positivos++; 20 | } else if (numero == 0){ 21 | neutros++; 22 | } else { 23 | negativos++; 24 | } 25 | i++; 26 | } 27 | 28 | cout << "\nPositivos: " << positivos; 29 | cout << "\nNegativos: " << negativos; 30 | cout << "\nNeutros: " << neutros; 31 | 32 | return 0; 33 | } 34 | 35 | -------------------------------------------------------------------------------- /taller_programacion/taller_6/ejercicio_4_printf.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | /** 7 | 4. Leer 20 numeros e imprimir cuantos con positivos, cuantos negativos y cuantos neutros 8 | */ 9 | int main(int argc, char *argv[]) { 10 | system("color 30"); 11 | 12 | int positivos = 0, negativos = 0, neutros = 0; 13 | float numero; 14 | 15 | int i = 1; 16 | while (i <= 20){ 17 | printf("Ingrese el %d numero: ", i); 18 | scanf("%f", &numero); 19 | 20 | if (numero > 0){ 21 | positivos++; 22 | } else if (numero == 0){ 23 | neutros++; 24 | } else { 25 | negativos++; 26 | } 27 | i++; 28 | } 29 | 30 | printf("\n\nPositivos: %d", positivos); 31 | printf("\nNegativos: %d", negativos); 32 | printf("\nNeutros: %d", neutros); 33 | 34 | return 0; 35 | } 36 | 37 | -------------------------------------------------------------------------------- /taller_programacion/taller_6/ejercicio_5_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_6/ejercicio_5_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_6/ejercicio_5_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_6/ejercicio_5_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_6/ejercicio_6_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_6/ejercicio_6_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_6/ejercicio_6_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_6/ejercicio_6_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_6/ejercicio_7_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_6/ejercicio_7_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_6/ejercicio_7_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_6/ejercicio_7_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_6/ejercicio_8_cout.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | /** 7 | 8. Simular el comportamiento de un reloj digital, imprimiendo la hora, minutos y segundos de un dia 8 | desde las 0:00:00 horas hasta las 23:59:59 horas 9 | */ 10 | 11 | int main(int argc, char *argv[]) { 12 | system("color 30"); 13 | 14 | int hora = 0; 15 | while ( hora <= 23 ){ 16 | int minutos = 0; 17 | while (minutos < 60){ 18 | int segundos = 0; 19 | while (segundos < 60){ 20 | sleep(1); 21 | system("clear"); /* UNIX */ 22 | // system("cls"); /* DOS */ 23 | cout << hora << ":" << minutos << ":" << segundos << endl; 24 | segundos++; 25 | } 26 | minutos++; 27 | } 28 | hora++; 29 | } 30 | 31 | return 0; 32 | } 33 | 34 | -------------------------------------------------------------------------------- /taller_programacion/taller_6/ejercicio_8_printf.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | /** 8 | 8. Simular el comportamiento de un reloj digital, imprimiendo la hora, minutos y segundos de un dia 9 | desde las 0:00:00 horas hasta las 23:59:59 horas 10 | */ 11 | 12 | int main(int argc, char *argv[]) { 13 | system("color 30"); 14 | 15 | int hora = 0; 16 | while (hora <= 23){ 17 | int minutos = 0; 18 | while (minutos < 60){ 19 | int segundos = 0; 20 | while (segundos < 60){ 21 | sleep(1); 22 | system("clear"); /* UNIX */ 23 | // system("cls"); /* DOS */ 24 | printf("%d:%d:%d\n", hora, minutos, segundos); 25 | segundos++; 26 | } 27 | minutos++; 28 | } 29 | hora++; 30 | } 31 | 32 | return 0; 33 | } 34 | 35 | -------------------------------------------------------------------------------- /taller_programacion/taller_6/ejercicio_9_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_6/ejercicio_9_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_6/ejercicio_9_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_6/ejercicio_9_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_7/ejercicio_10_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_7/ejercicio_10_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_7/ejercicio_10_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_7/ejercicio_10_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_7/ejercicio_11_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_7/ejercicio_11_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_7/ejercicio_11_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_7/ejercicio_11_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_7/ejercicio_12_cout.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main(int argc, char *argv[]) { 6 | system("color 30"); 7 | 8 | int grupos, alumnos, materias; 9 | float promedio_total = 0, promedio_grupo = 0, promedio_alumno = 0, promedio_materia = 0; 10 | float calificacion; 11 | 12 | cout << "Digite la cantidad de grupos: "; 13 | cin >> grupos; 14 | 15 | int i = 1; 16 | do { 17 | // Grupos 18 | cout << "Digite la cantidad de alumnos del grupo: "; 19 | cin >> alumnos; 20 | promedio_grupo = 0; 21 | 22 | int j = 1; 23 | do { 24 | // Alumnos 25 | cout << "\nDigite la cantidad de materias del alumno " << j << ": "; 26 | cin >> materias; 27 | promedio_alumno = 0; 28 | 29 | int k = 1; 30 | do { 31 | // Materia 32 | cout << "\nMateria " << k << endl; 33 | promedio_materia = 0; 34 | int l = 1; 35 | do { 36 | cout << "Ingrese la " << l << " nota: "; 37 | cin >> calificacion; 38 | promedio_materia += calificacion; 39 | l++; 40 | } while( l <= 3); 41 | 42 | promedio_materia = (promedio_materia/3); 43 | promedio_alumno += promedio_materia; 44 | k++; 45 | } while( k <= materias); 46 | 47 | promedio_alumno = (promedio_alumno/materias); 48 | promedio_grupo += promedio_alumno; 49 | 50 | cout << "\nEl promedio del Alumno " << j << " es de: " << promedio_alumno << endl; 51 | 52 | j++; 53 | } while(j <= alumnos); 54 | 55 | promedio_grupo = (promedio_grupo/alumnos); 56 | promedio_total += promedio_grupo; 57 | 58 | cout << "\nEl promedio del Grupo " << i << " es de: " << promedio_grupo; 59 | 60 | i++; 61 | } while(i <= grupos); 62 | 63 | promedio_total = (promedio_total/grupos); 64 | cout << "\nEl promedio del los grupos es de: " << promedio_total; 65 | 66 | return 0; 67 | } 68 | 69 | -------------------------------------------------------------------------------- /taller_programacion/taller_7/ejercicio_12_printf.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main(int argc, char *argv[]) { 7 | system("color 30"); 8 | 9 | int grupos, alumnos, materias; 10 | float promedio_total = 0, promedio_grupo = 0, promedio_alumno = 0, promedio_materia = 0; 11 | float calificacion; 12 | 13 | printf("Digite la cantidad de grupos: "); 14 | scanf("%d", &grupos); 15 | 16 | int i = 1; 17 | do { 18 | // Grupos 19 | printf("Digite la cantidad de alumnos del grupo: "); 20 | scanf("%d", &alumnos); 21 | promedio_grupo = 0; 22 | 23 | int j = 1; 24 | do { 25 | // Alumnos 26 | printf("\nDigite la cantidad de materias del alumno %d: ", j); 27 | scanf("%d", &materias); 28 | promedio_alumno = 0; 29 | 30 | int k = 1; 31 | do { 32 | // Materia 33 | printf("\nMateria %d \n", k); 34 | promedio_materia = 0; 35 | int l = 1; 36 | do { 37 | printf("Ingrese la %d nota: ", l); 38 | scanf("%f", &calificacion); 39 | promedio_materia += calificacion; 40 | l++; 41 | } while( l <= 3); 42 | 43 | promedio_materia = (promedio_materia/3); 44 | promedio_alumno += promedio_materia; 45 | k++; 46 | } while( k <= materias); 47 | 48 | promedio_alumno = (promedio_alumno/materias); 49 | promedio_grupo += promedio_alumno; 50 | 51 | printf("\nEl promedio del Alumno %d es de: %.2f\n", j, promedio_alumno); 52 | 53 | j++; 54 | } while(j <= alumnos); 55 | 56 | promedio_grupo = (promedio_grupo/alumnos); 57 | promedio_total += promedio_grupo; 58 | 59 | printf("\nEl promedio del Grupo %d es de: %.2f", i, promedio_grupo); 60 | 61 | i++; 62 | } while(i <= grupos); 63 | 64 | promedio_total = (promedio_total/grupos); 65 | printf("\nEl promedio del los grupos es de: %.2f", promedio_total); 66 | 67 | return 0; 68 | } 69 | 70 | -------------------------------------------------------------------------------- /taller_programacion/taller_7/ejercicio_13_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_7/ejercicio_13_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_7/ejercicio_13_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_7/ejercicio_13_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_7/ejercicio_14_cout.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main(int argc, char *argv[]) { 6 | system("color 30"); 7 | 8 | int obreros = 0; 9 | float precio_hora = 0, sueldo = 0; 10 | float horas=0, dobles=0, triples=0; 11 | 12 | cout << "Ingrese la cantidad de obreros: "; 13 | cin >> obreros; 14 | cout << "Ingrese el precio de la hora: "; 15 | cin >> precio_hora; 16 | 17 | int i = 1; 18 | do { 19 | cout << "\nObrero " << i << endl; 20 | cout << "Ingrese las horas trabajadas: "; 21 | cin >> horas; 22 | 23 | if (horas <= 40){ 24 | sueldo = horas*precio_hora; 25 | } else if (horas > 40){ 26 | dobles = (horas-40); 27 | sueldo = (precio_hora*40) + (dobles*precio_hora*2); 28 | if (dobles > 8){ 29 | triples = (dobles-8); 30 | sueldo = (precio_hora*40) + (precio_hora*8*2) + (triples*precio_hora*3); 31 | } 32 | } 33 | 34 | cout << "El sueldo del Obrero es de $" << sueldo << endl; 35 | 36 | i++; 37 | } while(i <= obreros); 38 | 39 | return 0; 40 | } 41 | 42 | -------------------------------------------------------------------------------- /taller_programacion/taller_7/ejercicio_14_printf.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main(int argc, char *argv[]) { 7 | system("color 30"); 8 | 9 | int obreros = 0; 10 | float precio_hora = 0, sueldo = 0; 11 | float horas=0, dobles=0, triples=0; 12 | 13 | printf("Ingrese la cantidad de obreros: "); 14 | scanf("%d", &obreros); 15 | printf("Ingrese el precio de la hora: "); 16 | scanf("%f", &precio_hora); 17 | 18 | int i = 1; 19 | do { 20 | printf("\nObrero %d\n", i); 21 | printf("Ingrese las horas trabajadas: "); 22 | scanf("%f", &horas); 23 | 24 | if (horas <= 40){ 25 | sueldo = horas*precio_hora; 26 | } else if (horas > 40){ 27 | dobles = (horas-40); 28 | sueldo = (precio_hora*40) + (dobles*precio_hora*2); 29 | if (dobles > 8){ 30 | triples = (dobles-8); 31 | sueldo = (precio_hora*40) + (precio_hora*8*2) + (triples*precio_hora*3); 32 | } 33 | } 34 | 35 | printf("El sueldo del Obrero es de $%.2f\n",sueldo); 36 | 37 | i++; 38 | } while(i <= obreros); 39 | 40 | return 0; 41 | } 42 | 43 | -------------------------------------------------------------------------------- /taller_programacion/taller_7/ejercicio_15_cout.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main(int argc, char *argv[]) { 6 | 7 | int gallinas = 0; 8 | float promedio_calidad = 0, calidad = 0, peso = 0, altura = 0, huevos = 0; 9 | float precio_kilo; 10 | 11 | cout << "Digite la cantidad de gallinas que hay en la granja: "; 12 | cin >> gallinas; 13 | 14 | int i = 1; 15 | do { 16 | cout << "\nGallina " << i ; 17 | cout << "\nIngrese el peso: "; 18 | cin >> peso; 19 | cout << "Ingrese la altura: "; 20 | cin >> altura; 21 | cout << "Ingrese la cantidad de huevos: "; 22 | cin >> huevos; 23 | calidad = (peso * altura) / huevos; 24 | 25 | promedio_calidad += calidad; 26 | 27 | i++; 28 | } while(i <= gallinas); 29 | 30 | promedio_calidad = (promedio_calidad/gallinas); 31 | 32 | if (promedio_calidad >= 15){ 33 | precio_kilo = promedio_calidad*1.2; 34 | } else if (promedio_calidad > 8 && promedio_calidad < 15){ 35 | precio_kilo = promedio_calidad*1; 36 | } else if (promedio_calidad <= 8) { 37 | precio_kilo = promedio_calidad*0.8; 38 | } 39 | 40 | cout << "\nEl precio de venta para cada kilo de huevo es de: $" << precio_kilo; 41 | 42 | return 0; 43 | } 44 | 45 | -------------------------------------------------------------------------------- /taller_programacion/taller_7/ejercicio_15_printf.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main(int argc, char *argv[]) { 7 | system("color 30"); 8 | 9 | int gallinas = 0; 10 | float promedio_calidad = 0, calidad = 0, peso = 0, altura = 0, huevos = 0; 11 | float precio_kilo; 12 | 13 | printf("Digite la cantidad de gallinas que hay en la granja: "); 14 | scanf("%d", &gallinas); 15 | 16 | int i = 1; 17 | do { 18 | printf("\nGallina %d", i ); 19 | printf("\nIngrese el peso: "); 20 | scanf("%f", &peso); 21 | printf("Ingrese la altura: "); 22 | scanf("%f", &altura); 23 | printf("Ingrese la cantidad de huevos: "); 24 | scanf("%f", &huevos); 25 | calidad = (peso * altura) / huevos; 26 | 27 | promedio_calidad += calidad; 28 | 29 | i++; 30 | } while(i <= gallinas); 31 | 32 | promedio_calidad = (promedio_calidad/gallinas); 33 | 34 | if (promedio_calidad >= 15){ 35 | precio_kilo = promedio_calidad*1.2; 36 | } else if (promedio_calidad > 8 && promedio_calidad < 15){ 37 | precio_kilo = promedio_calidad*1; 38 | } else if (promedio_calidad <= 8) { 39 | precio_kilo = promedio_calidad*0.8; 40 | } 41 | 42 | printf("\nEl precio de venta para cada kilo de huevo es de: $%.2f", precio_kilo); 43 | 44 | return 0; 45 | } 46 | 47 | -------------------------------------------------------------------------------- /taller_programacion/taller_7/ejercicio_16_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_7/ejercicio_16_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_7/ejercicio_16_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_7/ejercicio_16_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_7/ejercicio_1_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_7/ejercicio_1_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_7/ejercicio_1_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_7/ejercicio_1_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_7/ejercicio_2_cout.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main(int argc, char *argv[]) { 6 | system("color ba"); 7 | 8 | int obreros = 0; 9 | float horas = 0; 10 | float pago_normal=0, pago_extra=0, total_pagar; 11 | 12 | cout << "Ingrese la cantidad de obrero de la empresa: "; 13 | cin >> obreros; 14 | 15 | int i = 1; 16 | do { 17 | cout << "Obrero " << i << endl; 18 | cout << "Ingrese la cantidad de horas trabajadas: "; 19 | cin >> horas; 20 | 21 | if (horas > 40){ 22 | pago_normal = 40 * 20; 23 | pago_extra = (horas-40) * 25; 24 | } else { 25 | pago_normal = horas * 20; 26 | pago_extra = 0; 27 | } 28 | total_pagar = pago_normal + pago_extra; 29 | cout << "El salario del obrero es de: " << total_pagar << endl << endl; 30 | 31 | i++; 32 | } while(i <= obreros); 33 | 34 | return 0; 35 | } 36 | 37 | -------------------------------------------------------------------------------- /taller_programacion/taller_7/ejercicio_2_printf.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main(int argc, char *argv[]) { 7 | system("color ba"); 8 | 9 | int obreros = 0; 10 | float horas = 0; 11 | float pago_normal=0, pago_extra=0, total_pagar; 12 | 13 | printf("Ingrese la cantidad de obrero de la empresa: "); 14 | scanf("%d", &obreros); 15 | 16 | int i = 1; 17 | do { 18 | printf("Obrero %d\n", i); 19 | printf("Ingrese la cantidad de horas trabajadas: "); 20 | scanf("%f", &horas); 21 | 22 | if (horas > 40){ 23 | pago_normal = 40 * 20; 24 | pago_extra = (horas-40) * 25; 25 | } else { 26 | pago_normal = horas * 20; 27 | pago_extra = 0; 28 | } 29 | total_pagar = pago_normal + pago_extra; 30 | printf("El salario del obrero es de: %.2f\n\n", total_pagar); 31 | 32 | i++; 33 | } while(i <= obreros); 34 | 35 | return 0; 36 | } 37 | 38 | -------------------------------------------------------------------------------- /taller_programacion/taller_7/ejercicio_3_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_7/ejercicio_3_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_7/ejercicio_3_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_7/ejercicio_3_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_7/ejercicio_4_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_7/ejercicio_4_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_7/ejercicio_4_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_7/ejercicio_4_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_7/ejercicio_5_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_7/ejercicio_5_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_7/ejercicio_5_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_7/ejercicio_5_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_7/ejercicio_6_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_7/ejercicio_6_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_7/ejercicio_6_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_7/ejercicio_6_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_7/ejercicio_7_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_7/ejercicio_7_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_7/ejercicio_7_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_7/ejercicio_7_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_7/ejercicio_8_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_7/ejercicio_8_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_7/ejercicio_8_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_7/ejercicio_8_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_7/ejercicio_9_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_7/ejercicio_9_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_7/ejercicio_9_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_7/ejercicio_9_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_7/readme.md: -------------------------------------------------------------------------------- 1 | # Taller Do While 2 | 3 | 4 | 1. Una compañía de seguros tiene contratados a n vendedores. Cada uno hace tres ventas a la semana. Su política de pagos es que un vendedor recibe un sueldo base, y un 10% extra por comisiones de sus ventas. El gerente de su compañía desea saber cuánto dinero obtendrá en la semana cada vendedor por concepto de comisiones por las tres ventas realizadas, y cuánto tomando en cuenta su sueldo base y sus comisiones. 5 | 6 | 7 | 2. En una empresa se requiere calcular el salario semanal de cada uno de los n obreros que laboran en ella. El salario se obtiene de la siguiente forma: 8 | - Si el obrero trabaja 40 horas o menos se le paga $20 por hora 9 | - Si trabaja más de 40 horas se le paga $20 por cada una de las primeras 40 horas y $25 por cada hora extra. 10 | 11 | 12 | 3. Determinar cuántos hombres y cuántas mujeres se encuentran en un grupo de n personas, suponiendo que los datos son extraidos alumno por alumno. 13 | 14 | 15 | 4. El departamento de Seguridad Pública y Tránsito del D.F. desea saber, de los n autos que entran a la ciudad de México, cuántos entran con calcomanía de cada color. Conociendo el último dígito de la placa de cada automóvil se puede determinar el color de la calcomanía utilizando la siguiente relación: 16 | 17 | Dígito|Color 18 | ------|----- 19 | 1 ó 2 | Amarilla 20 | 3 ó 4 | Rosa 21 | 5 ó 6 | Roja 22 | 7 ó 8 | Verde 23 | 9 ó 0 | Azul 24 | 25 | 26 | 5. Obtener el promedio de calificaciones de un grupo de n alumnos. 27 | 28 | 29 | 6. Una persona desea invertir su dinero en un banco, el cual le otorga un 2% de interés. Cuál será la cantidad de dinero que ésta persona tendrá al cabo de un año si la ganancia de cada mes es reinvertida? 30 | 31 | 32 | 7. Calcular el promedio de edades de hombres, mujeres y de todo un grupo de alumnos. 33 | 34 | 35 | 8. Encontrar el menor valor de un conjunto de n números dados. 36 | 37 | 38 | 9. Encontrar el mayor valor de un conjunto de n números dados. 39 | 40 | 41 | 10. En un supermercado un cajero captura los precios de los artículos que los clientes compran e indica a cada cliente cuál es el monto de lo que deben pagar. Al final del día le indica a su supervisor cuánto fué lo que cobró en total a todos los clientes que pasaron por su caja. 42 | 43 | 44 | 11. Cinco miembros de un club contra la obesidad desean saber cuánto han bajado o subido de peso desde la última vez que se reunieron. Para eso de debe realizar un ritual de pesaje en donde cada uno de pesa en diez básculas distintas y así tener el promedio más exacto de su peso. Si existe diferencia positiva en ese promedio de peso y el peso de la última vez que se reunieron, significa que bajaron. Lo que el problema requiere es que por cada persona se imprima un letrero que diga: "ŚUBIÓ" ó "BAJÓ" y la cantidad de kilos que subió o bajó de peso. 45 | 46 | 47 | 12. Se desea obtener el promedio de g grupos que están en un mismo año escolar; siendo que cada grupo puede tener n alumnos que cada alumno puede llevar m materias y que en todas las materias se promedian tres calificaciones para obtener el promedio de la materia. Lo que se desea desplegar es el promedio de los grupos, el promedio de cada grupo y el promedio de cada alumno. 48 | 49 | 50 | 13. La presión, volumen y temperatura de una masa de aire se relacionan por la fórmula: 51 | 52 | `masa = (presion*volumen)/(0.37*(temperatura + 460))` 53 | 54 | Calcular el promedio de la masa de aire de los neumáticos de n vehículos que están en compostura en un servicio de alineación y balanceo. Los vehículos pueden ser motocicletas o automóviles. 55 | 56 | 57 | 14. Determinar la cantidad semanal de dinero que recibirá cada uno de los n obreros de una empresa. Se sabe que cuando las horas que trabaja un obrero exceden de 40, el resto se convierte en horas extras que se pagan al doble de una hora normal, cuando no exceden de 8; cuando las horas extras exceden de 8 se pagan las primeras 8 al doble de lo que se paga una hora normal y el resto al triple. 58 | 59 | 60 | 15. En una granja se requiere saber alguna información para determinar el precio de venta por cada kilo de huevo. Es importante determinar el promedio de calidad de las n gallinas que hay en la granja. La calidad de cada gallina se obtiene según la fórmula. 61 | 62 | `calidad = (peso de la gallina * altura de la gallina) / numero de huevos que pone` 63 | 64 | Finalmente para fijar el precio del kilo de huevo, se toma como base la siguiente tabla. 65 | 66 | PRECIO TOTAL DE CALIDAD | PESO POR KILO DEL HUEVO 67 | ------------------------|------------------------ 68 | Mayor o igual que 15 | 1.2 * promedio de calidad 69 | Mayor que 8 y menor que 15 | 1.00 * promedio de calidad 70 | Menor o igual que 8 | 0.80 * promedio de calidad 71 | 72 | 73 | 16. En la cámara de Diputados se levanta una encuesta con todos los integrantes con el fin de determinar el porcentaje de los n diputados que están a favor del Tratado de Libre Comercio, el porcentaje que está en contra y el porcentaje que se abstiene de votar. -------------------------------------------------------------------------------- /taller_programacion/taller_8/clase/ejercicio_2_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_8/clase/ejercicio_2_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_8/clase/ejercicio_do_while_cout.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main(int argc, char *argv[]) { 6 | system("color 30"); 7 | 8 | int cantidad = 5; 9 | int vector_A[5], vector_B[5], vector_C[5]; 10 | 11 | int i = 0; 12 | 13 | cout << "Ingrese los valores del vector A\n"; 14 | do { 15 | cin >> vector_A[i]; 16 | i++; 17 | } while (i < cantidad); 18 | 19 | cout << "\nIngrese los valores del vector B\n"; 20 | i = 0; 21 | do { 22 | cin >> vector_B[i]; 23 | i++; 24 | } while (i < cantidad); 25 | 26 | i = 0; 27 | cout << "\nLa suma de cada una de los elementos del vector A con el vector B es: \n"; 28 | do { 29 | vector_C[i] = vector_A[i] + vector_B[i]; 30 | cout << vector_A[i] << " + " << vector_B[i] << " = " << vector_C[i] << endl; 31 | i++; 32 | } while (i < cantidad); 33 | 34 | i = 0; 35 | cout << "\nLos valores del vector C son: \n"; 36 | do { 37 | cout << vector_C[i] << endl; 38 | i++; 39 | } while (i < cantidad); 40 | 41 | return 0; 42 | } 43 | 44 | -------------------------------------------------------------------------------- /taller_programacion/taller_8/clase/ejercicio_do_while_printf.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main(int argc, char *argv[]) { 7 | system("color 30"); 8 | 9 | int cantidad = 5; 10 | int vector_A[5], vector_B[5], vector_C[5]; 11 | 12 | int i = 0; 13 | 14 | printf("Ingrese los valores del vector A\n"); 15 | do { 16 | scanf("%d", &vector_A[i]); 17 | i++; 18 | } while (i < cantidad); 19 | 20 | printf("\nIngrese los valores del vector B\n"); 21 | i = 0; 22 | do { 23 | scanf("%d", &vector_B[i]); 24 | i++; 25 | } while (i < cantidad); 26 | 27 | i = 0; 28 | printf("\nLa suma de cada una de los elementos del vector A con el vector B es: \n"); 29 | do { 30 | vector_C[i] = vector_A[i] + vector_B[i]; 31 | printf("%d + %d = %d \n",vector_A[i], vector_B[i], vector_C[i]); 32 | i++; 33 | } while (i < cantidad); 34 | 35 | i = 0; 36 | printf("\nLos valores del vector C son: \n"); 37 | do { 38 | printf("%d\n", vector_C[i]); 39 | i++; 40 | } while (i < cantidad); 41 | 42 | return 0; 43 | } 44 | 45 | -------------------------------------------------------------------------------- /taller_programacion/taller_8/clase/ejercicio_for_cout.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main(int argc, char *argv[]) { 6 | system("color 30"); 7 | 8 | int cantidad = 5; 9 | int vector_A[5], vector_B[5], vector_C[5]; 10 | 11 | cout << "Ingrese los valores del vector A\n"; 12 | for (int i = 0; i < cantidad; i++) { 13 | cin >> vector_A[i]; 14 | } 15 | 16 | cout << "\nIngrese los valores del vector B\n"; 17 | for (int i = 0; i < cantidad; i++) { 18 | cin >> vector_B[i]; 19 | } 20 | 21 | cout << "\nLa suma de cada una de los elementos del vector A con el vector B es: \n"; 22 | for (int i = 0; i < cantidad; i++) { 23 | vector_C[i] = vector_A[i] + vector_B[i]; 24 | cout << vector_A[i] << " + " << vector_B[i] << " = " << vector_C[i] << endl; 25 | } 26 | 27 | cout << "\nLos valores del vector C son: \n"; 28 | for (int i = 0; i < cantidad; i++) { 29 | cout << vector_C[i] << endl; 30 | } 31 | 32 | return 0; 33 | } 34 | 35 | -------------------------------------------------------------------------------- /taller_programacion/taller_8/clase/ejercicio_for_printf.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main(int argc, char *argv[]) { 7 | system("color 30"); 8 | 9 | int cantidad = 5; 10 | int vector_A[5], vector_B[5], vector_C[5]; 11 | 12 | printf("Ingrese los valores del vector A\n"); 13 | for (int i = 0; i < cantidad; i++) { 14 | scanf("%d", &vector_A[i]); 15 | } 16 | 17 | printf("\nIngrese los valores del vector B\n"); 18 | for (int i = 0; i < cantidad; i++) { 19 | scanf("%d", &vector_B[i]); 20 | } 21 | 22 | printf("\nLa suma de cada una de los elementos del vector A con el vector B es: \n"); 23 | for (int i = 0; i < cantidad; i++) { 24 | vector_C[i] = vector_A[i] + vector_B[i]; 25 | printf("%d + %d = %d\n", vector_A[i], vector_B[i], vector_C[i]); 26 | } 27 | 28 | printf("\nLos valores del vector C son: \n"); 29 | for (int i = 0; i < cantidad; i++) { 30 | printf("%d\n", vector_C[i]); 31 | } 32 | 33 | return 0; 34 | } 35 | 36 | -------------------------------------------------------------------------------- /taller_programacion/taller_8/clase/ejercicio_while_cout.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main(int argc, char *argv[]) { 6 | system("color 30"); 7 | 8 | int cantidad = 5; 9 | int vector_A[5], vector_B[5], vector_C[5]; 10 | 11 | int i = 0; 12 | 13 | cout << "Ingrese los valores del vector A\n"; 14 | while (i < cantidad){ 15 | cin >> vector_A[i]; 16 | i++; 17 | } 18 | 19 | cout << "\nIngrese los valores del vector B\n"; 20 | i = 0; 21 | while (i < cantidad){ 22 | cin >> vector_B[i]; 23 | i++; 24 | } 25 | 26 | i = 0; 27 | cout << "\nLa suma de cada una de los elementos del vector A con el vector B es: \n"; 28 | while (i < cantidad){ 29 | vector_C[i] = vector_A[i] + vector_B[i]; 30 | cout << vector_A[i] << " + " << vector_B[i] << " = " << vector_C[i] << endl; 31 | i++; 32 | } 33 | 34 | i = 0; 35 | cout << "\nLos valores del vector C son: \n"; 36 | while (i < cantidad){ 37 | cout << vector_C[i] << endl; 38 | i++; 39 | } 40 | 41 | 42 | 43 | return 0; 44 | } 45 | 46 | -------------------------------------------------------------------------------- /taller_programacion/taller_8/clase/ejercicio_while_printf.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main(int argc, char *argv[]) { 7 | system("color 30"); 8 | 9 | int cantidad = 5; 10 | int vector_A[5], vector_B[5], vector_C[5]; 11 | 12 | int i = 0; 13 | 14 | printf("Ingrese los valores del vector A\n"); 15 | while (i < cantidad){ 16 | scanf("%d", &vector_A[i]); 17 | i++; 18 | } 19 | 20 | printf("\nIngrese los valores del vector B\n"); 21 | i = 0; 22 | while (i < cantidad){ 23 | scanf("%d", &vector_B[i]); 24 | i++; 25 | } 26 | 27 | i = 0; 28 | printf("\nLa suma de cada una de los elementos del vector A con el vector B es: \n"); 29 | while (i < cantidad){ 30 | vector_C[i] = vector_A[i] + vector_B[i]; 31 | printf("%d + %d = %d \n",vector_A[i], vector_B[i], vector_C[i]); 32 | i++; 33 | } 34 | 35 | i = 0; 36 | printf("\nLos valores del vector C son: \n"); 37 | while (i < cantidad){ 38 | printf("%d\n", vector_C[i]); 39 | i++; 40 | } 41 | 42 | 43 | 44 | return 0; 45 | } 46 | 47 | -------------------------------------------------------------------------------- /taller_programacion/taller_8/ejercicio_1_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_8/ejercicio_1_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_8/ejercicio_1_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_8/ejercicio_1_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_8/ejercicio_2_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_8/ejercicio_2_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_8/ejercicio_2_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_8/ejercicio_2_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_8/ejercicio_3_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_8/ejercicio_3_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_8/ejercicio_3_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_8/ejercicio_3_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_8/ejercicio_4_cout.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main(int argc, char *argv[]) { 7 | system("color 30"); 8 | 9 | int cantidad = 10, resultado = 0; 10 | int vector_A[10]; 11 | int vector_B[10]; 12 | 13 | for (int i = 0; i < cantidad; i++){ 14 | vector_A[i] = i; 15 | resultado = pow(vector_A[i], 2); 16 | vector_B[i] = resultado; 17 | 18 | cout << "Vector A: " << vector_A[i] << " => Vector B: " << vector_B[i] << endl; 19 | } 20 | 21 | return 0; 22 | } 23 | 24 | -------------------------------------------------------------------------------- /taller_programacion/taller_8/ejercicio_4_printf.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | int main(int argc, char *argv[]) { 8 | system("color 30"); 9 | 10 | int cantidad = 10, resultado = 0; 11 | int vector_A[10]; 12 | int vector_B[10]; 13 | 14 | for (int i = 0; i < cantidad; i++){ 15 | vector_A[i] = i; 16 | resultado = pow(vector_A[i], 2); 17 | vector_B[i] = resultado; 18 | 19 | printf("Vector A: %d => Vector B: %d \n", vector_A[i], vector_B[i]); 20 | } 21 | 22 | return 0; 23 | } 24 | 25 | -------------------------------------------------------------------------------- /taller_programacion/taller_8/ejercicio_5_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_8/ejercicio_5_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_8/ejercicio_5_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_8/ejercicio_5_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_8/ejercicio_6_cout.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main(int argc, char *argv[]) { 5 | 6 | return 0; 7 | } 8 | 9 | -------------------------------------------------------------------------------- /taller_programacion/taller_8/readme.md: -------------------------------------------------------------------------------- 1 | # Taller 8 (Taller de Vectores) 2 | 3 | **NOTA** Se debe implementar en los 3 primeros el ciclo while, los siguientes 3 en ciclo for y los 4 últimos en ciclo do while. 4 | 5 | 1. Calcular el promedio de 50 valores almacenados en un vector. Determinar además cuántos son mayores que el promedio, imprimir el promedio, el numero de datos mayores que el promedio y una lista de datos mayores que el promedio. 6 | - [Ejercicio 1. cout](ejercicio_1_cout.cpp) 7 | - [Ejercicio 1. printf](ejercicio_1_printf.cpp) 8 | 9 | 2. Llenar dos vectores A y B de 45 elementos cada uno, sumar el elemento uno del vector A con el elemento uno del vector B y así sucesivamente hasta 45, almacenar el resultado en un vector C, e imprimir el vector resultante. 10 | - [Ejercicio 2. cout](ejercicio_2_cout.cpp) 11 | - [Ejercicio 2. printf](ejercicio_2_printf.cpp) 12 | 13 | 3. Llenar un vector de 20 elementos, imprimir la posición y el valor del elemento mayor almacenado en el vector. Suponga que todos los elementos del vector son diferentes. 14 | - [Ejercicio 3. cout](ejercicio_3_cout.cpp) 15 | - [Ejercicio 3. printf](ejercicio_3_printf.cpp) 16 | 17 | 4. Almacenar 500 números en un vector, elevar al cuadrado cada valor almacenado en el vector, almacenar el resultado en otro vector. Imprimir el vector original y el vector resultante. 18 | - [Ejercicio 4. cout](ejercicio_4_cout.cpp) 19 | - [Ejercicio 4. printf](ejercicio_4_printf.cpp) 20 | 21 | 5. Almacenar 300 números en un vector, imprimir cuantos son ceros, cuántos son negativos, cuantos positivos. Imprimir además la suma de los negativos y la suma de los positivos. 22 | - [Ejercicio 5. cout](ejercicio_5_cout.cpp) 23 | - [Ejercicio 5. printf](ejercicio_5_printf.cpp) 24 | 25 | 6. Almacenar 150 números en un vector, almacenarlos en otro vector en orden inverso al vector original e imprimir el vector resultante. 26 | - [Ejercicio 6. cout](ejercicio_6_cout.cpp) 27 | - [Ejercicio 6. printf](ejercicio_6_printf.cpp) 28 | 29 | 30 | 7. Se tienen almacenados en la memoria dos vectores M y N de cien elementos cada uno. Hacer un algoritmo que escriba la palabra “Iguales” si ambos vectores es iguales y “Diferentes” si no lo son. 31 | Serán iguales cuando en la misma posición de ambos vectores se tenga el mismo valor para todos los elementos. 32 | - [Ejercicio 7. cout](taller/ejercicio_7_cout.cpp) 33 | - [Ejercicio 7. printf](taller/ejercicio_7_printf.cpp) 34 | 35 | 36 | 8. Se tiene el vector A con 100 elementos almacenados. Diseñe un algoritmo que escriba “SI” si el vector esta ordenado ascendente mente o “NO” si el vector no está ordenado. 37 | - [Ejercicio 8. cout](taller/ejercicio_8_cout.cpp) 38 | - [Ejercicio 8. printf](taller/ejercicio_8_printf.cpp) 39 | 40 | 41 | 9. Diseñe un algoritmo que lea un número cualquiera y lo busque en el vector X, el cual tiene almacenados 80 elementos. Escribir la posición donde se encuentra almacenado el número en el vector o el mensaje “NO” si no lo encuentra. Búsqueda secuencial. 42 | - [Ejercicio 9. cout](taller/ejercicio_9_cout.cpp) 43 | - [Ejercicio 9. printf](taller/ejercicio_9_printf.cpp) 44 | 45 | 46 | 10. Diseñe un algoritmo que lea dos vectores A y B de 20 elementos cada uno y multiplique el primer elemento de A con el ultimo de B y luego el segundo elemento de A por el diecinueveavo elemento de B y así sucesivamente hasta llegar al veinteavo elemento de A por el primer elemento de B. El resultado de la multiplicación almacenarlo en un vector C. 47 | - [Ejercicio 10. cout](taller/ejercicio_10_cout.cpp) 48 | - [Ejercicio 10. printf](taller/ejercicio_10_printf.cpp) 49 | -------------------------------------------------------------------------------- /taller_programacion/taller_8/taller/ejercicio_10_cout.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main(int argc, char *argv[]) { 7 | system("color 30"); 8 | int cantidad = 5; 9 | int vector_A[5], vector_B[5], vector_C[5]; 10 | 11 | int i = 0; 12 | cout << "Ingrese los elementos del vector A: \n"; 13 | do { 14 | cin >> vector_A[i]; 15 | i++; 16 | } while(i < cantidad); 17 | 18 | i = 0; 19 | cout << "\nIngrese los elementos del vector B: \n"; 20 | do { 21 | cin >> vector_B[i]; 22 | i++; 23 | } while(i < cantidad); 24 | 25 | i = 0; 26 | do { 27 | vector_C[i] = vector_A[i] * vector_A[cantidad-i-1]; 28 | cout << " - " << vector_A[i] << " * " << vector_B[cantidad-i-1] << " = " << vector_C[i] << endl; 29 | i++; 30 | } while(i < cantidad); 31 | 32 | return 0; 33 | } 34 | 35 | -------------------------------------------------------------------------------- /taller_programacion/taller_8/taller/ejercicio_10_printf.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main(int argc, char *argv[]) { 7 | system("color 30"); 8 | int cantidad = 5; 9 | int vector_A[5], vector_B[5], vector_C[5]; 10 | 11 | int i = 0; 12 | printf("Ingrese los elementos del vector A: \n"); 13 | do { 14 | scanf("%d", &vector_A[i]); 15 | i++; 16 | } while(i < cantidad); 17 | 18 | i = 0; 19 | printf("\nIngrese los elementos del vector B: \n"); 20 | do { 21 | scanf("%d", &vector_B[i]); 22 | i++; 23 | } while(i < cantidad); 24 | 25 | i = 0; 26 | do { 27 | vector_C[i] = vector_A[i] * vector_A[cantidad-i-1]; 28 | printf(" - %d * %d = %d\n", vector_A[i], vector_B[cantidad-i-1], vector_C[i]); 29 | i++; 30 | } while(i < cantidad); 31 | 32 | return 0; 33 | } 34 | 35 | -------------------------------------------------------------------------------- /taller_programacion/taller_8/taller/ejercicio_1_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_8/taller/ejercicio_1_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_8/taller/ejercicio_1_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_8/taller/ejercicio_1_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_8/taller/ejercicio_2_cout.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main(int argc, char *argv[]) { 6 | system("color 30"); 7 | 8 | int cantidad = 5; 9 | int vector_A[5], vector_B[5], vector_C[5]; 10 | 11 | int i = 0; 12 | 13 | cout << "Ingrese los valores del vector A\n"; 14 | while (i < cantidad){ 15 | cin >> vector_A[i]; 16 | i++; 17 | } 18 | 19 | cout << "\nIngrese los valores del vector B\n"; 20 | i = 0; 21 | while (i < cantidad){ 22 | cin >> vector_B[i]; 23 | i++; 24 | } 25 | 26 | i = 0; 27 | cout << "\nLa suma de cada una de los elementos del vector A con el vector B es: \n"; 28 | while (i < cantidad){ 29 | vector_C[i] = vector_A[i] + vector_B[i]; 30 | cout << vector_A[i] << " + " << vector_B[i] << " = " << vector_C[i] << endl; 31 | i++; 32 | } 33 | 34 | i = 0; 35 | cout << "\nLos valores del vector C son: \n"; 36 | while (i < cantidad){ 37 | cout << vector_C[i] << endl; 38 | i++; 39 | } 40 | 41 | 42 | 43 | return 0; 44 | } 45 | 46 | -------------------------------------------------------------------------------- /taller_programacion/taller_8/taller/ejercicio_2_printf.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main(int argc, char *argv[]) { 7 | system("color 30"); 8 | 9 | int cantidad = 5; 10 | int vector_A[5], vector_B[5], vector_C[5]; 11 | 12 | int i = 0; 13 | 14 | printf("Ingrese los valores del vector A\n"); 15 | do { 16 | scanf("%d", &vector_A[i]); 17 | i++; 18 | } while (i < cantidad); 19 | 20 | printf("\nIngrese los valores del vector B\n"); 21 | i = 0; 22 | do { 23 | scanf("%d", &vector_B[i]); 24 | i++; 25 | } while (i < cantidad); 26 | 27 | i = 0; 28 | printf("\nLa suma de cada una de los elementos del vector A con el vector B es: \n"); 29 | do { 30 | vector_C[i] = vector_A[i] + vector_B[i]; 31 | printf("%d + %d = %d \n",vector_A[i], vector_B[i], vector_C[i]); 32 | i++; 33 | } while (i < cantidad); 34 | 35 | i = 0; 36 | printf("\nLos valores del vector C son: \n"); 37 | do { 38 | printf("%d\n", vector_C[i]); 39 | i++; 40 | } while (i < cantidad); 41 | 42 | return 0; 43 | } 44 | 45 | -------------------------------------------------------------------------------- /taller_programacion/taller_8/taller/ejercicio_3_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_8/taller/ejercicio_3_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_8/taller/ejercicio_3_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_8/taller/ejercicio_3_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_8/taller/ejercicio_4_cout.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main(int argc, char *argv[]) { 7 | system("color 30"); 8 | 9 | int cantidad = 10, resultado = 0; 10 | int vector_A[10]; 11 | int vector_B[10]; 12 | 13 | for (int i = 0; i < cantidad; i++){ 14 | vector_A[i] = i; 15 | resultado = pow(vector_A[i], 2); 16 | vector_B[i] = resultado; 17 | 18 | cout << "Vector A: " << vector_A[i] << " => Vector B: " << vector_B[i] << endl; 19 | } 20 | 21 | return 0; 22 | } 23 | 24 | -------------------------------------------------------------------------------- /taller_programacion/taller_8/taller/ejercicio_4_printf.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | int main(int argc, char *argv[]) { 8 | system("color 30"); 9 | 10 | int cantidad = 10, resultado = 0; 11 | int vector_A[10]; 12 | int vector_B[10]; 13 | 14 | for (int i = 0; i < cantidad; i++){ 15 | vector_A[i] = i; 16 | resultado = pow(vector_A[i], 2); 17 | vector_B[i] = resultado; 18 | 19 | printf("Vector A: %d => Vector B: %d \n", vector_A[i], vector_B[i]); 20 | } 21 | 22 | return 0; 23 | } 24 | 25 | -------------------------------------------------------------------------------- /taller_programacion/taller_8/taller/ejercicio_5_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_8/taller/ejercicio_5_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_8/taller/ejercicio_5_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_8/taller/ejercicio_5_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_8/taller/ejercicio_6_cout.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main(int argc, char *argv[]) { 6 | 7 | int cantidad = 5; 8 | int vector_A[5], vector_B[5]; 9 | 10 | cout << "Ingrese los elementos del vector: \n"; 11 | 12 | for (int i = 0; i < cantidad; i++){ 13 | cin >> vector_A[i]; 14 | vector_B[ (cantidad-i-1) ] = vector_A[i]; 15 | } 16 | 17 | cout << "\nElementos dle vector B\n"; 18 | for (int i = 0; i < cantidad; i++){ 19 | cout << vector_B[i] << endl; 20 | } 21 | 22 | return 0; 23 | } 24 | 25 | -------------------------------------------------------------------------------- /taller_programacion/taller_8/taller/ejercicio_6_printf.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main(int argc, char *argv[]) { 7 | 8 | int cantidad = 5; 9 | int vector_A[5], vector_B[5]; 10 | 11 | printf("Ingrese los elementos del vector: \n"); 12 | 13 | for (int i = 0; i < cantidad; i++){ 14 | scanf("%d", &vector_A[i]); 15 | vector_B[ (cantidad-i-1) ] = vector_A[i]; 16 | } 17 | 18 | printf("\nElementos dle vector B \n"); 19 | for (int i = 0; i < cantidad; i++){ 20 | printf("%d \n", vector_B[i]); 21 | } 22 | 23 | return 0; 24 | } 25 | -------------------------------------------------------------------------------- /taller_programacion/taller_8/taller/ejercicio_7_cout.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main(int argc, char *argv[]) { 6 | system("color 30"); 7 | 8 | int cantidad = 5; 9 | int vector_A[5], vector_B[5]; 10 | bool iguales = true; 11 | 12 | cout << "Ingrese los valores del vector A \n"; 13 | int i = 0; 14 | do { 15 | cin >> vector_A[i]; 16 | i++; 17 | } while (i < cantidad); 18 | 19 | cout << "\nIngrese los valores del vector B \n"; 20 | i = 0; 21 | do { 22 | cin >> vector_B[i]; 23 | i++; 24 | } while (i < cantidad); 25 | 26 | i = 0; 27 | do { 28 | if (vector_A[i] != vector_B[i]){ 29 | iguales = false; 30 | break; 31 | } 32 | i++; 33 | } while(i < cantidad); 34 | 35 | if (iguales){ 36 | cout << "\nLos dos vectores son IGUALES"; 37 | } else { 38 | cout << "\nLos dos vectores son DIFERENTES"; 39 | } 40 | 41 | return 0; 42 | } 43 | 44 | -------------------------------------------------------------------------------- /taller_programacion/taller_8/taller/ejercicio_7_printf.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int main(int argc, char *argv[]) { 7 | system("color 30"); 8 | 9 | int cantidad = 5; 10 | int vector_A[5], vector_B[5]; 11 | bool iguales = true; 12 | 13 | printf("Ingrese los valores del vector A \n"); 14 | int i = 0; 15 | do { 16 | scanf("%d", &vector_A[i]); 17 | i++; 18 | } while (i < cantidad); 19 | 20 | printf("\nIngrese los valores del vector B \n"); 21 | i = 0; 22 | do { 23 | scanf("%d", &vector_B[i]); 24 | i++; 25 | } while (i < cantidad); 26 | 27 | i = 0; 28 | do { 29 | if (vector_A[i] != vector_B[i]){ 30 | iguales = false; 31 | break; 32 | } 33 | i++; 34 | } while(i < cantidad); 35 | 36 | if (iguales){ 37 | printf("\nLos dos vectores son IGUALES"); 38 | } else { 39 | printf("\nLos dos vectores son DIFERENTES"); 40 | } 41 | 42 | return 0; 43 | } 44 | 45 | -------------------------------------------------------------------------------- /taller_programacion/taller_8/taller/ejercicio_8_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_8/taller/ejercicio_8_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_8/taller/ejercicio_8_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_8/taller/ejercicio_8_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_8/taller/ejercicio_9_cout.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_8/taller/ejercicio_9_cout.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_8/taller/ejercicio_9_printf.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_8/taller/ejercicio_9_printf.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_9/ejercicio_1.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_9/ejercicio_1.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_9/ejercicio_10.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_9/ejercicio_10.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_9/ejercicio_11.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_9/ejercicio_11.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_9/ejercicio_2.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_9/ejercicio_2.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_9/ejercicio_3.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_9/ejercicio_3.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_9/ejercicio_4.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | /** 7 | 4. Hacer un algoritmo de llene una matriz de `20*20`. 8 | Sumar las columnas e imprimir que columna tuvo la máxima suma y la suma de esa columna. 9 | */ 10 | 11 | int main(){ 12 | system("color 30"); 13 | 14 | int filas = 2, columnas = 2; 15 | int matriz[2][2]; 16 | int suma_columnas[2], col_posicion = 0, suma_mayor = 0; 17 | 18 | for (int i = 0; i < columnas; i++){ 19 | suma_columnas[i] = 0; 20 | } 21 | 22 | printf("Ingrese los valores a la matriz: \n\n"); 23 | for (int fila = 0; fila < filas; fila++){ 24 | for (int columna = 0; columna < columnas; columna++){ 25 | printf("Posición [%d][%d]: ", fila, columna); 26 | scanf("%d", &matriz[fila][columna]); 27 | suma_columnas[columna] += matriz[fila][columna]; 28 | } 29 | } 30 | 31 | for (int i = 0; i < columnas; i++){ 32 | if (i == 0) 33 | suma_mayor = suma_columnas[i]; 34 | 35 | if (suma_columnas[i] >= suma_mayor){ 36 | suma_mayor = suma_columnas[i]; 37 | col_posicion = i; 38 | } 39 | } 40 | 41 | printf("\nLa posición de la columna que tuvo la máxima suma es: [%d]", col_posicion); 42 | printf("\nLa suma de los valores es de: %d", suma_mayor); 43 | 44 | return 0; 45 | } 46 | -------------------------------------------------------------------------------- /taller_programacion/taller_9/ejercicio_5.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_9/ejercicio_5.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_9/ejercicio_6.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | /** 7 | 6. Hacer un algoritmo que llene una matriz de `10*10` y que almacene en la diagonal principal unos y en las demas posiciones ceros 8 | */ 9 | 10 | int main(){ 11 | system("color 30"); 12 | 13 | int filas = 10, columnas = 10; 14 | int matriz[10][10]; 15 | 16 | cout << "Ingrese los valores a la matriz: \n\n"; 17 | for (int fila = 0; fila < filas; fila++){ 18 | for (int columna = 0; columna < columnas; columna++){ 19 | if (fila == columna) 20 | matriz[fila][columna] = 1; 21 | else 22 | matriz[fila][columna] = 0; 23 | } 24 | } 25 | 26 | cout << "\nLa matriz resultante es de. \n[\n"; 27 | for (int fila = 0; fila < filas; fila++){ 28 | for (int columna = 0; columna < columnas; columna++){ 29 | cout << "\t" << matriz[fila][columna]; 30 | } 31 | cout << endl; 32 | } 33 | cout << "]"; 34 | 35 | return 0; 36 | } 37 | -------------------------------------------------------------------------------- /taller_programacion/taller_9/ejercicio_7.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_9/ejercicio_7.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_9/ejercicio_8.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_9/ejercicio_8.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_9/ejercicio_9.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jocode/curso-cpp/d592781fa8ccab0a83e9d05789ee066b9f1657ed/taller_programacion/taller_9/ejercicio_9.cpp -------------------------------------------------------------------------------- /taller_programacion/taller_9/readme.md: -------------------------------------------------------------------------------- 1 | # Taller de Matrices 2 | 3 | 1. Hacer un algoritmo que almacene numeros en una matriz de `5*6`. Imprimir la suma de los números almacenados en la matriz. 4 | [Ejercicio 1](ejercicio_1.cpp) 5 | 6 | 2. Hacer un algoritmo que llene una matriz de `10*10` y determine la posición [renglon, columna] del número mayor almacenado en la matriz. 7 | [Ejercicio 2](ejercicio_2.cpp) 8 | 9 | 3. Hacer un algoritmo que llene una matriz de `7*7`. Calcular la suma de cada renglón y almacenarla en un vector, la suma de cada columna y almacenarla en otro vector. 10 | [Ejercicio 3](ejercicio_3.cpp) 11 | 12 | 4. Hacer un algoritmo de llene una matriz de `20*20`. Sumar las columnas e imprimir que columna tuvo la máxima suma y la suma de esa columna. 13 | [Ejercicio 4](ejercicio_4.cpp) 14 | 15 | 5. Hacer un algoritmo que llene una matriz de `5*5` y hacer que almacene la diagonal principal en un vector. Imprimir el vector resultante. 16 | [Ejercicio 5](ejercicio_5.cpp) 17 | 18 | 6. Hacer un algoritmo que llene una matriz de `10*10` y que almacene en la diagonal principal unos y en las demas posiciones ceros. 19 | [Ejercicio 6](ejercicio_6.cpp) 20 | 21 | 7. Hacer un algoritmo que llene una matriz de `6*8` y que almacene toda la matriz en un vector. Imprimir el vector resultante. 22 | [Ejercicio 7](ejercicio_7.cpp) 23 | 24 | 8. Hacer un algoritmo que llene una matriz de `8*8` que almacene la suma de los renglones y la suma de las columnas en un vector. Imprimir el vector resultante. 25 | [Ejercicio 8](ejercicio_8.cpp) 26 | 27 | 9. Hacer un algoritmo que llene una matriz de `5*6` y que imprima cuántos de los números son ceros, cuántos son positivos y cuantos son negativos. 28 | [Ejercicio 9](ejercicio_9.cpp) 29 | 30 | 10. Diseñe un algoritmo que escriba el número de la hilera cuya suma sea mayor que las demás hileras. Suponga que todas las hileras suman diferente cantidad. 31 | [Ejercicio 10](ejercicio_10.cpp) 32 | 33 | 11. El dueño de una tienda de artículos deportivos desea controlar sus ventas por medio de una computadora. Los datos de entrada son: 34 | - a) El Número de la tienda (1 a 50) 35 | - b) Un número que indica el deporte del artículo (1 a 20) 36 | - c) El costo del artículo 37 | 38 | Hacer un algoritmo que escriba al final del día lo siguiente 39 | - 1. Las ventas totales en el día para cada tienda 40 | - 2. Las ventas totales para cada uno de los deportes 41 | - 3. Las ventas totales de todas las tiendas. 42 | 43 | [Ejercicio 11](ejercicio_11.cpp) -------------------------------------------------------------------------------- /while.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main(){ 5 | 6 | cout << "Ciclo while " << endl; 7 | int i = 0; 8 | while (i <= 5) { 9 | cout << "Valor de i: " << i << endl; 10 | // Aumentamos el valor de la variable 11 | i++; 12 | } 13 | 14 | cout << "\nCiclo Do while " << endl; 15 | int a = 10; 16 | do { 17 | cout << "Valor de a: " << a << endl; 18 | // Aumentamos el valor de la variable 19 | a++; 20 | } while (a <= 5); 21 | 22 | cin.get(); 23 | return 0; 24 | } 25 | --------------------------------------------------------------------------------