Supongo que no soy el único que ha visto este tipo de imagen en Facebook (y otros sitios).

La imagen de arriba fue publicada hace 16 días, y ha acumulado 51 k comentarios. Algunas respuestas: 0, 4, 8, 48, 88, 120, 124 y así sucesivamente.

Desafío:

Las matemáticas en la pregunta no tienen sentido ¹ , por lo que no podemos encontrar la respuesta correcta mirando la ecuación (o como se llame ese lío de números y operadores). Sin embargo, hay una gran cantidad de personas que han respondido, ¡y el 10% de esas personas tienen razón!

¡Encontremos la respuesta correcta!

Tome un número entero, un porcentaje, un valor decimal 0-1o una fracción que Nrepresente el porcentaje del grupo de prueba que falló la pregunta (u opcionalmente cuántos respondieron correctamente) y una lista de números que representan las respuestas que publican las personas.

Encuentre el número que 100-Nrespondió el porcentaje del grupo de prueba y escríbalo. Si hay más de una respuesta que coincida con este criterio, debe enviarlas todas. Si no hay respuestas que estén representadas en 100-Nporcentaje del tiempo, entonces debe generar el número más cercano (medido en número de respuestas 100-N).

Para hacer que las reglas de entrada para Nclaro: Si el 90% falla, entonces es posible que la entrada 90, 10, 0.9o 0.1. Debe especificar cuál elige. Puede suponer que los números de porcentaje son enteros.

Casos de prueba:

En los casos de prueba a continuación, Nes el porcentaje que falló la prueba. Puede elegir ingresar usando cualquiera de los métodos de entrada permitidos.

N:  90   (meaning 90 % will fail and 10 % answer correctly)
List: 3 1 5 6 2 1 3 3 2 6
Output: 5   (because 90 % of the answers weren't 5)
---
N:  50   (50 % will answer correctly)
List: 3 6 1 6
Output: 6   (because 50 % of the answers weren't 6)
---
N:  69   (31 % will answer correctly)
List: 1 9 4 2 1 9 4 3 5 1 2 5 2 4 4 5 2 1 6 4 4 3
Output: 4    (because 31% of 22 is 6.82. There are 6 fours, which is the 
              closest to 6.82)
---
N = 10   (90 % will answer correctly)
List: 1 2 3 4 5 6 7 8 9 10
Output: 1 2 3 4 5 6 7 8 9 10 (because 9/10 will answer correctly. All numbers
                              have been answered the same number of times, thus
                              all are equally likely to be correct.
---
N:  90
List: 1 1 1
Output: 1

código-golf

¹ Por favor no discutas conmigo aquí. Si "sabe" la respuesta , ¡únase al otro 10% y publíquela en Facebook!

MATL , 16 14 bytes

-1 byte gracias a @Giuseppe

-1 byte gracias a @LuisMendo

SY'ts/i-|tX<=)

Explicación:

        % implicit input
S       % sort
Y'      % run-length encoding
ts      % duplicate elements and sum (get number of elements)
/       % array right division (get array of probability for each answer)
i-|     % get absolute difference with second input
tX<     % duplicate and get minimum value
=)      % get each answer that match with the minimum value
        % (implicit) convert to string and display

Pruébalo en línea! o verificar todos los casos de prueba

R , 65 bytes

function(N,A,x=table(A))names(x)[!(y=(abs(1-x/sum(x)-N)))-min(y)]

Pruébalo en línea!

Toma Ncomo un número entre 0y 1, y Acomo un vector (a veces tomado de STDIN en el enlace TIO para que no tenga que convertirlos en vectores R). Devuelve una lista de cadenas, según lo permitido por el OP .

function(N,A){
 x <- table(A)               # count occurrences of each value in A
 pct <- 1 - x/sum(x)         # compute percentages different from each value
 y <- abs(pct - N)           # find distances from N
 idx <- y!=min(y)            # find the indices of the minimum/minima
 names(x)[idx]               # return the names of the table (strings)
}

Jalea , 19 bytes

ĠL€÷⁸L¤e€ạÐṂ¥Tị⁸QṢ¤

Pruébalo en línea!

JavaScript (ES7), 103 99 bytes

Toma datos como (a, r)donde a es la lista de respuestas yr es la relación de éxito esperada en [0 ... 1] . Devuelve a Set.

(a,r,m)=>a.map(n=>(d=a.reduce((p,c)=>p-=c==n,r*a.length)**2)>m||(d==m?s:(m=d,s=new Set)).add(n))&&s

Casos de prueba

let f =

(a,r,m)=>a.map(n=>(d=a.reduce((p,c)=>p-=c==n,r*a.length)**2)>m||(d==m?s:(m=d,s=new Set)).add(n))&&s

format = s => JSON.stringify(Array.from(s))

console.log(format(f([3, 1, 5, 6, 2, 1, 3, 3, 2, 6], 0.1))) // 5
console.log(format(f([3, 6, 1, 6], 0.5))) // 6
console.log(format(f([1, 9, 4, 2, 1, 9, 4, 3, 5, 1, 2, 5, 2, 4, 4, 5, 2, 1, 6, 4, 4, 3], 0.31))) // 4
console.log(format(f([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 0.90))) // 1 2 3 4 5 6 7 8 9 10
console.log(format(f([1, 1, 1], 0.10))) // 1

Python 2 , 91 bytes

def f(l,p):c=[(abs(len(l)*p-l.count(a)),a)for a in l];print{v for x,v in c if x==min(c)[0]}

Pruébalo en línea!

Toma P como éxito ( 0.1= 10% correcto)

05AB1E , 19 16 15 bytes

Toma la tasa de éxito en la forma 0.31(lo que significa que el 31% tiene éxito).

{γD€gDO/IαWQϘÙ

Pruébalo en línea!