Su entrada es una lista / secuencia / vector / matriz de 5-255 enteros positivos, no necesariamente únicos. Puede suponer el formato de entrada más adecuado y que cada número entero (así como la cantidad de números enteros) se elige de manera uniforme al azar del rango 5-255.

El objetivo es generar la misma lista, en el mismo formato (o equivalente), pero ordenada en orden creciente (no decreciente). Un ejercicio temprano común para aprender un idioma. Envíos para incluir:

1. Una respuesta que funciona correctamente y logra el objetivo; y

2. Una segunda respuesta que contiene un error molesto. Entre el 1% y el 10% del tiempo, la salida debe ser una lista en el formato correcto y que contenga los elementos correctos, pero en el orden incorrecto (cualquier orden, excepto los ordenados correctamente). El resto del tiempo, el programa debe funcionar correctamente y alcanzar el objetivo.

Las dos respuestas deben tener Levenshtein distancia uno; es decir, podemos obtener uno del otro eliminando un byte, o agregando un byte, o cambiando un byte.

Anotar como de costumbre en code-golf (basado en la menor de sus dos respuestas), con las lagunas habituales prohibidas.

10% de bonificación (disminución de puntaje) si el molesto error es independiente de la entrada, es decir, usar la misma entrada nuevamente no reproduce el error (excepto entre 1% y 10% del tiempo).

Python 3 , 36 bytes

Versión libre de errores, 37 bytes

lambda l:sorted(l,reverse=l[-9:]==[])

Pruébalo en línea!

Versión molesta, 36 bytes

lambda l:sorted(l,reverse=l[9:]==[])

Pruébalo en línea!

Esto depende de la entrada y, por lo tanto, no califica para el bono.
Tiene una probabilidad de alrededor del 2% de fallar. Falla cuando la longitud de entrada es inferior a 10.

En combinación con la respuesta de LyricLy, esto obtiene 34 bytes:

lambda l:sorted(l)[::l[9:]>[]or 1]
lambda l:sorted(l)[::l[9:]>[]or-1]

05AB1E , 5 * 0.9 = 4.5 bytes

Solución de trabajo

