Görev

Sıralanan bir kayan nokta veri kümesi (herhangi bir yolla) göz önüne alındığında, çeyrekler arası ortalamayı döndürün (herhangi bir şekilde ve doğru değerin 1 within içinde) .

Bir olası algoritma

1. Veri noktalarının en düşük ve en yüksek çeyreklerini atın.
2. Kalan veri noktalarının ortalamasını (toplam sayısına bölünerek) hesaplayın.

Not: Veri kümesi boyutu dörde bölünemiyorsa , alt kümeler tarafından paylaşılan veri noktalarını tartmanız gerekir . Aşağıdaki Örnek değerlendirme 2'ye bakınız.

Örnek değerlendirme 1

Verilen {1, 3, 4, 5, 6, 6, 7, 7, 8, 8, 9, 38}

1. Veri sayısı 12'dir, bu nedenle en düşük ve en yüksek 3 veri noktasını kaldırırız:
   { 1, 3, 4, 5, 6, 6, 7, 7, 8, 8, 9, 38 }
2. Kalan 6 veri noktasının ortalaması:
   (5 + 6 + 6 + 7 + 7 + 8) / 6 = 6,5

Örnek değerlendirme 2

Verilen {1, 3, 5, 7, 9, 11, 13, 15, 17}

1. Sayı 9'dur, bu nedenle her çeyrek 2po veri noktasına sahiptir:
   { 1, 2, (0.25 × 5), (0.75 × 5), 7, 9, 11, (0.75 × 13), (0.25 × 13), 15, 17 }
2. Kalan 4.5 veri noktasının ortalaması:
   (0.75 × 5 + 7 + 9 + 11 + 0.75 × 13) / 4.5 = 9

Scilab, 8 bayt

trimmean

Belgelere bakınız . Varsayılan olarak discard=50, yani IQM hesaplanır.

EDIT: Biliyorsun, bu önemsiz bir yerleşik cevap, bu yüzden CW olarak işaretliyorum .

Pyth , 11 10 bayt

.O> <lqs * 4QL
.OsPtc4S * 4

Test odası.

Nasıl çalışır

Veri sayısının 4 ile bölünebilir olmasını sağlamak için giriş listesini dört katına çıkarır.

Yine de sıralamaya ihtiyacı var, çünkü *4her bir eleman yerine tüm listeye uygulanır.

Sonra, listeyi dört eşit parçaya böler, sonra ilk ve son kısmı alır.

Kalan liste düzleştirilir ve ortalama alınır.

MATL , 12 11 bayt

4Y"G"6L)]Ym

Giriş, formatı olan yatay bir vektördür

[1, 3, 4, 5, 6, 6, 7, 7, 8, 8, 9, 38]

veya

[1 3 4 5 6 6 7 7 8 8 9 38]

Çevrimiçi deneyin!

açıklama

4Y"    % Input horizontal vector implicitly. Repeat each element 4 times (run-length
       % decoding). The resulting array is still sorted.
G"     % Push input, for each: repeat as many times as the input size
  6L)  %   Remove first and last elements, by applying the index "2:end-1"
]      % End for each
Ym     % Compute mean. Display implicitly

Kardan adam , 66 bayt

}vg","aS:10sB;aM4aRAsOal`,4nD,`aG0AaGal`NdE`AaL1AfL:nA;alaF,nDtSsP

Çevrimiçi deneyin!

@LeakyNun yanıtları ile aynı algoritmayı kullanır .

}         enable variables b, e, and g
vg        read a line of input into b
","aS     split on commas (in-place)
:10sB;aM  convert each element in resulting array to number ("frombase(10)-map")
4aR       repeat the array 4 times
AsO       sort the array
al        take the length and put it in e without consuming b (the array)
`,        swap b and e, then move e to g; now b=length g=array
4nD       divide b by 4 (4 was stored in e, which is why the array was moved)
,`        move the array and length/4 back to their original positions
aG        split the array into groups of length (length/4)
0AaG      take all elements with index >0 (i.e. remove the first element)
al        store the length of the new array in e again
`NdE`     bring it up to b, decrement, and put it back
AaL       take all elements with index <length-1 (i.e. remove last)
1AfL      flatten the array 1 level deep
:nA;      push a block that adds two numbers (to e)
al        store the length of this new array in g
aF        fold b over e (sum the numbers)
,         move g (the length) into e
nD        divide the sum by the length, resulting in the average
tSsP      to-string and print

Python 3, 50 bayt

lambda n:sum(sorted(n*4)[len(n):-len(n)])/len(n)/2

Ideone!

