Вызов

Учитывая непустой список действительных чисел, вычислите его медиану.

Определения

Медиана вычисляется следующим образом: сначала отсортируйте список,

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

Примеры

[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:

• Первый - floor (length / 2) , который получает средний элемент, если длина нечетная, или левый элемент в центральной паре, если длина четная.
• Второе - двоичная инверсия длины списка, оцениваемая в -1 - floor (length / 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.

Brain-Flak , 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.

Matlab / Octave, 6 байтов

Скучный встроенный:

median

Попробуйте онлайн!

Mathematica, 6 байтов

Median

Как только я выясняю Mthmtca , я выкладываю решение в нем.

Perl 6 , 31 байт

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

Попытайся

Expanded:

*\     # 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

Попробуйте онлайн!

Это поезд. Оригинальный дфн был {(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

Common Lisp, 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 байт

Golfed:

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

Ungolfed:

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"

Принимает ввод как массив целых чисел на стандартном вводе. Выходы как невосстановленная дробь. Попробуйте онлайн!

объяснение

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