Solucionario Consolidado Utilizando PSeInt

ACM – ICPC Bolivia

Alberto J. Suxo Riveros 1

Solucionario Consolidado Utilizando PSeInt

2da Olimpiada Boliviana de Informática

Estado Plurinacional de Bolivia, febrero de 2013

Alberto J. Suxo Riveros <[email protected]>



Contenidos Fase 4 – Final Nacional....................................................................................................... 1

Problema A: Distancia de Hamming .............................................................................. 1 Problema B: Hallando números capicúas ....................................................................... 3 Problema C: Poema......................................................................................................... 5 Problema D: La Última Esperanza ................................................................................. 7 Problema E: Bolivia Word ............................................................................................ 10

Fase 3 - Departamental ..................................................................................................... 12 Problema A: Cena para Cinco....................................................................................... 12 Problema B: Código USSD .......................................................................................... 14 Problema C: Sumando Fibonacci.................................................................................. 17 Problema D: Leones ...................................................................................................... 19 Problema E: Número de la suerte ................................................................................. 21 Problema F: Aritmética Maya ....................................................................................... 24 Problema G: Narcisos ................................................................................................... 26

Fase 2 - Regional .............................................................................................................. 28 Problema A: Trinomios Triangulares ........................................................................... 28 Problema B: Calculadora Inca ...................................................................................... 30 Problema C: Aritmética ................................................................................................ 32 Problema D: Bender ...................................................................................................... 35 Problema E: Eratóstenes ............................................................................................... 37 Problema F: Examen ..................................................................................................... 39 Problema G: Lago ......................................................................................................... 42 Problema H: Química ................................................................................................... 44

Anexo ................................................................................................................................ 46 Opciones del Lenguaje .................................................................................................. 46 PSeInt ............................................................................................................................ 47



Fase 4 – Final Nacional Problema A: Distancia de Hamming

Autor: Jorge Terán La distancia de Hamming entre dos números está definida como el número de posiciones en sus representaciones binarias en las que difieren. Los ceros a la izquierda son usados si son necesarios para que a las representaciones binarias tengan misma longitud. Por ejemplo, los números 11010 y 01100 difieren en la primera, tercera y cuarta posición, así que dan una distancia de Hamming de 3. La entrada son cadenas que contienen las representaciones binarias de ciertos números (cada par de números tiene la misma longitud). Debe devolver las distancias de Hamming de todos los pares de números dados. Entrada La primera línea tendrá un número N, que es la cantidad de casos de prueba. Seguido de N líneas, En cada línea se vienen dos cadenas con las representaciones binarias separadas por un espacio. Cada cadena tendrá entre 1 y 50 caracteres, inclusive. Todos los elementos de números contendrán sólo los caracteres 1 y 0. Salida La salida consiste en una línea para cada caso de prueba que contiene la distancia Hamming. Ejemplo de entrada 3 11010 01100 10000001 10000001 11111111 00000000 Ejemplo de salida 3 0 8



Solución // Olimpiada Boliviana De Informatica // Problema : Distancia de Hamming // Autor : Alberto Suxo // Copyright: Team SIM // Lenguaje : Pseudocodigo PSeInt // ******************************* Proceso Hamming Definir N, i, j, cnt Como Entero; Definir a, b Como Caracter; Leer N; Para i<-1 Hasta N Con Paso 1 Hacer Leer a, b; cnt <- 0; Para j<-0 Hasta Longitud(a)-1 Con Paso 1 Hacer Si Subcadena(a,j,j) <> Subcadena(b,j,j) Entonces cnt <- cnt + 1; FinSi FinPara Escribir cnt; FinPara FinProceso



Problema B: Hallando números capicúas Autor: Jorge Terán

Tome un número, lo invierte, luego lo suma al número original, luego otra vez lo invierte y lo suma. Este proceso se repite hasta que la suma sea capicúa o se haya hecho 100 sumas. Por ejemplo el 14 lo invertimos y obtenemos 41 sumamos al número original obteniendo 55 es capicúa. Imprimimos 55. Otro ejemplo 95+59=154. Invertimos y sumamos 154+451=605. Repetimos el proceso 605+506=1111 que es capicúa. Entrada La primera fila tendrá un número N que es el número de datos de entrada, seguido de N líneas, cada línea consiste de un numero entero n ≤ 500 un una línea. Salida Por cada números de entrada el numero capicúa hallado. Si no existe un imprima la palabra imposible. Ejemplo de entrada 2 14 95 Ejemplo de salida 55 1111



Solución // Olimpiada Boliviana De Informatica // Problema : Hallando números capicúas // Autor : Alberto Suxo // Copyright: Team SIM // Lenguaje : Pseudocodigo PSeInt // ******************************* SubProceso resultado <- invertir ( a ) Definir resultado Como Entero; Definir aux como Entero; aux <- 0; Mientras a > 0 Hacer aux <- (aux * 10) + (a % 10); a <- trunc(a / 10); FinMientras resultado <- aux; FinSubProceso Proceso Capicuas Definir N, i, cnt, A, B Como Entero; Definir seguir Como Logico; Leer N; Para i<-1 Hasta N Con paso 1 Hacer Leer A; cnt <- 0; seguir <- verdadero; Mientras seguir Hacer B <- invertir( A ); Si A = B Entonces seguir <- falso; Sino A <- A + B; FinSi cnt <- cnt + 1; Si cnt=100 Entonces seguir <- falso; FinSi FinMientras Si cnt = 100 Entonces Escribir "Imposible"; Sino Escribir A; FinSi FinPara FinProceso



Problema C: Poema Autor: Alberto Suxo

Como cada año, en el colegio de José se organiza todo un evento por el día de la madre. Comenzará con un himno, coreografías de bailes, una pequeña obra de teatro, una banda de estudiantes tocará un tema especialmente dedicado y, por último, un poema, (a cargo de José). Pero, José está muy nervioso, ha hecho todo lo posible para memorizar el poema. Sus amigos decidieron ayudar a José quitando todas las vocales del poema y remplazarlos por guiones, luego dejaron que José lo lea para ver si realmente lo ha memorizado todo. El problema es que los amigos de José quieren estar seguros de remplazarlos bien sin arruinar el poema, para lo cual decidieron hacerlo mediante un programa. Tu trabajo es ayudar a estos niños. Entrada La primera línea tendrá un número entero N (0 < N < 1000) que representa el número de líneas que tendrá el poema. Cada línea del poema tendrá un máximo de 100 caracteres que contendrá: mayúscula (A-Z), minúscula (a-z), espacios ( ), puntos (.) y comas (,). Salida En la salida se mostrará el poema sin vocales como se muestra en el ejemplo de salida. Ejemplo de entrada 5 Creci de a poco con tu calor, me alimentaba con tus caricias y frases de amor. Con miedo de perderte... Se hizo la luz Ejemplo de salida Cr-c- d- - p-c- c-n t- c-l-r, m- -l-m-nt-b- c-n t-s c-r-c--s y fr-s-s d- -m-r. C-n m--d- d- p-rd-rt-... S- h-z- l- l-z



Solución // Olimpiada Boliviana De Informatica // Problema : Poema // Autor : Alberto Suxo // Copyright: Team SIM // Lenguaje : Pseudocodigo PSeInt // ******************************* SubProceso resultado <- esVocal( ch ) Definir resultado Como Logico; Definir c Como Caracter; c <- Minusculas( ch ); Si c="a" | c="e" | c="i" | c="o" | c="u" Entonces resultado <- verdadero; Sino resultado <- falso; FinSi FinSubProceso Proceso Poema Definir n, i, j Como Entero; Definir linea Como Caracter; Definir car, temporal Como Caracter; Leer n; Para j<-1 Hasta n Hacer Leer linea; Para i<-0 Hasta Longitud(linea)-1 Con paso 1 Hacer car <- Subcadena(linea,i,i); Si esVocal( car ) Entonces // Reemplazar un caracter :'( Si i > 0 Entonces temporal <- concatenar(Subcadena(linea,0,i-1),"-"); Sino temporal <- "-"; FinSi Si i<Longitud(linea)-1 Entonces temporal <- Concatenar(temporal,Subcadena(linea,i+1,Longitud(linea)-1)); FinSi linea <- temporal; // Fin de Reemplazar un caracter :-P FinSi FinPara Escribir linea; FinPara FinProceso



