Виклик

Враховуючи непорожній список реальних чисел, обчисліть його медіану.

Визначення

Медіана обчислюється так: Спочатку сортуйте список,

• якщо кількість записів непарна , медіана - це значення в центрі відсортованого списку,
• інакше медіана - це середнє арифметичне з двох значень, найближчих до центру відсортованого списку.

Приклади

[1,2,3,4,5,6,7,8,9] -> 5
[1,4,3,2] -> 2.5
[1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,-5,100000,1.3,1.4] -> 1.5
[1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,-5,100000,1.3,1.4] -> 1.5

Python 2 , 48 байт

Безіменна функція, яка повертає результат. -1 байт завдяки xnor.

lambda l:l.sort()or(l[len(l)/2]+l[~len(l)/2])/2.

Перший крок, очевидно, сортування масиву, використовуючи l.sort(). Однак у лямбда ми можемо мати лише одне твердження, тому ми використовуємо той факт, що функція сортування повертається Noneдодаваннямor - як Noneє фальшивим в Python, і це дає йому змогу оцінити та повернути наступну частину оператора.

Тепер у нас відсортований список, нам потрібно знайти або середнє, або середнє два значення.

Використання умовного для перевірки парності довжини було б занадто багатослівним, тому замість цього ми отримуємо індекси len(l)/2та ~len(l)/2:

• Перший є підлога (довжина / 2) , який отримує середній елемент, якщо довжина непарна, або лівий елемент у центральній парі, якщо довжина є парною.
• Друга - двійкова інверсія довжини списку, що оцінюється на -1 - поверх (довжина / 2) . Завдяки негативній індексації Python, це по суті робить те саме, що і перший індекс, але назад від кінця масиву.

Якщо список має непарну довжину, ці індекси будуть вказувати на те саме значення. Якщо вона має рівну довжину, то вони будуть вказувати на центральні два пункти.

Тепер, коли у нас є ці два індекси, ми знаходимо ці значення у списку, підсумовуємо їх та ділимо на 2. Значний десяткове місце у /2. переконується, що це ділення на поплавок, а не ціле ділення.

Результат неявно повертається, оскільки це лямбда-функція.

Спробуйте в Інтернеті!

Python3 - 31 30 байт

Збережено байт завдяки @Dennis!

Я не планував відповіді на вбудований, але знайшов цей модуль і подумав, що це дійсно круто, тому що я не уявляв, що він існує.

from statistics import*;median

Спробуйте його онлайн тут .

Власне , 1 байт

║

Спробуйте в Інтернеті!

Желе , 9 байт

L‘HịṢµ÷LS

Спробуйте в Інтернеті!

Пояснення

Я все ще перебуваю у висіванні Jelly ... Мені не вдалося знайти вбудовані для медіани або середнього списку, але для цього завдання дуже зручно, що Jelly дозволяє нецілі показники вносити до списків, у такому випадку він поверне пару двох найближчих значень. Це означає, що ми можемо працювати з половиною вхідної довжини як індекс і отримувати пару значень, коли нам потрібно це середнє значення.

L          Get the length of the input.
 ‘         Increment it.
  H        Halve it. This gives us the index of the median for an odd-length list
           (Jelly uses 1-based indexing), and a half-integer between the two indices
           we need to average for even-length lists.
   ịṢ      Use this as an index into the sorted input. As explained above this will
           either give us the median (in case of an odd-length list) or a pair of
           values we'll now need to average.
     µ     Starts a monadic chain which is then applied to this median or pair...
      ÷L     Divide by the length. L treats atomic values like singleton lists.
        S    Sum. This also treats atomic values like singleton lists. Hence this
             monadic chain leaves a single value unchanged but will return the
             mean of a pair.

Мозок-Флак , 914 + 1 = 915 байт

