Introducción:

En holandés, las palabras líder y sufrimiento, siendo 'leiden' y 'lijden' respectivamente, se pronuncian de la misma manera. Uno está escrito con un "ei corto" y otro con un "ij largo" , como diríamos los holandeses, pero tanto "ei" como "ij" se pronuncian [ɛi].

Desafío:

Dada una lista de números, determine cuáles (si los hay) son líderes y cuáles (si los hay) sufren.

Un número principal es:

• Un numero positivo
• Tiene al menos cuatro dígitos
• Está en el 50% más alto de la lista en términos de valor
• Todavía está en el 50% más alto de la lista en términos de valor, si su tercer dígito se reemplaza por su segundo dígito, y su posición del segundo dígito se llena con un 0 (es decir, 1234se convertiría en 1024)

Un número que sufre es:

• Un numero negativo
• Tiene al menos cuatro dígitos
• Está en el 50% más bajo de la lista en términos de valor
• Todavía está en el 50% más bajo de la lista en términos de valor, si su tercer dígito se reemplaza por su segundo dígito, y su posición del segundo dígito se llena con un 0 (es decir, -4321se convertiría en -4031)

Ejemplo:

Entrada: [5827, 281993, 3918, 3854, -32781, -2739, 37819, 0, 37298, -389]
Salida: líder [5827, 281993, 37819, 37298]:; sufrimiento:[-32781, -2739]

Explicación:

Si clasificamos y dividimos los números en dos mitades, sería:

[[-32781, -2739, -389, 0, 3798], [3854, 3918, 5827, 37819, 281993]]

Sólo hay dos números negativos con al menos cuatro dígitos: [-32781, -2739]. Cambiar los dígitos como se describió anteriormente no cambiaría su posición, por lo que ambos sufren números.
Para la mayor parte en dos, todos los números tienen al menos cuatro dígitos: [3854, 3918, 5827, 37819, 281993]. Sin embargo, cambiar los dígitos como se describió anteriormente cambiaría algunas de sus posiciones. El 3854se convertiría 3084, poniéndolo debajo de lo 3798que está en el 50% más bajo, por 3854lo que no es un número principal en esta lista. Lo mismo se aplica a lo 3918que sería 3098, poniéndolo también a continuación 3798. Los otros tres números son líderes, como lo 5827que se convertiría 5087, que todavía está arriba 3798y de hecho todavía está en el mismo índice de la lista ordenada. Entonces[5827, 37819, 281993] son los números principales

Reglas de desafío:

• I / O es flexible. La lista de entrada puede ser una lista de enteros, listas de dígitos 2D, lista de cadenas, etc. La salida puede ser una lista de listas de enteros, dos listas separadas, dos cadenas, ambas impresas en STDOUT, etc.
• Al determinar si un número es líder / sufriente, solo miramos su nueva posición de ese número si solo se cambian sus dígitos en consecuencia, no después de haber aplicado las modificaciones a todos los números.
• Generamos los números originales, no los modificados.
• Los números en las listas de salida principales y que sufren pueden estar en cualquier orden.
• Si el tamaño de la lista de entrada es impar, el número en el centro no pertenece a la mitad.
• Se garantiza que los números seguirán siendo únicos después de su modificación. Entonces, una lista como [0, 1, 1045, 1485]no es una lista de entrada válida, ya 1485que sería igual a 1045después de su modificación.

Reglas generales:

• Este es el código de golf , por lo que la respuesta más corta en bytes gana.
  No permita que los lenguajes de code-golf lo desanimen a publicar respuestas con lenguajes que no sean codegolf. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
• Las reglas estándar se aplican a su respuesta con las reglas de E / S predeterminadas , por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados y programas completos de tipo retorno. Tu llamada.
• Las lagunas predeterminadas están prohibidas.
• Si es posible, agregue un enlace con una prueba para su código (es decir, TIO ).
• Además, se recomienda agregar una explicación para su respuesta.

Casos de prueba:

Input: [5827, 281993, 3918, 3854, -32781, -2739, 37819, 0, 37298, -389]
Output: leading: [5827, 281993, 37819, 37298]; suffering: [-32781, -2739]

