Thử thách

Đưa ra một danh sách không có số thực, tính toán trung vị của nó.

Định nghĩa

Giá trị trung bình được tính như sau: Đầu tiên sắp xếp danh sách,

• nếu số lượng mục là số lẻ , trung vị là giá trị ở giữa danh sách được sắp xếp,
• mặt khác, trung vị là giá trị trung bình số học của hai giá trị gần trung tâm của danh sách được sắp xếp.

Ví dụ

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

Một hàm không tên trả về kết quả. -1 byte nhờ xnor.

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

Bước đầu tiên rõ ràng là sắp xếp mảng, sử dụng l.sort(). Tuy nhiên, chúng ta chỉ có thể có một câu lệnh trong lambda, vì vậy chúng ta sử dụng thực tế là hàm sắp xếp trả về Nonebằng cách thêm một or- như Nonelà giả trong Python, điều này nói với nó để đánh giá và trả về phần tiếp theo của câu lệnh.

Bây giờ chúng ta có danh sách được sắp xếp, chúng ta cần tìm các giá trị ở giữa hoặc hai ở giữa.

Sử dụng một điều kiện để kiểm tra tính chẵn lẻ của độ dài sẽ quá dài dòng, vì vậy thay vào đó chúng tôi nhận được các chỉ mục len(l)/2và ~len(l)/2:

• Đầu tiên là sàn (chiều dài / 2) , lấy phần tử ở giữa nếu độ dài là số lẻ hoặc mục bên trái trong cặp trung tâm nếu độ dài là chẵn.
• Thứ hai là đảo ngược nhị phân của độ dài danh sách, đánh giá đến -1 - sàn (chiều dài / 2) . Do lập chỉ mục tiêu cực của Python, điều này về cơ bản giống như chỉ mục đầu tiên, nhưng ngược lại từ cuối mảng.

Nếu danh sách có độ dài lẻ, các chỉ mục này sẽ trỏ đến cùng một giá trị. Nếu nó có độ dài bằng nhau, thì chúng sẽ chỉ vào hai mục trung tâm.

Bây giờ chúng ta có hai chỉ mục này, chúng ta tìm thấy các giá trị này trong danh sách, tính tổng chúng và chia chúng cho 2. Vị trí thập phân kéo dài để /2.đảm bảo rằng đó là phép chia float thay vì chia số nguyên.

Kết quả được trả về ngầm, vì đây là hàm lambda.

Hãy thử trực tuyến!

Python3 - 31 30 byte

Đã lưu một byte nhờ @Dennis!

Tôi đã không có kế hoạch cho một câu trả lời dựng sẵn, nhưng tôi đã tìm thấy mô-đun này và nghĩ rằng nó thực sự tuyệt vời vì tôi không biết nó tồn tại.

from statistics import*;median

Hãy thử trực tuyến tại đây .

Trên thực tế , 1 byte

║

Hãy thử trực tuyến!

Thạch , 9 byte

L‘HịṢµ÷LS

Hãy thử trực tuyến!

Giải trình

Tôi vẫn đang hiểu được Jelly ... Tôi không thể tìm thấy các phần tử tích hợp cho trung bình hoặc giá trị trung bình của danh sách, nhưng rất thuận tiện cho thử thách này khi Jelly cho phép các chỉ số không nguyên vào danh sách, trong trường hợp đó, nó sẽ trả về một cặp của hai giá trị gần nhất. Điều đó có nghĩa là chúng ta có thể làm việc với một nửa độ dài đầu vào dưới dạng chỉ mục và nhận được một cặp giá trị khi chúng ta cần lấy trung bình.

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 byte

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

Yêu cầu -Acờ chạy.

Hãy thử trực tuyến!

Giải trình

Xương sống của thuật toán này là một loại bong bóng tôi đã viết cách đây một thời gian.

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

Tôi không nhớ nó hoạt động như thế nào nên đừng hỏi tôi. Nhưng tôi biết nó sắp xếp ngăn xếp và thậm chí hoạt động cho tiêu cực

Sau khi mọi thứ đã được sắp xếp, tôi tìm thấy 2 lần trung vị với đoạn sau

