Você está na página 1de 21

1

Web Oficial: http://olimpiada.icpc-bolivia.edu.bo contacto: olimpiada@icpc-bolivia.edu.bo

Problema - Insertando Cadenas


LOS DATOS DE ENTRADA DEBEN LEER DE 227.in LA SALIDA DEBE GRABAR EN UN ARCHIVO LLAMADO
respuesta-227.out

Fox tiene una nueva operación con cadenas y funciona como sigue: Toma dos copias de una cadena X y
inserta una copia en algún lugar dentro de la otra cadena, que puede también ser al principio o al final.
Por ejemplo si X=Ciel, se puede expandir a CielCiel, CCieliel, CiCielel, o CieCiell.

Le dan dos cadenas S y T escriba Y es si la cadena T puede ser obtenida expandiendo S exactamente una
vez. Si no es posible escriba No.

Entrada
Los datos de entrada consisten en múltiples casos de prueba. La primera línea indica el número de casos
de prueba. Cada caso de prueba contiene dos cadenas, cada una en una línea. La primera línea de un
caso de prueba contiene S y la segunda contiene T.

Salida
Imprima en una línea Y es si la cadena T puede ser obtenida expandiendo S exactamente una vez. Si no
es posible escriba No.

Ejemplos de entrada Ejemplos de salida


7 Yes
Ciel No
CieCiell Yes
Ciel No
FoxCiel No
FoxCiel No
FoxFoxCielCiel Yes
FoxCiel
FoxCielCielFox
Ha
HaHaHaHa
TheHandleCanBeVeryLong
TheHandleCanBeVeryLong
Long
LongLong

Programa que resuelve el Problema


//============================================================================
// Name : sol.cpp
// Author :
// Version :
// Copyright : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================
2
Web Oficial: http://olimpiada.icpc-bolivia.edu.bo contacto: olimpiada@icpc-bolivia.edu.bo

#include <iostream>
#include <string>
using namespace std;
int main() {
int casos;
cin>>casos;
for(int j1=0;j1<casos;j1++){
string s;
string t;
cin>>s;
cin>>t;
int i,j,l;
i= t.find(s);
if (i>=0){
string x=t.substr(0,i)+t.substr(i+s.length());
if (!x.compare(s))
cout<<"Yes";
else
cout<<"No";
}
else
cout<<"No";
cout <<endl;
}
return 0;
}
3
Web Oficial: http://olimpiada.icpc-bolivia.edu.bo contacto: olimpiada@icpc-bolivia.edu.bo

Problema - X
LOS DATOS DE ENTRADA DEBEN LEER DE x.in LA SALIDA DEBE GRABAR EN UN ARCHIVO LLAMADO
respuesta-x.out

X es sin duda la letra y también el símbolo más usada en matemáticas, se utiliza como variable para el
valor de un eje del plano cartesiano, como incógnita de ecuaciones, y también n representa la operación
de multiplicación, por todo eso sin duda se merece un homenaje.

Estas encargado de realizar este homenaje de manera artística, debes mostrar X en la pantalla en forma
de cuadro formado por los caracteres ‘X’y ‘*’.

Entrada
La entrada consiste de varios casos de prueba. La primera línea indica el número de casos. Las líneas
siguientes corresponde a los casos de prueba, cada uno consiste en un numero entero impar n (1 ≤ n ≤
99).

Salida
Imprimir un cuadro formado por los símbolos ‘X’ y ‘*’ en donde el la forma de X se resalte.

Ejemplos de entrada Ejemplos de salida


3 X
1 X*X
3 *X*
5 X*X
X*****X
*X***X*
**X*X**
***X***
**X*X**
*X***X*
X*****X

Programa que resuelve el Problema


