Giới thiệu:

Trong tiếng Hà Lan, các từ dẫn đầu và đau khổ, lần lượt là 'leiden' và 'lijden', được phát âm theo cùng một cách. Một được viết bằng "ei ngắn" và một với "ij dài" , như người Hà Lan chúng ta thường nói, nhưng cả 'ei' và 'ij' đều được phát âm là [i].

Thử thách:

Đưa ra một danh sách các số, xác định cái nào (nếu có) đang dẫn đầu, và cái nào (nếu có) đang chịu đựng.

Một số hàng đầu là:

• Một số dương
• Có ít nhất bốn chữ số
• Nằm trong 50% cao nhất của danh sách về giá trị
• Vẫn nằm trong 50% cao nhất của danh sách về giá trị, nếu chữ số thứ 3 được thay thế bằng chữ số thứ 2 và vị trí chữ số thứ 2 của nó được điền bằng 0 (nghĩa là 1234sẽ trở thành 1024)

Một con số đau khổ là:

• Một số âm
• Có ít nhất bốn chữ số
• Nằm trong 50% thấp nhất của danh sách về giá trị
• Vẫn nằm trong 50% thấp nhất của danh sách về giá trị, nếu chữ số thứ 3 được thay thế bằng chữ số thứ 2 và vị trí chữ số thứ 2 của nó được điền bằng 0 (nghĩa là -4321sẽ trở thành -4031)

Thí dụ:

Đầu vào: [5827, 281993, 3918, 3854, -32781, -2739, 37819, 0, 37298, -389]
Đầu ra: hàng đầu : [5827, 281993, 37819, 37298]; đau khổ:[-32781, -2739]

Giải trình:

Nếu chúng ta sắp xếp và chia các số thành hai nửa, đó sẽ là:

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

Chỉ có hai số âm có ít nhất bốn chữ số : [-32781, -2739]. Thay đổi các chữ số như mô tả ở trên sẽ không thay đổi vị trí của chúng, vì vậy cả hai đều là những con số đau khổ.
Đối với một nửa lớn nhất, tất cả các số có ít nhất bốn chữ số : [3854, 3918, 5827, 37819, 281993]. Thay đổi các chữ số như mô tả ở trên sẽ thay đổi một số vị trí của họ. Điều 3854này sẽ trở thành 3084, đặt nó dưới 3798mức thấp nhất 50%, vì vậy 3854không phải là một số dẫn đầu trong danh sách này. Điều tương tự áp dụng cho 3918điều đó sẽ trở thành 3098, cũng đặt nó dưới đây 3798. Ba con số khác đang dẫn đầu, như 5827sẽ trở thành 5087, vẫn còn ở trên 3798và trên thực tế vẫn ở cùng một chỉ mục của danh sách được sắp xếp. Vì thế[5827, 37819, 281993] là những con số hàng đầu.

Quy tắc thử thách:

• I / O là linh hoạt. Danh sách đầu vào có thể là danh sách các số nguyên, danh sách chữ số 2D, danh sách các chuỗi, v.v ... Đầu ra có thể là danh sách các số nguyên, hai danh sách riêng biệt, hai chuỗi, cả hai được in ra STDOUT, v.v.
• Khi xác định xem một số có dẫn đầu / đau khổ hay không, chúng ta chỉ nhìn vào vị trí mới của số đó nếu chỉ các chữ số của nó được thay đổi tương ứng, không phải sau khi chúng ta áp dụng các sửa đổi cho tất cả các số.
• Chúng tôi xuất số gốc, không phải số đã sửa đổi.
• Các số trong danh sách đầu ra hàng đầu và chịu đựng có thể theo bất kỳ thứ tự nào.
• Nếu kích thước của danh sách đầu vào là số lẻ, số ở giữa không thuộc một nửa.
• Số được đảm bảo duy nhất sau khi sửa đổi. Vì vậy, một danh sách như [0, 1, 1045, 1485]không phải là một danh sách đầu vào hợp lệ, vì 1485sẽ bằng với 1045sau khi sửa đổi.

Quy tắc chung:

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.
  Đừng để ngôn ngữ mã-golf ngăn cản bạn đăng câu trả lời với các ngôn ngữ không mã hóa. Cố gắng đưa ra một câu trả lời càng ngắn càng tốt cho ngôn ngữ lập trình 'bất kỳ'.
• Quy tắc chuẩn áp dụng cho câu trả lời của bạn với quy tắc I / O mặc định , vì vậy bạn được phép sử dụng STDIN / STDOUT, các hàm / phương thức với các tham số thích hợp và kiểu trả về, chương trình đầy đủ. Cuộc gọi của bạn.
• Lỗ hổng mặc định bị cấm.
• Nếu có thể, vui lòng thêm một liên kết với một bài kiểm tra cho mã của bạn (ví dụ TIO ).
• Ngoài ra, thêm một lời giải thích cho câu trả lời của bạn rất được khuyến khích.

Các trường hợp thử nghiệm:

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

Hãy thử trực tuyến!

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]

Hãy thử trực tuyến!

Đầu ra như suffering, leading.

Thạch , 30 byte

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

Hãy thử trực tuyến!

Với độ dài câu trả lời 05AB1E của Grimy , tôi chắc chắn rằng điều này có thể được chơi golf tốt hơn, nhưng đây là.

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

Hãy thử trực tuyến!

Hàm ẩn danh lấy một mảng các số làm đầu vào và xuất ra một mảng 2 phần tử làm đầu ra. Phần tử đầu tiên trong mảng đầu ra là một mảng gồm các số đứng đầu, phần tử thứ hai trong mảng đầu ra là một mảng gồm các số sau.

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