Meydan okuma

Gerçek sayıların boş olmayan bir listesi göz önüne alındığında, medyanını hesaplayın.

Tanımlar

Ortanca aşağıdaki gibi hesaplanır: İlk önce listeyi sıralayın,

• Giriş sayısı tek ise, ortanca, sıralanan listenin ortasındaki değerdir.
• aksi halde, medyan, sıralanmış listenin merkezine en yakın iki değerin aritmetik ortalamasıdır.

Örnekler

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

Sonucu döndüren adsız bir işlev. Xnor sayesinde -1 bayt.

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

İlk adım açıkça kullanarak diziyi sıralamak l.sort(). Bununla birlikte, lambdada yalnızca bir ifadeye sahip olabiliriz, bu yüzden sort işlevinin Python'da sahte olduğu gibi Nonebir or- ekleyerek döndürdüğü gerçeğinden faydalanırız None, bu, ifadenin bir sonraki bölümünü değerlendirmesini ve geri vermesini söyler.

Şimdi sıralanan listeye sahibiz, ya orta ya da orta iki değeri bulmamız gerekiyor.

Uzunluk paritesini kontrol etmek için bir koşullu kullanmak çok ayrıntılı olacaktır, bu yüzden indeksleri alırız len(l)/2ve ~len(l)/2:

• Birincisi , uzunluk tek ise orta elemanı , taban çift ​​ise sol ise orta çiftte bulunan tabandır (uzunluk / 2) .
• İkincisi, liste uzunluğunun -1 - kat (uzunluk / 2) olarak değerlendirilen ikili çevrimidir . Python'un negatif indekslemesi nedeniyle, bu esas olarak ilk indeksle aynıdır, ancak dizinin sonundan geriye doğru.

Listenin uzunluğu tek ise, bu indeksler aynı değere işaret edecektir. Eşit uzunlukta ise, merkezi iki maddeye işaret edeceklerdir.

Şimdi bu iki endekse sahip olduğumuz için, bu değerleri listede buluruz, toplar ve 2'ye böleriz. İzleyen ondalık basamak /2., tamsayı bölmesinden ziyade kayan bölme olduğundan emin olur.

Sonuç bir lambda işlevi olduğu için dolaylı olarak döndürülür.

Çevrimiçi deneyin!

Python3 - 31 30 bayt

@Dennis sayesinde bir bayt kaydedildi!

Yerleşik bir cevabı planlamıyordum, ama bu modülü buldum ve bunun harika olduğunu düşündüm çünkü var olduğunu bilmiyordum.

from statistics import*;median

Burada çevrimiçi deneyin .

Aslında , 1 bayt

║

Çevrimiçi deneyin!

Jöle , 9 bayt

L‘HịṢµ÷LS

Çevrimiçi deneyin!

açıklama

Hala Jelly'i alıyorum ... Ortanca veya listenin ortalaması için yerleşik bileşenler bulamadım, ancak Jelly’in tamsayı olmayan indekslerin listelerde bulunmasına izin vermesi bu zorluk için çok uygun. bu durumda en yakın iki değerin bir çiftini döndürecektir. Bu, giriş uzunluğunun yarısı ile indeks olarak çalışabileceğimiz ve ortalamaya ihtiyacımız olduğunda bir çift değer alabileceğimiz anlamına gelir.

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 bayt

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

-ABayrağın çalıştırılmasını gerektirir .

Çevrimiçi deneyin!

açıklama

Bu algoritmanın bel kemiği, bir süre önce yazdığım bir baloncuk türüdür.

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

Bunun nasıl çalıştığını hatırlamıyorum, o yüzden bana sorma. Ancak yığını destekliyor ve negatifler için bile işe yaradığını biliyorum

Her şey sıralandıktan sonra, takip eden öbek ile medyanın 2 katını buldum

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

Şimdi geriye kalan tek şey ASCII'ye dönüştürmek.

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

median

İstatiksel bir programlama dili olan R'nin bu yerleşik bir yapıya sahip olması şaşırtıcı değildir.

MATL , 4 bayt

.5Xq

Bu, medyan olan 0,5-kuantili bulur.

Çevrimiçi deneyin!

Pyth - 11 bayt

Hem geriye hem de ileriye götürülen orta öğenin ortalamasını bulur.

.O@R/lQ2_BS

Test Takımı .

Oktav , 38 bayt

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

Bu isimsiz bir işlevi tanımlar. Giriş bir satır vektörüdür.

Çevrimiçi deneyin!

açıklama

            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 bayt

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

Diziyi sayısal olarak sıralayın. Dizi eşit uzunluktaysa, 2 orta sayıyı bulun ve ortalayın. Dizi tuhafsa, ortadaki numarayı iki kez bulun ve 2'ye bölün.

Matlab / Octave, 6 bayt

Sıkıcı bir yerleşik:

median

Çevrimiçi deneyin!

Mathematica, 6 bayt

Median

En kısa sürede dışarı ben figürü olarak Mthmtca , onunla ilgili bir çözüm post ediyorum.

Perl 6 , 31 bayt

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

Dene

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 bayt

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

Çevrimiçi deneyin!

Bu bir tren. Orijinal dfn öyleydi {(2+/2/⍵[⍋⍵])[≢⍵]÷2}.