//============================================================================
// Name : sol.cpp
// Author : Hernan Payrumani
//============================================================================
#include <iostream>
using namespace std;
int main()
{
int n;
4
Web Oficial: http://olimpiada.icpc-bolivia.edu.bo contacto: olimpiada@icpc-bolivia.edu.bo
int casos;
cin >> casos;
while(casos>0){
cin>>n;
for(int filas = 0; filas < n; filas++){
for(int columnas = 0; columnas < n; columnas++){
if(filas == columnas || columnas == ((n-1) - filas)) {
cout<<"X";
}
else{
cout<<"*";
}
}
cout<<endl;
}
casos--;
}
return 0;
}
5
Web Oficial: http://olimpiada.icpc-bolivia.edu.bo contacto: olimpiada@icpc-bolivia.edu.bo

Problema - Juego de Vida


LOS DATOS DE ENTRADA DEBEN LEER DE 235.in LA SALIDA DEBE GRABAR EN UN ARCHIVO LLAMADO
respuesta-234.out

Un conejo y un gato inventaron una variación al Juego de la Vida.

Se tienen N celdas acomodadas en un círculo. Estas celdas están numeradas del 0 al N − 1. Para todas las
celdas entre i y N −2, inclusive, la iesima celda es adyacente a la celda i−1 la celda N − 1 y la celda 0 son
adyacentes. Cada celda tiene exactamente dos celdas adyacentes. Cada celda puede tener dos estados
vivir, o morir.

El gato y el conejo pueden decidir el estado de las celdas en el instante t = 0. Para t > 0 los estados se
determinan como sigue:

• Considere tres celdas: la celda iesima y sus dos celdas adyacentes.


• Si al menos dos de los tres celtas son vivir en el tiempo t−1 el estado de la celda iesima será vivir
• Si al menos dos de la tres celdas son morir en el tiempo t−1 el estado de la celda iesima será
morir

En el tiempo inicial se tiene una cadena donde cada caracter representa una celda. La iesima celda está
representada por el caracter 0, que significa morir o el caracter 1 que significa vivir.

Dado el tiempo t se le pide hallar el estado el estado final.

Por ejemplo: dada la cadena 01010 en el tiempo t = 1 la cadena se vuelve 00100, en el tiempo t = 2 se
convierte en 00000. Esta es la respuesta para t = 2.

Entrada
La entrada consiste en varios casos de prueba. La primera línea indica el número de casos de prueba.
Cada caso de prueba está en dos líneas la primera línea que contiene la cadena don los estados iniciales
y la segundo el valor de t.

Salida
Escriba en una línea en el mismo formato de la entrada el estado al que se llegara en el tiempo t.

Ejemplos de entrada Ejemplos de salida


01010 00000
2 101010
010101 111111
5 111111111
111010 110000000001111110000000000001
58 00101110011
111111111
6
Web Oficial: http://olimpiada.icpc-bolivia.edu.bo contacto: olimpiada@icpc-bolivia.edu.bo

511
110010000010111110010100001001
1000
00101110011
0

Programa que resuelve el Problema


// ========================================================================
// Name : sol.cpp
// Author : Jorge Teran
// ========================================================================
#include <iostream>
#include <string>
#include <stdlib.h>
#include <cstdlib>
#include <algorithm>
#include <vector>
using namespace std ;
int main ( ) {
int vivir = 1;
int morir = 0;
int casos;
cin >> casos;
for ( int j1=0; j1<casos; j1++ ) {
string s;
cin >> s;
int len= s.length();
int t;
cin >> t;
int estado[len] ;
for ( int j=0 ; j<len; j++ )
estado[j] = s[j]−48;
int suma=0;
for ( int j=0; j<t; j++ ) {
for ( int i=0; i<len; i++ ) {
suma=0;
if( i==0 )
suma=estado[len−1]+estado[i]+estado[i+1];
else
if( i==len−1 )
suma=estado[i−1]+estado[i]+estado[0];
else
suma=estado[i−1]+estado[i]+estado[i+1];
if( suma>1 )
estado[i]=vivir;
else
estado[i]=morir;
}
}
for ( int j=0; j<len; j++ )
cout << estado[j];
cout << endl ;
}
7
Web Oficial: http://olimpiada.icpc-bolivia.edu.bo contacto: olimpiada@icpc-bolivia.edu.bo
return 0 ;
}
8
Web Oficial: http://olimpiada.icpc-bolivia.edu.bo contacto: olimpiada@icpc-bolivia.edu.bo

