From a159662c5ff71c1ba9894ce58ed0e8897ff0019c Mon Sep 17 00:00:00 2001 From: Gabriel Czernikier Date: Mon, 21 Aug 2023 20:31:19 -0300 Subject: [PATCH 01/12] Renombrar ahorcado.md --- ejercicios/pildoras/{ahorcado.psc => ahorcado.md} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename ejercicios/pildoras/{ahorcado.psc => ahorcado.md} (100%) diff --git a/ejercicios/pildoras/ahorcado.psc b/ejercicios/pildoras/ahorcado.md similarity index 100% rename from ejercicios/pildoras/ahorcado.psc rename to ejercicios/pildoras/ahorcado.md From 912efcded9c795132470f66333cca3442e248424 Mon Sep 17 00:00:00 2001 From: Gabriel Czernikier Date: Mon, 21 Aug 2023 20:41:29 -0300 Subject: [PATCH 02/12] ahorcado.md: reemplaza contenido por referencia a otro archivo --- ejercicios/pildoras/ahorcado.md | 237 +------------------------------- 1 file changed, 1 insertion(+), 236 deletions(-) diff --git a/ejercicios/pildoras/ahorcado.md b/ejercicios/pildoras/ahorcado.md index fd0e411..d3d157a 100644 --- a/ejercicios/pildoras/ahorcado.md +++ b/ejercicios/pildoras/ahorcado.md @@ -1,236 +1 @@ -//################################################################################ -//Procedimiento LeerSecreto: Inicializamos la palabra secreta (no más de 20 -//caracteres) y el vector de aciertos a Falso. -//Parámetro de entrada y salida: Palabra que hay que adivinar, y aciertos: vector -//de valores lógicos que se inicializan a falso indicando que no se han acertado -//ninguna letra. -//################################################################################ - -Funcion LeerSecreto(secreto Por Referencia,aciertos Por Referencia) - definir i como Entero; - Repetir - Escribir "Introduce la palabra a a adivinar:"; - Leer secreto; - Si Longitud(secreto)>20 Entonces - Escribir "No puede tener más de 20 caracteres"; - FinSi - Hasta Que Longitud(secreto)<=20; - Para i<-0 hasta 19 Hacer - aciertos[i]<-Falso; - FinPara - Borrar Pantalla; -FinFuncion - -//################################################################################ -//Función NumeroAciertos: Recibe el vector de aciertos y devuelve cuantas letras -//se han acertado (valores Verdadero). -//Parámetro de entrada: aciertos: vector de valores lógicos que indica las letras -//que se han acertado. -//Dato devuelto: Número de letras acertadas -//################################################################################ - -Funcion num <- NumeroAciertos(aciertos) - Definir num,i Como Entero; - num<-0; - Para i<-0 hasta 19 Hacer - Si aciertos[i] Entonces - num<-num+1; - FinSi - FinPara -FinFuncion - -//################################################################################ -//Procedimiento EscribirSecreto: Recibe la palabra secreta (no más de 20 -//y el vector de aciertos. Y muestra por pantalla un carácter o un * según la -//posición del carácter indique en el vector aciertos que se ha acertado la letra -//(valor Verdadero) -//Parámetro de entrada: Palabra que hay que adivinar, y aciertos: vector de valores -//lógicos que indica las letras que se han acertado. -//################################################################################ - -Funcion EscribirSecreto(secreto,aciertos) - Definir i como Entero; - //Recorro la cadena de caracteres - Para i<-0 hasta Longitud(secreto)-1 Hacer - //Si la posición del vector aciertos igual a la posición de un carácter - // es verdadero imprimo el carácter - Si aciertos[i] Entonces - Escribir sin saltar Subcadena(secreto,i,i); - SiNo //Sino imprimo un * - Escribir sin saltar "*"; - FinSi - FinPara - Escribir ""; -FinFuncion - -//################################################################################ -//Función ComprobarSecreto: Recibe un carácter, la cadena a adivinar y el vector -//de aciertos y devuelve si el carácter está en la cadena. Además si es así cambia -//en el vector aciertos las posiciones donde se encuentra el carácter de Falso a -//Verdadero. -//Parámetro de entrada: un carácter, la cadena y el vector de aciertos -//Dato devuelto: Valor lógico, Verdadero si el carácter está en la cadena, -//Falso en caso contrario. -//################################################################################ - -Funcion acierto <- ComprobarSecreto(letra,secreto,aciertos por Referencia) - Definir i como Entero; - Definir acierto como Logico; - acierto<-Falso; - Para i<-0 hasta Longitud(secreto)-1 Hacer - Si Subcadena(secreto,i,i)=letra Entonces - aciertos[i]<-Verdadero; - acierto<-Verdadero; - FinSi - FinPara - Escribir ""; -FinFuncion - -//################################################################################ -//Procedimiento LeerLetra: Lee un carácter por teclado y lo devuelve. Además -//devuelve un cadena con las letras que se han leído anteriormente. -//Parámetro de entrada y salida: la letra leída por teclado, y la cadena con todas -//las letras leídas anteriormente. -//################################################################################ - -Funcion LeerLetra(letra Por Referencia,letras Por Referencia) - Repetir - Escribir Sin Saltar "Introduce una letra:"; - Leer letra; - Si Longitud(letra)<>1 Entonces - Escribir "Una sola letra!!!"; - FinSi - Hasta Que Longitud(letra)=1; - letras<-Concatenar(letras,Concatenar(letra," ")); -FinFuncion - -//################################################################################ -//Procedimiento MostarAhorcado: Recibe el número de fallos, y según el valor muestra -//el nivel de "ahorcamiento" que lleva el jugador. -//Parámetro de entrada: Número de fallos -//################################################################################ - -Funcion MostrarAhorcado(fallos) - Escribir ""; - Escribir "La horca!!!"; - Escribir ""; - Segun fallos Hacer - 0: - Escribir ""; - Escribir ""; - Escribir ""; - Escribir ""; - Escribir ""; - Escribir ""; - 1: - Escribir ""; - Escribir ""; - Escribir ""; - Escribir ""; - Escribir ""; - Escribir "_________"; - 2: - Escribir "|"; - Escribir "|"; - Escribir "|"; - Escribir "|"; - Escribir "|"; - Escribir "_________"; - 3: - Escribir "------"; - Escribir "|"; - Escribir "|"; - Escribir "|"; - Escribir "|"; - Escribir "_________"; - 4: - Escribir "------"; - Escribir "| |"; - Escribir "| o"; - Escribir "| "; - Escribir "| "; - Escribir "_________"; - 5: - Escribir "------"; - Escribir "| |"; - Escribir "| o"; - Escribir "| /|"; - Escribir "|"; - Escribir "_________"; - - 6: - Escribir "------"; - Escribir "| |"; - Escribir "| o"; - Escribir "| /|\"; - Escribir "|"; - Escribir "_________"; - 7: - Escribir "------"; - Escribir "| |"; - Escribir "| o"; - Escribir "| /|\"; - Escribir "| / "; - Escribir "_________"; - 8: - Escribir "------"; - Escribir "| |"; - Escribir "| o"; - Escribir "| /|\"; - Escribir "| / \"; - Escribir "_________"; - FinSegun - Escribir ""; -FinFuncion - -//################################################################################ -//Escribe un programa para jugar al ahorcado. -//################################################################################ - -Proceso Ahorcado - Definir secreto,letras,letra como Caracter; - Definir aciertos como Logico; - Definir num_fallos como Entero; - Dimension aciertos[20]; - //Letras: cadena donde se van a ir guardando las letras introducidas - letras<-""; - num_fallos<-0; - //Se introduce por teclado la palabra secreta a adivinar - LeerSecreto(secreto,aciertos); - //Se repite hasta que el número de aciertos sea igual a la longitud de la palabra o el número de fallos sea 6 - Repetir - - Borrar Pantalla; - //Se escribe la palabra (* las letras no acertadas) - EscribirSecreto(secreto,aciertos); - - //Se muestra el dibujo del ahorcado, se haya acertado o no. - MostrarAhorcado(num_fallos); - - //Se muestran las letras que se han introducido anteriormente - Escribir "Letras introducidas: ",letras; - - //Se lee una letra y se actualiza las letras leídas - LeerLetra(letra,letras); - //Si no hemos acertado la letra mostramos mensaje de error e incrementamos número de fallos. - Si no ComprobarSecreto(letra,secreto,aciertos) Entonces - num_fallos<-num_fallos+1; - FinSi - - - - Hasta Que NumeroAciertos(aciertos)=Longitud(secreto) o num_fallos=8; - //Podemos salir del bucle por dos razones - //Si el número de fallos es 6 hemos perdido - - - Si num_fallos=8 Entonces - Borrar Pantalla; - EscribirSecreto(secreto,aciertos); - MostrarAhorcado(num_fallos); - Escribir "Has perdido!!!"; - SiNo //Hemos ganado!!!! - Escribir "Has ganado!!!"; - FinSi -FinProceso - +[Juego del ahorcado](../mas_ejercicios/ejercicio10.psc) \ No newline at end of file From dea4fefaddeb67f22aec062a730b6f82bc1b4ef4 Mon Sep 17 00:00:00 2001 From: Gabriel Czernikier Date: Mon, 21 Aug 2023 21:31:20 -0300 Subject: [PATCH 03/12] Modifica comentarios en el programa --- ejercicios/mas_ejercicios/ejercicio3.psc | 80 ++++++++++++------------ 1 file changed, 41 insertions(+), 39 deletions(-) diff --git a/ejercicios/mas_ejercicios/ejercicio3.psc b/ejercicios/mas_ejercicios/ejercicio3.psc index 95143fa..d34a4c8 100644 --- a/ejercicios/mas_ejercicios/ejercicio3.psc +++ b/ejercicios/mas_ejercicios/ejercicio3.psc @@ -1,68 +1,70 @@ //################################################################################ -//Función CalcularVuelta: Recibe el dinero que hay que devolver y el valor de un -//billete o una moneda, devuelve el número de billetes o monedas de esa cantidad -//que hay que devolver y actualiza el dinero que queda por devolver. -//Parámetros de entrada: cantidad: valor del billete o la moneda +//Función CalcularVuelta: Recibe el dinero que hay que devolver y el valor nominal +// de un billete o una moneda con la que se quiere devolver dicho dinero. +//Devuelve el número máximo de billetes o monedas de ese +//valor nominal que no se pase del dinero recibido y actualiza el dinero que +//quedará pendiente por devolver después de la devolución actual. +//Parámetros de entrada: valor_nominal: valor del billete o la moneda //Parámetros de entrada y salida : dinero que hay que devolver, se devuelve con el //dinero que queda por devolver. //Dato devuelto: vuelta: Número de billetes o monedas que hay que devolver. //################################################################################ -Funcion vuelta <- CalcularVuelta(dinero Por Referencia,cantidad) +Funcion vuelta <- CalcularVuelta(dinero Por Referencia,valor_nominal) Definir vuelta como Entero; //Realizamos la división entera entre el dinero - //que hay que devolver y la cantidad del billete o moneda - vuelta<-Trunc(dinero/cantidad); + //que hay que devolver y el valor_nominal del billete o moneda + vuelta<-Trunc(dinero/valor_nominal); //Actualizamos el dinero que queda por devolver - dinero<-dinero - vuelta*cantidad; + dinero<-dinero - vuelta*valor_nominal; FinFuncion //################################################################################ -//Procedimiento InicializaBilletesMonedas: Recibe un vector "cantidades" donde +//Procedimiento InicializaBilletesMonedas: Recibe un vector "valores_nominales" donde //vamos a guardar el valor de los billetes y monedas de mayor a menor. -//Parámetros de entrada y salida : cantidades +//Parámetros de entrada y salida : valores_nominales //################################################################################ -Funcion InicializaBilletesMonedas(cantidades Por Referencia) - cantidades[0]<-500; - cantidades[1]<-200; - cantidades[2]<-100; - cantidades[3]<-50; - cantidades[4]<-20; - cantidades[5]<-10; - cantidades[6]<-5; - cantidades[7]<-2; - cantidades[8]<-1; - cantidades[9]<-0.50; - cantidades[10]<-0.20; - cantidades[11]<-0.10; - cantidades[12]<-0.05; - cantidades[13]<-0.02; - cantidades[14]<-0.01; +Funcion InicializaBilletesMonedas(valores_nominales Por Referencia) + valores_nominales[0]<-500; + valores_nominales[1]<-200; + valores_nominales[2]<-100; + valores_nominales[3]<-50; + valores_nominales[4]<-20; + valores_nominales[5]<-10; + valores_nominales[6]<-5; + valores_nominales[7]<-2; + valores_nominales[8]<-1; + valores_nominales[9]<-0.50; + valores_nominales[10]<-0.20; + valores_nominales[11]<-0.10; + valores_nominales[12]<-0.05; + valores_nominales[13]<-0.02; + valores_nominales[14]<-0.01; FinFuncion //################################################################################ -//Procedimiento EscribirVuelta: Recibe la cantidad de billetes o monedas y su valor +//Procedimiento EscribirVuelta: Recibe el número de billetes o monedas y su valor //y los imprime por pantalla. Se imprime si hay que devolver de ese billete o moneda -//es decir, si la vuelta>0. Si la cantidad>2 se devuelven billetes (euros), -//sino se devuelven monedas y si la cantidad es >=1 se devuelven euros, sino céntimos. -//Parámetros de entrada: vuelta: cantidad de billetes o monedas a devolver y -//cantidad: valor del billete o moneda +//es decir, si la vuelta>0. Si el valor nominal>2 se devuelven billetes (euros), +//sino se devuelven monedas y si el valor nominal es >=1 se devuelven euros, sino céntimos. +//Parámetros de entrada: vuelta: número de billetes o monedas a devolver y +//valor_nominal: valor del billete o moneda //################################################################################ -Funcion EscribirVuelta(vuelta,cantidad) +Funcion EscribirVuelta(vuelta,valor_nominal) //Se imprime si hay algo que devolver Si vuelta>0 Entonces - //Si la cantidad es menor de 2 devolvemos billetes - Si cantidad>2 Entonces - Escribir vuelta, " billetes de ",cantidad," euros."; + //Si el valor nominal es menor de 2 devolvemos billetes + Si valor_nominal>2 Entonces + Escribir vuelta, " billetes de ",valor_nominal," euros."; SiNo //SiNo devolvemos monedas - //Si la cantidad>=1 devolvemos euros - Si cantidad>=1 Entonces - Escribir vuelta, " monedas de ",cantidad," euros."; + //Si el valor nominal>=1 devolvemos euros + Si valor_nominal>=1 Entonces + Escribir vuelta, " monedas de ",valor_nominal," euros."; SiNo //Devolvemos céntimos (lo multiplicamos por 100) - Escribir vuelta, " monedas de ",cantidad*100," céntimos."; + Escribir vuelta, " monedas de ",valor_nominal*100," céntimos."; FinSi FinSi FinSi From 90d2bcb645f413713a9906cf220e3df025e7b3a1 Mon Sep 17 00:00:00 2001 From: Gabriel Czernikier Date: Mon, 21 Aug 2023 21:35:13 -0300 Subject: [PATCH 04/12] =?UTF-8?q?Corrige=20errores=20de=20l=C3=B3gica?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ejercicios/mas_ejercicios/ejercicio3.psc | 32 ++++++++++++------------ 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/ejercicios/mas_ejercicios/ejercicio3.psc b/ejercicios/mas_ejercicios/ejercicio3.psc index d34a4c8..840e252 100644 --- a/ejercicios/mas_ejercicios/ejercicio3.psc +++ b/ejercicios/mas_ejercicios/ejercicio3.psc @@ -26,21 +26,21 @@ FinFuncion //################################################################################ Funcion InicializaBilletesMonedas(valores_nominales Por Referencia) - valores_nominales[0]<-500; - valores_nominales[1]<-200; - valores_nominales[2]<-100; - valores_nominales[3]<-50; - valores_nominales[4]<-20; - valores_nominales[5]<-10; - valores_nominales[6]<-5; - valores_nominales[7]<-2; - valores_nominales[8]<-1; - valores_nominales[9]<-0.50; - valores_nominales[10]<-0.20; - valores_nominales[11]<-0.10; - valores_nominales[12]<-0.05; - valores_nominales[13]<-0.02; - valores_nominales[14]<-0.01; + valores_nominales[1]<-500; + valores_nominales[2]<-200; + valores_nominales[3]<-100; + valores_nominales[4]<-50; + valores_nominales[5]<-20; + valores_nominales[6]<-10; + valores_nominales[7]<-5; + valores_nominales[8]<-2; + valores_nominales[9]<-1; + valores_nominales[10]<-0.50; + valores_nominales[11]<-0.20; + valores_nominales[12]<-0.10; + valores_nominales[13]<-0.05; + valores_nominales[14]<-0.02; + valores_nominales[15]<-0.01; FinFuncion //################################################################################ @@ -90,7 +90,7 @@ Proceso Devolucion //Incializamos las cantidades de billetes o monedas InicializaBilletesMonedas(cantidades); //Por cada cantidad, calculamos la vuelta e imprimimos lo que hay que devolver - Para indice<-0 hasta 14 Hacer + Para indice<-1 hasta 15 Hacer vuelta<- CalcularVuelta(dinero,cantidades[indice]); EscribirVuelta(vuelta,cantidades[indice]); FinPara From ee073d2c19eb6e46bf7f0e9499514b0ac1aeda05 Mon Sep 17 00:00:00 2001 From: Gabriel Czernikier Date: Fri, 25 Aug 2023 08:55:20 -0300 Subject: [PATCH 05/12] Renombrar archivo ejercicios/pildoras/mastermind.md --- ejercicios/pildoras/{mastermind.psc => mastermind.md} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename ejercicios/pildoras/{mastermind.psc => mastermind.md} (100%) diff --git a/ejercicios/pildoras/mastermind.psc b/ejercicios/pildoras/mastermind.md similarity index 100% rename from ejercicios/pildoras/mastermind.psc rename to ejercicios/pildoras/mastermind.md From 00d1dd03a86f451482d1660f0f6d3dc76b361c33 Mon Sep 17 00:00:00 2001 From: Gabriel Czernikier Date: Fri, 25 Aug 2023 08:57:36 -0300 Subject: [PATCH 06/12] mastermind.md: reemplaza contenido por referencia a otro archivo --- ejercicios/pildoras/mastermind.md | 145 +----------------------------- 1 file changed, 1 insertion(+), 144 deletions(-) diff --git a/ejercicios/pildoras/mastermind.md b/ejercicios/pildoras/mastermind.md index 3dcef81..1ec64ad 100644 --- a/ejercicios/pildoras/mastermind.md +++ b/ejercicios/pildoras/mastermind.md @@ -1,144 +1 @@ -//################################################################################ -//Función EstaRepetido: Recibe un número y un vector de cuatro números y comprueba -// si el número no está en el vector. -//Parámetro de entrada: Número y vector -//Dato devuelto: Valor lógico: Verdadero si el número está en el vector y falso si no. -//################################################################################ - -Funcion repetido <- EstaRepetido(num,vector) - Definir repetido Como Logico; - Definir indice Como Entero; - repetido<-Falso; - Para indice<-0 hasta 3 Hacer - Si num=vector[indice] Entonces - repetido<-Verdadero; - FinSi - FinPara -FinFuncion - -//################################################################################ -//Procedimiento GenerarSecuencia: Recibe un vector que se inicializa con 4 enteros -//no repetidos -//Parámetro de entrada y salida: Vector de 4 enteros -//################################################################################ - -Funcion GenerarSecuencia(vector Por Referencia) - Definir indice Como Entero; - Definir num Como Entero; - //Se incializa el vector para que se pueda comprobar si tiene algún número repetido - Para indice<-0 hasta 3 Hacer - vector[indice] <- -1; - FinPara - //Se inicializa cada elemento con un número - Para indice<-0 hasta 3 Hacer - //Se comprueba que no tenga número repetidos - Repetir - num<-Aleatorio(0,9); - Hasta Que no EstaRepetido(num,vector); - vector[indice]<-num; - FinPara -FinFuncion - -//################################################################################ -//Procedimiento LeerSecuencia: Recibe un vector que se inicializa con 4 enteros -//leídos por teclado por el usuario, asegurando de que no se introduce ninguno -//repetido. -//Parámetro de entrada y salida: Vector de 4 enteros -//################################################################################ - -Funcion LeerSecuencia(vector por Referencia) - Definir i,num Como Entero; - Definir repetido como Logico; - //Se inicializa el vector para que se pueda comprobar si tiene algún número repetido - Para i<-0 hasta 3 Hacer - vector[i] <- -1; - FinPara - //Se inicializa cada elemento con un número leído por teclado - Para i<-0 Hasta 3 Hacer - Repetir //Se comprueba que el número leído no se haya repetido - Escribir sin Saltar "Número ",i+1,":"; - Leer num; - repetido<-EstaRepetido(num,vector); - Si repetido Entonces - Escribir "No debes indicar números repetidos."; - FinSi - Hasta Que no repetido; - vector[i]<-num; - FinPara -FinFuncion - -//################################################################################ -//Procedimiento ComprobarSecuencia: Recibe dos vectores, el secreto y el introducido -//por el usuario y devuelve el número de coincidencias en la misma posición (muertos) -// y las coincidencias en distintas posición (heridos). -//Parámetros de entrada: Dos vectores -//Parámetro de entrada y salida: muertos y heridos -//################################################################################ - -Funcion ComprobarSecuencia(secreto,usuario,m Por Referencia,h Por Referencia) - Definir indice_secreto,indice_usuario como Entero; - //recorro los dos vectores - Para indice_secreto<-0 Hasta 3 Hacer - Para indice_usuario<-0 Hasta 3 Hacer - Si secreto[indice_secreto]=usuario[indice_usuario] Entonces - //Si el elemento coincide y además están en la misma posición, incremento los muertos. - Si indice_secreto=indice_usuario Entonces - m<-m+1; - SiNo - //Si el elemento coincide pero no están en la misma posición, incremento los heridos. - h<-h+1; - FinSi - FinSi - FinPara - FinPara -FinFuncion - -//################################################################################ -//Vamos a programar el juego "Mastermind", para ello el programa debe "eligir" un -//número de cuatro cifras (sin cifras repetidas), que será el código que el jugador -//debe adivinar en la menor cantidad de intentos posibles. Cada intento consiste en -//una propuesta de un código posible que escribe el jugador, y una respuesta del -//programa. Las respuestas le darán pistas al jugador para que pueda deducir el código. -// * Número de "MUERTOS": Es la cantidad de dígitos que están en el número secreto -//y en la misma posición, -// * Número de "HERIDOS:" Es la cantidad de dígitos que están en el número secreto -//pero no en la misma posición. -//################################################################################ - -Proceso MisterMind - Definir indice,intentos Como Entero; - Definir numero Como Caracter; - Definir resultados Como Caracter; - Dimension resultados[100]; - Definir secreto,usuario como Entero; - Definir muertos,heridos como Entero; - Dimension secreto[4]; - Dimension usuario[4]; - - //Se genera el número secreto a adivinar - GenerarSecuencia(secreto); - //Se repeti hasta que se acierte, número de muertos = 4 - intentos<-0; - Repetir - //Leemos la secuencia propuesta por el usuario - LeerSecuencia(usuario); - muertos<-0; - heridos<-0; - //Se comprueba la propuesta - ComprobarSecuencia(secreto,usuario,muertos,heridos); - //Voy a guardar el numero, con el resultado - numero<-""; - Para indice<-0 hasta 3 Hacer - numero<-concatenar(numero,convertiratexto(usuario[indice])); - FinPara - //Y se imprimen los muertos y heridos - resultados[intentos]<- Concatenar(numero,concatenar(" - MUERTOS: ",concatenar(convertiratexto(muertos),concatenar(" - HERIDOS: ",convertiratexto(heridos))))); - //Muestro los resiltados - Borrar Pantalla; - Para indice<-intentos Hasta 0 con paso -1 Hacer - Escribir resultados[indice]; - FinPara - intentos<-intentos+1; - - Hasta Que muertos=4; -FinProceso +[Juego Mastermind](../mas_ejercicios/ejercicio9.psc) \ No newline at end of file From 012dd497608e8945417e8e15353ab2f6382e39a5 Mon Sep 17 00:00:00 2001 From: Gabriel Czernikier Date: Fri, 25 Aug 2023 10:00:48 -0300 Subject: [PATCH 07/12] ejercicios/arreglos/ejercicio4.psc: borrar variable num --- ejercicios/arreglos/ejercicio4.psc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ejercicios/arreglos/ejercicio4.psc b/ejercicios/arreglos/ejercicio4.psc index 99ea5b8..d78cf44 100644 --- a/ejercicios/arreglos/ejercicio4.psc +++ b/ejercicios/arreglos/ejercicio4.psc @@ -13,13 +13,13 @@ // Datos de entrada: Leo número positivos y los guardo en el vector, hasta que lea //un número negativo o lea todos los elementos del vector. // Información de salida:Los elementos (números positivos) guardados en el vector. -// Variables: vector (vector de 10 enteros), tam_vector,indice,num (Entero) +// Variables: vector (vector de 10 enteros), tam_vector,indice (Entero) //################################################################################ Proceso VectorPositivo Definir vector Como Entero; Dimension vector[10]; - Definir tam_vector,indice,num como Entero; + Definir tam_vector,indice como Entero; indice<-0; tam_vector<-10; //Recorro el vector y voy inicializando sus elementos From fec47cc52331ee2a5ce6383527e289fa6cc84ad0 Mon Sep 17 00:00:00 2001 From: Gabriel Czernikier Date: Fri, 25 Aug 2023 10:03:08 -0300 Subject: [PATCH 08/12] =?UTF-8?q?ejercicios/arreglos/ejercicio7.psc:=20cor?= =?UTF-8?q?recci=C3=B3n=20menor?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ejercicios/arreglos/ejercicio7.psc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ejercicios/arreglos/ejercicio7.psc b/ejercicios/arreglos/ejercicio7.psc index 70c0ada..f66338e 100644 --- a/ejercicios/arreglos/ejercicio7.psc +++ b/ejercicios/arreglos/ejercicio7.psc @@ -9,7 +9,7 @@ // Datos de entrada: Números para el primer vector, números para el segundo vector // Información de salida: Los números del tercer vector, que es la suma de //los anteriores -// Variables: vector1,vector2,vector3 (vector de 12 enteros), +// Variables: vector1,vector2,vector3 (vector de 5 enteros), // indice, tam_vector (entero) //################################################################################ From ea20226f440a9abf93cf5727c1313bffc3b5d0fd Mon Sep 17 00:00:00 2001 From: Gabriel Czernikier Date: Tue, 29 Aug 2023 21:59:07 -0300 Subject: [PATCH 09/12] ejercicio11.psc: borrado de variable suma --- ejercicios/arreglos/ejercicio11.psc | 1 - 1 file changed, 1 deletion(-) diff --git a/ejercicios/arreglos/ejercicio11.psc b/ejercicios/arreglos/ejercicio11.psc index 93feeeb..9869040 100644 --- a/ejercicios/arreglos/ejercicio11.psc +++ b/ejercicios/arreglos/ejercicio11.psc @@ -20,7 +20,6 @@ Proceso Diagonal Dimension matriz[5,5]; Definir fila,col como Entero; Definir num_filas, num_cols Como Entero; - Definir suma como Entero; num_filas<-5; num_cols<-5; //Recorro la tabla From f9b7731e40f437ea6bf52db6d6065a066a887cbe Mon Sep 17 00:00:00 2001 From: Gabriel Czernikier Date: Fri, 1 Sep 2023 11:33:35 -0300 Subject: [PATCH 10/12] =?UTF-8?q?ejercicio14.psc:=20correcci=C3=B3n=20de?= =?UTF-8?q?=20la=20dimensi=C3=B3n=20del=20arreglo?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ejercicios/arreglos/ejercicio14.psc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ejercicios/arreglos/ejercicio14.psc b/ejercicios/arreglos/ejercicio14.psc index 298b026..4aeb863 100644 --- a/ejercicios/arreglos/ejercicio14.psc +++ b/ejercicios/arreglos/ejercicio14.psc @@ -20,7 +20,7 @@ // Datos de entrada: Precio de 5 artículos y la cantidad vendida de cada artículo en 4 //sucursales // Información de salida: Las que indica el enunciado -// Variables: Precio (tabla de 5 reales), Cantidad (tabla de 4 x 3 reales) +// Variables: Precio (tabla de 5 reales), Cantidad (tabla de 4 x 5 reales) // Suma,NumMayor,Ariculos_Sucursal2,MayorRec,TotalSucursal,TotalEmpresa // (Real) //################################################################################ From bd862825f486b4c91ae596d669ec4c62cff10e89 Mon Sep 17 00:00:00 2001 From: Gabriel Czernikier Date: Fri, 1 Sep 2023 11:49:40 -0300 Subject: [PATCH 11/12] arreglos/ejercicio15.psc: renombramiento equipos x partidos, num_equipos x num_partidos --- ejercicios/arreglos/ejercicio15.psc | 34 ++++++++++++++--------------- 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/ejercicios/arreglos/ejercicio15.psc b/ejercicios/arreglos/ejercicio15.psc index 7a04c10..1c3846e 100644 --- a/ejercicios/arreglos/ejercicio15.psc +++ b/ejercicios/arreglos/ejercicio15.psc @@ -7,37 +7,37 @@ //dos columnas, en la primera se guarda el número de goles del equipo que está //guardado en la primera columna de la tabla anterior, y en la segunda los goles //del otro equipo. -//El programa ira pidiendo los nombres de los equipos de cada partido y el +//El programa irá pidiendo los nombres de los equipos de cada partido y el //resultado del partido, a continuación se imprimirá la quiniela de esa jornada. //################################################################################ //Análisis -//Recorro las tablas para incializar el nombre de los dos quipos y el resultado del partido +//Recorro las tablas para inicializar el nombre de los dos quipos y el resultado del partido //Recorro las tablas, muestro el nombre de los equipos // Un 1 si el que juega en casa ha ganado (primer equipo gana) // Un 2 si el que juega de visitante ha ganado (segundo equipo gana) // Una X si hay empate // Datos de entrada: Nombre de los dos quipos y el resultado del partido (para cada partido) // Información de salida: Los nombres de los equipos y el resultado de la quiniela -// Variables: equipos (tabla de 15 x 2 cadenas), resultados (tabla de 15 x 2 enteros) -// indice,num_equpos (entero) +// Variables: partidos (tabla de 15 x 2 cadenas), resultados (tabla de 15 x 2 enteros) +// indice,num_partidos (entero) //################################################################################ Proceso Quiniela - Definir indice,num_equipos Como Entero; - Definir equipos Como Caracter; - Dimension equipos[15,2]; + Definir indice,num_partidos Como Entero; + Definir partidos Como Caracter; + Dimension partidos[15,2]; Definir resultados Como Entero; Dimension resultados[15,2]; - num_equipos<-15; + num_partidos<-15; //Recorro las tablas para incializar el nombre de los dos quipos y el resultado del partido - Para indice<-0 hasta num_equipos-1 Hacer + Para indice<-0 hasta num_partidos-1 Hacer Escribir Sin Saltar "Introduce el nombre del equipo 1 del partido ", indice+1,":"; - Leer equipos[indice,0]; + Leer partidos[indice,0]; Escribir Sin Saltar "Introduce el nombre del equipo 2 del partido ", indice+1,":"; - Leer equipos[indice,1]; - Escribir Sin Saltar "Introduce los goles metidos por el equipo ",equipos[indice,0],": "; + Leer partidos[indice,1]; + Escribir Sin Saltar "Introduce los goles metidos por el equipo ",partidos[indice,0],": "; Leer resultados[indice,0]; - Escribir Sin Saltar "Introduce los goles metidos por el equipo ",equipos[indice,1],": "; + Escribir Sin Saltar "Introduce los goles metidos por el equipo ",partidos[indice,1],": "; Leer resultados[indice,1]; FinPara Escribir "QUINIELA"; @@ -47,14 +47,14 @@ Proceso Quiniela // Un 1 si el que juega en casa ha ganado (primer equipo gana) // Un 2 si el que juega de visitante ha ganado (segundo equipo gana) // Una X si hay empate - Para indice<-0 hasta num_equipos-1 Hacer + Para indice<-0 hasta num_partidos-1 Hacer Si resultados[indice,0]>resultados[indice,1] Entonces - Escribir equipos[indice,0], " - ",equipos[indice,0]," -> 1"; + Escribir partidos[indice,0], " - ",partidos[indice,0]," -> 1"; SiNo Si resultados[indice,0] 2"; + Escribir partidos[indice,0], " - ",partidos[indice,0]," -> 2"; SiNo - Escribir equipos[indice,0], " - ",equipos[indice,0]," -> X"; + Escribir partidos[indice,0], " - ",partidos[indice,0]," -> X"; FinSi FinSi FinPara From de68f038e600f2e17fdbebcb8d3eb35fb064227c Mon Sep 17 00:00:00 2001 From: Gabriel Czernikier Date: Fri, 1 Sep 2023 11:56:46 -0300 Subject: [PATCH 12/12] =?UTF-8?q?arreglos/ejercicio15.psc:=20correcci?= =?UTF-8?q?=C3=B3n=20de=20=C3=ADndice=20de=20arreglo?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ejercicios/arreglos/ejercicio15.psc | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/ejercicios/arreglos/ejercicio15.psc b/ejercicios/arreglos/ejercicio15.psc index 1c3846e..10669db 100644 --- a/ejercicios/arreglos/ejercicio15.psc +++ b/ejercicios/arreglos/ejercicio15.psc @@ -30,15 +30,15 @@ Proceso Quiniela Dimension resultados[15,2]; num_partidos<-15; //Recorro las tablas para incializar el nombre de los dos quipos y el resultado del partido - Para indice<-0 hasta num_partidos-1 Hacer - Escribir Sin Saltar "Introduce el nombre del equipo 1 del partido ", indice+1,":"; - Leer partidos[indice,0]; - Escribir Sin Saltar "Introduce el nombre del equipo 2 del partido ", indice+1,":"; + Para indice<-1 hasta num_partidos Hacer + Escribir Sin Saltar "Introduce el nombre del equipo 1 del partido ", indice,":"; Leer partidos[indice,1]; - Escribir Sin Saltar "Introduce los goles metidos por el equipo ",partidos[indice,0],": "; - Leer resultados[indice,0]; + Escribir Sin Saltar "Introduce el nombre del equipo 2 del partido ", indice,":"; + Leer partidos[indice,2]; Escribir Sin Saltar "Introduce los goles metidos por el equipo ",partidos[indice,1],": "; Leer resultados[indice,1]; + Escribir Sin Saltar "Introduce los goles metidos por el equipo ",partidos[indice,2],": "; + Leer resultados[indice,2]; FinPara Escribir "QUINIELA"; Escribir "========"; @@ -47,14 +47,14 @@ Proceso Quiniela // Un 1 si el que juega en casa ha ganado (primer equipo gana) // Un 2 si el que juega de visitante ha ganado (segundo equipo gana) // Una X si hay empate - Para indice<-0 hasta num_partidos-1 Hacer - Si resultados[indice,0]>resultados[indice,1] Entonces - Escribir partidos[indice,0], " - ",partidos[indice,0]," -> 1"; + Para indice<-1 hasta num_partidos Hacer + Si resultados[indice,1]>resultados[indice,2] Entonces + Escribir partidos[indice,1], " - ",partidos[indice,2]," -> 1"; SiNo - Si resultados[indice,0] 2"; + Si resultados[indice,1] 2"; SiNo - Escribir partidos[indice,0], " - ",partidos[indice,0]," -> X"; + Escribir partidos[indice,1], " - ",partidos[indice,2]," -> X"; FinSi FinSi FinPara