課題は、0から10までのn個の正の実数が与えられたゴルフコードプログラムを作成することです（形式xy、yは0または5のみです：0、0.5、1、1.5、2、2.5…9.5および10）。一部のオリンピックのスコアリングと同様に、最低値と最高値を破棄し（繰り返されても1つだけ）、残りの平均をxy形式で表示します（yは0または5に丸めることができます）。

例：入力->出力

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

注：入力が2つの数値のみの場合は、何も破棄せず、それらを平均してください。入力が1つの数値の場合、出力は同じです。

丸め規則の明確化（すみません、少し混乱します）：

x.01〜x.25 x.0に丸めます

x.26からx.75に丸めてx.5に

x.76〜x.99をx + 1.0に丸める

ゼリー、12バイト

ṢṖḊȯµÆmḤær0H

オンラインでお試しください！

    µ           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.

2番目のテストケースを犠牲にして、仕様に従って半分に切り捨てるバージョン：

ゼリー、12バイト

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

オンラインでお試しください！

ここでの丸め方法は、Jonathan Allanの方法に近いものです。

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

網膜、86バイト

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

オンラインでお試しください！リンクにはテストケースが含まれます。説明：

\.5
__
\d+
*4*__

Retinaは小数またはゼロの数値を簡単に処理できないため、各数値は値の4倍以上の1として単項で表されます。.5従って2つのに展開_しながら、S *4*_整数部分に適用され、そして最終的に_接尾辞れます。

O`_+

番号を順番に並べ替えます。

_+ (.+) _+
$1

数字が3つ以上ある場合は、最初（最小）と最後（最大）を破棄します。

O`.

最初にスペースを並べ替え、数値も合計します。

^ *
$.&*__:

スペースの数を数えて_、セパレータを追加します。これは、除算する必要がある数を表します。

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

合計を数値の数で割り、元の数値の4の倍数で作業していることを考慮して、整数部分と小数部分を直接抽出できるようにします。これは切り捨ての除算ですが、幸いにも_各数値に余分な数値を追加したため、結果には実質的に余分な0.25が含まれているため、必要な丸めが得られます。

編集：この答えはそれ以来無効になりました。投稿後約30分有効でした。

ゼリー、10バイト

ṢḊṖȯƊÆmḤḞH

オンラインでお試しください！

J、³⁶ 35バイト

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

オンラインでお試しください！

無関係の文字列から0.5刻みに丸めるためのdouble / floor / halfveトリックを借用しました。

Python 3、62バイト

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

オンラインでお試しください！

JavaScript（V8）、213 211 189 176バイト

^{編集：-2バイト;\n}は}、愚かな間違いで終わる可能性があるときに終わったためです。}

^{編集2：一般的なJSゴルフのヒントを読んで、-22バイト増やします。r丸め関数で入れ子になった3進数からかっこを取り除くことができ、ビット単位の数学演算を使用してMath.floor、Math.ceil}

^{編集3：-13バイト。a.lengthショートカット関数を、a.length4バイトを節約するための直接呼び出しに置き換えることができたため。また、g（）関数はreturnステートメントに直接移動しました。これは1回しか使用されなかったため、残りのバイトが削除されたためです。}

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())}

オンラインでお試しください！

私はかなり新しいので改善できると確信していますが、これを解決するのは楽しかったです。改善できる主なことは、私の丸めのロジック/メソッド、およびメイン関数が関数本体（{ }およびreturn）を使用しているという事実だと思います。

質問には例と一致しないものが1つあり、その処理方法が本当にわかりませんでした。例と一致するように実装しましたが、指定された丸め規則を正確に反映していません。一貫性がないことがわかった例を次に示します。

6.5、9-> 8

平均は7.75ですが、8にする必要があります。端数処理ルールでは、+ 1になるには少なくとも0.76でなければならないということです。丸め規則の代わりに例を反映することを選択したので、0.5の場合は0.25以上0.75以下の範囲で、+ 1の場合は> = 0.75、-1の場合は<= 0.25です。丸めの仕様が変更された場合、丸め関数の数値を変更するだけで、バイト数を変更せずにコードを適合させることができrます。規則に応じて、3進ステートメントの順序を変更することもできます。

説明を少し控えめにしました（数学演算はビット演算に変更され、g（）は直接returnステートメントにあります）

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());
}

ゼリー、12 バイト

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

数値を生成する数値のリストを受け入れるモナディックリンク。

オンラインでお試しください！

どうやって？

ṢṖḊȯ⁸Æ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バイト

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

オンラインでお試しください！

そして、丸めはゼリーでぎこちないと思いました！

Swift、203バイト

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

オンラインでお試しください！

PHP、110バイト

PHPには、このための優れた組み込み関数があるようです。全体をarray_sumするだけで、3つ以上の要素がある場合は、min（）とmax（）の値を減算し、配列の長さよりも2少ない数で割ります。

丸めには、PHP_ROUND_HALF_DOWNフラグ（= 2）を指定してround（）関数を使用し、平均値の2倍にし、それを2で割って、0.5の増分になるようにします。

編集：[6.5、9]の場合、元の例のように7.75は7.5に丸められ、8は丸められないという規定のルールに従っています。

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;}

オンラインでお試しください！

zshの、^141の 136バイト

オンラインでお試しください！   _141バイト

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]

ソリューションは最新の仕様に従います。暗黙を使用して数バイトを節約しました($@)。

を使用して引数を暗黙的に反復処理し、for x積算合計を作成してt、最大値、最小値も見つけますm, n。引数の数がa2より大きい場合、破棄mしてnは、平均からます。s結果の平均の2倍です。の仮数がs0.5より大きい場合はs切り上げ、それ以外の場合はで切り捨てs^0ます。最後に、2で除算して出力します。