Die Herausforderung besteht darin, ein Golfcode-Programm zu schreiben, das bei n positiven reellen Zahlen von 0 bis 10 (Format xy, y kann nur 0 oder 5: 0, 0,5, 1, 1,5, 2, 2,5… 9,5 und 10 sein). Verwerfen Sie die niedrigsten und höchsten Werte (nur einen, obwohl sie wiederholt werden) und zeigen Sie den Durchschnitt der verbleibenden Werte im xy-Format (y kann 0 oder 5 sein, auf den nächsten gerundet), ähnlich wie bei einigen Olympischen Spielen.

Beispiele: Eingabe -> Ausgabe

6 -> 6

6,5, 9 -> 8

9, 7, 8 -> 8

6, 5, 7, 8, 9 -> 7

5, 6,5, 9, 8, 7 -> 7

6,5, 6,5, 9,5, 8, 7 -> 7

5, 6,5, 7,5, 8,5, 9,5 -> 7,5

Hinweise: Wenn die Eingabe nur aus zwei Zahlen besteht, verwerfen Sie keine, sondern mitteln Sie sie. Wenn die Eingabe eine Zahl ist, ist die Ausgabe dieselbe.

Klarstellung der Rundungsregel (sorry, wenig verwirrend):

x.01 bis x.25 rund auf x.0

x.26 bis x.75 rund auf x.5

x.76 bis x.99 rund auf x + 1.0

Gelee , 12 Bytes

ṢṖḊȯµÆmḤær0H

Probieren Sie es online aus!

    µ           Take
Ṣ               the input sorted,
 Ṗ              without its last
  Ḋ             or first element,
   ȯ            or the unchanged input if that's empty,
     Æm         then calculate the mean,
       Ḥ        double it,
        ær      round it to the nearest multiple of
          0     10^-0 (= 1),
           H    and halve it.

Eine Version, die auf Kosten des zweiten Testfalls gemäß der Spezifikation die Hälfte abrundet:

Gelee , 12 Bytes

ṢṖḊȯµÆmḤ_.ĊH

Probieren Sie es online aus!

Die Rundungsmethode hier ist näher an Jonathan Allans:

Ḥ        Double,
 _       subtract
  .      one half,
   Ċ     round up,
    H    and halve.

Netzhaut , 86 Bytes

\.5
__
\d+
*4*__
O`_+
_+ (.+) _+
$1
O`.
^ *
$.&*__:
(_+):(\1{4})*(\1\1)?_*
$#2$#3*$(.5

Probieren Sie es online aus! Link enthält Testfälle. Erläuterung:

\.5
__
\d+
*4*__

Da die Netzhaut nicht ohne weiteres mit Bruch- oder Nullzahlen umgehen kann, wird jede Zahl unary als 1 mehr als das Vierfache des Wertes dargestellt. Das .5erweitert sich daher auf 2 _s, während das *4*_für den gesamten _Zahlenteil gilt und ein Finale angehängt wird.

O`_+

Sortieren Sie die Zahlen in der richtigen Reihenfolge.

_+ (.+) _+
$1

Wenn mindestens drei Zahlen vorhanden sind, verwerfen Sie die erste (kleinste) und die letzte (größte).

O`.

Sortieren Sie die Leerzeichen zum Anfang und summieren Sie so auch die Zahlen.

^ *
$.&*__:

Zählen Sie die Anzahl der Leerzeichen und fügen Sie _ein Trennzeichen hinzu. Dies stellt dann die Zahl dar, durch die wir teilen müssen.

(_+):(\1{4})*(\1\1)?_*
$#2$#3*$(.5

Teilen Sie die Summe durch die Anzahl der Zahlen, wobei Sie berücksichtigen, dass wir in Vielfachen des 4-fachen der ursprünglichen Zahl arbeiten, damit die Ganzzahl- und Dezimalanteile direkt extrahiert werden können. Dies ist eine abschneidende Unterteilung, aber glücklicherweise _enthält das Ergebnis , da wir jeder Zahl ein Extra hinzugefügt haben, effektiv ein Extra von 0,25, wodurch wir die gewünschte Rundung erhalten.