Problema - Asignación de cuartos


LOS DATOS DE ENTRADA DEBEN LEER DE 234.in LA SALIDA DEBE GRABAR EN UN ARCHIVO LLAMADO
respuesta-234.out

Usted ha sido introducido a una competencia de programación en línea llamada SRM. Existen N
codificadores en la competencia, incluyéndolo a usted. La información se la dan como ratings i donde i es
el rating de un codificador. Eu rating está en i = 0.

Ahora pasamos a la fase de asignación de cuartos para la competencia. Existen K cuartos. Cada
Codificador será asignado a un cuarto de la siguiente forma: en orden descendente de ratings, se
asignan uno por uno a los cuartos.

Usted desea ganar la competencia, y desea saber cuántos competidores con más rating que usted hay
en el cuarto que le toco.

Por ejemplo: si tenemos 7 codificadores 491, 981, 1199, 763, 994, 879, 888 y tres cuartos. Los
codificadores serian asignados a los cuartos como sigue:

Cuarto 1 1199, 888, 491

Cuarto 2 994, 879

Cuarto 3 981, 763

Le toco el cuarto número 1 y tiene dos codificadores con mayor rating que el suyo. La respuesta seria 2.

Entrada
La entrada consiste de múltiples casos de prueba. La primera línea indica el número casos de prueba.
Cada caso de prueba consiste de tres líneas. La primera línea contiene el número N de codificadores. La
segunda línea contiene los (1 ≤ N ≤ 50) ratings separados por un espacio. La tercera línea tiene el
número de cuartos (1 ≤ K ≤ 50) con el número de cuartos que se utilizarán.

Salida
Por cada caso de entrada muestre en una línea el número de codificadores con mayor rating que el suyo
en el cuarto que se le asigno.

Ejemplos de entrada
6
7
491 981 1199 763 994 879 888
3
3
1024 1000 600
9
Web Oficial: http://olimpiada.icpc-bolivia.edu.bo contacto: olimpiada@icpc-bolivia.edu.bo

1
4
505 679 900 1022
2
9
716 58 1000 1004 912 822 453 1100 558
3
14
422 623 1023 941 882 776 852 495 803 622 618 532 751 500
4
5
1197 1198 1196 1195 1199
1

Ejemplos de salida
2
0
1
1
3
2

Programa que resuelve el Problema


//============================================================================
// Name : sol.cpp
// Author : Jorge Teran
//============================================================================

#include <iostream>
#include <string>
#include <stdlib.h>
#include <stdio.h>
#include<cstdlib>
#include<algorithm>
#include<vector>
using namespace std;

int main() {
int casos;
cin>>casos;
for(int j1=0;j1<casos;j1++){
int n;
cin >> n;
int s[n];
for (int i = 0; i < n; i++)
s[i]=0;
for (int i = 0; i < n; i++)
cin >> s[i];
10
Web Oficial: http://olimpiada.icpc-bolivia.edu.bo contacto: olimpiada@icpc-bolivia.edu.bo
int j=0,k=0;
cin >> k;
int miRating=s[0];
sort(s,s+n);
int cuartos[k];
for (int i = 0; i < k; i++)
cuartos[i]=0;
int resp=0;
for (int i = 0; i < n; i++) {
if (s[i]>miRating)
cuartos[i%k]++;
else
if (s[i]==miRating)
resp=i%k;
}
cout << cuartos[resp] << endl;
}
return 0;
}
11
Web Oficial: http://olimpiada.icpc-bolivia.edu.bo contacto: olimpiada@icpc-bolivia.edu.bo

Problema - Emparejando Peones


LOS DATOS DE ENTRADA DEBEN LEER DE 232.in LA SALIDA DEBE GRABAR EN UN ARCHIVO LLAMADO
respuesta-232.out

Emparejar peones es un juego que se juega en una cinta de papel dividida en N celdas que están
etiquetadas de 0 a N − 1. Cada celda tiene un número arbitrario de peones.

El objetivo del juego es traer el mayor número de peones a la celda 0. Las únicas movidas validas son:

• Encontrar un par de peones que compartan una celda digamos X.


