OBI 2007

Fase I - Nível 1
Linguagem - Python
Detectando Colisões
Detecção de colisão é uma das operações mais comuns (e importantes) em jogos
eletrônicos. O objetivo, basicamente, é verificar se dois objetos quaisquer colidiram, ou
seja, se a interseção entre eles é diferente de vazio. Isso pode ser usado para saber se
duas naves colidiram, se um monstro bateu numa parede, se um personagem pegou um
item, etc.
Para facilitar as coisas, muitas vezes os objetos são aproximados por figuras geométricas
simples (esferas, paralelepípedos, triângulos etc). Neste problema, os objetos são
aproximados por retângulos num plano 2D.

Tarefa
Escreva um programa que, dados dois retângulos, determine se eles se interceptam ou
não.

Entrada
A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de
entrada padrão (normalmente o teclado). Cada caso de teste contém duas linhas. Cada
linha contém quatro inteiros (x0, y0, x1, y1, sendo 0 ≤ x0 < x1 ≤ 1.000.000 e 0 ≤ y0 < y1 ≤
1.000.000) separados por um espaço em branco representando um retângulo. Os lados
do retângulo são sempre paralelos aos eixos x e y.

Saída
Seu programa deve imprimir, na saída padrão, uma única linha para cada caso de teste,
contendo o número 0 (zero) caso não haja interseção ou o número 1 (um) caso haja.

Exemplos
Entrada Saída

0011 1
0011

Entrada Saída

0022 1
1133

Entrada Saída

0011 0
2233

Fonte: http://olimpiada.ic.unicamp.br/pratique/programacao/nivel1/2007f1p1_colisoes
 Os problemas da primeira fase são geralmente problemas mais simples e exigem
apenas um conhecimento básico de programação do competidor. Associado a este
conhecimento de programação, o bom competidor deve dominar bem princípios básicos
de lógica e matemática. Estes conhecimentos são valiosos para seu bom desempenho.
Esse problema exige do competidor um conhecimento, mesmo que superficial, de
geometria analítica. Cada entrada corresponde as coordenadas de um retângulo que
possui seus lados paralelos aos eixos do plano cartesiano. Podemos entender melhor a
afirmação acima analisando a segunda entrada do exemplo do problema:

x0 y0 x1 y1
0 0 2 2

Essas são as coordenadas dos cantos inferior esquerdo (0, 0) e superior direito (2,
2) do primeiro retângulo. Isso gera a seguinte figura:
y

2 (2,2)

(0,0) 2
x

As coordenadas do segundo retâgulo correspondem a segunda linha da entrada:

x0 y0 x1 y1
1 1 3 3

Essas são as coordenadas dos cantos inferior esquerdo (1, 1) e superior direito (3,
3) do primeiro retângulo. Isso gera a seguinte figura:
y
(3,3)
3

1
(1,1)

1 2 3
x
 Juntando as duas figuras temos:

y
(3,3)
3

1
(1,1)

(0,0) 1 2 3
x
Para a entrada acima obtém-se a saída '1'. Essa saída ocorre quando há uma
intersecção entre os dois objetos.
O algoritmo para a resolução é bem simples! Para montá-lo, basta que o
competidor crie duas situações extremas em que os retângulos se tocam:

1ª Situação:
y
Retângulo 1

Retângulo 2

x2[0] x1[0] x2[2] x1[2]

x
2ª Situação:
y
Retângulo 1

Retângulo 2

x1[0] x2[0] x1[2] x2[2]

x
 Antes de explicarmos a figura acima são necessários alguns exclarecimentos
acerca das nomenclaturas usadas. Devido a sintaxe da linguagem, foram trocadas as
coordenadas x0 e y0 por xn[0] e xn[1], respectivamente, e as coordenadas x 1 e y1 por xn[2]
e xn[3], respectivamente, onde n corresponde ao número associado ao retângulo. Essa
mudança na nomenclatura se deve a forma de entrada dos dados. Em python, as listas
começam com índice 0. Logo, temos:

x0 y0 x1 y1
xn[0] xn[1] xn[2] xn[3]

Observando as figuras acima, é possível verificar as duas situações em que é

