Consells

Java

Llegir l'entrada ràpid

Si una solució en Java et dona TLE (temps límit excedit) amb una entrada gran, pot ser culpa de java.util.Scanner, que és molt lent.

Al JOEL recomanem fer servir aquest Fast Input/Output, desenvolupat per l'Adrian Moreno i provat a fons amb els nostres problemes. Copia'l sencer i escriu el teu codi dins de main: llegeix amb in.nextInt(), in.nextLong(), in.next() o in.nextLine(), escriu amb out.writeString(...) i, sobretot, acaba amb out.flush() o no s'escriurà res.

import java.util.*;

import java.io.*;

public class Main {
    static final int MOD = 1000000007; 
    static InputReader in = new InputReader(System.in);
    static BufferOutput  out = new BufferOutput();


    public static void main(String[] args) throws IOException {

    }

    static class BufferOutput {

        private DataOutputStream dout;
        final private int BUFFER_SIZE = 1 << 16;
        private byte[] buffer;
        private int pointer = 0;

        public BufferOutput() {
            buffer = new byte[BUFFER_SIZE];
            dout = new DataOutputStream(System.out);
        }

        public BufferOutput(OutputStream out) {

            buffer = new byte[BUFFER_SIZE];
            dout = new DataOutputStream(out);
        }

        public void writeBytes(byte arr[]) throws IOException {

            int bytesToWrite = arr.length;

            if (pointer + bytesToWrite >= BUFFER_SIZE) {
                flush();
            }

            for (int i = 0; i < bytesToWrite; i++) {
                buffer[pointer++] = arr[i];
            }
        }

        public void writeString(String str) throws IOException {
            writeBytes(str.getBytes());
        }

        public void flush() throws IOException {
            dout.write(buffer, 0, pointer);
            dout.flush();
            pointer = 0;
        }

        public void close() throws IOException{
            dout.close();
        }
    }

    static class InputReader {
        private InputStream in;
        private byte[] buffer = new byte[1024];
        private int curbuf;
        private int lenbuf;

        public InputReader(InputStream in) {
            this.in = in;
            this.curbuf = this.lenbuf = 0;
        }

        public String nextLine() {
            StringBuilder sb = new StringBuilder();
            int b = readByte();
            while (b != 10 && b != -1) {
                sb.appendCodePoint(b);
                b = readByte();
            }
            // Finals de línia de Windows: treu el '\r' d'abans del '\n'
            if (sb.length() > 0 && sb.charAt(sb.length() - 1) == '\r')
                sb.setLength(sb.length() - 1);
            return sb.toString();
        }

        public boolean hasNextByte() {
            if (curbuf >= lenbuf) {
                curbuf = 0;
                try {
                    lenbuf = in.read(buffer);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (lenbuf <= 0)
                    return false;
            }
            return true;
        }

        private int readByte() {
            if (hasNextByte())
                return buffer[curbuf++];
            else
                return -1;
        }

        private boolean isSpaceChar(int c) {
            return !(c >= 33 && c <= 126);
        }

        private void skip() {
            while (hasNextByte() && isSpaceChar(buffer[curbuf]))
                curbuf++;
        }

        public boolean hasNext() {
            skip();
            return hasNextByte();
        }

        public String next() {
            if (!hasNext())
                throw new NoSuchElementException();
            StringBuilder sb = new StringBuilder();
            int b = readByte();
            while (!isSpaceChar(b)) {
                sb.appendCodePoint(b);
                b = readByte();
            }
            return sb.toString();
        }

        public int nextInt() {
            if (!hasNext())
                throw new NoSuchElementException();
            int c = readByte();
            while (isSpaceChar(c))
                c = readByte();
            boolean minus = false;
            if (c == '-') {
                minus = true;
                c = readByte();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res = res * 10 + c - '0';
                c = readByte();
            } while (!isSpaceChar(c));
            return (minus) ? -res : res;
        }

        public long nextLong() {
            if (!hasNext())
                throw new NoSuchElementException();
            int c = readByte();
            while (isSpaceChar(c))
                c = readByte();
            boolean minus = false;
            if (c == '-') {
                minus = true;
                c = readByte();
            }
            long res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res = res * 10 + c - '0';
                c = readByte();
            } while (!isSpaceChar(c));
            return (minus) ? -res : res;
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }

        public int[] nextIntArray(int n) {
            int[] a = new int[n];
            for (int i = 0; i < n; i++)
                a[i] = nextInt();
            return a;
        }

        public long[] nextLongArray(int n) {
            long[] a = new long[n];
            for (int i = 0; i < n; i++)
                a[i] = nextLong();
            return a;
        }

        public char[][] nextCharMap(int n, int m) {
            char[][] map = new char[n][m];
            for (int i = 0; i < n; i++)
                map[i] = next().toCharArray();
            return map;
        }
    }
}
Compte amb els int

Si treballes amb nombres grans, fes servir long. Un int que passa del seu límit (uns 2.147 milions) es torna negatiu sense avisar. Encara que l'enunciat digui que els nombres són més petits que 2^31, pensa que potser els estàs sumant o multiplicant.

Python

Llegir molts nombres d'una línia

Si tens molts nombres en una sola línia, els pots llegir tots de cop i posar-los en una llista:

nums = list(map(int, input().split()))
Llegir l'entrada ràpid

Amb entrades molt grans, input() pot ser lent. Pots llegir-ho tot de cop amb sys.stdin:

import sys

dades = sys.stdin.read().split()
n = int(dades[0])

O substituir input per una versió més ràpida al principi del programa:

import sys
input = sys.stdin.readline

(Compte: sys.stdin.readline manté el salt de línia final; fes servir .strip() si llegeixes text.)

Per a tothom

  • Mira bé el format de sortida de l'exemple: majúscules, espais i salts de línia compten.
  • No escriguis missatges com "Introdueix un nombre:". El jutge només vol la resposta.
  • Prova els casos extrems: 0, nombres negatius, el valor màxim de l'enunciat, una llista buida...
  • Si no saps per què falla, fes servir les pistes i llegeix les respostes del jutge.