Introdução:

Em holandês, as palavras liderança e sofrimento, sendo 'leiden' e 'lijden', respectivamente, são pronunciadas da mesma maneira. Um é escrito com um "ei curto" e outro com um "ij longo" , como diríamos os holandeses, mas ambos 'ei' e 'ij' são pronunciados [ɛi].

Desafio:

Dada uma lista de números, determine quais (se houver) estão liderando e quais (se houver) estão sofrendo.

Um número inicial é:

• Um número positivo
• Tem pelo menos quatro dígitos
• Está nos 50% mais altos da lista em termos de valor
• Ainda está nos 50% mais altos da lista em termos de valor, se o terceiro dígito for substituído pelo segundo e a posição do segundo dígito for preenchida com um 0 (ou seja, 1234se tornaria 1024)

Um número de sofrimento é:

• Um número negativo
• Tem pelo menos quatro dígitos
• Está nos 50% mais baixos da lista em termos de valor
• Ainda está nos 50% mais baixos da lista em termos de valor, se o terceiro dígito for substituído pelo segundo e a posição do segundo dígito for preenchida com um 0 (ou seja, -4321se tornaria -4031)

Exemplo:

Entrada: [5827, 281993, 3918, 3854, -32781, -2739, 37819, 0, 37298, -389]
Saída: à esquerda [5827, 281993, 37819, 37298]:; sofrimento:[-32781, -2739]

Explicação:

Se ordenarmos e dividirmos os números em duas metades, seria:

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

Existem apenas dois números negativos, com pelo menos quatro dígitos: [-32781, -2739]. Alterar os dígitos como descrito acima não mudaria de posição, portanto, ambos estão sofrendo números.
Para a maior halve, todos os números têm pelo menos quatro dígitos: [3854, 3918, 5827, 37819, 281993]. Alterar os dígitos, conforme descrito acima, alteraria algumas de suas posições. O resultado 3854seria 3084, colocando-o abaixo 3798dos 50% mais baixos, portanto, 3854este não é um número principal nesta lista. O mesmo se aplica ao 3918que se tornaria 3098, colocando-o também abaixo 3798. Os outros três números estão à frente, como o 5827que se tornaria 5087, o qual ainda está acima 3798e ainda está no mesmo índice da lista classificada. assim[5827, 37819, 281993] são os números principais.

Regras do desafio:

• A E / S é flexível. A lista de entrada pode ser uma lista de números inteiros, listas de dígitos 2D, lista de cadeias, etc. A saída pode ser uma lista de listas de inteiros, duas listas separadas, duas cadeias, ambas impressas em STDOUT, etc.
• Ao determinar se um número está levando / sofrendo, apenas examinamos sua nova posição desse número se apenas seus dígitos forem alterados de acordo, não depois de aplicarmos as modificações em todos os números.
• Nós produzimos os números originais, não os modificados.
• Os números nas listas de saída iniciais e em sofrimento podem estar em qualquer ordem.
• Se o tamanho da lista de entrada for ímpar, o número no centro não pertence a nenhuma das duas partes.
• É garantido que os números permaneçam únicos após sua modificação. Portanto, uma lista como [0, 1, 1045, 1485]não é uma lista de entrada válida, pois 1485seria igual a 1045após a modificação.

Regras gerais:

• Isso é código-golfe , então a resposta mais curta em bytes vence.
  Não permita que idiomas com código de golfe o desencorajem a postar respostas com idiomas que não sejam codegolf. Tente encontrar uma resposta o mais curta possível para 'qualquer' linguagem de programação.
• As regras padrão se aplicam à sua resposta com as regras de E / S padrão , para que você possa usar STDIN / STDOUT, funções / método com os parâmetros adequados e programas completos do tipo retorno. Sua chamada.
• As brechas padrão são proibidas.
• Se possível, adicione um link com um teste para o seu código (ou seja, TIO ).
• Além disso, é altamente recomendável adicionar uma explicação para sua resposta.

Casos de teste:

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*₄@Ï

Experimente online!

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]

Experimente online!

Saídas como suffering, leading.

Gelatina , 30 bytes

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

Experimente online!

Dada a duração da resposta 05AB1E do Grimy , tenho certeza de que isso pode ser melhor, mas aqui 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)]

Experimente online!

Função anônima que recebe uma matriz de números como entrada e gera uma matriz de 2 elementos como saída. O primeiro elemento na matriz de saída é uma matriz de números iniciais, o segundo elemento na matriz de saída é uma matriz dos seguintes 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)
  ]