Einführung:

Im Niederländischen werden die Wörter Führen und Leiden, die "leiden" bzw. "lijden" sind, auf die gleiche Weise ausgesprochen. Einer ist mit einem "kurzen ei" und einer mit einem "langen ij" geschrieben , wie wir Holländer sagen würden, aber sowohl "ei" als auch "ij" werden ausgesprochen [ɛi].

Herausforderung:

Bestimmen Sie anhand einer Liste von Zahlen, welche (falls vorhanden) führend sind und welche (falls vorhanden) leiden.

Eine führende Zahl ist:

• Eine positive Zahl
• Hat mindestens vier Ziffern
• Ist in den höchsten 50% der Liste in Bezug auf den Wert
• Befindet sich wertmäßig immer noch in den höchsten 50% der Liste, wenn die 3. Ziffer durch die 2. Ziffer ersetzt wird und die 2. Ziffernposition mit einer 0 gefüllt wird (dh 1234würde 1024)

Eine leidende Zahl ist:

• Eine negative Zahl
• Hat mindestens vier Ziffern
• Ist in den niedrigsten 50% der Liste in Bezug auf den Wert
• Befindet sich in Bezug auf den Wert immer noch in den niedrigsten 50% der Liste, wenn die 3. Ziffer durch die 2. Ziffer ersetzt wird und die 2. Ziffernposition mit einer 0 gefüllt wird (dh -4321würde -4031)

Beispiel:

Eingabe: [5827, 281993, 3918, 3854, -32781, -2739, 37819, 0, 37298, -389]
Ausgabe: führend : [5827, 281993, 37819, 37298]; Leiden:[-32781, -2739]

Erläuterung:

Wenn wir die Zahlen sortieren und in zwei Hälften teilen, wäre dies:

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

Es gibt nur zwei negative Zahlen mit mindestens vier Ziffern : [-32781, -2739]. Das Ändern der Ziffern wie oben beschrieben würde ihre Position nicht ändern, daher leiden beide unter Zahlen.
Für die größte Hälfte haben alle Zahlen mindestens vier Ziffern : [3854, 3918, 5827, 37819, 281993]. Das Ändern der Ziffern wie oben beschrieben würde jedoch einige ihrer Positionen ändern. Das 3854würde werden 3084, wenn man es unter 3798die niedrigsten 50% legt , 3854ist also keine führende Zahl in dieser Liste. Gleiches gilt für 3918das 3098, was auch unten stehen würde 3798. Die anderen drei Zahlen sind führend, wie 5827es werden würde 5087, was immer noch über 3798und tatsächlich immer noch auf dem gleichen Index der sortierten Liste liegt. Damit[5827, 37819, 281993] sind die führenden Zahlen.

Herausforderungsregeln:

• E / A ist flexibel. Die Eingabeliste kann eine Liste von Ganzzahlen, 2D-Ziffernlisten, eine Liste von Zeichenfolgen usw. sein. Die Ausgabe kann eine Liste von Listen von Ganzzahlen, zwei getrennten Listen, zwei Zeichenfolgen sein, die beide auf STDOUT gedruckt sind usw.
• Wenn wir feststellen, ob eine Zahl führend ist / leidet, betrachten wir ihre neue Position dieser Zahl nur, wenn nur ihre Ziffern entsprechend geändert werden, nicht nachdem wir die Änderungen auf alle Zahlen angewendet haben.
• Wir geben die ursprünglichen Zahlen aus, nicht die geänderten.
• Die Nummern in den führenden und leidenden Ausgabelisten können in beliebiger Reihenfolge sein.
• Wenn die Größe der Eingabeliste ungerade ist, gehört die Zahl in der Mitte nicht zu einer der beiden Hälften.
• Die Nummern bleiben nach der Änderung garantiert eindeutig. Eine Liste wie [0, 1, 1045, 1485]ist also keine gültige Eingabeliste, da 1485sie 1045nach ihrer Änderung gleich wäre .

Allgemeine Regeln:

• Dies ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.
  Lassen Sie sich nicht von Code-Golf-Sprachen davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, eine möglichst kurze Antwort für "jede" Programmiersprache zu finden.
• Für Ihre Antwort gelten Standardregeln mit Standard-E / A-Regeln . Sie können also STDIN / STDOUT, Funktionen / Methoden mit den richtigen Parametern und vollständige Programme vom Rückgabetyp verwenden. Ihr Anruf.
• Standardschlupflöcher sind verboten.
• Wenn möglich, fügen Sie bitte einen Link mit einem Test für Ihren Code (dh TIO ) hinzu.
• Es wird dringend empfohlen, eine Erklärung für Ihre Antwort hinzuzufügen.

Testfälle:

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

Probieren Sie es online aus!

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]

Probieren Sie es online aus!

Ausgänge als suffering, leading.

Gelee , 30 Bytes

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

Probieren Sie es online aus!

Angesichts der Länge von Grimys 05AB1E-Antwort bin ich sicher, dass dies besser gespielt werden kann, aber hier ist es.

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

Probieren Sie es online aus!

Anonyme Funktion, die ein Array von Zahlen als Eingabe verwendet und ein Array mit 2 Elementen als Ausgabe ausgibt. Das erste Element im Ausgabearray ist ein Array führender Zahlen, das zweite Element im Ausgabearray ist ein Array folgender Zahlen.

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