Вычислить медиану

32

Вызов

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

Определения

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

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

Примеры

[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
flawr
источник
Можем ли мы вывести в виде дроби более 2 (например, 7/2или 8/2)
Мастер пшеницы
По этой фракции все в порядке.
flawr
15
Как это уже не проблема?
orlp
1
@orlp Это часть этой задачи .
AdmBorkBork
3
Это также делает хорошую быструю задачу кода, поскольку есть некоторые интересные линейные алгоритмы времени.

Ответы:

18

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.гарантирует, что это деление с плавающей запятой, а не целочисленное деление.

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

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

FlipTack
источник
Похоже, что лямбда выигрывает, несмотря на повторение:lambda l:l.sort()or(l[len(l)/2]+l[~len(l)/2])/2.
xnor
@xnor Спасибо! Когда я попробовал это, я случайно подсчитал f=, думая, что это на 1 байт длиннее.
FlipTack
13

Python3 - 31 30 байт

Сохраненный байт благодаря @Dennis!

Я не планировал встроенный ответ, но нашел этот модуль и подумал, что это действительно круто, потому что я понятия не имел, что он существует.

from statistics import*;median

Попробуйте это онлайн здесь .

Maltysen
источник
6
from statistics import*;medianсохраняет байт.
Деннис
@ Денис, круто. это всегда короче?
Maltysen
2
Это всегда лучше __import__, но import math;math.logлучше from math import*;log.
Деннис
9

Желе , 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.
Мартин Эндер
источник
Конечно, Æṁтеперь будет работать
caird coinheringaahing
9

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
Мастер пшеницы
источник
7

R, 6 байт

median

Не удивительно, что R, статистический язык программирования, имеет эту встроенную функцию.

rturnbull
источник
4
Rбить Желе: D: D: D
JAD
5

MATL , 4 байта

.5Xq

Это находит 0.5-квантиль, который является медианой.

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

Луис Мендо
источник
Я как раз собирался понять это!
flawr
Ах нет, я имею в виду, что я выяснял, как это сделать в MATL =) (Но у меня было 5-байтовое решение, так что да ...)
flawr
@flawr Опубликуйте это тогда! Это, безусловно, будет интереснее моего
Луис Мендо
Нет, это было так же, как у вас, только с i впереди :)
flawr
@flawr То же самое, iчто вы предлагали сделать неявным? :-P
Луис Мендо
5

Pyth - 11 байт

Находит среднее значение среднего предмета, взятого как вперед, так и вперед.

.O@R/lQ2_BS

Тестовый пакет .

Maltysen
источник
5

Октава , 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
Луис Мендо
источник
1
Тьфу ... умное использование " bsxfun" и mean:-)
Стьюи Гриффин
5

JavaScript, 57 52 байта

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

Сортировать массив численно. Если массив четной длины, найдите 2 средних числа и усредните их. Если массив нечетный, найдите среднее число дважды и разделите на 2.

Grax32
источник
1
Я обнаружил, что Array.sort()это не работает должным образом с десятичными
числами
3
Это происходит, если вы передаете функцию сортировки, как я. Если вы вызываете Array.sort () без параметров, он использует алфавитную сортировку.
Grax32
Интересный. Не знал этого
TrojanByAccident
Вы можете сохранить несколько байт, используя возвращаемое значение sort()непосредственно и избавления от tпеременного:v=>(v.sort((a,b)=>a-b)[(x=v.length)>>1]+v[--x>>1])/2
Arnauld
1
Не то, чтобы вы обязательно исправляли это, но если x>=2**31это не получится. >>является признаком распространяющихся сдвиг вправо , а это означает , что , когда число интерпретируется как 32 битное целое число, если MSB установлен, то он остается установить, что делает отрицательный результат для 2**32>x>=2**31. Ибо x>=2**32это просто дает 0.
Патрик Робертс
5

Matlab / Octave, 6 байтов

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

median

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

flawr
источник
Я забыл правила для анонимных функций в MATLAB / Octave, это должно быть @median?
Джузеппе
@ Giuseppe Я не знаю, каков в настоящее время принятый способ оценки встроенных функций.
flawr
4

Mathematica, 6 байтов

Median

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

Павел
источник
В Mthmtca 0.1 / 10.1.0.0 код будет иметь bytes CBC8( ËÈ). Однако до тех пор, пока я не применю другой патч, понятие вызова функций может не соответствовать стандартам PPCG.
LegionMammal978
4

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
Брэд Гилберт b2gills
источник
1
24 байта
Джо Кинг,
4

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
Kritixi Lithos
источник
3

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))
CoreDump
источник
3

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" вставляет текст, который был выдернут (в данном случае список)
nmjcman101
источник
3

