Informática 3ra Olimpiada 3ra Etapa Nivel2 PDF

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
#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
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.

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

//============================================================================
// Name : sol.cpp
// Author : Hernan Payrumani
//============================================================================
#include <iostream>
int main()
{
int n;
4
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
Problema - Juego de Vida

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.

01010 00000
2 101010
010101 111111
5 111111111
111010 110000000001111110000000000001
58 00101110011
111111111
6
511
110010000010111110010100001001
1000
00101110011
0

// ========================================================================
// 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
return 0 ;
}
8
Problema - Asignación de cuartos

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
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

//============================================================================
// Name : sol.cpp
//============================================================================
#include <iostream>
#include <string>
#include <stdlib.h>
#include <stdio.h>
#include<cstdlib>
#include<algorithm>
#include<vector>
int main() {
int casos;
cin>>casos;
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
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
Problema - Emparejando Peones

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
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
1
0
3921

//============================================================================
// Name : sol.cpp
//============================================================================
#include <iostream>
#include <string>
#include <stdlib.h>
#include<vector>
int main() {
int casos;
cin>>casos;
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
Problema - Izquierda o Derecha

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.

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

//============================================================================
// Name : sol.cpp
//============================================================================
14
#include <iostream>
#include <string>
#include <stdlib.h>
int main() {
int casos;
cin>>casos;
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
Problema - Concurso de Invierno

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 4 resolvió su segunda 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

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

//============================================================================
// Name : sol.cpp
//============================================================================
#include <iostream>
#include <string>
#include <stdlib.h>
int main() {
int casos;
cin>>casos;
int c [1000050];
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
Problema - Jakub
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
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

//============================================================================
// Name : sol.cpp
//============================================================================
#include <iostream>
#include <string>
#include <stdlib.h>
int main() {
int casos;
cin>>casos;
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
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
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.

1 11.45514
1 1
10 10

//============================================================================
// Name : sol.cpp
// Author : Hernan Payrumani
//============================================================================
#include <iostream>
#include <cmath>
#include <stdio.h>
#include <math.h>
int main(){
double tiempo, distancia, x1, x2, y1, y2;
int casos;
cin >> casos;
20
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
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

Informática 3ra Olimpiada 3ra Etapa Nivel2 PDF

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Informática 3ra Olimpiada 3ra Etapa Nivel2 PDF

Enviado por

Direitos autorais:

Formatos disponíveis

1

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

Problema - Insertando Cadenas

Ejemplos de entrada Ejemplos de salida

Programa que resuelve el Problema

Ejemplos de entrada Ejemplos de salida

Programa que resuelve el Problema

Problema - Juego de Vida

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

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

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

Ejemplos de entrada Ejemplos de salida

Programa que resuelve el Problema

Problema - Asignación de cuartos

Cuarto 1 1199, 888, 491

Cuarto 2 994, 879

Cuarto 3 981, 763

Programa que resuelve el Problema

Problema - Emparejando Peones

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

Usted puede realizar tantas movidas como desee en cualquier orden.

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

Programa que resuelve el Problema

Problema - Izquierda o Derecha

Ejemplos de entrada Ejemplos de salida

Programa que resuelve el Problema

Problema - Concurso de Invierno

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

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

• El concursante 4 resolvió su primera tarea

Halle el número de concursante que gano.

Ejemplos de entrada Ejemplos de salida

Programa que resuelve el Problema

Programa que resuelve el Problema

Ejemplos de entrada Ejemplos de salida

Programa que resuelve el Problema

Proponentes de los Problemas

Você também pode gostar