Pengantar:

Di Belanda, kata-kata memimpin dan menderita, masing-masing 'leiden' dan 'lijden', diucapkan dengan cara yang sama. Satu ditulis dengan "ei pendek", dan satu dengan "ij panjang" , seperti yang akan dikatakan oleh orang Belanda, tetapi 'ei' dan 'ij' dilafalkan [ɛi].

Tantangan:

Diberikan daftar angka, tentukan yang mana (jika ada) yang memimpin, dan mana (jika ada) yang menderita.

Nomor utama adalah:

• Angka positif
• Setidaknya memiliki empat digit
• Berada dalam 50% tertinggi dari daftar dalam hal nilai
• Masih di 50% tertinggi dari daftar dalam hal nilai, jika digit ke-3 diganti dengan digit ke-2, dan posisi ke-2 digit-nya diisi dengan angka 0 (yaitu 1234akan menjadi 1024)

Jumlah yang menderita adalah:

• Angka negatif
• Setidaknya memiliki empat digit
• Berada di 50% terendah dari daftar dalam hal nilai
• Masih di 50% terendah dari daftar dalam hal nilai, jika digit ke-3 diganti dengan digit ke-2, dan posisi ke-2 digit diisi dengan angka 0 (artinya -4321akan menjadi -4031)

Contoh:

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

Penjelasan:

Jika kita mengurutkan dan membagi angka menjadi dua, itu adalah:

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

Hanya ada dua angka negatif dengan setidaknya empat digit: [-32781, -2739]. Mengubah digit seperti dijelaskan di atas tidak akan mengubah posisi mereka, sehingga keduanya adalah angka penderitaan.
Untuk membagi dua terbesar, semua angka memiliki setidaknya empat digit: [3854, 3918, 5827, 37819, 281993]. Mengubah digit seperti yang dijelaskan di atas akan mengubah beberapa posisi mereka. The 3854akan menjadi 3084, meletakkannya di bawah 3798yang di terendah 50%, sehingga 3854bukan nomor terkemuka di daftar ini. Hal yang sama berlaku untuk 3918yang akan menjadi 3098, juga meletakkannya di bawah 3798. Tiga angka lainnya sedang memimpin, seperti 5827yang akan terjadi 5087, yang masih di atas 3798dan pada kenyataannya masih pada indeks yang sama dari daftar yang diurutkan. Begitu[5827, 37819, 281993] adalah angka utama.

Aturan tantangan:

• I / O fleksibel. Input-list dapat berupa daftar bilangan bulat, daftar digit 2D, daftar string, dll. Output dapat berupa daftar daftar bilangan bulat, dua daftar terpisah, dua string, keduanya dicetak ke STDOUT, dll.
• Saat menentukan apakah suatu angka memimpin / menderita, kita hanya melihat posisi barunya dari angka itu jika hanya digitnya yang diubah, bukan setelah kita menerapkan modifikasi pada semua angka.
• Kami menampilkan angka asli, bukan yang dimodifikasi.
• Angka-angka dalam daftar keluaran terkemuka dan menderita bisa dalam urutan apa pun.
• Jika ukuran daftar input ganjil, angka di tengah tidak termasuk setengah.
• Angka dijamin tetap unik setelah dimodifikasi. Jadi daftar seperti [0, 1, 1045, 1485]bukan daftar input yang valid, karena 1485akan sama dengan 1045setelah modifikasi itu.

Aturan umum:

• Ini adalah kode-golf , jadi jawaban tersingkat dalam byte menang.
  Jangan biarkan bahasa kode-golf mencegah Anda memposting jawaban dengan bahasa non-codegolf. Cobalah untuk memberikan jawaban sesingkat mungkin untuk bahasa pemrograman 'apa pun'.
• Aturan standar berlaku untuk jawaban Anda dengan aturan I / O default , sehingga Anda diizinkan untuk menggunakan STDIN / STDOUT, fungsi / metode dengan parameter yang tepat dan tipe pengembalian, program penuh. Panggilanmu.
• Celah default tidak diperbolehkan.
• Jika memungkinkan, silakan tambahkan tautan dengan tes untuk kode Anda (yaitu TIO ).
• Juga, menambahkan penjelasan untuk jawaban Anda sangat dianjurkan.

Kasus uji:

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 byte

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

Cobalah online!

Python 2 , 119 118 111 107 byte

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]

Cobalah online!

Output sebagai suffering, leading.

Jelly , 30 byte

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

Cobalah online!

Mengingat panjangnya jawaban 05AB1E Grimy , saya yakin ini bisa bermain golf lebih baik, tapi ini dia.

JavaScript (Node.js) , 162 byte

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

Cobalah online!

Fungsi anonim yang mengambil array angka sebagai input dan output array 2-elemen sebagai output. Elemen pertama dalam array output adalah array nomor terdepan, elemen kedua dalam array output adalah array nomor-nomor berikut.

// 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)
  ]