• Quitar un par de peones de la celda X.
• Adicionar un peón a la celda X − 1.

Usted puede realizar tantas movidas como desee en cualquier orden.

Al final se pide mostrar cuantos peones hay en la celda 0.

Entrada
La entrada consiste de múltiples casos de prueba. La primera línea indica el número casos de prueba.
Cada caso de prueba tiene dos líneas. La primera línea contiene el número de celda N. La segunda línea
contiene N números que representan el número de peones que hay en cada celda.

Salida
Muestre en una línea cuantos peones hay en la celda 0.

Ejemplos de entrada
6
2
0 2
2
10 3
4
0 0 0 8
4
0 1 1 2
19
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 123456
8
1000 2000 3000 4000 5000 6000 7000 8000
Ejemplos de salida
1
11
1
12
Web Oficial: http://olimpiada.icpc-bolivia.edu.bo contacto: olimpiada@icpc-bolivia.edu.bo
1
0
3921

Programa que resuelve el Problema


//============================================================================
// Name : sol.cpp
// Author : Jorge Teran
//============================================================================

#include <iostream>
#include <string>
#include <stdlib.h>
#include<vector>
using namespace std;

int main() {
int casos;
cin>>casos;
for(int j1=0;j1<casos;j1++){
int n;
cin >> n;
int s[n];
for (int i = 0; i < n; i++)
cin >> s[i];
int j=0;
for (int i = n - 1; i >0; i--) {
if(s[i]>1)
s[i-1]+=s[i]/2;
}
cout << s[0] <<endl;
}
return 0;
}
13
Web Oficial: http://olimpiada.icpc-bolivia.edu.bo contacto: olimpiada@icpc-bolivia.edu.bo

Problema - Izquierda o Derecha


LOS DATOS DE ENTRADA DEBEN LEER DE 230.in LA SALIDA DEBE GRABAR EN UN ARCHIVO LLAMADO
respuesta-230.out

La universidad está desarrollando un nuevo robot espía. Actualmente este robot solo acepta dos
comandos izquierda = L y Derecha = R. L mueve el robot una unidad de distancia a la izquierda, y R
mueve el robot una unidad de distancia a la derecha. Un programa es una secuencia de instrucciones
Para un programa dado, el alcance es la distancia entre el punto de inicio y la distancia más lejana
visitada.

Por ejemplo el alcance del programa LLLR es 3 porque después de las tres primeras instrucciones se
llegó a la ubicación 3 unidades más lejos del punto de inicio.

Los programas fueron escritos a mano y luego de hacer un reconocimiento automático de los caracteres
muchos no pudieron identificarse y se cambiaron por un símbolo de interrogación.

Dada una cadena que describe un programa del robot donde cada caracter puede ser L, R o ? donde ?
representa un caracter no identificado. Remplace la ? por caracteres L o R de tal forma que el programa
corregido haga que el alcance sea máximo.

Entrada
La entrada consiste en varios casos de prueba. La primera línea indica el número casos de prueba. Cada
caso de prueba está en una línea y se compone de caracteres L,R o ?.

Salida
Por cada caso de prueba imprima en una línea el alcance máximo que el robot puede alcanzar una vez
corregido el programa.

Ejemplos de entrada Ejemplos de salida


6 3
LLLRLRRR 4
R???L 6
?????? 11
LL???RRRRRRR??? 13
???RRRRRRR??? 4
L?L?

Programa que resuelve el Problema


//============================================================================
// Name : sol.cpp
// Author : Jorge Teran
//============================================================================
14
Web Oficial: http://olimpiada.icpc-bolivia.edu.bo contacto: olimpiada@icpc-bolivia.edu.bo
#include <iostream>
#include <string>
#include <stdlib.h>
using namespace std;

int main() {
int casos;
cin>>casos;
for(int j1=0;j1<casos;j1++){
string p;
cin >> p;
int maximo=0, pos=0, d=0;
for (int i = 0; i < p.length(); i++){
if (p.at(i)=='?')
d++;
if (p.at(i)=='L')
pos++;
if (p.at(i)=='R')
pos--;
maximo=max(maximo,abs(pos)+d);
}
cout << maximo << endl;
}
return 0;
}
15
Web Oficial: http://olimpiada.icpc-bolivia.edu.bo contacto: olimpiada@icpc-bolivia.edu.bo

