도전

비어 있지 않은 실수 목록이 주어지면 중앙값을 계산하십시오.

정의

중앙값은 다음과 같이 계산됩니다. 먼저 목록을 정렬하고

• 항목 수가 홀수 인 경우 중앙값은 정렬 된 목록의 중앙에있는 값입니다.
• 그렇지 않으면 중앙값은 정렬 된 목록의 중심에 가장 가까운 두 값의 산술 평균입니다.

예

[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

파이썬 2 , 48 바이트

결과를 반환하는 명명되지 않은 함수입니다. xnor 덕분에 -1 바이트

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

첫 단계는를 사용하여 배열을 정렬하는 것 l.sort()입니다. 그러나 우리는 람다에 하나의 문장 만 가질 수 있으므로 파이썬에서 거짓을 -를 None추가 하여 정렬 함수가 반환한다는 사실을 활용 하여 명령문의 다음 부분을 평가하고 반환하도록 지시합니다.orNone

이제 우리는 정렬 된리스트를 가지게됩니다. 중간 또는 중간 2 값을 찾아야합니다.

조건을 사용하여 그래서 대신에 우리가 인덱스를 얻을 길이의 패리티가 너무 자세한 것 확인 len(l)/2하고 ~len(l)/2:

• 첫 번째는 floor (length / 2) 이며, 길이가 홀수 인 경우 중간 요소를 가져 오거나 길이가 짝수 인 경우 중앙 쌍의 왼쪽 항목을 가져옵니다.
• 두 번째는 목록 길이의 이진 반전으로 -1-floor (length / 2)로 평가됩니다 . 파이썬의 네거티브 인덱싱으로 인해 이것은 기본적으로 첫 번째 인덱스와 동일하지만 배열 끝에서 거꾸로 수행됩니다.

목록의 길이가 홀수 인 경우 이러한 인덱스는 동일한 값을 가리 킵니다. 길이가 짝수이면 중앙 두 항목을 가리 킵니다.

이제이 두 인덱스가 있으므로 목록에서이 값을 찾아 합산 한 다음 2로 나눕니다. 소수점 이하 자릿수 /2.는 정수 나누기보다는 부동 나누기입니다.

람다 함수이므로 결과가 암시 적으로 반환됩니다.

온라인으로 사용해보십시오!

Python3 - 31 30 바이트

@Dennis 덕분에 바이트를 절약했습니다!

나는 기본 답변을 계획하지 않았지만 이 모듈을 발견 하고 그것이 정말 멋진 cuz라고 생각했습니다.

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-quantile을 찾습니다.

온라인으로 사용해보십시오!

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

자바 스크립트, 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를 해결책을 게시하고 있습니다.

펄 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정렬 된 목록의 중간 요소에 대한 0 기준 인덱스입니다. 것은 가능 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" k 된 텍스트를 삽입합니다 (이 경우 목록).

TI 기본, 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요소를 가져옵니다 .

작동 원리

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

자바 스크립트, 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}

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

온라인으로 사용해보십시오

Pari / GP-37 39 바이트

하자 A는 값을 포함하는 rowvector합니다.

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)       

온라인으로 사용해보십시오!

apt, 20 바이트

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

온라인으로 테스트하십시오! Japt에는이 과제에 대한 간단한 답변을 만드는 데 필요한 기본 제공 기능이 거의 없습니다.

설명

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

자바 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둘 다 중간 요소의 인덱스로 나눕니다. 숫자는 그 자체에 더 해지고 결과는 2로 나뉘어 원래 값을 산출합니다.

온라인으로 사용해보십시오

SmileBASIC, 45 바이트

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

floor (length / 2) 및 floor (length / 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.}

내장, 51 바이트 를 사용 하지 않는 Rmedian

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.