Un algoritmo deve gestire input non validi e può avere percorsi hard-coded per determinati dati di input? [duplicare]

Ho alcune precondizioni sui dati di input e ho bisogno di progettare un algoritmo per quei dati. Devo anche gestire le precondizioni non valide? Inoltre è normale che il mio algoritmo funzioni solo per un certo numero di input, ad esempio 4, e per un numero minore di input avrò la clausola "if input.size"?

Per chiarire la mia domanda. Beh, in realtà è un compito da un libro, ma comunque. Quindi dice che mi viene dato un array ordinato, quindi invertito in modo che appaia come "4567123" la prima parte "123" sia scambiata. Quindi, dovrei preoccuparmi di progettare algoritm per il caso non swapato? Anche il mio algoritmo non funziona bene per le dimensioni di input 1, 2, 3, quindi ho inserito i casi per 1, 2, 3. Va bene. Quindi ecco il codice:

//file SwapedArraySearch.java\
public class SwapedArraySearch {
    public static int search(int[] arr) {
        switch (arr.length){
            case 1:
                return arr[0];
            case 2:
                return arr[0] > arr[1]?arr[1]:arr[0];
            case 3:
                return arr[0] > arr [1] ? (arr[1] > arr[2]?arr[2]: arr[1]):
                                            (arr[0] > arr[2]?arr[2]: arr[0]);
        }
        int x = arr[0];
        int n = arr.length/2;
        int prevn = arr[n] > x ? arr.length -1 : 1; 
        int t;
        while(prevn != n) {
            if (x < arr[n]) {
               if (arr[n] > arr [n + 1] )
                   return arr[n+1];
                t = n;
                n = n + (prevn - n)/2;
                prevn = t;
            } else {
                if (arr[n - 1] > arr[n])
                    return arr[n];
                t = n;
                n = prevn + (n - prevn)/2;
                prevn = t;
            }
        }
        return arr[0] > arr[1] ? arr[arr.length - 1] : arr[0];
    }

    public static void main(String... args) {
        int[] arr = new int[args.length];
        for (int i = 0; i < args.length; i++)
            arr[i] = Integer.valueOf(args[i]);
        System.out.println(search(arr));            
    }
}

Inoltre mi preoccupo che sia troppo complesso. Non è o va bene?

Inoltre, diciamo, la ricerca binaria, ovviamente, non dovrebbe controllare prima di far sì che quell'array sia stato ordinato prima, giusto?