Números de liderança e sofrimento

9

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 é , 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]
Kevin Cruijssen
fonte
A julgar pelos casos de teste, parece que você quer que os 50% arredondem para baixo quando o comprimento da lista é ímpar. Você pode especificar isso explicitamente.
Grimmy
Caso de teste sugerido: [1000, -1000]
Grimmy
@ Grimy Quanto ao seu primeiro comentário, a regra " Se o tamanho da lista de entrada for ímpar, o número no centro não pertence a nenhuma das partes " deve cobrir isso, certo? E adicionou o caso de teste sugerido.
Kevin Cruijssen 27/05/19

Respostas:

6

05AB1E , 27 24 23 22 21 bytes

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

Experimente online!

Grimmy
fonte
1
22 bytes com base no seu atual byter de 23 bytes
Kevin Cruijssen 27/05
@KevinCruijssen Acabei de editar minha resposta para outras 22 que encontrei de forma independente. Agora, para ver se podemos combinar essas otimizações para um 21 ...
Grimmy
1
Provavelmente não. Usei o ©e em ®Åmvez do seu ÅmUye Xpara salvar um byte, mas agora você o removeu UXtambém fazendo o Åm ... ‹ydepois do mapa, por isso é uma otimização semelhante. Na verdade, eu gosto mais da sua, pois, nesse caso, ela não usa variáveis ​​desnecessárias. :)
Kevin Cruijssen
Dang, encontrar muito agradável com 0šāǝ! : D Nunca teria pensado nisso!
Kevin Cruijssen
@KevinCruijssen Thanks! Há também D¦0š2Lǝ, que é a mesma contagem de bytes que D1è0šāǝ.
Grimmy
5

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.

TFeld
fonte
1

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)
  ]
dana
fonte