Algoritmo de particionamiento de Hoare para valores duplicados de pivote

El siguiente es un algoritmo de particionamiento de Hoare según Wikipedia.

Código pseudo de Wikipedia:

algoritmo particion(A, lo, hi) es 
  // Valor pivote
  pivot := A[ floor((hi + lo) / 2) ] // El valor en el medio del arreglo

// Índice izquierdo
  i := lo - 1 

// Índice derecho
  j := hi + 1

loop infinito 
    // Mueva el índice izquierdo hacia la derecha al menos una vez y mientras el elemento en
    // el índice izquierdo sea menor que el pivote
    hacer i := i + 1 mientras A[i] < pivot

// Mueva el índice derecho hacia la izquierda al menos una vez y mientras el elemento en
// el índice derecho sea mayor que el pivote
hacer j := j - 1 mientras A[j] > pivot

// Si los índices se cruzaron, retorne
si i ≥ j entonces retorne j

// Intercambia los elementos en los índices izquierdo y derecho
intercambiar A[i] con A[j]

Una implementación en Java:

public class Main {
    public static void main(String[] args) {
        int[] arr = new int[] { 2, 1, 2, 4, 3 };
        Hoare.partition(arr, 0, 4);

        for (int x : arr) System.out.println(x);
    }
}

class Hoare {
    private static void Swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

    public static int partition(int []arr, int low, int high) {
        int pivot = arr[(low + high) / 2]; // el pivote es 2 para este caso.
        // Resultado esperado es:
        // 1 2 2 3 4
        // o
        // 1 2 2 4 3
        //
        // El resultado actual es:
        // 2 1 2 4 3
        // Dado que 3 y 4 son mayores que 2, el particionamiento no está funcionando.

        int i = low - 1;
        int j = high + 1;

        while(true) {
            do {
                i++;
            }
            while (arr[i] < pivot);

            do {
                j--;
            }
            while (arr[j] > pivot);

            if (i >= j) {
                return j;
            }

            Swap(arr, i, j);
        }
    }
}

¿Por qué la salida es incorrecta (indicado en los comentarios del código)? ¿Es esa una limitación conocida del algoritmo de Hoare? ¿Mi implementación o el pseudo código de Wikipedia es incorrecto?