BEARBEITEN: Diese Antwort ist seitdem ungültig geworden. Es war ungefähr eine halbe Minute gültig, nachdem es veröffentlicht wurde.

Gelee , 10 Bytes

ṢḊṖȯƊÆmḤḞH

Probieren Sie es online aus!

J , ³⁶ 35 Bytes

[:(1r4<.@+&.+:+/%#)}:@}.^:(2<#)@/:~

Probieren Sie es online aus!

Leihte den Doppel- / Boden- / Halbtrick zum Runden auf 0,5 Schritte von Unrelated String.

Python 3 , 62 Bytes

def f(s):z=sorted(s)[1:-1]or s;return round(2*sum(z)/len(z))/2

Probieren Sie es online aus!

JavaScript (V8) , 213 211 189 176 Byte

^{Bearbeiten: -2 Bytes, weil ich mit endete ;\n} mit einem }dummen Fehler .}

^{Bearbeiten Sie 2: -22 weitere Bytes, indem Sie allgemeine JS-Golftipps lesen. Ich habe es geschafft, Klammern aus meinen verschachtelten Ternären in der rRundungsfunktion zu entfernen , und habe bitweise mathematische Operationen verwendet, um die Verwendung zu vermeidenMath.floor undMath.ceil}

^{Bearbeiten Sie 3: -13 Bytes, da ich die a.lengthVerknüpfungsfunktion durch direkte Aufrufe ersetzen konnte a.length, um 4 Bytes zu sparen. Ich habe auch die Funktion g () direkt in die return-Anweisung verschoben, da sie nur einmal verwendet wurde, wodurch der Rest der Bytes entfernt wurde.}

a=>{s=i=>a.splice(i,1)
e=_=>a.reduce((t,i)=>t+=i)/a.length
r=n=>(m=n%1,m<0.75?m>0.25?~~(n)+0.5:~~(n):n%1?-~n:n)
return a.length>2?r((a.sort((x,y)=>x-y),s(0),s(-1),e())):r(e())}

Probieren Sie es online aus!

Ich bin sicher, dass es verbessert werden kann, da ich ziemlich neu bin, aber es hat Spaß gemacht, dieses Problem zu lösen. Ich glaube, die wichtigsten Dinge, die verbessert werden könnten, sind meine Rundungslogik / -methoden und die Tatsache, dass die Hauptfunktion einen Funktionskörper ( { }und return) verwendet.

Es gab eine Sache in der Frage, die nicht mit den Beispielen übereinstimmte, und ich war mir nicht sicher, wie ich damit umgehen sollte. Ich habe es so implementiert, dass es mit den Beispielen übereinstimmt, aber es spiegelt nicht genau die angegebenen Rundungsregeln wider. Hier ist das Beispiel, das ich als inkonsistent empfunden habe:

6,5, 9 -> 8

Sie sagen, es sollte 8 sein, obwohl der Durchschnitt 7,75 ist. In den Rundungsregeln sagen Sie, dass es mindestens 0,76 sein muss, um +1 zu erhalten. Ich habe mich dafür entschieden, die Beispiele anstelle Ihrer Rundungsregeln wiederzugeben, also> = 0,75 für +1 und <= 0,25 für -1 zwischen 0,25 und 0,75 (exklusiv) für 0,5. Wenn sich die Rundungsspezifikationen ändern, sollte sich mein Code anpassen können, ohne die Anzahl der Bytes zu ändern, indem nur die Zahlen in der Rundungsfunktion geändert werdenr und möglicherweise die Reihenfolge der ternären Anweisung in Abhängigkeit von den Regeln geändert werden.

Mit Erklärung etwas ungolfed (die mathematischen Operationen wurden in bitweise Operationen geändert und g () steht direkt in der return-Anweisung)