possível ocorrer intersecção. A primeira situação ocorre a intersecção quando x1[0]
encontra-se entre x2[0] e x2[2]. Essa situação pode ser representada em python da
seguinte forma: x2[0] <= x1[0] <= x2[2]. Ou seja, ocorrerá intersecção quando x1[0]
estiver contido no intervalo [x2[0];x2[2]]. Na segunda situação, a intersecção ocorre
quando x2[0] encontra-se entre x1[0] e x1[2]. Essa situação pode ser representada da
seguinte forma: x1[0] <= x2[0] <= x1[2]. Ou seja, ocorrerá intersecção quando x2[0]
estiver contido no intervalo [x1[0];x1[2]]. Essas condições devem ser implementadas em
um “if”, ligadas por um “or”. A partícula or demonstra que para qualquer um dos casos
ocorrerá intersecção e o programa deverá imprimir “1”, já em caso contrário deverá
imprimir “0”. O código python é mostrado no quadro abaixo:

1 #! /usr/bin/env python2.7
2
3 """
4 xn[0] -> xo
5 xn[1] -> yo
6 xn[2] -> x1
7 xn[3] -> y1
8 """
9
10 import sys
11
12 # Leitura dos dados de entrada.
13 x1 = map(int,sys.stdin.readline().split())
14 x2 = map(int,sys.stdin.readline().split())
15
16 #Análise dos casos de interesecção.
17 if x1[0]<=x2[0]<=x1[2] or x2[0]<=x1[0]<=x2[2]:
18 print 1
19 else:
20 print 0

Observação Importante !

Apesar do código acima compilar corretamente e conseguir todos os pontos

disponíveis para a tarefa, ele está incompleto...
Peça Perdida
Joãozinho adora quebra-cabeças, essa é sua brincadeira favorita. O grande
problema, porém, é que às vezes o jogo vem com uma peça faltando. Isso irrita bastante
o pobre menino, que tem de descobrir qual peça está faltando e solicitar uma peça de
reposição ao fabricante do jogo. Sabendo que o quebra-cabeças tem N peças,
numeradas de 1 a N e que exatamente uma está faltando, ajude Joãozinho a saber qual
peça ele tem de pedir.

Tarefa
Escreva um programa que, dado um inteiro N e N - 1 inteiros numerados de 1 a N,
descubra qual inteiro está faltando.

Entrada
A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de
entrada padrão (normalmente o teclado). A entrada contém 2 linhas. A primeira linha
contém um inteiro N (2 ≤ N ≤ 1.000). A segunda linha contém N - 1 inteiros numerados de
1 a N (sem repetições).

Saída
Seu programa deve imprimir, na saída padrão, uma única linha, contendo o número que
está faltando na sequência dada.

Exemplos
Entrada Saída

3 2
3 1

Entrada Saída

5 4
1 2 3 5

Entrada Saída

4 1
2 4 3
 Esse pode ser considerado o problema mais simples dessa fase nesse ano. O
problema consiste basicamente em verificar se um dado número está contido em uma
lista. Esse problema tem duas facilidades. A primeira é que a lista de entrada não possui
valores repetidos e a segunda se deve ao fato de ser composta unicamente de inteiros.
Para resolver esse problema deve-se inicialmente criar uma lista utilizando a
função Range():

- range(1, n+1)

onde n corresponde ao número total de peças do quabra-cabeça. O limite inferior da

função Range() é 1 e o limite superior é n + 1. O limite superior deve ser acrescido de 1
para que sejam contemplados todos os valores do quebra-cabeça nessa nova lista. A lista
criada pelo método Range() corresponde ao quebra-cabeça sem a ausência da da peça
perdida. Após criar essas lista deve-se percorrê-la utilizando a iterador for:

- for i in range(1,n+1):

essa iteração irá percorrer toda a lista criada. Por meio da partícula condicional if not será
verificado se peça i está contida na lista de peças do quebra-cabeça:

- for i in range(1,n+1):
if not i in lista:

em caso positivo ( a peça não estiver contida na lista de peças do quebra-cabeça) o

programa irá imprimir na tela a peça faltosa e quebrará o loop com a partícula break.

- for i in range(1,n+1):
if not i in lista:
print i
break

1 #! /usr/bin/env python2.7
2
3 import sys
4
5 #Leitura dos dados de entrada.
6 n = int(sys.stdin.readline())
7 lista = map(int,sys.stdin.readline().split())
8
9 #Busca da peça perdida.
10 for i in range(1,n+1):
11 if not i in lista:
12 print i
13 break