{TLΩi

Pruébalo en línea!

Explicación

{      # sort input
 TL    # push the range [1 ... 10]
   Ω   # pick a random number in the range
    i  # if true (equal to 1), do nothing

Solución que contiene el error

Da la solución incorrecta el 10% del tiempo (independiente de la entrada)

{TLΩiR

Pruébalo en línea!

Explicación

Igual que la solución de trabajo, excepto que invierte la lista si el número elegido es verdadero.

Gelatina , 7 * (100% - 10%) = 6.3 bytes

Ṣ¹⁵X:¤¡

Pruébalo en línea!

Versión con errores:

ṢẊ⁵X:¤¡

Pruébalo en línea!

En ambos enlaces, hay un arnés de prueba que ejecutará el código 100 veces, cada vez con la lista que proporcione como argumento, y luego devolverá los resultados.

La probabilidad de cada longitud de entrada es:

0.1 - 0.1/(length!)

Entonces, para la longitud 1 hay una probabilidad de 0%, para la longitud 2 5%, para la longitud 3 8.83̅%, para la longitud 4 9.583̅%, etc. hasta la longitud ∞ que tiene una probabilidad del 10%.

Python 3, puntaje 58 57 - 10% = 51.3

Salvó un byte gracias a los ovs.

Versión libre de errores, 57 bytes

lambda m:sorted(m)[::random()>.1or 1]
from random import*

Pruébalo en línea!

Versión con errores, 57 bytes

lambda m:sorted(m)[::random()>.1or-1]
from random import*

Pruébalo en línea!

Decidí probar una solución que usa la bonificación. No supera la otra respuesta de Python, pero me divertí pensando en ello.

C, 71 * 0.9 = 63.9 bytes

Libre de errores:

c(int*a,int*b){return*a-*b;}f(a,n)int*a;{if(rand()%1<9)qsort(a,n,4,c);}

Pruébalo en línea!

Calesa:

c(int*a,int*b){return*a-*b;}f(a,n)int*a;{if(rand()%10<9)qsort(a,n,4,c);}

Pruébalo en línea!

Groovy , 31 bytes

Solución con errores:

{a->a.sort()[a[9]?0..-1:-1..0]}

Solución de trabajo:

{a->a.sort()[a[0]?0..-1:-1..0]}

El operador de subíndice Groovy (el getAtmétodo) devuelve nulo para las listas si el índice es mayor que el tamaño. Entonces, si hay un noveno elemento, se mantendrá igual que la lista ordenada, pero si no (1.99203187% de probabilidad) se revertirá. Sin embargo, siempre habrá un primer elemento porque el tamaño de la lista siempre es mayor o igual a 5. Por lo tanto, el 0 en a[0]podría intercambiarse con 1, 2, 3 o 4.

Wolfram Language (Mathematica) , 29 bytes

Esto es 26.1 bytes con el bono, pero no estoy completamente seguro de ganar el bono; en una entrada ya ordenada, ambas versiones siempre producen una salida ordenada.

Versión libre de errores (29 bytes)

If[RandomReal[]<0.,#,Sort@#]&

Pruébalo en línea!

Versión molesta (30 bytes)

If[RandomReal[]<0.1,#,Sort@#]&

Pruébalo en línea!

PHP, 70 bytes

Versión libre de errores, 70 bytes

<?unset($argv[0]);((rand(1,9)?"":r).sort)($argv);echo join(" ",$argv);

Pruébalo en línea!

Versión con errores, 70 bytes

<?unset($argv[0]);((rand(0,9)?"":r).sort)($argv);echo join(" ",$argv);

Pruébalo en línea!

La versión con errores se ordena en orden inverso el 10% del tiempo (según un generador de números aleatorios).

Python 2 , 26 bytes

Calesa:

lambda l:l[9:]and l.sort()

Pruébalo en línea!

Salidas modificando la lista de entrada . Ordena la lista solo si su longitud es de al menos 10. La versión sin errores reemplaza la 9con a 0para ordenar siempre.

Trabajando:

lambda l:l[0:]and l.sort()

Pruébalo en línea!

Podemos modificar la función para devolver la lista a un costo de 4 bytes, para un total de 30 bytes:

lambda l:l[9:]and l.sort()or l

Pruébalo en línea!

25 bytes con algunos tramos de las reglas:

[list,sorted][id(0)%17>0]

Pruébalo en línea!

Emite una función literal que ordena o es la identidad, que se utiliza id(0)como fuente aleatoria. Cambie >a >=para arreglar, o 0a ~0.

Cáscara , 6 bytes

Versión con errores:

?OIV¦9

Pruébalo en línea!

Versión correcta:

?OIVK9

Pruébalo en línea!

Explicación

Estos programas son completamente deterministas. De hecho, Husk actualmente no tiene ningún soporte para números aleatorios.

?  V    If any element
    ¦9  is divisible by 9 (in buggy version),
    K9  is truthy when replaced by 9 (in correct version),
 O      sort the list,
  I     otherwise return it unchanged.

Afirmo que la salida del programa con errores no está ordenada con una probabilidad entre 1% y 2%. Denote por N = 251 el número de valores posibles de los elementos. La probabilidad de que una lista aleatoria de longitud L no contenga múltiplos de 9 es ((NK) / N) ^ L , donde K es el número de valores divisibles por 9 (en nuestro caso K = 28 ). La probabilidad total es el promedio de esto para 5 ≤ L ≤ 255 , que es aproximadamente 1.98%. Algunas de estas listas son falsos positivos, ya que ya están ordenadas. La probabilidad de que se clasifique una lista aleatoria de longitud L es como máximo ((N + N * (N-1) / 2) / N ^ 2) ^ ⌊L / 2⌋ : si dividimos la lista en trozos de longitud 2, cada uno de losLos ⌊L / 2⌋Los trozos deben ser ordenados. La probabilidad total de que se ordene una lista está limitada por el promedio de lo anterior para 5 ≤ L ≤ 255 , que es aproximadamente 0.30%. Por lo tanto, la probabilidad de que la función devuelva una lista no ordenada está entre 1.67% y 1.98%.

Golpetazo , 26 bytes

Versión correcta

s=n
sort -${s:RANDOM%20<0}

Pruébalo en línea! o verificar las probabilidades .

Versión con errores

s=n
sort -${s:RANDOM%20<1}

Pruébalo en línea! o verificar las probabilidades .

Toma datos como números separados por nueva línea. Utiliza la variable integrada RANDOM, que siempre devuelve un número (pseudo) aleatorio en el rango de 0 a 32767 . Usando %20resultados en una tasa de falla de aproximadamente 5% (gracias @Titus por aclarar problemas con%10 ).

Esta aleatoriedad significa que la tasa de falla es independiente de la entrada, pero esto requiere que la matriz de entrada incluya al menos un número con más de un dígito, porque la salida de falla se ordena lexicográficamente.

Versión alternativa, 27 bytes.

((RANDOM+20))||cat&&sort -n

La versión con errores reemplaza la +con a %. Pruébelo en línea o inténtelo con errores .

Pyth , puntaje 8 * 0.9 = 7.2

Primer fragmento (correcto):

h.uSNT.S

Pruébalo aquí!

Segundo fragmento (uno molesto):

O.uSNT.S

Pruébalo aquí!

¡ Ahorró dos bytes (y 1,8 puntos) gracias a isaacg !

JavaScript (ES6), 24 bytes

Versión libre de errores (al menos para enteros en el rango 0-2147483647, por lo que cualquier cosa en el rango dado):

a=>a.sort((a,b)=>a-b>>0)

Versión con errores:

a=>a.sort((a,b)=>a-b>>1)

Depende de a) el algoritmo de clasificación del motor yb) la lista de entrada que contiene dos valores en el orden incorrecto que difieren en 1. (Si la probabilidad de que eso sea demasiado baja, entonces 1puede aumentar, pero para cuando llegue a 8que simplemente no va a solucionar nada en el rango 5-255).

PHP, 62 bytes

inspirado en la solución de Jo (y acabo de notar: es un puerto de Justin Mariner ):

trabajando (tipo ascendente):

unset($argv[0]);(r[rand()+20].sort)($argv);echo join(_,$argv);

buggy (aprox. 5% de probabilidad de descender):

unset($argv[0]);(r[rand()%20].sort)($argv);echo join(_,$argv);

Corre con -nr

Pushy , 9 bytes - 10% = 8.1

Solución Bugged:

g0TUn?};_

Pruébalo en línea!

Solución de trabajo:

g1TUn?};_

Pruébalo en línea!

El código con errores hace lo siguiente:

g0TUn?};_

