# Entradas e saídas
## 📚 Introdução
Nesse artigo, vamos aprender como fazer as entradas e saídas nos exercícios de programação competitiva, no geral usaremos os comandos padrões `input()` e `print()`, porém existem alguns casos que valem a pena serem explicados com mais detalhes, como os exercícios que utilizam EOF (End of File) e os que precisam de fast io.
## 📥 Entradas
Como mencionado, normalmente usaremos o método padrão de input do Python, com a função `input()`.
Quando queremos ler mais de uma string na mesma linha, como por exemplo:
```
ufms feijoada
```
podemos usar o `split()`:
```py
a, b = input().split()
```
Agora se quisermos ler mais de um valor numérico, é melhor usar a função `map()`, que já converte os valores para o tipo desejado:
```py
a, b = map(int, input().split())
```
Se precisarmos que os valores sejam armazenados em uma lista, podemos usar a coompreensão de listas.
```py
a = [int(x) for x in input().split()]
```
Esse métodos é mais lento que o `map()`, então só o use quando você realmente precisa de uma lista, ou quando não se sabe o número de valores que serão lidos.
Antes de continuar, é importante conversar um pouco sobre os diferentes tipos de entradas que podemos encontrar, geralmente sabemos exatamente o número de linhas que serão lidas, por alguma estipulação do enunciado ou um valor do próprio input nos indica, como no exercício 1410 do Beecrowd:
A entrada pode parecer complicada, mas note que a primeira linha lida nos indica exatamente quantos valores vem a seguir, e o fim é indicado por dois valores 0 seguidos, então podemos ler a entrada da seguinte forma:
```py
while True:
atacantes, defensores = map(int, input().split())
if atacantes == 0 or defensores == 0:
break
```
Porém, existem casos onde não sabemos o número de linhas que serão lidas, como no exercício 2850 do Beecrowd:
O exercício nem nos disse isso, mas o final de um arquivo de entrada é sempre indicado por EOF (End of File), como não sabemos o número de linhas que serão lidas, nossa única opção é usar um loop infinito e tentar ler a entrada, e quando o EOF for encontrado, o Python lançará uma exceção `EOFError`, que podemos usar para sair do loop:
```py
while True:
try:
lado = input()
# restante do código
except EOFError:
break # entrada acabou, podemos sair do loop
```
Existe algo a mais que podemos fazer para deixar nossas entradas e saídas mais rápidas, isso é chamado de fast io, ou métodos rápidos de entrada e saída, o jeito mais rápido de ler valores em Python é usando o `sys.stdin.readline()`:
```py
import sys
a, b = map(int, sys.stdin.readline().split())
vet = [int(x) for x in sys.stdin.readline().split()]
```
Como pode ver, na maior parte dos casos só trocar o `input()` por `sys.stdin.readline()` é suficiente, porém temos que manter algumas coisas em mente ao usar o `sys.stdin.readline()`:
* Ele lê o no final da linha, isso normalmente não afeta em nada, pois o `split()` e `int()` já o removem, porém se quisermos ler uma única string a cada linha, temos que usar o `.rstrip()`.
* Essa função dá um erro diferente de `EOFError` ao ler um EOF, então temos que usar o `try` e `except` para lidar com isso.
## 📤 Saídas
O método padrão de output do Python é o `print()`, e é ele que usaremo na maior parte dos casos, porém, se precisarmos de fast io, temos que usar o `sys.stdout.write()`:
```py
import sys
sys.stdout.write(str(a) + '\n')
```
Note que usei ambas `str()` e `+ '\n'`, isso porque, assim como anteriormente, temos que manter algumas coisas em mente ao usar o `sys.stdout.write()`:
* Ele só aceita strings, então se quisermos escrever um inteiro, temos que usar o `str()` ou f-strings:
```py
import sys
a = 42
sys.stdout.write(str(a) + '\n')
sys.stdout.write(f'{a}\n')
```
* Ele não coloca o automaticamente no final da linha, isso é importante pois os juízes de código não aceitam a resposta se não tiver o no final da linha.
## 🧑🏫 Exercícios
Nenhum dos exercícios sugeridos abaixo necessariamente demanda o fast io, mas é uma boa hora pra você treinar isso e os diferentes tipos de entradas que vimos!
* Exercício [2850](https://judge.beecrowd.com/pt/problems/view/2850) do Beeecrowd, que estava no aquecimento da OBI 2018, na fase nacional.
* Exercício [1248](https://www.beecrowd.com.br/judge/pt/problems/view/1248) do Beecrowd, que caiu na OBI 2012.
* Exercício [2408](https://www.beecrowd.com.br/judge/pt/problems/view/2408) do Beecrowd, que caiu na OBI 2012.
* Exercício [2420](https://www.beecrowd.com.br/judge/pt/problems/view/2420) do Beecrowd, que caiu na OBI 2012.
* Exercício [1410](https://www.beecrowd.com.br/judge/pt/problems/view/1410) do Beecrowd, que caiu na ACM/ICPC South America Contest 2007.
* Exercício [2770](https://www.beecrowd.com.br/judge/pt/problems/view/2770) do Beecrowd, que caiu na V Maratona Norte Mineira de Programação, não se assuste com o nível 7 desse exercício, mantenha a calma e leia o que se pede.
---
# Agent Instructions: Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://facompetindo.gitbook.io/programacao-competitiva/python/entradas_saidas.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.