Problema D: La Última Esperanza Autor: Alvaro Rojas

Los Terrans están siendo atacados por los Protoss una raza de Humanoides que aparecen en la serie Star Craft. Los Terrans ya casi sin tropas y con poca estructuras solo tienen una esperanza para vencer en esta guerra contra los Protoss. Y esa esperanza es poder usar el arma más poderosa que tienen, “la Bomba Nuclear”. Entonces necesitan un soldado para poder marcar el blanco para el ataque nuclear a los Protoss, el cual es Ghost, un soldado capaz de volverse invisible y poder infiltrarse en la base de los Protoss. Ghost se dirige hacia la Base de los Protoss y logra infiltrarse en ella para poder marcar el blanco del ataque Nuclear. Ghost está indeciso para marcar el blanco para el ataque Nuclear así que los Terrans piden tu ayuda. Ghost te enviara coordenadas de cada estructura de la base Protoss. Así que él quiere saber el número de estructuras que serán destruidas dadas las coordenadas del blanco de la bomba nuclear y el radio de alcance de esta. Entrada La primera línea es un entero T (1 ≤ T ≤ 100) el número de casos de prueba. Seguidamente se te dará un entero N (1 ≤ N ≤ 100) el número de coordenadas x, y que te enviará Ghost. A continuación vendrán N líneas, cada una de 2 valores x, y (0 ≤ x, y ≤ 1000) donde cada una representa la coordenada de una estructura Protoss. La última línea tendrá 3 valores x, y, r. Donde x, y son las coordenadas del blanco del ataque nuclear y r (1 ≤ r ≤ 500) el radio de alcance de la bomba Nuclear. Salida Para cada caso de prueba imprimir el número de estructuras Potross destruidas por la bomba Nuclear (Una estructura será destruida si la coordenada de la estructura Protoss está en el radio de alcance de la Bomba Nuclear)



Ejemplo de entrada 3 2 1 1 1 0 0 0 1 2 1 1 1 0 0 0 5 2 0 0 50 50 5 5 10 Ejemplo de salida 1 2 1

El gráfico corresponde al primer caso de prueba, donde claramente podemos notar que el alcance del radio de la bomba nuclear llega a tocar el punto (1, 0) (Pues la distancia del punto de la estructura Protoss a la bomba es menor o igual al radio de alcance de la bomba), por lo tanto la Bomba destruye una estructura, en cambio la estructura que se encuentra en el punto (1, 1) no es alcanzada por la bomba Nuclear.



Solución // Olimpiada Boliviana De Informatica // Problema : Ultima Esperanza // Autor : Alberto Suxo // Copyright: Team SIM // Lenguaje : Pseudocodigo PSeInt // ******************************* SubProceso resultado <- distancia( P1x, P1y, P2x, P2y) Definir resultado Como Real; resultado <- RC( (P1x-P2x)^2 + (P1y-P2y)^2 ); FinSubProceso Proceso UltimaEsperanza Definir t, n, coords, X, Y Como Entero; Definir bombX, bombY, radio Como Entero; Definir i, total Como Entero; Dimension coords[1001,2]; // alamacenaremos todas las coordenadas en las columnas // correspondientes, X en la primera columna y Y en la segunda. X <- 0; Y <- 1; Leer t; Mientras t > 0 Hacer t <- t - 1; Leer n; Para i <- 0 Hasta n-1 Hacer Leer coords[i,X]; Leer coords[i,Y]; FinPara // leer datos de la bomba Leer bombX, bombY, radio; total <- 0; Para i <- 0 Hasta n-1 Hacer Si distancia( coords[i,X], coords[i,Y], bombX, bombY)<= radio Entonces total <- total + 1; FinSi FinPara Escribir total; FinMientras FinProceso



Problema E: Bolivia Word Autor: Alvaro Rojas

La organización de la IOI BOLIVIA hizo hacer letras de tamaño grande, para poder ponerlas en varios lugares del evento. Mientras transportaban el paquete que almacenaba las letras este se rompió y dejo caer las letras, al caer las letras varias de estas se perdieron. Así que ellos no están seguros si con las letras restantes podrán armar las palabras que ellos querían. Por ejemplo si tenemos las letras O, I, L, I, B, V, A, Z, T y queremos armar la palabra BOLIVIA, notaremos claramente que es posible armarla. En cambio si tuviéramos las letras O, L, I, B, V, A, Z, T no será posible armar la palabra BOLIVIA pues no faltaría una letra (la letra I). Los organizadores piden tu ayuda. Ellos te darán las letras disponibles y quieren saber si es posible armar la palabra BOLIVIA. Entrada La primera línea contendrá un entero N (1 ≤ N ≤ 10) el número de casos de prueba. A continuación se te dará N líneas, cada una con una cadena (solo mayúsculas), donde cada carácter representa la letra disponible para armar la palabra BOLIVIA. Salida Para cada cadena que se te dio anteriormente, si es posible armar la palabra BOLIVIA imprimir “ES POSIBLE”, caso contrario “NO ES POSIBLE”'. Ejemplo de entrada 3 BOLIVIA BOOIILVA BOLVZATY Ejemplo de salida ES POSIBLE ES POSIBLE NO ES POSIBLE



Solución // Olimpiada Boliviana De Informatica // Problema : Bolivia Word // Autor : Alberto Suxo // Copyright: Team SIM // Lenguaje : Pseudocodigo PSeInt // ******************************* Proceso BoliviaWord Definir N, j, k Como entero; Definir linea Como caracter; Definir car Como caracter; Definir B, O, L, I, V, A como Entero; Leer N; Para k <- 1 Hasta N Con Paso 1 Hacer Leer linea; B <- 0; O <- 0; L <- 0; I <- 0; V <- 0; A <- 0; Para j <- 0 Hasta Longitud(linea)-1 Con paso 1 Hacer car <- Subcadena(linea,j,j); Si car="B" Entonces B <- B + 1; Sino Si car="O" Entonces O <- O + 1; sino Si car="L" Entonces L <- L + 1; Sino Si car="I" Entonces I <- I + 1; Sino Si car="V" Entonces V <- V + 1; Sino Si car="A" Entonces A <- A + 1; FinSi FinSi FinSi FinSi FinSi FinSi FinPara Si B<1 | O<1 | L<1 | I<2 | V<1 | A<1 Entonces Escribir "NO ES POSIBLE"; Sino Escribir "ES POSIBLE"; FinSi FinPara FinProceso



Fase 3 - Departamental Problema A: Cena para Cinco

Autor: Gabriel Rea En un popular show llamado Cena para cinco, cinco concursantes compiten preparando delicias culinarias. Todas las noches uno de ellos hace la cena los otros cuatro lo califican entre 1 y 5. La cantidad de puntos que un concursante obtiene es igual a la suma de puntos que obtuvo. El ganador del programa de televisión es por supuesto el que obtiene más puntos. Escribe un programa que determine al ganador y cuantos puntos obtuvo. Entrada La primera línea contendrá un entero N (1 ≤ N ≤ 10) el número de casos de prueba. Cada caso de prueba está dado en cinco líneas, cada una contiene 4 enteros, los puntos que cada concursante obtuvo. Los concursantes están numerados del 1 al 5 en el orden en que sus puntajes son dados. Se garantiza que la entrada genera una solución única. Salida La salida es una línea con el número del ganador y sus puntos separados por un espacio. Ejemplos de entrada 5 4 4 5 5 4 4 4 5 5 4 4 5 5 5 4 4 4 4 5 4 4 3 3 5 4 3 5 5 5 2 4 5 5 5 1 4 4 4 4 Ejemplos de salida 4 19 2 17