g          \ Sort the stack correctly
 0TU       \ Generate random(0, 10)
    n? ;   \ If this is zero:
      }    \    Cyclically shift the stack right once
        _  \ Print the result

El código fijo simplemente cambia 0a 1. Como random(1, 10)nunca será 0, la instrucción if nunca se ejecutará.

MATL , 7 * 0.9 = 6.3 6 * 0.9 = 5.4 bytes

Versión con errores:

Gr.9<?S

Pruébalo en línea!

Explicación:

G        % Grab input
 r       % Push a random number between 0 and 1
  .9     % Push 0.9
    <    % Check if the random number is smaller than 0.9
     ?   % If true
      S  % Sort input
         % Implicit output

Versión libre de errores:

Gr9<?S

Pruébalo en línea!

Explicación:

G       % Grab input
 r      % Push a random number between 0 and 1
  9     % Push 9
   <    % Check if the random number is smaller than 9 (always true)
    ?   % If true
     S  % Sort the input
        % Implicit output     

Jq 1.5 , 42 bytes

Calesa

sort|if length%13<=0then reverse else. end

Trabajando (eliminar el =)

sort|if length%13<0then reverse else. end

Suponiendo que las longitudes de línea son uniformes en el rango [5,255] aproximadamente el 7% activará el error

Pruébalo en línea!

J, 22.5 bytes (25 bytes - 10%)

con error:

[:]`(1&A.)@.(0.1>?@0:)/:~

sin error:

[:]`(0&A.)@.(0.1>?@0:)/:~

Pruébalo en línea!

R , 30 * .9 = 27 bytes

(calesa)

function(l)sort(l,runif(1)<.1)

Pruébalo en línea!

(no con errores)

function(l)sort(l,runif(1)<.0)

La versión con errores se clasifica en el decreasing=T10% del tiempo, tomando muestras de una distribución uniforme (0,1). La versión sin errores es siempredecreasing=F

Röda , 42 bytes - 10% = 37.8

Libre de errores:

{sort key={|i|currentTime|[_%20//19*0+i]}}

Calesa:

{sort key={|i|currentTime|[_%20//19*i+i]}}

Pruébalo en línea!

Esto usa la currentTimefunción para crear números aleatorios. Parece que su distribución varía un poco entre máquinas. La relación 20//19se puede ajustar para obtener resultados diferentes sin penalización por byte (a menos que sea menor que 99//98).

Octava , 36 * 0.9 = 32.4 bytes

Versión con errores:

@(x)sort(x)(shift(1:end,+(rand<.1)))

Pruébalo en línea!

Versión libre de errores:

@(x)sort(x)(shift(1:end,+(rand<.0)))

Pruébalo en línea!

Esto ordena el vector, luego desplaza todos los números uno a la derecha si un número aleatorio es menor que 0.1.

Java 8, 45 34.2 ( 50 38 - 10%) bytes

Versión normal:

a->{if(Math.random()>0.)a.sort(null);}

Explicación:

Pruébalo aquí

a->{                    // Method with ArrayList<Integer> parameter and no return-type
  if(Math.random()>0.)  //  If the random 0-1 double is larger than 0:
    a.sort(null);       //   Sort the input-List
}                       // End of method

Versión con errores ( 51 39 bytes):

a->{if(Math.random()>0.1)a.sort(null);}

LD de 1: 1 agregado.

Explicación:

Pruébalo aquí

a->{                     // Method with ArrayList<Integer> parameter and no return-type
  if(Math.random()>0.1)  //  If the random 0-1 double is larger than 0.1:
    a.sort(null);        //   Sort the input-List
}                        // End of method

JavaScript, 25 * 0.9 = 22.5

new Date%25?x:x.sort()

entrada x