Defesa do Trabalho 1 – Algoritmos 1
•
Esta defesa é composta por 3 exercícios do Trabalho 1;
◦
Os exercícios a serem resolvidos são diferentes para cada aluno. O aluno deverá fazer os
exercícios indicados com seu respectivo nome;
◦
Esta defesa inicia às 20h35 e finaliza às 22h10
•
Está vedada a consulta a materiais impressos, digitais e internet;
•
Os manuais do sistema, via man, estão disponíveis;
•
Segue também, neste pdf, os pseudo-códigos de funções que podem auxiliar em algum
exercício;
•
Nota
Exercícios Resolvidos Nota
3
Mantém a nota do trabalho
2
Reduz 30% da nota do trabalho
1
A nota do trabalho será igual a P2
0
Zero
algorithm separa(A, p, r) is c:=A[p] i:= p+1 j:= r enquanto i <= j faça se A[i] <= c então i++ senão se c < A[j] então j senão troca(A[i],A[j]) i++,j A[p]:= A[j] A[j]:= c return j intercala (int p, int q, int r, int v[]) { int i, j, k, *w; w = mallocc ((rp) * sizeof (int)); for (i = p; i < q; ++i) w[ip] = v[i]; for (j = q; j < r; ++j) w[rp+qj1] = v[j]; i = 0; j = rp1; for (k = p; k < r; ++k) if (w[i] <= w[j]) v[k] = w[i++]; else v[k] = w[j]; free (w); }r
i
m
o
\
f
o
o
t
n
o
t
e
{
h
t
t
p
:
/
/
e
n
.
w
i
k
i
p
e
d
i
a
.
o
r
g
/
w
i
k
i
/
I
l
l
e
g
a
l
\
_
PAO07 - Păo a metro (Janderson, Henrique, Luan)
Pão a metro é um tipo de sanduíche gigante que é uma excelente opção de lanche para torneios de programação, embora a experiência já tenha mostrado que o oferecimento de sanduiches pode gerar reclamação dos
competidores. Outro grande problema é que algumas pessoas são mais gulosas que outras e, dessa maneira, acabam pegando pedaços maiores que os pedaços dos outros. Para a final da OBI, a coordenação estava pensando em providenciar pão a metro para os competidores, porém tais problemas os fizeram recuar na idéia.
Embora a idéia tenha sido momentaneamente abandonada, uma idéia simples surgiu: cortar previamente o pão em fatias de tamanho iguais e distribuí-las entre as pessoas. O único problema com tal idéia é que se o número de pessoas for muito grande, fica impraticável ter apenas um pão. Por exemplo, se quisermos que 1.000 pessoas recebam 20 centímetros de sanduíche, seria necessário um sanduíche de 20.000 centímetros, ou 200 metros! Alguém levantou a seguinte hipótese: se houvessem N pessoas e fossem encomendados K sanduíches de empresas diferentes, cada qual com uma determinada metragem (tamanho) Mi (1 ≤ i ≤ K), seria possível retirar desses pães N fatias de mesmo tamanho, possivelmente sobrando partes nao utilizadas. A questão seria: qual o tamanho inteiro máximo que essas fatias poderão ter?
Por exemplo, se tivermos K = 4, com os tamanhos (em centímetros) M1 = 120, M2 = 89, M3 = 230 e M4 = 177 e N = 10, podemos retirar N fatias iguais de tamanho máximo 57, pois assim conseguimos 2 fatias no primeiro pão, 1 no segundo, 4 no terceiro e 3 no quarto, totalizando as 10 fatias necessárias. Se tentarmos cortar fatias de tamanho 58, só será possível obter 3 fatias do terceiro pão, totalizando 9 e, portanto, 57 é realmente o melhor que podemos obter. Note que não podemos usar duas ou mais fatias menores de diferentes pães para formarmos uma fatia do tamanho selecionado. (ficaria muito deselegante dar um lanche recortado `às pessoas).
Tarefa
Escreva um programa que, dados os tamanhos de pão disponíveis (em centímetros) e a quantidade de pessoas a serem atendidas, retorne o tamanho inteiro máximo (em centímetros) da fatia que pode ser cortada de maneira a atender todas as pessoas.
Entrada
A entrada contém um único conjunto de testes, que deve ser lido do dispositivo de entrada padrão (normalmente o teclado). A primeira linha da entrada contém um inteiro N que indica a quantidade pessoas (1 ≤ N ≤ 10.000). A segunda linha contém um inteiro K (1 ≤ K ≤ 10.000) que é a quantidade de sanduíches disponível. Na terceira linha há K inteiros M (1 ≤ M ≤ 10.000) separados por um espaço em branco representando o tamanho de cada pão.
Saída
Seu programa deve imprimir, na saída padrão, uma única linha, contendo o tamanho inteiro máximo da fatia que pode ser cortada.
Exemplos
Entrada:
10 4 120 89 230 177Saída:
57Entrada:
3 2 45 85Saída:
42Entrada:
7 7 100 98 99 505 102 97 101Saída:
101ONP - Transform the Expression (Todos)
Na notação usual de expressões aritméticas, os operadores são escritos entre os operandos; por isso,
a notação é chamada infixa. Na notação posfixa, ou polonesa, os operadores são escritos depois dos
operandos. Eis alguns exemplos de expressões infixas e correspondentes expressões posfixas:
infixa
posfixa
(A+B*C)
ABC*+
(A*(B+C)/D-E)
ABC+*D/E-(A+B*(C-D*(E-F)-G*H)-I*3)
ABCDEF-*-GH*-*+I3*-(A+B*C/D*E-F)
ABC*D/E*+F-(A+B+C*D-E*F*G)
AB+CD*+EF*G*-(A+(B-(C+(D-(E+F)))))
ABCDEF+-+-+
(A*(B+(C*(D+(E*(F+G))))))
ABCDEFG+*+*+*
Note que os operandos (A, B, C, etc.) aparecem na mesma ordem na expressão infixa e na
correspondente expressão posfixa. Note também que a notação posfixa dispensa parênteses e regras
de precedência entre operadores (como a precedência de * sobre + por exemplo), que são
indispensáveis na notação infixa.
Transform the algebraic expression with brackets into RPN form (Reverse Polish Notation).
Two-argument operators: +, -, *, /, ^ (priority from the lowest to the highest), brackets ( ). Operands: only
letters: a,b,...,z. Assume that there is only one RPN form (no expressions like a*b*c).
Input
t [the number of expressions <= 100]
expression [length <= 400]
[other expressions]
Text grouped in [ ] does not appear in the input file.
Output
The expressions in RPN form, one per line.
Example
Input:
3 (a+(b*c)) ((a+b)*(z+x)) ((a+t)*((b+(a+c))^(c+d)))Output:
abc*+ ab+zx+* at+bac++cd+^*ROBOCOL - Robô colecionador (Gabriel, Henrique, Luan)
Um dos esportes favoritos na Robolândia é o Rali dos Robôs. Este rali é praticado em uma arena retangular gigante de N linhas por M colunas de células quadradas. Algumas das células estão vazias, algumas contêm figurinhas da Copa (muito apreciadas pelas inteligências artificiais da Robolândia) e algumas são ocupadas por pilastras que sustentam o teto da arena. Em seu percurso os robôs podem ocupar qualquer célula da arena, exceto as que contém pilastras, que bloqueiam o seu movimento. O percurso do robô na arena durante o rali é
determinado por uma sequência de instruções. Cada instrução é representada por um dos seguintes caracteres: ‘D’, ‘E’ e ‘F’, significando, respectivamente, “gire 90 graus para a direita”, “gire 90 graus para a esquerda” e “ande uma célula para a frente”. O robô começa o rali em uma posição inicial na arena e segue fielmente a sequência de instruções dada (afinal, eles são robôs!). Sempre que o robô ocupa uma célula que contém uma figurinha da Copa ele a coleta. As figurinhas da Copa não são repostas, ou seja, cada figurinha pode ser coletada uma unica vez. Quando um robô tenta andar para uma célula onde existe uma pilastra ele patina, permanecendo na célula onde estava, com a mesma orientação. O mesmo também acontece quando um robô tenta sair da arena.
Dados o mapa da arena, descrevendo a posição de pilastras e figurinhas, e a sequência de instruções de um robô, você deve escrever um programa para determinar o número de figurinhas coletadas pelo robô.
Entrada
A entrada contém vários casos de teste. A primeira linha de um caso de teste contém três números inteiros N, M e S (1 ≤ N, M ≤ 100, 1 ≤ S ≤ 5 × 104 ), separados por espaços em branco, indicando respectivamente o número de linhas e o número de colunas da arena e o número de instruções para o robô. Cada uma das N linhas seguintes da entrada descreve uma linha de células da arena e contém uma cadeia com M caracteres. A primeira linha que aparece na descrição da arena é a que está mais ao Norte; a primeira coluna que aparece na descrição de uma linha de células da arena é a que está mais a Oeste.
Cada célula da arena pode conter um dos seguintes caracteres: ‘.’ — célula normal; ‘*’ — célula que contém uma figurinha da Copa; ‘#’ — célula que contém uma pilastra; ‘N’, ‘S’, ‘L’, ‘O’ — célula onde o robô inicia o percurso (única na arena). A letra representa a orientação inicial do robô (Norte, Sul, Leste e Oeste, respectivamente).
A ultima linha da entrada contém uma sequência de S caracteres dentre ‘D’, ‘E’ e ‘F’, representando as instruções do robô.
O último caso de teste é seguido por uma linha que contém apenas três números zero separados por um espaço em branco.
Saída
Para cada rali descrito na entrada seu programa deve imprimir uma única linha contendo um único inteiro, indicando o número de figurinhas que o robô colecionou durante o rali.
Exemplo Entrada: 3 3 2 *** *N* *** DE 4 4 5 ...# *#O. *.*. *.#. FFEFF 10 10 20 ....*... ...*.. ...*.... ..*.#... ...#N.*..* ...*... ... ... ... ... FDFFFFFFEEFFFFFFEFDF 0 0 0 Saída: 0 1 3
PROIBIDO - Número Proibido (Gabriel, Janderson)
Os números proibidos são números que possuem alguma representação problemática, por exemplo, número do azar, de algo ruim, e até números que são senhas do governo.
O número proibido mais conhecido é um número primo[1] que foi descoberto em 2001 e representa o arquivo binário da versão compactada do código C que implementa o algoritmo DeCSS, que pode ser utilizado para lograr o sistema de proteção do DVD.
Luan, um rapaz que tem muito receio de ser procurado por agências espiãs internacionais coletou um conjunto de números ilegais e está filtrando esses números de todos os seus arquivos no computador.
Infelizmente, Luan ainda não sabe programar muito bem e pediu a sua ajuda para implementar um programa que receba um conjunto de números ilegais e responda se um outro conjunto de números fazem parte dos números ilegais.
[1]http://en.wikipedia.org/wiki/Illegal_prime
Entrada
A entrada é composta por um único caso teste que possui diversas linhas. A primeira linha possui um número N ( 1 <= N <= 140000 ) que representa a quantidade de números proibidos existentes. A segunda linha do caso de teste possui N números Pi ( 0 <= Pi <= 231 ) representando os números proibidos.
Depois existirão diversas linhas contendo um único número que se quer saber se é proibido ou não. A entrada termina em EOF.
Saída
Para cada número da consulta deve-se imprimir uma única linha contendo a palavra sim se o número for proibido, ou nao caso o número não seja proibido.