Solución // Olimpiada Boliviana De Informatica // Problema : Cena para Cinco // Autor : Alberto Suxo // Copyright: Team SIM // Lenguaje : Pseudocodigo PSeInt // ******************************* Proceso Cena Definir N, i, j, k, sum, puntos, ganador, x Como Entero; Leer N; Para k<-1 Hasta N Hacer puntos <- 0; ganador <- 0; Para i<-1 Hasta 5 Hacer sum <- 0; Para j<-1 Hasta 4 Hacer Leer x; sum <- sum + x; FinPara Si sum > puntos Entonces puntos <- sum; ganador <- i; FinSi FinPara Escribir ganador , " " , puntos; FinPara FinProceso



Problema B: Código USSD Autor: Jorge Terán

La empresa telefónica está implementando los códigos USSD para comunicarse con los teléfonos celulares de sus clientes para los cual te ha contratado con la finalidad de que elabores un programa que determine si un código USSD es válido. Los códigos USSD consisten de un texto que contiene un caracter asterisco seguido de un número de tres caracteres numéricos, continúa un segundo asterisco, sigue una cantidad variable de caracteres numéricos y termina con un caracter numeral. Por Ejemplo: *109*123456# . Se consideran códigos validos los que cumplen esta especificación. Entrada La primera línea contiene el número de casos de prueba. Las líneas siguientes contienen un caso de prueba. Salida Por cada caso de prueba imprima la frase "bien" si la cadena de caracteres es un código USSD valido ó "mal" si es código USSD es invalido. Ejemplos de entrada 8 *109*1234# *1234*109# *109*109# *109*1234#2 *109*109 109*109# *abc*1234# *109*ab34# Ejemplos de salida bien mal bien mal mal mal mal mal



Solución // Olimpiada Boliviana De Informatica // Problema : Código USSD // Autor : Alberto Suxo // Copyright: Team SIM // Lenguaje : Pseudocodigo PSeInt // ******************************* SubProceso resultado <- NoEsValido( car ) Definir resultado Como Logico; Si car="0" | car="1" | car="2" | car="3" | car="4" | car="5" | car="6" | car="7" | car="8" | car="9" Entonces resultado <- falso; Sino resultado <- verdadero; FinSi FinSubProceso Proceso CodigoUSSD Definir casos, tam, i, j Como Entero; Definir cad, num Como Caracter; Definir sw Como Logico; Leer casos; Para i<-1 Hasta casos Hacer Leer cad; Si Subcadena(cad,0,0)<>"*" Entonces Escribir "mal"; Sino Si Subcadena(cad,4,4)<>"*" Entonces Escribir "mal"; Sino tam <- Longitud(cad); Si Subcadena(cad,tam-1, tam-1)<>"#" Entonces Escribir "mal"; Sino sw <- Verdadero; num <- Subcadena(cad,1,4); Escribir num; Para j<-0 Hasta 2 Hacer Si NoEsValido( Subcadena(num,j,j) ) Entonces sw <- falso; FinSi FinPara Si sw Entonces num <- Subcadena(cad,5,tam-1); Escribir num; Para j<-0 Hasta Longitud(num)-2 Hacer Si NoEsValido( subcadena(num,j,j) ) Entonces sw <- falso; FinSi



FinPara FinSi Si sw Entonces Escribir "bien"; Sino Escribir "mal"; FinSi FinSi FinSi FinSi FinPara FinProceso



Problema C: Sumando Fibonacci Autor: Jorge Terán

La serie de Fibonacci es aquella que se forma por la expresión f(n) = f(n - 1) + f(n - 2). Los primeros números de la serie son 1, 1, 2, 3, 5, 8, 13, 21, … Podemos representar cada número entero como una suma de números Fibonacci. Por ejemplo el número 33 puede expresarse como:

33 = 1 * 1 + 0 * 2 + 1 * 3 + 0 * 5 + 1 * 8 + 0 * 13 + 1 * 21 Tomando solamente los números binarios tendríamos

Fib(33) = 1010101 Otros ejemplos son:

Fib(18) = 000101 Fib(6) = 1001

Entrada La entrada de datos consiste en una línea con la representación de un número como la suma de números Fibonacci. Termina cuando no hay más datos. Vea que cuando lea la línea de entrada leerá caracteres 1 y 0 que se representan como los ascii 48 y 49 respectivamente. Salida La salida consiste en el número entero representado por la representación leída. Se imprime un número en una línea por cada línea de entrada. Ejemplos de entrada 1010101 000101 1001 Ejemplos de salida 33 18 6



Solución // Olimpiada Boliviana De Informatica // Problema : Sumando Fibonacci // Autor : Alberto Suxo // Copyright: Team SIM // Lenguaje : Pseudocodigo PSeInt // ******************************* Proceso Fibo Definir linea Como Caracter; Definir tam, i, valor Como Entero; Definir vec Como Entero; Dimension vec[100]; Leer linea; tam <- Longitud( línea ); vec[0] <- 1; vec[1] <- 2; Para i<-2 Hasta tam Hacer vec[i] <- vec[i-1] + vec[i-2]; FinPara valor <- 0; Para i<-0 Hasta tam-1 Hacer Si Subcadena( linea, i, i )="1" Entonces valor <- valor + vec[i]; FinSi FinPara Escribir valor; FinProceso



Problema D: Leones Autor: Leticia Blanco

En la selva se han mimetizado varios leones, grrrrr....., debemos pasar la selva.... es necesario.... pero no queremos morir....... :S, - piensa Hugo; pero como debe guardar compostura y mantener la calma con sus hermanos Paco y Luis; no muestra su temor. Más al contrario ha decidido buscar cuántos leones hay mimetizados para saber el número de balas que debe cargar si es necesario tomar alguna medida de emergencia. Pero hay un problema y es que la selva de letras que deben atravesar puede ser muy tupida y complicada; por lo que ha decidido recordar sus dotes de programador y no ha tenido éxito. Por lo que ha solicitado que escribas un programa para encontrar el número de leones, dado que se tiene la selva de letras. Entrada La entrada consiste de un número entero n que indica la cantidad de casos, le siguen n líneas con cadenas de hasta 200 caracteres en mayúscula. Cada una de estas cadenas representa una selva de letras. Salida La salida es un número entero, que indica la cantidad de leones que hay en la selva. Ejemplos de entrada 2 SELVADELEJEMPLODONDESEENCUNETRANDOSLEONES LEONIDASUNGRANGUERRERODELAANTIGUAGRECIA Ejemplos de salida 2 1



Solución // Olimpiada Boliviana De Informatica // Problema : Leones // Autor : Alberto Suxo // Copyright: Team SIM // Lenguaje : Pseudocodigo PSeInt // ******************************* SubProceso posi <- buscar (selva, letra, pos ) Definir posi Como Entero; Definir i Como Entero; posi <- -1; i <- pos ; Mientras i < Longitud(selva) & posi = -1 Hacer Si Subcadena(selva,i,i) = letra Entonces posi <- i; FinSi i <- i + 1; FinMientras FinSubProceso // retornará 'posi' SubProceso cant <- contarLeon ( selva ) Definir cant Como Entero; Definir pos, i Como Entero; Definir leon, letra Como Caracter; leon <- "LEON"; i <- 0; pos <- 0; cant <- 0; Mientras pos <> -1 Hacer Si i < 4 Entonces letra <- Subcadena( leon, i, i ); pos <- buscar ( selva, letra, pos ); Si pos <> -1 Entonces pos <- pos + 1; FinSi i <- i + 1; FinSi Si i = 4 & pos <> -1 Entonces cant <- cant + 1; i <- 0; FinSi FinMientras FinSubProceso // retornará 'cant' Proceso Leones Definir n, i Como Entero; Definir selva Como Caracter; Leer n; Para i <- 1 Hasta n Hacer Leer selva; Escribir contarLeon( selva ); FinPara FinProceso



