Führende und leidende Zahlen

9

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 , 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]
Kevin Cruijssen
quelle
Den Testfällen nach zu urteilen, scheinen Sie zu bedeuten, dass die 50% abrunden, wenn die Länge der Liste ungerade ist. Möglicherweise möchten Sie dies explizit angeben.
Grimmy
Vorgeschlagener Testfall: [1000, -1000]
Grimmy
@Grimy Was Ihren ersten Kommentar betrifft, sollte die Regel " Wenn die Größe der Eingabeliste ungerade ist, gehört die Zahl in der Mitte nicht zu einer der beiden Hälften " dies abdecken, oder? Und fügte den vorgeschlagenen Testfall hinzu.
Kevin Cruijssen

Antworten:

6

05AB1E , 27 24 23 22 21 Bytes

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

Probieren Sie es online aus!

Grimmy
quelle
1
22 Bytes basierend auf Ihrem aktuellen 23-Byter
Kevin Cruijssen
@ KevinCruijssen Ich habe gerade meine Antwort auf weitere 22 bearbeitet, die ich unabhängig gefunden habe. Nun, um zu sehen, ob wir diese Optimierungen für eine 21 kombinieren können ...
Grimmy
1
Wahrscheinlich nicht. Ich habe das ©und ®Åmanstelle Ihres ÅmUyund verwendet X, um ein Byte zu speichern, aber Sie haben jetzt auch das entfernt, UXindem Sie das Åm ... ‹yNach der Karte ausgeführt haben. Es handelt sich also um eine ähnliche Optimierung. Ich mag deine eigentlich besser, da sie in diesem Fall keine unnötigen Variablen verwendet. :)
Kevin Cruijssen
Dang, sehr schöner Fund mit 0šāǝ! : D Daran hätte ich nie gedacht!
Kevin Cruijssen
@ KevinCruijssen Danke! Es gibt auch D¦0š2Lǝdie gleiche Byteanzahl wie 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]

Probieren Sie es online aus!

Ausgänge als suffering, leading.

TFeld
quelle
1

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