Nasıl çalışır

Bu Pyth'deki cevabımın bir çevirisidir .

Jelly , 14 13 12 bayt

x4ṫL '$ $LN $ S ÷ LH x4ṫL' $ 
NLN $ S ÷ LH
x4œs4ḊṖFS ÷ LH

Çevrimiçi deneyin!

Test odası.

Nasıl çalışır

Bu Pyth'deki cevabımın bir çevirisidir .

Pyke, 16 13 bayt

4*S4ftOsDsRl/

Burada dene!

Brachylog , 21 bayt

:3jo@4brbcLl/N,L+:N*.

Çevrimiçi deneyin! veya birden fazla test vakasını doğrulayın

açıklama

Bu temelde @ LeakyNun Pyth cevap algoritmasıdır.

:3j      Append 3 copies of the input to itself
o@4      Sort and split in 4 lists of equal length
brb      Remove the head and the tail of the list of lists
cL       Concatenate the 2 sublists into a list L
l/N,     N is the inverse of the length of L
L+:N*.   Output is the product of N and the sum of the elements of L

Buradaki tek küçük püf noktası, uzunluk ile bölmek yerine, uzunluğun tersi ile çarpmaktır, çünkü 2 tam sayı arasındaki bölünme, tamsayı bölmedir.

Oktav , 44 bayt