Problema E: Número de la suerte Autor: Jorge Terán

En la teoría de números, un número de la suerte es un número natural en un conjunto que se genera por una criba similar a la Criba de Eratóstenes que genera los números primos. Comenzando con una lista de números enteros a partir de 1:

1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, … Se eliminan los números de dos en dos, todos los números pares; en esta primera iteración sólo quedan los números impares:

1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, … El segundo término de esta secuencia es 3. Entonces se eliminan todos los números de tres en tres:

1, 3, 7, 9, 13, 15, 19, 21, 25, …

El tercer número que ha quedado es 7, así que cada séptimo número que queda se elimina:

1, 3, 7, 9, 13, 15, 21, 25, … Dado que este procedimiento se repite indefinidamente, los sobrevivientes son los números de la suerte:

1, 3, 7, 9, 13, 15, 21, 25, 31, 33, 37, 43, 49, 51, 63, 67, 69, 73, 75, 79, 87, 93, 99, … La lista anterior es también la lista de números de la suerte menores a 100. Entrada No existe entrada como tal, el estudiante debe asumir que buscamos los números de la suerte menores a 200. Salida Imprima en una línea cuantos números de la suerte existen menores a 200. Por ejemplo, para 100 es 23.



Solución // Olimpiada Boliviana De Informatica // Problema : Número de la suerte // Autor : Alberto Suxo // Copyright: Team SIM // Lenguaje : Pseudocodigo PSeInt // ******************************* // Cuenta el número de elementos del vector 'numeros' SubProceso resultado <- tam ( numeros ) Definir resultado Como Entero; Definir i como entero; i <- 0; Mientras numeros[i] > 0 Hacer i <- i + 1; FinMientras resultado <- i; FinSubProceso // Quita el elemento i del vector 'numeros' SubProceso quitar( numeros, i ) Definir j Como Entero; j <- i; Mientras numeros[j]>0 hacer numeros[j]<-numeros[j+1]; j <- j + 1; FinMientras FinSubProceso Proceso Suerte Definir max, i, j, vil, c, a, it, numerosTam Como Entero; Definir numeros Como Entero; Definir sw Como Logico; max <- 200; // <- buscamos en entre los primeros 200 Dimension numeros[201]; i <- 1; j <- 0; Mientras i <= max Hacer numeros[j] <- i; i <- i + 2; j <- j + 1; FinMientras sw <- Verdadero; numeros[j] <- 0; it <- 1; Mientras sw Hacer vil <- numeros[it]; it <- it + 1; numerosTam <- tam( numeros ); c <- numerosTam % vil;



a <- numerosTam - c - 1; Si vil >= numerosTam Entonces sw <- falso; Sino i <- a; Mientras i>1 Hacer quitar( numeros, I ); i <- i - vil; FinMientras FinSi FinMientras Escribir numerosTam; FinProceso



Problema F: Aritmética Maya Autor: Jorge Terán

Los Mayas tenían una forma de escribir números que les permitía hacer los cálculos. La notación de sus números era con puntos y rayas que las representaremos por guiones. Cada punto representa la unidad y una raya representa 5 unidades. Veamos: -.. representaría el número 7, esto es una raya cinco más dos puntos da siete. Cada vez que tenemos 5 unidades, o sea 5 puntos se cambian por una raya. El número más grande que se puede representar es el 20 que son cuatro rayas. Como ejemplo veamos el siguiente número Maya --. .. -... --- Cada una de las líneas representa un dígito Maya, por lo que las 4 líneas representan los dígitos 11, 2, 8, 15 que en notación decimal es 88975. El dígito 0 se representa con un cero en una sola línea. El digito menos significativo es el 15. Entrada La entrada contiene múltiples casos de entrada. La primera línea tiene el número de casos de prueba. Cada caso de prueba contiene 4 líneas. Cada línea contiene un número de cuatro dígitos en representación Maya. Salida Imprima en una línea el equivalente decimal del número Maya. Ejemplos de entrada 4 --. .. -... --- . 0 0 0 --. . 0 0 0 0 0 -

Ejemplos de salida 88975 8000 88400 5



Solución // Olimpiada Boliviana De Informatica // Problema : Aritmética Maya // Autor : Alberto Suxo // Copyright: Team SIM // Lenguaje : Pseudocodigo PSeInt // ******************************* Proceso Maya Definir casos, c1, decimal, i, j, unos, cincos Como Entero; Definir maya Como Caracter; Leer casos; Para c1<-1 Hasta casos hacer decimal <- 0; Para i<-0 Hasta 3 hacer Leer maya; unos <- 0; cincos <- 0; Para j<-0 Hasta Longitud(maya)-1 Hacer Si Subcadena(maya,j,j)="-" Entonces cincos <- cincos + 1; Finsi Si Subcadena(maya,j,j)="." Entonces unos <- unos + 1; finsi finpara decimal <- decimal*20+(cincos*5+unos); finpara escribir decimal; finpara FinProceso



Problema G: Narcisos Autor: Leticia Blanco

Como te imaginarás en el mundo de los números hay variedad de sociedades, una muy marcada es la comunidad de narcisistas. Estos ciudadanos son especiales y tienen niveles de alcurnia que están denotados por e, por ejemplo el 153 es un narcisista de nivel 3, ya que la suma de sus cifras elevadas al cubo suman el mismo número: 153 = 13 + 53 + 33. En general un número narciso num que tiene la forma: dn…d3d2d1d0, se dice que es narcisista de nivel de alcurnia e, si se cumple que num = dn

e +…+ d3e + d2

e + d1e + d0

e. En esta comunidad especial, es necesario identificar el nivel de alcurnia de algunos números si son narcisos. Para ello se cuenta con el número y sobre la base de esta información debes decidir cuál es el nivel de alcurnia del narciso. Se sabe que en esta comunidad ningún narciso tiene nivel de alcurnia menor a 2 ni mayor a 6. Por supuesto, hay números que quieren pasar por narcisos, en caso de no demostrar su alcurnia dentro los cañones de la comunidad, se debe emitir -1 como respuesta. Entrada La entrada consiste de un número entero c que indica la cantidad de casos. En las próximas c líneas están los números que quieren demostrar su nivel de narcisismo. Salida La salida por cada caso es el nivel de alcurnia del supuesto narciso. Ejemplos de entrada 3 153 1 22 Ejemplos de salida 3 2 -1



Solución // Olimpiada Boliviana De Informatica // Problema : Narcisos // Autor : Alberto Suxo // Copyright: Team SIM // Lenguaje : Pseudocodigo PSeInt // ******************************* SubProceso procesar( n ) Definir res, suma, copia, i Como Entero; Definir narciso Como Logico; narciso <- falso; i <- 2; Mientras i <= 6 & ~ narciso Hacer copia <- n; suma <- 0; mientras copia > 0 Hacer suma <- suma + (copia%10)^i; copia <- copia / 10; FinMientras narciso <- (suma=n); res <- i; i <- i + 1; FinMientras Si narciso Entonces Escribir res; Sino Escribir -1; FinSi FinSubProceso Proceso Narcisos Definir n, i, num Como Entero; Leer n; Para i<-1 Hasta n Hacer Leer num; procesar( num ); FinPara FinProceso



Fase 2 - Regional Problema A: Trinomios Triangulares

Autor: Jorge Terán Consideremos la siguiente expresión:

(1 + x + x2)n