Tren aşağıdaki gibi yapılandırılmıştır

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

⊢ doğru argümanı gösterir.

⌷ indeks

• ⊂∘⍋dizinlenir endeksleri ⊢sonuçları ⊢kriteri olan

• ÷∘2içine ⊢2 ile bölünmesiyle

2/bunu iki kez çoğalt, böylece 1 5 7 8olur1 1 5 5 7 7 8 8

2+/ çift ​​toplamı al, bu olur (1+1)(1+5)(5+5)(5+7)(7+7)(7+8)(8+8)

⊃ bu seçimden

• ≢ uzunluğuna eşit indeksli eleman ⊢

Önceki çözümler

{.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))

Ben pozisyonda elemanlarının ortalama hesaplamak (floor middle)ve (ceiling middle)nerede, middlesıralı listenin orta elemanı için sıfır tabanlı endeksidir. Bu middlegibi 1bir büyüklükteki bir giriş listesi gibi bir tam sayı (10 20 30)veya bunun gibi eşit sayıda eleman içeren listeler için bir kesir 3/2olmak mümkündür (10 20 30 40). Her iki durumda da beklenen medyan değerini hesaplıyoruz.

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

Vim, 62 bayt

Başlangıçta bunu V’e sonuna kadar sadece metin manipülasyonu kullanarak yaptım, ancak [X] ve [X, Y] 'yi kullanmaktan bıktım, işte bu yüzden kolay versiyon. Yaklaşık aynı uzunluktadırlar.

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

Çevrimiçi deneyin!

Unprintables:

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

Şeref Ödülü:

• ^O sizi bir komut için ekleme modundan çıkarır (let komutu).
• ^R" yerleştirilen metni ekler (bu durumda liste)

TI-Basic, 2 bayt

median(Ans

Çok basit.

C #, 126 bayt

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

Oldukça basit, burada değerleri sıralamak için LINQ ile, listenin yarısını atlayın, çift / tek ve ortalamanın değerine göre bir veya iki değer alın.

C ++ 112 Bayt

Baytları kurtarmama yardım ettiğin için @ original.legin'e teşekkürler

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

Kullanımı:

    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 bayt

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

Çevrimiçi deneyin!

BMO'nun dizi çoğaltma numarasına ek olarak , tüm diziyi iki yönde sıralayarak ekleyebileceğimizi öğrendim. Sonra iki adımın tersine çevrilebileceğinin farkına vardım, yani iki diziyi ekleyin, sonra onları çoğaltın ve nöğeyi alın.

Nasıl çalışır

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

Önceki cevaplar

J ile statseklenti, 18 bayt

load'stats'
median

Çevrimiçi deneyin!

Kütüphane işlevi FTW.

median'nin uygulaması şöyle gözüküyor:

J , 31 bayt

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

Çevrimiçi deneyin!

Nasıl çalışır

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

Birazcık golf bunu veriyor:

J , 28 bayt

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

Çevrimiçi deneyin!

J, 19 bayt

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

Açıklama:

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

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 bayt

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

Çevrimiçi deneyin

Pari / GP - 37 39 Bayt

Let bir değerler içeren bir rowvector ol.

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 etkileşimli olduğundan, sonucu görüntülemek için ek bir komut gerekmez.

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)       

Çevrimiçi deneyin!

Japt, 20 bayt

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

Çevrimiçi test edin! Japt, bu mücadeleye gerçekten kısa bir cevap verebilmek için gerekli olan herhangi bir yapıya sahip değil.

açıklama

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 bayt

Parite eğlencelidir! İşte double[]ila bir lambda Double.

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

Burada çok karmaşık bir şey olmaz. Dizi sıralanır ve sonra diziden iki sayının ortalamasını alırım. İki dava var:

• Uzunluk eşitse, ilk sayı dizinin ortasının hemen önünden alınır ve ikinci sayı tam sayı bölme ile bundan önceki konumdan alınır. Bu sayıların ortalaması, girişin medyanıdır.
• Uzunluk tek ise sve s-1her ikisi de orta öğenin indeksine bölün. Sayı kendine eklenir ve sonuç ikiye bölünerek orijinal değer elde edilir.

Çevrimiçi Deneyin

SmileBASIC, 45 bayt

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

Kattaki elemanların ortalamasını alır (uzunluk / 2) ve kattaki (uzunluk / 2-0.5) Çok basit, ancak etrafta dolaştırarak 1 bayt tasarruf ettim:

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

Kabuğu , 10 bayt

½ΣF~e→←½OD

Çevrimiçi deneyin!

açıklama

Bu işlev, olduğunu kullanır.$[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

_{Maalesef ½listeler için türüne sahip [a] -> [[a]]değil [a] -> ([a],[a])izin vermez hangi F~+→←beri foldl1ihtiyaçları türde bir fonksiyonu a -> a -> abeni kullanmaya zorlayarak, ilk argüman olarak e.}

R olmadan kullanılarak mediankomutuna 51 bayt

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

Çevrimiçi deneyin!

GolfScript , 27 25 20 17 bayt

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

Girdiyi stdin'deki bir tamsayı dizisi olarak alır. İndirgenmemiş bir kesir olarak çıkar. Çevrimiçi deneyin!

açıklama

$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

Çıktı gibi bir şey olacak 10/2.