@(x)mean(reshape(~~(1:4)'*x,[],4)(:,2:3)(:))

Bu isimsiz bir işlevi tanımlar.

Giriş yatay bir vektördür.

İdeone üzerinde dene .

açıklama

Girdi yatay vektörü ilk önce matris ile çarpılır ( *) dörtlü bir sütun vektörü ile (inşa edilir ~~(1:4)'). Sonuç, her satırın giriş vektörünün bir kopyası olduğu dört sütunlu bir matristir. Bu daha sonra, elemanların doğrusal sırasını koruyarak 4 sütunlu bir matriste ( reshape(...,[],4)) yeniden şekillendirilir . Ortadaki iki sütun tutulur ( (:,2:3)) ve (:)ortalamaları hesaplanan tek bir sütuna ( ) doğrusallaştırılır ( mean(...)).

J , 20 18 bayt

@Miles sayesinde 2 bayt

# -.:. '% ~ - @ # + / @} #} -4 #]
- @ # (+ /% #) '} #} -4 #]..

Çevrimiçi deneyin! ( Çevrimiçi tercüman )

kullanım

>> f =: -@#(+/%#)@}.#}.4#]
>> f 1 3 5 7 9 11 13 15 17
<< 9

Nasıl çalışır

Bu Pyth'deki cevabımın bir çevirisidir .

Aslında , 20 15 13 bayt

; l╗; +; + S╜t @ HΣ╜τ @ / 
; l; τ; a; +; + StHΣ /
Örnek l, τ; aττStHΣ /

Çevrimiçi deneyin!

Nasıl çalışır

Bu Pyth'deki cevabımın bir çevirisidir .

Oktav, 42 bayt

Octave için başka bir anonim işlev.

@(x)mean([x;x;x;x](:)((b=numel(x))+1:3*b))

Şunları yapabilirsiniz çevrimiçi denemek . Basitçe bu komutu girin ve ardından ans([1 2 4 5 6 9])gerekli olan herhangi bir sayı veya işlemi yapın.

Bu, ilk önce dört kopyayı dikey olarak birleştirerek her bir girdi öğesinden 4'üyle bir girdi dizisinden bir tane oluşturarak ve ardından dikey olarak düzleştirerek başlar. Bu sıralama düzenini korur.

Daha sonra eleman dizisini giriş dizisinin uzunluğundan artı 1 ile giriş dizisinin uzunluğunun üç katına çıkartır. Yeni dizi dört kat daha uzun olduğundan, bu alt ve üst çeyrekleri keser.

Sonunda yeni dizinin ortalaması döndürülür.

05AB1E, 15 bayt

€D€D¹gô¦¨˜DOsg/

açıklama

€D€D             # quadruple each element in list
    ¹gô          # split into pieces the size of input
       ¦¨˜       # remove the first and last and flatten the middle 2
          DOsg/  # sum and divide by length

Çevrimiçi deneyin

APL (Dyalog) , 15 bayt

IQM←(+/÷≢)≢↓-∘≢↓4∘/

Çevrimiçi deneyin!

4∘/ her bir öğeyi dört katına çıkarmak

-∘≢↓ bağımsız değişkenlerde olduğu kadar sondaki öğeleri bırak

≢↓ bağımsız değişkende olduğu kadar çok sayıda öncü öğesi bırak

(… ) Aşağıdaki taktik işlevini uygulayın:

 +/ toplam

 ÷ bölü

 ≢ taksitli

JavaScript (ES6), 75 bayt

a=>a.concat(a,a,a).sort(g=(x,y)=>x-y).slice(l=a.length,-l).reduce(g,0)/l/-2

Açık ve dörtlü sıralama yaklaşımını kullanır ve kullanmaya başladım reduce, ki bu hoş bir şey. Buradaki tek hile, tüm dizi öğelerini sıfırdan çıkarmak için sıralama karşılaştırıcısını yeniden kullanarak 4 baytı kurtarmaktır, bu da bana -2listediğim yanıtı katlar.

Golf Betiği, 28 29 bayt

~ .4 * $ \,. '/ 1> 2 <{+} * {+} * '/'' 2 *
~ .4 * $ \,. '/ 1> 2 <{+} * {+} * \ 2 * -1? *

Çevrimiçi deneyin!

Aslında, 12 bayt

4α;l¼≈;±(Htæ

Çevrimiçi deneyin! (şu anda çalışmıyor çünkü TIO bir kaç versiyon daha var)

Açıklama:

4α;l¼≈;±(Htæ
4α            repeat each element 4 times
  ;l¼≈        length divided by 4, as integer
      ;±      copy, unary negate
        (Ht   remove first and last quartiles
           æ  mean

Mathematica, 51 bayt

Mean@#[[(l=1+Length@#/4);;-l]]&@Sort@Join[#,#,#,#]&

Listenin dört kopyasını sıralar (liste uzunluğu değil dört katları ile sorunları önlemek için), yer alır "1 quarter the length of resulting list plus 1"kadar "1/4 length list + 1 from the end", onların sürer Mean.

Java 146 126 Bayt

Böyle java çok ayrıntılı!

float m(float[]n){float r=0;int l=n.length,i=l/4;r-=(n[i])*(l%4)/4;r+=n[i*3]*(4-(l%4))/4;for(;i<l*3/4;r+=n[i],i++);return r/l*2;}

Eski Ungolfed test durumlarıyla kısmen okunabilir

/**
 *
 * @author rohan
 */
public Golf{

float m(float[]n){
//declarations 
float r=0;
int x,i=0,l=n.length;
//sum the array 
for(float m:n){r+=m;}
//remove the excess
for(;i<l/4;r-=n[i]+n[l-i-1],i++);
//weight the quartiles
r-=(n[l/4]+n[l*3/4])*(l%4)/4;
//return the sum/length but multiply by two since only half of the set is averaged
return r/l*2;
    }
static void interQuartileMean(float... set){
    System.out.println(new Golf().m(set));
}
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
    //test cases pass with flying colours
        interQuartileMean(1, 3, 4, 5, 6, 6, 7, 7, 8, 8, 9, 38);
        interQuartileMean(1, 3, 5, 7, 9, 11, 13, 15, 17);   
    }

}

Clojure, 82 81 bayt

Düzenleme: "2 n tarafından sağla" bölümünü yeniden yazarak 1 bayt daha az.

#(let[n(count %)](*(/ n)0.5(apply +(subvec(vec(for[i % j(range 4)]i))n(* 3 n)))))

Önceki:

#(let[n(count %)](/(apply +(subvec(vec(for[i % j(range 4)]i))n(* 3 n)))(* 2.0 n)))

Kesirli sonuçlara sahip olmamak için forfloat kullanarak 4 tekrarlanan değer üretmek için kullanır 2.0, gerisi sadece standart.

R, 17 11 bayt

mean(n,0.25)

Varsayım n, standart R formundaki giriş vektörüdür n=c(1, 2, 3, ...).

Bu, R'nin “istatistiksel hesaplama dili” olarak kabul edilebileceği ve pek çok istatistiksel yapıya sahip olması nedeniyle şaşırtıcı değildir.

GÜNCELLEŞTİRME. Rturnbull sayesinde 6 bayt kaydedildi trim, çünkü varsayılan olarak ilk isteğe bağlı argümandır!

Test durumları:

a <- c(1, 3, 4, 5, 6, 6, 7, 7, 8, 8, 9, 38)
b <- c(1, 3, 5, 7, 9, 11, 13, 15, 17)
mean(a,trim=0.25) # Returns 6.5
mean(b,trim=0.25) # Returns 9

Excel, 17 bayt

=TRIMMEAN(A:A,.5)

Rahat giriş formatı bunu kolaylaştırır. A sütununa her satıra bir tane girin.