Dado un valor de n se quiere conocer cuál es valor de los coeficientes de la expresión. Por ejemplo si n toma el valor de 1 los términos de la expresión son 1, 1, 1. Cuando n = 2 tenemos 1 + 2x + 3x2 + 2x3 + x4 por lo que la respuesta es 1, 2, 3, 2, 1 Entrada La primera línea contiene un número que indica el número de casos de prueba. En una línea viene un caso de prueba que contiene el numero 0 ≤ n ≤ 40 exponente de la expresión. Salida Por cada caso de prueba su programa debe escribir en una línea y separados por un espacio los coeficientes del polinomio resultante. Ejemplos de entrada 3 1 2 0 Ejemplos de salida 1 1 1 1 2 3 2 1 1



Solución // Olimpiada Boliviana De Informatica // Problema : Trinomios Triangulares // Autor : Alberto Suxo // Copyright: Team SIM // Lenguaje : Pseudocodigo PSeInt // ******************************* Proceso Trinomiales // pre-calculamos todo // debemos llegar a la siguiente matriz: // 1 0 0 // 1 1 1 0 0 // 1 2 3 2 1 0 0 // 1 3 6 7 6 3 1 0 0 // 1 ..... Definir Mat Como Entero; Definir i, j, k, sum Como Entero; Definir casos, n Como Entero; Dimension Mat[41,84]; Mat[0,0] <- 1; Mat[0,1] <- 0; Mat[0,2] <- 0; Para i<-1 hasta 40 hacer Para j<-0 Hasta i*2 Hacer sum <- 0; Para k<-(j-2) Hasta j Hacer Si k>=0 entonces sum <- sum + Mat[i-1,k]; FinSi FinPara Mat[i,j] <- sum; FinPara Mat[i,i*2+1] <- 0; Mat[i,i*2+2] <- 0; FinPara // Leemos los datos Leer casos; Mientras casos>0 Hacer Leer n; casos <- casos - 1; j <- 0; Mientras Mat[n,j]>0 Hacer Escribir Mat[n,j]; j <- j + 1; FinMientras FinMientras FinProceso



Problema B: Calculadora Inca Autor: Jorge Terán

La Calculadora de los Incas denominada Yupana consiste de una base parecida a la base binaria. Los números se representan por varios unos y ceros que se dividen en 4 grupos como se muestra:

00000 000 00 0 Cada grupo representa a un número específico y corresponden a los números 5, 3, 2, 1. Cuando queremos representar un número simplemente colocamos en 1 en algunos de los 0 de las columnas. Por ejemplo para representar el numero 12 escogemos dos números de la columna de los cincos y uno de la columna del dos y escribimos:

00011 000 01 0 Un mismo número puede tener múltiples representaciones. La siguiente tabla muestra varias representaciones y su equivalente decimal.

00000 000 01 0 = 2 00000 000 11 0 = 4 00011 000 00 0 = 10 00000 011 00 0 = 6 00001 000 00 1 = 6

Hay que hacer notar que hay varias interpretaciones diferentes de una Yupana y esta es una de ellas, no hay un consenso sobre el tema. Entrada La primera línea contiene un número que indica el número de casos de prueba. Cada caso de prueba contiene una línea con la representación en el formato de la Yupana que consiste en 11 números 1 o ceros. Salida Por cada caso de prueba su programa debe escribir en una línea y separados por un espacio la representación en formato decimal del número en formato de Yupana. Ejemplos de entrada 5 00000000010 00000000110 00011000000 00000011000 00001000001

Ejemplos de salida 2 4 10 6 6



Solución // Olimpiada Boliviana De Informatica // Problema : Calculadora Inca // Autor : Alberto Suxo // Copyright: Team SIM // Lenguaje : Pseudocodigo PSeInt // ******************************* Proceso CalculadoraInca Definir casos, i, total Como Entero; Definir cad Como Caracter; Leer casos; Para i<-1 Hasta casos Hacer total <- 0; Leer cad; Si Subcadena(cad, 0, 0) = "1" Entonces total <- total + 5; FinSi Si Subcadena(cad, 1, 1) = "1" Entonces total <- total + 5; FinSi Si Subcadena(cad, 2, 2) = "1" Entonces total <- total + 5; FinSi Si Subcadena(cad, 3, 3) = "1" Entonces total <- total + 5; FinSi Si Subcadena(cad, 4, 4) = "1" Entonces total <- total + 5; FinSi Si Subcadena(cad, 5, 5) = "1" Entonces total <- total + 3; FinSi Si Subcadena(cad, 6, 6) = "1" Entonces total <- total + 3; FinSi Si Subcadena(cad, 7, 7) = "1" Entonces total <- total + 3; FinSi Si Subcadena(cad, 8, 8) = "1" Entonces total <- total + 2; FinSi Si Subcadena(cad, 9, 9) = "1" Entonces total <- total + 2; FinSi Si Subcadena(cad, 10, 10) = "1" Entonces total <- total + 1; FinSi Escribir total; FinPara FinProceso



Problema C: Aritmética Autor: Hernan Payrumani

En la clase de matemática el profesor a veces se siente cansado y para que el tiempo pase rápido da de tarea unas operaciones aritméticas. Las operaciones a veces son cortas como 10 dígitos de longitud, pero a veces son largas con 100 dígitos de longitud. Es estos días donde tu profesor esta aburrido tú también lo estas, por eso prefieres que tu computadora resuelva estos ejercicios de aritmética, por lo tanto primero debes escribir un programa que te devuelva los resultados de estas operaciones Entrada La Primera línea contiene el número de casos de entrada, cada caso de entrada contiene 3 líneas. La primera línea contiene un entero positivo x, el primer operando. La segunda línea contiene un caracter ‘+’ o ‘*’representando la suma y la multiplicación. La tercera línea contiene un entero positivo y, el segundo operando. Los enteros x e y son potencias de 10 de hasta 10 dígitos. Salida El resultado de la operación entre x e y. Ejemplos de entrada 4 1000 * 100 10000 + 10 10 + 1000 1 * 1000 Ejemplos de salida 100000 10010 1010 1000



Solución // Olimpiada Boliviana De Informatica // Problema : Aritmetica // Autor : Alberto Suxo // Copyright: Team SIM // Lenguaje : Pseudocodigo PSeInt // ******************************* SubProceso Multiplicar( A, B ) Definir tamB, i Como Entero; Definir resultado Como Caracter; resultado <- A; tamB <- Longitud( B ); i <- 1; Mientras i < tamB Hacer resultado <- Concatenar( resultado, "0" ); i <- i + 1 ; FinMientras Escribir resultado; FinSubProceso SubProceso Sumar( A, B ) Definir tamA, tamB, max, i, sum Como Entero; Definir resultado Como Caracter; tamA <- Longitud( A ); tamB <- Longitud( B ); Si tamA > tamB Entonces max <- tamA; Sino max <- tamB; FinSi tamA <- tamA - max; tamB <- tamB - max; resultado <- ""; Para i<-0 Hasta max-1 Hacer sum <- 0; Si tamA>=0 & Subcadena(A,tamA,tamA)="1" Entonces sum <- sum + 1; FinSi Si tamB>=0 & Subcadena(B,tamB,tamB)="1" Entonces sum <- sum + 1; FinSi Segun sum Hacer 0: resultado <- Concatenar(resultado, "0" ); 1: resultado <- Concatenar(resultado, "1" ); 2: resultado <- Concatenar(resultado, "2" ); FinSegun tamA <- tamA + 1; tamB <- tamB + 1; FinPara Escribir resultado; FinSubProceso



Proceso Aritmerica Definir casos Como Entero; Definir i Como Entero; Definir A, B, op Como Caracter; Leer casos; Para i <- 1 Hasta casos Hacer Leer A, op, B; Si op= "+" Entonces Sumar ( A, B ); sino // entonces op = "*" Multiplicar ( A, B ); FinSi FinPara FinProceso



Problema D: Bender Autor: Hernan Payrumani