Input: [-100, 472, 413, -1782]
Output: leading: []; suffering: [-1782]

Input: [-1234, -1235, -1236, 1234, 1235, 1236]
Output: leading: [1234, 1235, 1236]; suffering: [-1234, -1235, -1236]

Input: [-1919, -1819, -1719, -1619, -1500, -1444, 40, 4444, 18]
Output: leading: [4444]; suffering: []

Input: [-1004, -1111, -1000]
Output: leading: []; suffering: [-1111]

Input: [-1004, -1111, -1010, 1000]
Output: leading: [1000]; suffering: [-1111]

Input: [1000, -1000]
Output: leading: [1000]; suffering: [-1000]

Input: [1000, -5000, 4000]
Output: leading: [4000]; suffering: [-5000]

05AB1E , 27 24 23 22 21 bytes

(‚εÅmyεD1è0šāǝ}‹y*₄@Ï

Pruébalo en línea!

Python 2 , 119 118 111 107 bytes

lambda a:[[n for n in a if sorted(a)[::d][~len(a)/2]*d<int('0'.join(`n*d`[:2])+`n*d`[3:])>999]for d in-1,1]

Pruébalo en línea!

Salidas como suffering, leading.

Jalea , 30 bytes

,NµD2ị;0Ʋ2,3¦ḌƊ>ẠɗƇÆṁ;999Ɗ)N2¦

Pruébalo en línea!

Dada la longitud de la respuesta 05AB1E de Grimy , estoy seguro de que esto se puede jugar mejor, pero aquí está.

Javascript (Node.js) , 162 bytes

a=>[(g=i=>a.filter(n=>n*i>999&(h=t=>a.reduce((a,c)=>a+(c!=n&i*c<i*t(n)),0)>=a.length/2)(x=>x)&h(m=x=>x<0?-m(-x):x>999?m(x/10)*10+x%10:x-x%100+x/10%10)))(1),g(-1)]

Pruébalo en línea!

Función anónima que toma una matriz de números como entrada y genera una matriz de 2 elementos como salida. El primer elemento en la matriz de salida es una matriz de números iniciales, el segundo elemento en la matriz de salida es una matriz de los siguientes números.

// a: input array of numbers
a=>
  // begin output array
  [
    // define a function g with input i
    // when i is 1, generate leading
    // when i is -1, generate following
    (g=i=>
      // function g returns a subset of a,
      // use filter() to select elements
      a.filter(n=>
        // n must be 4 digits and explicitly
        // positive or negative depending
        // on whether we are calculating
        // leading or following numbers
        n*i>999&
        // function h determines whether
        // the current number is in the
        // larger or smaller half,
        // depending on whether we are
        // calculating the leading or
        // following numbers.
        // argument t defines a
        // transformation that should
        // be applied to th current number
        (h=t=>
          // use reduce() to count the
          // number of numbers greater or
          // less than the transformed
          // current number
          a.reduce((a,c)=>
            // add the current total to...
            a+
            // either 0 or 1 depending on
            // whether the transformed
            // current number is in the
            // opposite group (leading vs
            // following
            (c!=n&i*c<i*t(n)),0)>=
          // are at least half in the
          // opposite group?
          a.length/2)
          // invoke h with the identity
          // transform
          (x=>x)&
          // invoke h again with a
          // transform m that moves the
          // 2nd digit to the 3rd digit and
          // 0's out the 2nd digit.
          // input for m is number x
          h(m=x=>
            // is x negative?
            x<0
              // invoke m with negated input
              // to force it to a positive value
              // and negate the result to
              // convert back to negative
              ?-m(-x)
              // otherwise, does x have 4 or
              // more digits?
              :x>999
                // recursively call m with 1
                // fewer digit, then add digit
                // back to the result
                ?m(x/10)*10+x%10
                // 3 or fewer digits, move
                // the 2nd digit to the 3rd
                // and 0 put the 2nd digit
                :x-x%100+x/10%10
        )
      )
    )
    // invoke g with input 1 for leading
    (1),
    // invoke g with input -1 for following
    g(-1)
  ]