TI-Basic, 2 байта

median(Ans

Очень просто.

Timtech
источник
1
@Mego вашей ссылки и комментарий смущает меня ... в зависимости от голосования, то это разрешено. Я что-то пропустил?
Патрик Робертс
@PatrickRoberts В настоящее время ведутся споры о пороге приемлемости. Несколько пользователей (включая меня) следовали правилу, согласно которому для метода требуется минимум +5 и как минимум вдвое больше голосов, чем голосов, что было правилом, изначально заявленным в этом посте (с тех пор оно было удалено), и следует ли этому правилу для стандартных лазеек.
Mego
Тот, кто удалил мой комментарий дважды из моего собственного поста, раздражает. Поскольку не существует четко принятого правила приемлемости, я не вижу здесь проблемы. Вы можете увидеть мои ответы на SO о том, как это используется в качестве аргументов для программы.
Timtech
@Mego +38 более чем в два раза -18
Timtech
3

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, чтобы упорядочить значения, пропустить половину списка, взять одно или два значения в зависимости от четного / нечетного и усреднить их.

Jens
источник
Вы должны включить using System.Linq; в свой счетчик байтов, однако вы можете отменить это, внеся некоторые изменения. Скомпилируйте в a Func<float[], float>и присвойте значение по модулю переменной для 106 байтов:using System.Linq;a=>{int x=a.Length,m=x%2<1?1:0;return a.OrderBy(g=>g).Skip(x/2-m).Take(++m).Average();};
TheLethalCoder
@TheLethalCoder Я никогда не совсем уверен, что составляет полную программу. Вы правы насчет использования. Объединение объявлений модуля с длиной также является хорошей идеей. Я немного поэкспериментировал с этим, но не смог сделать его короче, чем поместить его туда дважды. Рискну сказать, что ваши оптимизации сами по себе заслуживают ответа, так как они весьма существенны, и я бы не стал их предлагать.
Йенс
В задаче не говорится, что вам нужна полная программа, поэтому анонимный метод вполне подойдет. Кроме того, я лишь изложил некоторые общие советы по игре в гольф, поэтому мне не нужно добавлять ответ, просто поиграйте в гольф самостоятельно!
TheLethalCoder
3

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;
    }
Уэйд Тайлер
источник
1
Вы можете использовать floatвместо того, doubleчтобы сохранить два байта. Также в GCC вы можете использовать #import<vector>и #import<algorithm>вместо #include. (Обратите внимание, что вам не нужно пробел после или #includeили #import)
Steadybox
@Steadybox Я не считал эти два включения в счет. Нужно ли мне? Кроме того, я в основном использую Clang, поэтому я не знаю много о GCC, но спасибо.
Уэйд Тайлер
Да, включения должны быть включены в число байтов, если код не компилируется без них.
Steadybox
3

J , 16 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%~[:+/(<.,>.)@(-:@<:@#){/:~

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

фонтанчик для питья
источник
1
Хорошо сделанный, порт J моего ответа APL был бы #{0,2+/\2#-:/:]в 15 байтах (человек, которого я скучаю ⎕io).
Критиси Литос
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
Мэринус
источник
Вы можете сохранить байт, убрав скобки и применив ~непосредственно к каждому<.@-:@#{/:~-:@+\:~
мили
2

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}
TrojanByAccident
источник
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;
}

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

Peech
источник
Я немного разочарован, даже в Java 7 достаточно короткий синтаксис сортировки, который en.wikipedia.org/wiki/… неоптимален
JollyJoker
Вам не нужно рассчитывать импорт java.util.Arrays?
FlipTack
Ой, спасибо за уведомление. :)
peech
Привет из будущего! Вы можете сохранить 14 байтов, используя усечение с целочисленным делением для обработки четности длины. Смотрите мой ответ на Java 8 .
Якоб
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 является интерактивным, для отображения результата не требуется никаких дополнительных команд.


Для ссылки "попробуй это онлайн" добавлена ​​строка до и после. Чтобы получить печать, медиана-результат хранится в переменной w

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)       

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

Готфрид Хелмс
источник
2

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
ETHproductions
источник
2

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оба делятся на индекс среднего элемента. Число добавляется к самому себе, а результат делится на два, давая исходное значение.

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

Jakob
источник
2

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
12Me21
источник
2

Шелуха , 10 байт

½ΣF~e→←½OD

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

объяснение

[a1aN][a1a1aNaN]

½Σ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.

ბიმო
источник
2

GolfScript , 27 25 20 17 байт

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

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

объяснение

ll1l

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

DLosc
источник