El robot Bender es muy parecido a los humanos, en cuanto al sueño solo duerme bien cuando no tiene pesadillas. A diferencia de los humanos Bender sueña solo con dígitos binarios 0 y 1. Bender tiene pesadillas cuando sueña con dígitos distintos a 0 y 1. Por ejemplo si Bender sueña con 001111000111 el tendrá un dulce sueño. Pero si Bender sueña con 1110011111120000 Bender tendrá una pesadilla. Entrada La primera línea de entrada contiene el número de casos a ser evaluados. La primera línea de cada caso contiene c y f el número de columnas y filas de una matriz. Las siguientes líneas contienen f líneas con c dígitos entre 0 y 9. Salida Si la matriz solo contienen dígitos binarios 0, 1, imprime Dulce. Si la matriz contiene algún dígito que no es binario imprime Pesadilla Ejemplos de entrada 2 3 3 111 101 011 4 4 1110 0233 1111 0000 Ejemplos de salida Dulce Pesadilla



Solución // Olimpiada Boliviana De Informatica // Problema : Bender // Autor : Alberto Suxo // Copyright: Team SIM // Lenguaje : Pseudocodigo PSeInt // ******************************* Proceso Bender Definir n, m, i, j, casos, k Como Entero; Definir resultado, linea Como Caracter; Definir aux Como Caracter; Leer casos; Para k<-1 Hasta casos Hacer Leer n, m; resultado <- "Dulce"; Para i<-1 Hasta n Hacer Leer linea; Para j<-0 Hasta m-1 Hacer aux <- Subcadena(linea, j, j); Si aux<>"0" & aux<>"1" Entonces resultado <- "Pesadilla"; FinSi FinPara FinPara Escribir resultado; FinPara FinProceso



Problema E: Eratóstenes Autor: Hernan Payrumani

La criba de Eratóstenes es un famoso algoritmo para buscar todos los números primos hasta N. El algoritmo es: 1. Escribir todos los números entre 2 y N inclusive. 2. Buscar el menor número no tachado y llamarlo P, donde P es primo. 3. Dejando fuera P, tachar todos los múltiplos que aún no estén tachados. 4. Si todos los números no han sido tachados ir al paso 2. Escribe un programa que dado un número N y K encuentre el K-esimo entero que será tachado. Entrada La primera línea indica el número de casos a ser evaluados. Cada caso consiste en dos enteros N y K (2 ≤ K < N ≤ 1000) Saluda Imprimir el K-esimo número a ser tachado. Ejemplos de entrada 3 7 3 15 12 10 7 Ejemplos de salida 6 7 9 En el tercer ejemplo, tachamos en el siguiente orden: 2, 4, 6, 8, 10, 3, 9, 5 y 7 el séptimo número es 9.



Solución // Olimpiada Boliviana De Informatica // Problema : Eratostenes // Autor : Alberto Suxo // Copyright: Team SIM // Lenguaje : Pseudocodigo PSeInt // ******************************* Proceso Eratostenes Definir n, k, vec, cont, i, j, casos, k Como Entero; Dimension vec[500]; Leer casos; Para k<-1 Hasta casos Hacer Leer n; Leer k; cont <- 0; Para i<-2 Hasta n Hacer vec[i] <- 0; FinPara Para i<-2 Hasta n Hacer Si vec[i]=0 Entonces Para j<-i Hasta n Con Paso i Hacer Si vec[j] = 0 Entonces vec[j] <- 1; cont <- cont + 1; Si cont = k Entonces Escribir j; FinSi FinSi FinPara FinSi FinPara FinPara FinProceso



Problema F: Examen Autor: Hernan Payrumani

Alvaro, Edwin y Gabriel darán un examen para ingresar a un instituto, este instituto tiene la peculiaridad de siempre realizar exámenes de selección múltiple. Desafortunadamente ellos no siempre tienen tiempo de estudiar pero quieren aprovechar que se les dará un examen de selección múltiple, ya que ellos tienen una teoría sobre estos. Alvaro dice que tendrá mejor nota utilizando la secuencia: A, B, C, A, B, C, A, B, C ... Edwin está convencido de que la mejor secuencia: es B, A,B, C, B, A, B, C, B, A, B, C... Gabriel utilizara la secuencia: C, C, A, A, B, B, C, C, A, A, B, B ... Tu tarea es determinar las respuestas correctas para el examen y así determinar quién de los tres tenía razón con su secuencia, la cual es la que contiene más respuestas correctas. Entrada La primera línea contiene un entero N (1 ≤ N ≤ 100), la cantidad de preguntas en el examen. La segunda línea contiene una cadena con N letras ´A’, ’B’, ’C´ Estas son en orden las respuestas correctas de las preguntas del examen. Salida En la primera línea imprime M, la cantidad máxima de respuestas correctas de uno de los tres. Después imprime los nombres de los chicos en orden alfabético de quienes tienen M respuestas correctas. Ejemplos de entrada 5 BAACC 9 AAAABBBBB Ejemplos de salida 3 Edwin 4 Alvaro Edwin Gabriel



Solución // Olimpiada Boliviana De Informatica // Problema : Examen // Autor : Alberto Suxo // Copyright: Team SIM // Lenguaje : Pseudocodigo PSeInt // ******************************* Proceso Examen Definir len Como Entero; Definir linea, abc, babc, ccaabb Como Caracter; Definir ptsAlvaro, ptsEdwin, ptsGabriel Como Entero; Definir i, maximo Como Entero; Definir car Como Caracter; abc <- "ABC"; babc <- "BABC"; ccaabb <- "CCAABB"; Leer len; Leer linea; ptsAlvaro <- 0; ptsEdwin <- 0; ptsGabriel <- 0; Para i<-0 Hasta len-1 hacer car <- Subcadena( linea, i, i ); Si car = Subcadena( abc, i%3, i%3) Entonces ptsAlvaro <- ptsAlvaro + 1; FinSi Si car =Subcadena( babc, i%4, i%4) Entonces ptsEdwin <- ptsEdwin + 1; FinSi Si car = Subcadena( ccaabb, i%6, i%6 ) Entonces ptsGabriel <- ptsGabriel + 1; FinSi FinPara // encontrar el maximo maximo <- 0; Si ptsAlvaro > maximo Entonces maximo <- ptsAlvaro; FinSi Si ptsEdwin > maximo Entonces maximo <- ptsEdwin; FinSi Si ptsGabriel > maximo Entonces maximo <- ptsGabriel; FinSi // imprimir la respuesta Escribir maximo; Si ptsAlvaro = maximo Entonces Escribir "Alvaro"; FinSi Si ptsEdwin = maximo Entonces



Escribir "Edwin"; FinSi Si ptsGabriel = maximo Entonces Escribir "Gabriel"; FinSi FinProceso



Problema G: Lago Autor: Alvaro Rolas

El lago Titicaca es el más alto y navegable del mundo, se encuentra a 3900 m sobre el nivel del mar. Este 2012 vinieron científicos reconocidos de Europa para poder hacer un análisis e investigaciones en el lago. La primera curiosidad que tienen es calcular el área (que es un polígono) del lago. Para tal propósito pudieron sacar las coordenadas x, y para poder calcular dicha área. Necesitan tu ayuda como participante IOI para poder calcular dicha área del lago. Se te darán coordenadas x y de manera ordenada y tú deberías retornar el área obtenida del lago. Entrada La entrada inicia con un entero N (Número de puntos x,y), seguidamente será listado N puntos xi, yi La entrada termina cuando N sea igual a 0. (3 ≤ n ≤ 50000), (−10000 ≤ x, y ≤ 10000). Salida Retornar el área del polígono. Ejemplos de entrada 3 0 0 1 0 0 1 0 Ejemplos de salida 0.50