([]<(()())>(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{}<(())>)  #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

Bây giờ tất cả những gì còn lại là chuyển đổi sang 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 byte

median

Không có gì đáng ngạc nhiên khi R, một ngôn ngữ lập trình thống kê, được tích hợp sẵn.

MATL , 4 byte

.5Xq

Điều này tìm thấy 0,5 lượng tử, là trung vị.

Hãy thử trực tuyến!

Pyth - 11 byte

Tìm trung bình của mục giữa lấy cả lùi và tiến.

.O@R/lQ2_BS

Phòng thử nghiệm .

Octave , 38 byte

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

Điều này xác định một chức năng ẩn danh. Đầu vào là một vector hàng.

Hãy thử trực tuyến!

Giải trình

            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 byte

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

Sắp xếp các mảng số. Nếu mảng có độ dài chẵn, hãy tìm 2 số ở giữa và lấy trung bình của chúng. Nếu mảng là số lẻ, tìm số giữa hai lần và chia cho 2.

Matlab / Octave, 6 byte

Một tích hợp nhàm chán:

median

Hãy thử trực tuyến!

Toán học, 6 byte

Median

Ngay khi tôi tìm ra M nhịp điệu , tôi sẽ đăng một giải pháp trong đó.

Perl 6 , 31 byte

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

Thử nó

Mở rộng:

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

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

Hãy thử trực tuyến!

Đây là một chuyến tàu. Các dfn ban đầu là {(2+/2/⍵[⍋⍵])[≢⍵]÷2}.

Tàu được cấu trúc như sau

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

⊢ biểu thị cho lập luận đúng.

⌷ mục lục

• ⊂∘⍋các chỉ số được lập chỉ mục thành ⊢kết quả trong ⊢việc được sắp xếp

• ÷∘2vào ⊢chia cho 2

2/nhân rộng điều này hai lần, vì vậy 1 5 7 8trở thành1 1 5 5 7 7 8 8

2+/ lấy tổng số theo cặp, điều này trở thành (1+1)(1+5)(5+5)(5+7)(7+7)(7+8)(8+8)

⊃ từ lựa chọn này

• ≢ phần tử có chỉ số bằng độ dài của ⊢

Giải pháp trước đây

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

Lisp thường gặp, 89

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

Tôi tính giá trị trung bình của các phần tử tại vị trí (floor middle)và (ceiling middle), trong đó middlechỉ số dựa trên zero cho phần tử ở giữa của danh sách được sắp xếp. Có thể middlelà toàn bộ một số, như 1đối với danh sách đầu vào có kích thước 3 (10 20 30), hoặc một phần cho các danh sách có số phần tử chẵn, như 3/2cho (10 20 30 40). Trong cả hai trường hợp, chúng tôi tính giá trị trung bình dự kiến.

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

Vim, 62 byte

Ban đầu tôi đã làm điều này trong V chỉ sử dụng thao tác văn bản cho đến khi kết thúc, nhưng đã nản lòng với việc xử lý [X] và [X, Y], vì vậy đây là phiên bản dễ dàng. Chúng có cùng chiều dài.

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

Hãy thử trực tuyến!

Không thể in

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

Đề cập đến danh dự:

• ^O đưa bạn ra khỏi chế độ chèn cho một lệnh (lệnh let).
• ^R" chèn văn bản đã được kéo mạnh (trong trường hợp này là danh sách)

TI-Basic, 2 byte

median(Ans

Rất đơn giản.

C #, 126 byte

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

Khá đơn giản, ở đây với LINQ để sắp xếp các giá trị, bỏ qua một nửa danh sách, lấy một hoặc hai giá trị tùy thuộc vào chẵn / lẻ và trung bình chúng.

C ++ 112 byte

Cảm ơn @ original.legin đã giúp tôi lưu byte.

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

Sử dụng:

    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 byte

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

Hãy thử trực tuyến!

Ngoài thủ thuật sao chép mảng của BMO , tôi thấy rằng chúng ta có thể thêm toàn bộ mảng được sắp xếp theo hai hướng. Sau đó, tôi nhận ra rằng hai bước có thể được đảo ngược, tức là thêm hai mảng, sau đó nhân đôi chúng và lấy nphần tử thứ.

Làm thế nào nó hoạt động

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

Câu trả lời trước

J với statsaddon, 18 byte

load'stats'
median

Hãy thử trực tuyến!

Chức năng thư viện FTW.

medianTriển khai của nó trông như thế này:

J , 31 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

Một chút của golf cho điều này:

J , 28 byte

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

Hãy thử trực tuyến!

J, 19 byte

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

Giải trình:

        (        )~   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 byte

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 byte

Chơi gôn

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

Ung dung:

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

Dùng thử trực tuyến

Pari / GP - 37 39 byte

Đặt a là một rowvector chứa các giá trị.

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

Vì Pari / GP tương tác, không cần thêm lệnh để hiển thị kết quả.

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)       

Hãy thử trực tuyến!

Japt, 20 byte

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

Kiểm tra nó trực tuyến! Japt thực sự thiếu bất kỳ nội dung cần thiết nào để tạo ra một câu trả lời thực sự ngắn cho thử thách này ...

Giải trình

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 byte

Chẵn lẻ là niềm vui! Đây là một lambda từ double[]đến Double.

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

Không có gì quá phức tạp đang diễn ra ở đây. Mảng được sắp xếp, và sau đó tôi lấy giá trị trung bình của hai số từ mảng. Có hai trường hợp:

• Nếu độ dài là chẵn thì số thứ nhất được lấy từ ngay trước phần giữa của mảng và số thứ hai được lấy từ vị trí trước số đó bằng cách chia số nguyên. Giá trị trung bình của các số này là trung vị của đầu vào.
• Nếu độ dài là số lẻ svà s-1cả hai đều chia cho chỉ số của phần tử ở giữa. Số được thêm vào chính nó và kết quả chia cho hai, mang lại giá trị ban đầu.

Dùng thử trực tuyến

SmileBASIC, 45 byte

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

Lấy trung bình của các phần tử ở tầng (chiều dài / 2) và sàn (chiều dài / 2-0,5) Rất đơn giản, nhưng tôi đã có thể tiết kiệm 1 byte bằng cách di chuyển mọi thứ xung quanh:

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

Husk , 10 byte

½ΣF~e→←½OD

Hãy thử trực tuyến!

Giải trình

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

_{Thật không may ½cho danh sách có loại [a] -> [[a]]và không [a] -> ([a],[a])cho phép F~+→←vì foldl1cần một hàm loại a -> a -> alàm đối số đầu tiên, buộc tôi phải sử dụng e.}

R không sử dụng mediannội trang, 51 byte

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

Hãy thử trực tuyến!

GolfScript , 27 25 20 17 byte

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

Đưa đầu vào như một mảng các số nguyên trên stdin. Đầu ra là một phần chưa được xác định. Hãy thử trực tuyến!

Giải trình

$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

Đầu ra sẽ là một cái gì đó như 10/2.