Cómo encontrar un algoritmo para encontrar tanto el mínimo como el máximo de n números usando menos de 3n / 2 comparaciones

Sugerencia n. ° 1: si organiza los números en pares, ordenar cada par cuesta n / 2 comparaciones.

Sugerencia n. ° 2: si recibe un par de números (x, y) de modo que x <= y, solo necesita verificar x para el mínimo e y para el máximo.

Avíseme si aún no puede encontrar la solución, y agregaré más pistas.

Aquí hay una función basada en esta idea, en Haskell:

minMax :: (Ord t) => [t] -> Quizás (t, t)
minMax list = lista de casos de
(x: rest) -> Solo $ minMax0 (x, x) rest
[] -> Nada

minMax0 :: (Ord t) => (t, t) -> [t] -> (t, t)
minMax0 (acc_min, acc_max) list = lista de casos de
(a: b: descanso) ->
let (x, y) = si a <= b entonces (a, b) más (b, a)
en minMax0 (min x acc_min, max y acc_max) resto
[x] -> (min x acc_min, max x acc_max)
[] -> (acc_min, acc_max)

Pitón:

def min_max (números):
si len (números) <1:
regresar Ninguno
acc_min = números [0]
acc_max = números [0]
i = 1
mientras yo <len (números):
a = números [i]
b = números [i + 1] si i + 1 <len (números) más a
(x, y) = (a, b) si a <= b más (b, a)
acc_min = min (x, acc_min)
acc_max = max (y, acc_max)
i + = 2
volver acc_min, acc_max

Nemerle (sugerido por Matt Eri):

def minmax (l: lista [int]) {
actualización de def (a, b, prevmin, prevmax) {(Min (a, prevmin), Max (b, prevmax))}
partido (l) {
El | x :: y :: cola => def (min, max) = minmax (cola);
if (x <y) actualizar (x, y, min, max) más actualizar (y, x, min, max)
El | [x] => (x, x)
El | [] => (int.MaxValue, int.MinValue)
}
}

AlgoritmosInformática teóricaProgramación informática

Si a, b, c son números reales tales que 0 <a <1, 0 <b <1, 0 <c <1, a + b + c = 2, ¿cómo demuestra que [matemáticas] \ frac {a} {1 - a} \ frac {b} {1 - b} \ frac {c} {1 - c} \ geq 8 [/ math]?

¿Qué es 7/6 en binario?

¿Qué problemas abiertos en matemáticas tendrían aplicaciones prácticas inmediatas si se resolvieran?

No entiendo correctamente la cita de Alan Kay sobre sus antecedentes matemáticos. ¿Alguien puede explicarlo en términos simples?

Dado un número N y un flujo continuo de enteros de entrada, ¿podría encontrar dos números en el flujo cuya suma fuera el primer número N?

¿El uso de un teclado mecánico sobre un teclado de membrana realmente le permite escribir significativamente más rápido, aumentando así su productividad?

Con la indirecta de @ Máté Kovács

Lo extiendo:

public static void findMinimumAndMaximumOf (int [] numbers) {
afirmar números.longitud> = 2;
List bigList = new ArrayList <> (numbers.length / 2);
List biggerList = new ArrayList <> (numbers.length / 2);
int i = 1;
para (; i if (números [i]> números [i – 1]) {
bigList.add (números [i]);
biggerList.add (números [i – 1]);
} más {
bigList.add (números [i – 1]);
biggerList.add (números [i]);
}
}
if ((numbers.length & 1) == 1) {
if (números [números.longitud – 1]> números [números.longitud – 2]) {
bigList.add (números [números.longitud – 1]);
} más {
biggerList.add (números [números.length – 1]);
}
}
Iterator iBig = bigList.iterator ();
int más grande = iBig.next ();
while (iBig.hasNext ()) {
int actual = iBig.next ();
if (actual> mayor) {
mayor = actual;
}
}
Iterador iSmall = más pequeñoLista.iterador ();
int más pequeño = iSmall.next ();
while (iSmall.hasNext ()) {
int actual = iSmall.next ();
if (actual más pequeño = actual;
}
}
System.out.println (String.format (“Máx .:% d, Mín .:% d”, más grande, más pequeño));
}