Solución // Olimpiada Boliviana De Informatica // Problema : Lago // Autor : Alberto Suxo // Copyright: Team SIM // Lenguaje : Pseudocodigo PSeInt // ******************************* // Debe saber que el area de un poligono irregular se calcula // de la siguiente forma, dados los puntos: // P_1 = (x_1, y_1) // P_2 = (x_2, y_2) // . // : // P_n = (x_n, y_n) // // el área se calcula mediante la fórmula determinante de Gauss // | x_1 y_1 | // | x_1 y_1 | // | x_1 y_1 | // Area = _1_ | . . | // 2 | : : | // | x_n y_n | // | x_1 y_1 | Proceso Lago Definir n, sumas, i Como Entero; Definir X, Y Como Entero; Definir area Como Real; Dimension X[50001]; Dimension Y[50001]; Leer n; Mientras n>0 Hacer // Leer coordenadas Para i<-1 Hasta n Hacer Leer X[i]; // Leer un entero en la posicion i del vector X Leer Y[i]; FinPara // se copia la 1ra coordenada al final de los vectores X y Y X[n+1] <- X[1]; Y[n+1] <- Y[1]; // Se asume que los puntos estan ordenados // pro lo que no es necesario ordenarlos aqui sumas <- 0; Para i<-1 Hasta n Hacer sumas <- sumas + (X[i]*Y[i+1] - X[i+1]*Y[i] ); FinPara area <- sumas / 2.0; Escribir area; Leer n; // terminos cuando n=0 FinMientras FinProceso



Problema H: Química Autor: Hernan Payrumani

Lucas está jugando otra vez en la clase de química. En vez de estar balanceando ecuaciones él está escribiendo secuencias codificadas en un papel. Lucas modifica cada palabra adicionando después de cada vocal la letra ‘p’ y luego la misma vocal de nuevo. Por ejemplo, él tiene “clase” que llega a convertirse en “clapasepe” y la palabra “juego” llega a convertirse en “jupuepegopo”. El profesor mira el papel del Lucas con las palabras codificadas y desea saber que escribió. Escribe un programa que decodifique lo que escribió Lucas. Entrada En la primera línea se indica el número de casos que deberán ser evaluados. Cada una de las siguientes líneas es un caso de prueba que es una línea que contiene la sentencia codificada. La secuencia contiene solo letras minúsculas y espacios. Las palabras estarán separadas por un solo espacio y no habrá espacios de más al inicio o al final. La cantidad total de caracteres no sobrepasara los 100. Salida Imprime la sentencia decodificada en una sola línea. Ejemplos de entrada 2 zepelepenapa papapripikapa bapas jepe doposapadgapa opovapa kepemipijapa Ejemplos de salida zelena paprika bas je dosadga ova kemija



Solución // Olimpiada Boliviana De Informatica // Problema : Quimica // Autor : Alberto Suxo // Copyright: Team SIM // Lenguaje : Pseudocodigo PSeInt // ******************************* Proceso Quimica Definir linea, car, resultado Como Caracter; Definir i, tam, casos Como Entero; Leer casos; Mientras casos > 0 Hacer casos <- casos - 1; Leer linea; tam <- Longitud(linea); i <- 0; resultado <- ""; Mientras i < tam Hacer car <- Subcadena( linea, i, i ); resultado <- Concatenar( resultado, car ); i <- i + 1; Si car="a" | car="e" | car="i" | car="o" | car="u" Entonces i <- i + 2; FinSi FinMientras Escribir resultado; FinMientras FinProceso



Anexo Opciones del Lenguaje La ICPC- Bolivia ha visto por conveniente utiliza PSeInt como herramienta para programación y ejecución de diagramas de flujo. PSeInt puede ser encontrado en el siguiente enlace: http://pseint.sourceforge.net Una instalada la Herramienta PSeInt, PSeInt le preguntará Cuál opción de lenguaje utilizará. El presente documento está desarrollado bajo la opción de lenguaje “Estricto”

http://pseint.sourceforge.net/



PSeInt El presente anexo no pretende ser un manual de PSeInt, simplemente se listarán algunas de las opciones que ofrece PSeInt al estudiante. Nosotros lo utilizaremos ya que hace fácil al estudiante migrar del pseudocódigo a su respectivo lenguaje, además, PSeInt ofrece la posibilidad a futuro de exportar el Pseudocódigo a lenguaje C (esto está aún en fase experimental). Comentarios Los comentarios sin segmentos que no afectan el flujo del programan, inicial con ‘//’ y son utilizados para adicionar aclaraciones del código que por sí mismas no son muy intuitivas. También se debe aclarar que los comentarios son segmentos de documentación aclaratoria que es considerada como una buena práctica. Ejemplo // Todo o que sigue a esos dos ‘/’s es un comentario // y jamás se ejecuta. Tipos de Datos PSeInt soporta 4 tipos de datos.

Entero Acepta valores enteros Real Acepta valore decimales Logico Acepta solo valores lógicos (verdadero o falso) Caracter Acepta caracteres y cadenas.

Para definir una o más variables usamos la siguiente sintaxis: Sintaxis Definir <variable1> [,<variable2>,...,<variableN>] Como <Tipo> Ejemplo: Definir linea Como Caracter; Ejemplo: Definir x, y como Real; Asignación Primero evalúa la expresión de la derecha y luego asigna el resultado a la variable de la izquierda. (Deben coincidir en tipo). Sintaxis: <variable> <- <expresión> ; Ejemplo: nombre <- "Juan Perez"; Ejemplo: contador <- contador + 1 ; Operaciones o instrucciones Representaremos las operaciones de forma simple y lo más claro posible. Ejemplos: resultado <- 12 * 4 ; costo <- (resultado * 2) + 7 ; hipotenusa <- raiz( a*a + b*b ) ;



Operadores La jerarquía de los operadores matemáticos es igual a la del algebra, y puede alterarse mediante el uso de paréntesis.

Operador Significado Ejemplo Relacionales > < = <= >= <>

Mayor que Menor que Igual que Menor o igual que Mayor i igual que Distinto que

3 > 2 10 < 50 4 = 5 2 <= 2 var >= 0 0 <> 0

Lógicos & | ~

Conjunción ( y ) Disyunción ( o ) Negación ( no )

(2<4) & (0=>1) // falso (2<4) | (0=>1) // verdadero ~( 2 < 4 ) // falso

Algebraicos + - * / ^

Suma Resta Multiplicación División Potencia

Entrada de datos Podemos leer variables desde teclado. La entrada es secuencial y cada línea es almacenada en cada una de las variables respectivamente. Podemos definir más de una variable separándolas con comas. Sintaxis: Leer <variable1> [, <variable2>,…,<variableN>] ; Ejemplo: Leer nombre; Ejemplo: Leer x, y, radio; Salida de datos Podemos escribir datos en la pantalla, estos datos son los resultados de las expresiones o los contenidos de las variables. También podemos tener uno o más parámetros separados por comas. Sintaxis: Escribir <expresion1> [,<expresion2>,…,<expresionN>]; Ejemplo: Escribir "Ingrese un numero: "; Ejemplo: Escribir "Resultado: " , x*2 ; Condicionales Selectiva – si Las instrucciones selectivas representan instrucciones que pueden o no ejecutarse, según el cumplimiento de su condición.