Problema - Concurso de Invierno


LOS DATOS DE ENTRADA DEBEN LEER DE 229.in LA SALIDA DEBE GRABAR EN UN ARCHIVO LLAMADO
respuesta-229.out

Exactamente un millón de concursantes, numerados desde 1 hasta 1, 000, 000 tomaron parte en un
concurso de programación. Las reglas del concurso eran simples:

• El ganador del concurso es el que resuelve la mayor cantidad de tareas.


• En caso de empate el ganador es el primero en resolver todas sus tareas.

Durante la competencia los jueces mantienen una bitácora de todas las soluciones aceptadas. Para que
pueda determinar el ganador se le entregará esta bitácora.

Por ejemplo si los eventos son 4, 7, 4, 1, lo que ocurrió es:

• El concursante 4 resolvió su primera tarea


• El concursante 7 resolvió su primera tarea
• El concursante 4 resolvió su segunda tarea
• El concursante 1 resolvió su primera tarea

Halle el número de concursante que gano.

Entrada
La entrada consiste en múltiples casos de prueba. La primera línea indica el número casos de prueba.
Cada caso de prueba consiste de dos líneas. La Primera contiene el número (1 n 50) de tareas resueltas.
La segunda línea contiene el las n tareas separados por un espacio. Cada Tarea es un número (1 ≤ t ≤ 1,
000, 000).

Salida
Imprima en una línea el número del participante que gano

Ejemplos de entrada Ejemplos de salida


4 4
4 10
4 7 4 1 456
5 4
10 20 30 40 50
6
123 123 456 456 456 123
10
1 2 2 3 3 3 4 4 4 4
16
Web Oficial: http://olimpiada.icpc-bolivia.edu.bo contacto: olimpiada@icpc-bolivia.edu.bo

Programa que resuelve el Problema


//============================================================================
// Name : sol.cpp
// Author : Jorge Teran
//============================================================================

#include <iostream>
#include <string>
#include <stdlib.h>
using namespace std;

int main() {
int casos;
cin>>casos;
int c [1000050];
for(int j1=0;j1<casos;j1++){
int t;
cin >>t;
for (int i = 0; i < 1000050; i++)
c[i]=0;
long max=-1, gana=0, j=0;
for (int i = 0; i < t; i++){
cin >> j;
c[j]++;
//cout << j << endl;
//cout << c[j] << endl;
if (c[j]>max){
max=c[j];
gana=j;
}
}
cout << gana << endl;
}
return 0;
}
17
Web Oficial: http://olimpiada.icpc-bolivia.edu.bo contacto: olimpiada@icpc-bolivia.edu.bo

Problema - Jakub
LOS DATOS DE ENTRADA DEBEN LEER DE 228.in LA SALIDA DEBE GRABAR EN UN ARCHIVO LLAMADO
respuesta-228.out

Jacuk está probando un teclado unidimensional. Consiste de una fila de teclas. La distancia entre dos
teclas adyacentes es 1. Cada letra contiene una letra distinta del alfabeto inglés. Jackub utiliza un solo
dedo para escribir en el teclado. Y él quiere conocer cuál es la distancia total más pequeña que tendrá
que mover su dedo para escribir una palabra dada.

Por ejemplo si el teclado es qwertyuiop y le dan a escribir la palabra potter tendrá que mover su dedo
de la p a la o, con una distancia de 1, luego de la o a la t con distancia de 4, la distancia de la t a la t es
cero. De la t a la e es 2 y de la e a la r es 1 totalizando 1 + 4 + 0 + 2 + 1 = 8.

Entrada
La entrada consiste de múltiples casos de prueba. La primera línea indica el número casos de prueba.
Cada caso de prueba contiene dos líneas, la primera con el teclado que podrá tener entre 1 y 26
caracteres. La segunda con la palabra a escribir.

