Solucionario Consolidado Utilizando PSeInt PDF

ACM – ICPC Bolivia
Solucionario Consolidado
Utilizando PSeInt
2da Olimpiada Boliviana de Informática
Estado Plurinacional de Bolivia, febrero de 2013
Alberto J. Suxo Riveros

<albertosuxo@gmail.com>
Alberto J. Suxo Riveros 1

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

// Problema : Hallando números capicúas
// *******************************
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

// Problema : Poema
// *******************************
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

// Problema : Ultima Esperanza
// *******************************
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
// Problema : Bolivia Word
// *******************************
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

// Problema : Cena para Cinco
// *******************************
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

// Problema : Código USSD
// *******************************
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
// Problema : Sumando Fibonacci
// *******************************
Proceso Fibo
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
// Problema : Leones
// *******************************
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

// Problema : Número de la suerte
// *******************************
// 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 Ejemplos de salida

4 88975
--. 8000
.. 88400
-... 5
---
.
0
0
0
--.
.
0
0
0
0
0
-

Solución
// Problema : Aritmética Maya
// *******************************
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 = dne +…+ d3e + d2e + d1e + d0e.
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
// Problema : Narcisos
// *******************************
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
// Problema : Trinomios Triangulares
// *******************************
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 Ejemplos de salida

5 2
00000000010 4
00000000110 10
00011000000 6
00000011000 6
00001000001

Solución
// Problema : Calculadora Inca
// *******************************
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
total <- total + 5;
FinSi
total <- total + 5;
FinSi
total <- total + 5;
FinSi
total <- total + 5;
FinSi
total <- total + 3;
FinSi
total <- total + 3;
FinSi
total <- total + 3;
FinSi
total <- total + 2;
FinSi
total <- total + 2;
FinSi
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
// Problema : Aritmetica
// *******************************
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" );
FinSegun
tamA <- tamA + 1;
tamB <- tamB + 1;
FinPara
Escribir resultado;
FinSubProceso

Proceso Aritmerica
Definir casos 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
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
// Problema : Bender
// *******************************
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";
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
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
// Problema : Eratostenes
// *******************************
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;
vec[i] <- 0;
FinPara
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
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
// Problema : Examen
// *******************************
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
// Problema : Lago
// *******************************
// 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
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;
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
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
// Problema : Quimica
// *******************************
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”

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:
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 3 > 2
< Menor que 10 < 50
= Igual que 4 = 5
<= Menor o igual que 2 <= 2
>= Mayor i igual que var >= 0
<> Distinto que 0 <> 0
Lógicos
& Conjunción ( y ) (2<4) & (0=>1) // falso
| Disyunción ( o ) (2<4) | (0=>1) // verdadero
~ Negación ( no ) ~( 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 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) Raíz Cuadrada de X
ABS(X) Valor Absoluto de X
LN(X) Logaritmo Natural de X
EXP(X) Función Exponencial de X
SEN(X) Seno de X
COS(X) Coseno de X
ATAN(X) Arco tangente de X
TRUNC(X) Parte entera de X
REDON(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) Retorna la cantidad de caracteres de una cadena x.
Mayusculas(x) Convierte a mayúsculas la cadena x.
Minusculas(x) Convierte a minúsculas la cadena x.
Subcadena(x,inicio,fin) Extrae una parte de la cadena x indicando desde cual
hasta que letra.
Concatenar(x,y) Une las cadenas x y y.

Solucionario Consolidado Utilizando PSeInt PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Solucionario Consolidado Utilizando PSeInt PDF

Cargado por

Copyright:

Formatos disponibles

ACM – ICPC Bolivia

Alberto J. Suxo Riveros

Alberto J. Suxo Riveros 1

Alberto J. Suxo Riveros 2

Fase 4 – Final Nacional

La distancia de Hamming entre dos números está definida como el número de

La entrada son cadenas que contienen las representaciones binarias de ciertos

Todos los elementos de números contendrán sólo los caracteres 1 y 0.

Alberto J. Suxo Riveros 1

// Olimpiada Boliviana De Informatica

Alberto J. Suxo Riveros 2

Problema B: Hallando números capicúas

Por ejemplo el 14 lo invertimos y obtenemos 41 sumamos al número original obteniendo

Otro ejemplo 95+59=154. Invertimos y sumamos 154+451=605. Repetimos el proceso

Alberto J. Suxo Riveros 3

// Olimpiada Boliviana De Informatica

SubProceso resultado <- invertir ( a )

Alberto J. Suxo Riveros 4

Tu trabajo es ayudar a estos niños.

Alberto J. Suxo Riveros 5

// Olimpiada Boliviana De Informatica

SubProceso resultado <- esVocal( ch )

Alberto J. Suxo Riveros 6

Problema D: La Última Esperanza

A continuación vendrán N líneas, cada una de 2 valores x, y (0 ≤ x, y ≤ 1000) donde

Alberto J. Suxo Riveros 7

Alberto J. Suxo Riveros 8

// Olimpiada Boliviana De Informatica

SubProceso resultado <- distancia( P1x, P1y, P2x, P2y)

Alberto J. Suxo Riveros 9

Problema E: Bolivia Word

Por ejemplo si tenemos las letras O, I, L, I, B, V, A, Z, T y queremos armar la palabra

Alberto J. Suxo Riveros 10

Alberto J. Suxo Riveros 11

La cantidad de puntos que un concursante obtiene es igual a la suma de puntos que

Escribe un programa que determine al ganador y cuantos puntos obtuvo.

Se garantiza que la entrada genera una solución única.

Alberto J. Suxo Riveros 12

// Olimpiada Boliviana De Informatica

Alberto J. Suxo Riveros 13

Problema B: Código USSD

Se consideran códigos validos los que cumplen esta especificación.

Alberto J. Suxo Riveros 14

// Olimpiada Boliviana De Informatica

SubProceso resultado <- NoEsValido( car )

Alberto J. Suxo Riveros 15

Alberto J. Suxo Riveros 16

Problema C: Sumando Fibonacci

Tomando solamente los números binarios tendríamos

Alberto J. Suxo Riveros 17

Alberto J. Suxo Riveros 18

En la selva se han mimetizado varios leones, grrrrr....., debemos pasar la selva.... es

Alberto J. Suxo Riveros 19

SubProceso posi <- buscar (selva, letra, pos )

SubProceso cant <- contarLeon ( selva )

Alberto J. Suxo Riveros 20

Problema E: Número de la suerte

En la teoría de números, un número de la suerte es un número natural en un conjunto

Comenzando con una lista de números enteros a partir de 1:

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

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

La lista anterior es también la lista de números de la suerte menores a 100.