([]){({}[()]<(([])<{({}[()]<([([({}<(({})<>)<>>)<><({}<>)>]{}<(())>)](<>)){({}())<>}{}({}<><{}{}>){{}<>(<({}<({}<>)<>>)<>({}<>)>)}{}({}<>)<>>)}{}<>{}>[()]){({}[()]<({}<>)<>>)}{}<>>)}{}([]<(()())>(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{}<(())>){((<{}{}([[]]()){({}()()<{}>)}{}(({}){}<([]){{}{}([])}{}>)>))}{}{(<{}([[]]()()){({}()()<{}>)}{}({}{}<([]){{}{}([])}{}>)>)}{}([(({}<((((((()()()){}){}){}()){})[()()()])>)<(())>)](<>)){({}())<>}{}<>{}{}<>(({})){{}{}<>(<(())>)}{}(({}<>)<{(<{}([{}])>)}{}{(({})<((()()()()()){})>)({}(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{})({}<({}<>)<>>((((()()()){}){}){}){})((()()()()()){})<>({}<>)(()()){({}[()]<([([({})](<()>))](<>())){({}())<>}{}<>{}{}<>(({})){{}{}<>(<(())>)}{}(({})<>)<>{(<{}([{}])>)}{}({}<>)<>({}<><({}<>)>)>)}{}({}(<>))<>([()]{()<(({})){({}[()])<>}{}>}{}<><{}{}>)<>(({}{}[(())])){{}{}(((<{}>)))}{}{}{(<{}<>([{}])><>)}{}<>}{}>){(<{}(((((()()()()())){}{})){}{})>)}{}

Потрібно -A прапор для запуску.

Спробуйте в Інтернеті!

Пояснення

Основою цього алгоритму є міхурний сорт, про який я писав деякий час тому.

([]){({}[()]<(([])<{({}[()]<([([({}<(({})<>)<>>)<><({}<>)>]{}<(())>)](<>)){({}())<>}{}({}<><{}{}>){{}<>(<({}<({}<>)<>>)<>({}<>)>)}{}({}<>)<>>)}{}<>{}>[()]){({}[()]<({}<>)<>>)}{}<>>)}{}

Я не пам'ятаю, як це працює, тому не питайте мене. Але я знаю, він сортує стек і навіть працює на негативи

Після того як все було відсортовано, я знаходжу в 2 рази медіану з наступним фрагментом

([]<(()())>(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{}<(())>)  #Stack height modulo 2
{((<{}{}          #If odd
 ([[]]())         #Push negative stack height +1
 {                #Until zero 
  ({}()()<{}>)    #add 2 to the stack height and pop one
 }{}              #Get rid of garbage
 (({}){}<         #Pickup and double the top value
 ([]){{}{}([])}{} #Remove everything on the stack
 >)               #Put it back down
>))}{}            #End if
{(<{}                     #If even
  ([[]]()())              #Push -sh + 2
  {({}()()<{}>)}{}        #Remove one value for every 2 in that value
  ({}{}<([]){{}{}([])}{}>)#Add the top two and remove everything under them
>)}{}                     #End if

Тепер все, що залишилося, - це зробити перетворення на ASCII

([(({}<((((((()()()){}){}){}()){})[()()()])>)<(())>)](<>)){({}())<>}{}<>{}{}<>(({})){{}{}<>(<(())>)}{}(({}<>)<
{(<{}([{}])>)}{}  #Absolute value (put "/2" beneath everything)

{                 #Until the residue is zero 
(({})<            #|Convert to base 10
((()()()()()){})  #|
>)                #|...
({}(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{})
({}<({}<>)<>>((((()()()){}){}){}){})((()()()()()){})<>({}<>)
                  #|
(()()){({}[()]<([([({})](<()>))](<>())){({}())<>}{}<>{}{}<>(({})){{}{}<>(<(())>)}{}(({})<>)<>{(<{}([{}])>)}{}({}<>)<>({}<><({}<>)>)>)}{}({}(<>))<>([()]{()<(({})){({}[()])<>}{}>}{}<><{}{}>)<>(({}{}[(())])){{}{}(((<{}>)))}{}{}{(<{}<>([{}])><>)}{}<>
}{}               #|
>)
{(<{}(((((()()()()())){}{})){}{})>)}{}  #If it was negative put a minus sign

R, 6 байт

median

Не дивно, що R, статистична мова програмування, має цю вбудовану.

MATL , 4 байти

.5Xq

Це знаходить 0,5-квантиль, який є медіаною.

Спробуйте в Інтернеті!

Pyth - 11 байт

Знаходить середнє значення середнього елемента, взятого назад і вперед.

.O@R/lQ2_BS

Тестовий сюїт .

Октава , 38 байт

@(x)mean(([1;1]*sort(x))(end/2+[0 1]))

Це визначає анонімну функцію. Введення - векторний рядок.

Спробуйте в Інтернеті!

Пояснення

            sort(x)                 % Sort input x, of length k
      [1;1]*                        % Matrix-multiply by column vector of two ones
                                    % This vertically concatenates the sort(x) with 
                                    % itself. In column-major order, this effectively 
                                    % repeats each entry of sort(x)
     (             )(end/2+[0 1])   % Select the entry at position end/2 and the next.
                                    % Entries are indexed in column-major order. Since
                                    % the array has 2*k elements, this picks the k-th 
                                    % and (k+1)-th. Because entries were repeated, for
                                    % odd k this takes the original (k+1)/2-th entry
                                    % (1-based indexing) twice. For even k this takes
                                    % the original (k/2)-th and (k/2+1)-th entries
mean(                            )  % Mean of the two selected entries

JavaScript, 57 52 байти

v=>(v.sort((a,b)=>a-b)[(x=v.length)>>1]+v[--x>>1])/2

Сортувати масив чисельно. Якщо масив рівномірної довжини, знайдіть 2 середніх числа і середнє їх значення. Якщо масив непарний, знайдіть середнє число вдвічі і розділіть на 2.

Матлаб / Октава, 6 байт

Нудна вбудована:

median

Спробуйте в Інтернеті!

Математика, 6 байт

Median

Як тільки я з'ясував Mthmtca , я розміщую рішення в ньому.

Perl 6 , 31 байт

*.sort[{($/=$_/2),$/-.5}].sum/2

Спробуй це

Розширено:

*\     # WhateverCode lambda ( this is the parameter )

.sort\ # sort it

[{     # index into the sorted list using a code ref to calculate the positions

  (
    $/ = $_ / 2 # the count of elements divided by 2 stored in ｢$/｣
  ),            # that was the first index

  $/ - .5       # subtract 1/2 to get the second index

                # indexing operations round down to nearest Int
                # so both are effectively the same index if given
                # an odd length array

}]\

.sum / 2        # get the average of the two values

APL (Dyalog Unicode) , 14 байт

≢⊃2+/2/⊂∘⍋⌷÷∘2

Спробуйте в Інтернеті!

Це поїзд. Оригінальний dfn був {(2+/2/⍵[⍋⍵])[≢⍵]÷2}.

Поїзд побудований наступним чином

┌─┼───┐
≢ ⊃ ┌─┼───┐
    2 / ┌─┼───┐
    ┌─┘ 2 / ┌─┼─┐
    +       ∘ ⌷ ∘
           ┌┴┐ ┌┴┐
           ⊂ ⍋ ÷ 2

⊢ позначає правильний аргумент.

⌷ покажчик

• ⊂∘⍋індекси, які індексуються, ⊢призводять до ⊢сортування

• ÷∘2в ⊢розподілі на 2

2/повторити це двічі, так 1 5 7 8стає1 1 5 5 7 7 8 8

2+/ взяти парну суму, це стає (1+1)(1+5)(5+5)(5+7)(7+7)(7+8)(8+8)

⊃ з цього вибору

• ≢ елемент з індексом, рівним довжині ⊢

Попередні рішення

{.5×+/(⍵[⍋⍵])[(⌈,⌊).5×1+≢⍵]}
{+/(2/⍵[⍋⍵]÷2)[0 1+≢⍵]}
{+/¯2↑(1-≢⍵)↓2/⍵[⍋⍵]÷2}
{(2+/2/⍵[⍋⍵])[≢⍵]÷2}
{(≢⍵)⊃2+/2/⍵[⍋⍵]÷2}
≢⊃2+/2/2÷⍨⊂∘⍋⌷⊢
≢⊃2+/2/⊂∘⍋⌷÷∘2

Загальний Лісп, 89

(lambda(s &aux(m(1-(length s)))(s(sort s'<)))(/(+(nth(floor m 2)s)(nth(ceiling m 2)s))2))

Я обчислюю середнє значення елементів у положенні (floor middle)та (ceiling middle)де middleнульовий індекс для середнього елемента відсортованого списку. Це може middleбути ціле число, як 1для вхідного списку розміру 3, наприклад (10 20 30), або дробу для списків з парними числами елементів, наприклад, 3/2для (10 20 30 40). В обох випадках ми обчислюємо очікувану медіану.

(lambda (list &aux
             (m (1-(length list)))
             (list (sort list #'<)))
  (/ (+ (nth (floor m 2) list)
        (nth (ceiling m 2) list))
     2))

Vim, 62 байти

Я спочатку робив це у V, використовуючи лише текстові маніпуляції до кінця, але розчарувався в обробці [X] та [X, Y], тому ось проста версія. Вони приблизно однакової довжини.

c$:let m=sort(")[(len(")-1)/2:len(")/2]
=(m[0]+m[-1])/2.0

Спробуйте в Інтернеті!

Недруковані матеріали:

c$^O:let m=sort(^R")[(len(^R")-1)/2:len(^R")/2]
^R=(m[0]+m[-1])/2.0

Почесна згадка:

• ^O виводить вас із режиму вставки для однієї команди (команда let).
• ^R" вставляє текст, який було вирвано (у цьому випадку список)

TI-Basic, 2 байти

median(Ans

Дуже прямо.

C #, 126 байт

using System.Linq;float m(float[] a){var x=a.Length;return a.OrderBy(g=>g).Skip(x/2-(x%2==0?1:0)).Take(x%2==0?2:1).Average();}

Досить просто, тут LINQ для впорядкування значень, пропустіть половину списку, візьміть одне або два значення залежно від парних / непарних та середніх.

C ++ 112 байт

Дякуємо @ original.legin за допомогу в збереженні байтів.

#include<vector>
#include<algorithm>
float a(float*b,int s){std::sort(b,b+s);return(b[s/2-(s&1^1)]+b[s/2])/2;}

Використання:

    int main()
    {
        int n = 4;
        float e[4] = {1,4,3,2};
        std::cout<<a(e,n); /// Prints 2.5

        n = 9;
        float e1[9] = {1,2,3,4,5,6,7,8,9};
        std::cout<<a(e1,n); /// Prints 5

        n = 13;
        float e2[13] = {1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,-5,100000,1.3,1.4};
        std::cout<<a(e2,n); /// Prints 1.5

        return 0;
    }

J , ₁₆ 14 байт

2%~#{2#/:~+\:~

Спробуйте в Інтернеті!

Окрім трюку дублювання масиву BMO , я виявив, що ми можемо додати цілий масив, відсортований у двох напрямках. Тоді я зрозумів, що два кроки можна змінити, тобто додати два масиви, а потім дублювати їх і взятиn th елемент.

Як це працює

2%~#{2#/:~+\:~
                Input: array of length n
       /:~      Sort ascending
           \:~  Sort descending
          +     Add the two element-wise
     2#         Duplicate each element
   #{           Take n-th element
2%~             Halve

Попередні відповіді

J з statsаддоном, 18 байт

load'stats'
median

Спробуйте в Інтернеті!

Функція бібліотеки FTW.

medianРеалізація виглядає приблизно так:

J , 31 байт

-:@(+/)@((<.,>.)@(-:@<:@#){/:~)

Спробуйте в Інтернеті!

Як це працює

-:@(+/)@((<.,>.)@(-:@<:@#){/:~)
         (<.,>.)@(-:@<:@#)       Find center indices:
                  -:@<:@#          Compute half of given array's length - 1
          <.,>.                    Form 2-element array of its floor and ceiling
                          {/:~   Extract elements at those indices from sorted array
-:@(+/)                          Sum and half

Трохи гольфу дає це:

J , 28 байт

2%~[:+/(<.,>.)@(-:@<:@#){/:~

Спробуйте в Інтернеті!

J, 19 байт

<.@-:@#{(/:-:@+\:)~

Пояснення:

        (        )~   apply monadic argument twice to dyadic function 
         /:           /:~ = sort the list upwards
               \:     \:~ = sort the list downwards
           -:@+       half of sum of both lists, element-wise
<.@-:@#               floor of half of length of list
       {              get that element from the list of sums

JavaScript, 273 байт

function m(l){a=(function(){i=l;o=[];while(i.length){p1=i[0];p2=0;for(a=0;a<i.length;a++)if(i[a]<p1){p1=i[a];p2=a}o.push(p1);i[p2]=i[i.length-1];i.pop()}return o})();return a.length%2==1?l[Math.round(l.length/2)-1]:(l[Math.round(l.length/2)-1]+l[Math.round(l.length/2)])/2}

Java 7, 99 байт

Гольф:

float m(Float[]a){java.util.Arrays.sort(a);int l=a.length;return l%2>0?a[l/2]:(a[l/2-1]+a[l/2])/2;}

Безголівки:

float m(Float[] a)
{
    java.util.Arrays.sort(a);
    int l = a.length;
    return l % 2 > 0 ? a[l / 2] : (a[l / 2 - 1] + a[l / 2]) / 2;
}

Спробуйте в Інтернеті

Пари / ГП - 37 39 байт

Нехай a - рядковий вектор, що містить значення.

b=vecsort(a);n=#b+1;(b[n\2]+b[n-n\2])/2  \\ 39 byte              

n=1+#b=vecsort(a);(b[n\2]+b[n-n\2])/2    \\ obfuscated but only 37 byte

Оскільки Pari / GP є інтерактивним, додаткова команда не потрібна для відображення результату.

a=vector(8,r,random(999))           
n=1+#b=vecsort(a);w=(b[n\2]+b[n-n\2])/2      
print(a);print(b);print(w)       

Спробуйте в Інтернеті!

Japt, 20 байт

n gV=0|½*Ul)+Ug~V)/2

Перевірте це в Інтернеті!Япту дійсно не вистачає будь-яких вбудованих програм, необхідних для створення дійсно короткої відповіді на це завдання ...

Пояснення

n gV=0|½*Ul)+Ug~V)/2  // Implicit: U = input list
n                     // Sort U.
   V=0|½*Ul)          // Set variable V to floor(U.length / 2).
  g                   // Get the item at index V in U.
            +Ug~V     // Add to that the item at index -V - 1 in U.
                 )/2  // Divide by 2 to give the median.
                      // Implicit: output result of last expression

Java 8, 71 байт

Паритет - це весело! Ось лямбда від double[]до Double.

l->{java.util.Arrays.sort(l);int s=l.length;return(l[s/2]+l[--s/2])/2;}

Тут нічого надто складного не відбувається. Масив сортується, і тоді я беру середнє значення з двох чисел з масиву. Є два випадки:

• Якщо довжина є парною, то перше число береться прямо перед серединою масиву, а друге число береться з положення перед цим шляхом цілого поділу. Середнє значення цих чисел - медіана вводу.
• Якщо довжина непарна, sі s-1обидва ділять на індекс середнього елемента. Число додається до себе, а результат ділиться на два, даючи вихідне значення.

Спробуйте це в Інтернеті

SmileBASIC, 45 байт

DEF M A
L=LEN(A)/2SORT A?(A[L-.5]+A[L])/2
END

Отримує середнє значення елементів підлоги (довжина / 2) та підлоги (довжина / 2-0.5) Дуже просто, але мені вдалося зберегти 1 байт, переміщуючи речі:

DEF M A
SORT A    <- extra line break
L=LEN(A)/2?(A[L-.5]+A[L])/2
END

Лушпиння , 10 байт

½ΣF~e→←½OD

Спробуйте в Інтернеті!

Пояснення

Ця функція використовує медіану $[a_1 \dots a_N]$ - це те саме, що медіана $[a_1 \; a_1 \dots a_N \; a_N]$ що дозволяє уникнути некрасивого розрізнення списків непарних / парних довжин.

½ΣF~e→←½OD  -- example input: [2,3,4,1]
         D  -- duplicate: [2,3,4,1,2,3,4,1]
        O   -- sort: [1,1,2,2,3,3,4,4]
       ½    -- halve: [[1,1,2,2],[3,3,4,4]]
  F         -- fold the following
   ~        -- | compose the arguments ..
     →      -- | | last element: 2
      ←     -- | | first element: 3
    e       -- | .. and create list: [2,3]
            -- : [2,3]
 Σ          -- sum: 5
½           -- halve: 5/2

_{На жаль , ½для списків мають тип [a] -> [[a]]і [a] -> ([a],[a])який не дозволяє , F~+→←оскільки foldl1потребам функції типу в a -> a -> aякості першого аргументу, змушуючи мене використовувати e.}

R без використання medianвбудованого, 51 байт

function(x,n=sum(x|1)+1)mean(sort(x)[n/2+0:1*n%%2])

Спробуйте в Інтернеті!

GolfScript , 27 25 20 17 байт

~..+$\,(>2<~+"/2"

Приймає введення як масив цілих чисел на stdin. Виходи у вигляді необмеженої частки. Спробуйте в Інтернеті!

Пояснення

Медіана масиву, як пояснюється у відповіді Хуска БМО , дорівнює медіані масиву вдвічі довше, коли кожен елемент повторюється двічі. Отже, ми об'єднуємо масив у себе, сортуємо і беремо середнє значення середніх двох елементів. Якщо довжина вихідного масиву дорівнює$l$, середні два елементи подвоєного масиву знаходяться в індексах $l-1$ і $l$.

~                  Evaluate input (converting string -> array)
 ..                Duplicate twice
   +               Concatenate two of the copies
    $              Sort the doubled array
     \,            Swap with the non-doubled array and get its length: l
       (           Decrement: l-1
        >          Array slice: all elements at index (l-1) and greater
         2<        Array slice: first two elements (originally at indices l-1 and l)
           ~       Dump array elements to stack
            +      Add
             "/2"  Push that string
                   Output all items on stack without separator

Вихід буде чимось на зразок 10/2.