Salida
Por cada línea de entrada en una línea escriba la distancia mínima que deberá mover su dedo para
escribir la palabra dada.

Ejemplos de entrada
5
qwertyuiop
potter
tc
tctcttccctccccttc
a
aaaaaaaaaaa
kwadrutove
rowerowe
qwertyuiopasdfghjklzxcvbnm
topcodersingleroundmatchgoodluckhavefun

Ejemplos de salida
8
9
0
39
322
18
Web Oficial: http://olimpiada.icpc-bolivia.edu.bo contacto: olimpiada@icpc-bolivia.edu.bo

Programa que resuelve el Problema


//============================================================================
// Name : sol.cpp
// Author : Jorge Teran
//============================================================================

#include <iostream>
#include <string>
#include <stdlib.h>
using namespace std;

int main() {
int casos;
cin>>casos;
for(int j1=0;j1<casos;j1++){
string t;
string p;
cin>>t;
cin>>p;
int teclado[255];
for (int i = 0; i < 255; i++)
teclado[i]=0;
for (int i = 0; i < t.length(); i++)
teclado[t.at(i)]=i;
int s=0;
for (int i = 1; i < p.length(); i++)
s+= abs(teclado[p.at(i-1)]-teclado[p.at(i)]);
cout << s << endl;
}
return 0;
}
19
Web Oficial: http://olimpiada.icpc-bolivia.edu.bo contacto: olimpiada@icpc-bolivia.edu.bo

Problema - GPS
LOS DATOS DE ENTRADA DEBEN LEER DE gps.in LA SALIDA DEBE GRABAR EN UN ARCHIVO LLAMADO
respuesta-gps.out

Gabriela Pando Salcedo perdió su teléfono celular en el trayecto a su casa. Por suerte este cuenta con un
GPS interno que le indica la posición de su celular. Lamentablemente es tarde y no puede tardar mucho
buscando su celular, utilizando su computadora portátil ella tiene también su ubicación actual y la
ubicación de su celular pero como utiliza un programa antiguo de consola estos solo le muestran las
posiciones x, y del celular y la suya.

Sabiendo que las personas caminan en promedio 1.11111 metros por segundo, cuanto tiempo tardaría
Gabriela en buscar su celular?

Entrada
La entrada consiste de múltiples casos de prueba. La primera línea indica el número casos de prueba.
Cada caso de prueba consiste en cuatro números reales x1, y1 y x2, y2 representado dos puntos en el
plano cartesiano la primera la posición actual de Gabriel, la segunda el punto en donde el celular se
encuentra.

Salida
Imprimir cuanto tiempo se tardara Gabriel de ir desde x1, y1 hasta x2, y2, la salida debe tener 5
decimales de precisión.

Ejemplos de entrada Ejemplos de salida


1 11.45514
1 1
10 10

Programa que resuelve el Problema


//============================================================================
// Name : sol.cpp
// Author : Hernan Payrumani
//============================================================================
#include <iostream>
#include <cmath>
#include <stdio.h>
#include <math.h>
using namespace std;

int main(){
double tiempo, distancia, x1, x2, y1, y2;
int casos;
cin >> casos;
20
Web Oficial: http://olimpiada.icpc-bolivia.edu.bo contacto: olimpiada@icpc-bolivia.edu.bo
while(casos>0 ){
cin >> x1 >> y1 >> x2 >> y2;
distancia = sqrt( pow(x2 - x1, 2.0) + pow(y2 - y1, 2.0) );
tiempo = distancia / 1.11111;
printf("%.5f\n", tiempo);
casos--;
}
return 0;
}
21
Web Oficial: http://olimpiada.icpc-bolivia.edu.bo contacto: olimpiada@icpc-bolivia.edu.bo

Proponentes de los Problemas


• X - Hernan Payrumani
• GPS - Hernan Payrumani
• Insertando Cadenas - Jorge Teran
• Jacub - Jorge Teran
• Curso de Invierno - Jorge Teran
• Izquierda o Derecha - Jorge Teran
• Emparejando Peones - Jorge Teran
• Asignaci´on de Cuartos - Jorge Teran
• Juego de Vida - Jorge Teran