Sintaxis Si <condición> Entonces Instrucciones [Sino Instrucciones] FinSi La condición puede ser simple o compuesta, dando como único resultado una respuesta o verdadera o falsa. Ejemplo Si edad >= 18 Entonces Escribir "ya puede votar"; FinSi La instrucciones selectiva doble es opcional, solo se aplica cuando requerimos realiza otra tarea cuando no se cumple la condición. Ejemplo Si edad >= 18 Entonces Escribir "Ya puede votar" ; Sino Escribir "esperar una año más" ; Escribir "vuelva a intentar" ; FinSi Selectiva múltiple-casos Permite elegir entre dos o más posibles grupos de acciones. Evalúa el contenido de la variable y selecciona el camino a seguir. La variable debe ser de tipo numérico. Las opciones se delimitan por los dos puntos al final. Si un grupo de acciones se debe ejecutar en dos o más casos, los valores se pueden poner separados por comas en la misma línea. La opción final puede ser ‘De otro modo’, y se ejecuta si la variable no coincide con ninguna de las anteriores. Sintaxis Segun <variable> Hacer <valor1>[,<valor2>,…,<valorN>]: <instrucción(es)>; [<valor>,…<valor>:<instriccion(es)>;] [De Otro Modo: <Instrucción(es)>;] FinSegun Ejemplo: Leer A; Segun A Hacer 1: Escribir 1; 2,3,5,7: Escribir "es numero primo menor a 10"; De Otro Modo: Escribir "intente de nuevo"; FinSegun Estructuras iterativas (bucles) Mientras Como su nombre lo indica, se repite mientras la condiciones sea verdadera. En el bucle ‘mientras’ las instrucciones del contenido pueden o no ser ejecutadas dependiendo de



la condiciones, (de ser inicialmente falsa jamás entrará dentro del bucle). Debe contener dentro alguna acción que pueda modificar la condición para salir. Sintaxis Mientras <condición> Hacer <instrucciones> FinMientras Ejemplo edad <-16 ; Mientras edad<18 Hacer Escribir edad; edad <- edad + 1 ; FinMientras Escribir "por fin puede votar con: " , edad , " años" ; Este programita dará como resultado: 16 17 Por fin puede votar con: 18 años Hacer – mientras La estructura ‘Hacer – Mientras’ no es soportada por PSeInt, pero estada definida en casi todos los lenguajes de programación. A diferencia del bucle ‘mientras’, en ‘hacer – mientras’ se tiene la seguridad que siempre se ejecutará por lo menos una vez el contenido del bucle, este contenido se ejecutará mientras la condición sea verdadera. Sintaxis: Hacer <instrucciones>; Mientras <condición>; Ejemplo ahorro <-10 ; Hacer ahorro <- ahorro + 10 ; Escribir "ya tengo Bs. " , ahorro , " de ahorro" ; Mientras ahorro<97 ; En este pequeño programita, seguiremos ahorrando hasta tener Bs.100 Bucle Repetir Algunos lenguajes de programación implementan el bucle ‘repetir – hasta que’ (ejemplo: Pascal), sin embargo, en lenguajes como C o Java simplemente no existe, pero se puede llegar a implementar negando la condición y utilizando la estructura ‘Hacer – Mientras’. El contenido del bucle se ejecutará hasta que la condición sea verdadera (o, lo que es lo mismo con ‘mientras’, se ejecutará mientras la condición sea falsa). Sintaxis Repetir <instrucciones>; Hasta Que <condición>;



El equivalente con ‘Hacer – Mientras’ es: Hacer <Instrucciones>; Mientras ~ <condición> ; Ejemplo horasTrabajadas <- 0 ; Repetir Escribir "Trabajando…" ; horasTrabajadas <- horasTrabajadas + 1 ; Hasta Que horasTrabajadas=8 ; Bucle Para Quizá la estructura de control más utilizada, la cual se utiliza cuando se desea iterar un número conocido de veces, empleando una variable como índice que se incremente (o decremente). Sintaxis Para <variable> <- <valor inicial> Hasta <valor final> [Con Paso <incremento/decremento>] Hacer <instrucciones>; FinPara El equivalente con ‘mientras’ es: <variable> <- <valor inicial> Mientras <variable> <> <valor final> hacer <instrucciones>; <variable> <- <varialbe> + <incremento/decremento> ; FinMientras ‘Con Paso’ es opcional, cuando no está definido el incremento será de 1: Ejemplo Para i <- 1 Hasta 12 Hacer Escribir "Número " , i ; FinPara Este ejemplo escribe los números: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 y 12. Ejemplo: Para j <- 10 Hasta 0 Con paso -2 Hacer Escribir j; FinPara; En este ejemplo, los números resultantes serán: 10, 8, 6, 4, 2 y 0, en ese orden respectivamente. Arreglos Los arreglos son estructuras de datos unidimensionales (vectores) bidimensionales (matrices), etc de datos del mismo tipo.



Para cerrar arreglos primero debemos definir su tipo, y luego, definir su tamaño de la siguiente forma: Sintaxis: Definir <nombre de arreglo> Como <Tipo de Dato>; Dimension <nombre de arreglo>[<tamaño>[,<tamaño>,…]]; Para declararlos utilizaremos la palabra ‘arreglo’ seguido de nombre de la variable y su tamaño. Ejemplo vector Definir i Como Entero; Definir datos Como Entero; Dimension datos[20]; datos[0] <- 0; datos[1] <- 1; Para i<-2 Hasta 19 Hacer datos[i] <- datos[i-1] + datos[i-2]; FinPara Escribir "El 20vo numero de Fivonacci es : " , datos[19]; Debemos tener claro que, cuando definimos un vector o matriz, siempre comenzará desde 0, es decir, si definimos un vector de 20 elementos, las posiciones de esos elementos serán: 0, 1, 2, … 17, 18 y 19, sumando un total de 20 elementos. Ejemplo matriz Definir mat, fila, col Como Entero; Dimension mat[4,6]; Para fila<-0 Hasta 3 Hacer Para col<-0 Hasta 5 Hacer mat[fila][col] <- fila + col; FinPara FinPara En este ejemplo podemos ver que una matriz se define por lo general como un arreglo de dimensionado por filas x columnas, siendo el número total de elementos la multiplicación de estos datos, (en el ejemplo es 4x6=24). También podemos ver que los bucles pueden anidarse. Funciones En muchas ocasiones, el número de instrucciones es muy grande y muchas veces repetitiva, para lo cual, utilizamos las funciones para simplificar el programa. Las funciones pueden o no recibir parámetros de entrada, y, no siempre devolverá algún resultado. Sintaxis SubProceso [<var resultado> <-] <nombre función>[(<paramentos>)] [Definir <var resultado> Como <Tipo>; ] <instrucciones>;

[<var resultado> <- <instrucción> ; ] FinSubProceso



Ejemplo: SubProceso prom <- Promedio ( arreglo, cantidad ) Definir i como Entero; Definir suma como Real; Definir prom como Real; suma <- 0; Para i<-0 Hasta cantidad-1 Hacer suma <- suma + arreglo[i]; FinPara prom <- suma/cantidad; FinSubProceso Proceso Principal Definir i,N como Entero; Definir acum,datos,prom como Reales; Dimension datos[100]; Escribir "Ingrese la cantidad de datos:"; Leer n; Para i<-0 Hasta n-1 Hacer Escribir "Ingrese el dato ",i+1,":"; Leer datos[i]; FinPara Escribir "El promedio es: ",Promedio(datos,n); FinProceso PSeInt nos provee de funciones predefinidas Funciones Matemáticas

Función Significado RC(X) ABS(X) LN(X) EXP(X) SEN(X) COS(X) ATAN(X) TRUNC(X) REDON(X)

Raíz Cuadrada de X Valor Absoluto de X Logaritmo Natural de X Función Exponencial de X Seno de X Coseno de X Arco tangente de X Parte entera de X Entero más cercano a X

La función raíz cuadrada no debe recibir un argumento negativo. La función exponencial no debe recibir un argumento menor o igual a cero. Funciones para Cadenas Función Significado Longitud(x) Mayusculas(x) Minusculas(x) Subcadena(x,inicio,fin) Concatenar(x,y)

Retorna la cantidad de caracteres de una cadena x. Convierte a mayúsculas la cadena x. Convierte a minúsculas la cadena x. Extrae una parte de la cadena x indicando desde cual hasta que letra. Une las cadenas x y y.

Documents

Solucionario Consolidado Utilizando PSeInt