a => { // a is the input array
    s = i=>a.splice(i, 1); // shortcut to remove index i for 1 element
    e = _=>a.reduce((t, i) => t += i) / a.length; // get array avg
    g = _=>(a.sort((x,y)=>x-y), s(0), s(-1), e()); // what to execute when > 2: sort, remove 1st/last, get avg
    t = n=>Math.floor(n); // Math.floor shortcut

    // apply olympic rounding to number by checking the value of n%1
    r = n=>(m=n%1,m < 0.75 ? (m > 0.25 ? t(n) + 0.5 : t(n)) : Math.ceil(n));

    // if arr length > 2: round g(), otherwise round e()
    return a.length > 2 ? r(g()) : r(e());
}

Gelee , 12 Bytes

ṢṖḊȯ⁸ÆmḤ+.ḞH

Ein monadischer Link, der eine Liste von Zahlen akzeptiert, die eine Zahl ergibt.

Probieren Sie es online aus!

Wie?

ṢṖḊȯ⁸ÆmḤ+.ḞH - Link, list of numbers, X
Ṣ            - sort X
 Ṗ           - remove the right-most
  Ḋ          - remove the left-most
    ⁸        - chain's left argument, X
   ȯ         - logical OR (if we have nothing left use X instead)
     Æm      - arithmetic mean
       Ḥ     - double
         .   - literal half
        +    - add
          Ḟ  - floor
           H - halve

Brachylog , 19 Bytes

o{bṀk|}⟨+/l⟩×₄<÷₂/₂

Probieren Sie es online aus!

Und ich fand die Rundung in Jelly unangenehm!

Schnell , 203 Bytes

func a(b:[Double])->Void{var r=0.0,h=0.0,l=11.0
b.forEach{(c)in h=c>h ?c:h;l=c<l ?c:l;r+=c}
var d=Double(b.count)
r=d>2 ?(r-h-l)/(d-2.0):r/d
d=Double(Int(r))
r=r-d<=0.25 ?d:r-d<=0.75 ?d+0.5:d+1
print(r)}

Probieren Sie es online aus!

PHP , 110 Bytes

Es scheint, dass PHP einige gute integrierte Funktionen dafür hat. Ich habe nur array_sum die ganze Sache, dann, wenn es mehr als zwei Elemente gibt, subtrahiere die min () und max () Werte und dividiere durch 2 weniger als die Länge des Arrays.

Für die Rundung verwende ich die Funktion round () mit dem Flag PHP_ROUND_HALF_DOWN (welches = 2) im doppelten Durchschnitt und dividiere es dann durch 2, sodass es in Schritten von 0,5 erfolgt

BEARBEITEN: Für den Fall von [6.5, 9] folge ich der angegebenen Regel, dass 7,75 auf 7,5 rundet und nicht 8 wie im ursprünglichen Beispiel.

function s($s){$c=count($s);$t=array_sum($s);if($c>2){$c-=2;$t-=min($s)+max($s);}return round($t/$c*2,0,2)/2;}

Probieren Sie es online aus!

Zsh , ¹⁴¹ 136 Bytes

Probieren Sie es online aus!   _{141 Bytes}

setopt FORCE_FLOAT
m=$1 n=$1 a=$#
for x ((t+=x))&&m=$[x>m?x:m]&&n=$[x<n?x:n]
s=$[2*(a>2?(t-m-n)/(a-2):t/a)]
<<<$[(s^0+(s-s^0>.5?1:0))/2]

Die Lösung folgt der neuesten Spezifikation. Einige Bytes wurden implizit gespeichert($@) .

Wir iterieren implizit über die Argumente mit for xund erstellen eine laufende Summe tund finden auch Maxima, Minima m, n. Wenn die Anzahl der Argumente agrößer als 2 ist, verwerfen wir mund naus dem Durchschnitt. sist 2x der resultierende Durchschnitt. Wenn die Mantisse von sgrößer als 0,5 ist, runden Sie sauf, andernfalls kürzen Sie mit s^0. Zum Schluss durch 2 teilen und ausgeben.