छद्म तत्वों को फ़िल्टर करें!

Question

हम एक सरणी / सूची के हाइपर-औसत को परिभाषित करते हैं (संख्याओं के) इसके उपसर्गों के सममित माध्य।

उदाहरण के लिए, सूची के हाइपर-एवरेज की [1, 4, -3, 10]गणना निम्न तरीके से की जाती है:

• हम उपसर्गों मिलती है: [1], [1, 4], [1, 4, -3], [1, 4, -3, 10]।

• प्रत्येक योग [1, 5, 2, 12]:।

• और अब इस सूची में तत्वों के अंकगणितीय माध्य प्राप्त करें (1 + 5 + 2 + 12) / 4 = 5:।

किसी सरणी का एक छद्म तत्व एक ऐसा तत्व है जिसका मूल्य उसके अति-औसत से कड़ाई से कम है। इसलिए, हमारे उदाहरण सूची के छद्म तत्व हैं 1, 4और -3।

---

फ्लोटिंग-पॉइंट नंबरों की सूची को देखते हुए, आपका काम छद्म तत्वों की सूची को वापस करना है।

• आपको फ्लोटिंग-पॉइंट अशुद्धियों के बारे में चिंता करने की ज़रूरत नहीं है।

• इनपुट सूची कभी खाली नहीं होगी और इसमें पूर्णांक और फ़्लोट दोनों शामिल हो सकते हैं। यदि उल्लेख किया गया है, तो पूर्णांक को फ्लोट के रूप में लिया जा सकता है (साथ <integer>.0)

• आप मान सकते हैं कि संख्याएँ आपकी पसंद की भाषा में फिट होती हैं, लेकिन कृपया इसे किसी भी तरह से दुरुपयोग न करें।

• वैकल्पिक रूप से, आप सरणी की लंबाई इनपुट के रूप में भी ले सकते हैं।

• यह कोड-गोल्फ है , इसलिए टैग के लिए मानक नियम लागू होते हैं। बाइट्स में सबसे छोटा कोड ( प्रत्येक भाषा में ) जीतता है!

---

परीक्षण के मामलों

इनपुट -> आउटपुट

[१०.३] -> []
[5.4, 5.9] -> [5.4, 5.9]
[1, 4, -3, 10] -> [1, 4, -3]
[-300, -20.9, 1000] -> [-300, -20.9]
[3.3, 3.3, 3.3, 3.3] -> [3.3, 3.3, 3.3, 3.3]
[-289.93, 912.3, -819.39, 1000] -> [-289.93, -819.39]

Comments

यदि कुछ भाषाओं को अतिरिक्त इनपुट के रूप में सरणी की लंबाई लेने की अनुमति है, तो इसे सभी भाषाओं के लिए अनुमति दी जानी चाहिए ।

— ngenisis

@ngenisis यह सभी भाषाओं के लिए है। यदि लंबाई लेने के साथ-साथ आपके कार्यक्रम में कमी आती है, तो बेझिझक इसे करें। यह कल्पना बिल्कुल भी भाषा प्रतिबंधक नहीं है।

— श्री एक्सकोडर

Answer 1

MATL , 8 बाइट्स

ttYsYm<)

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

tt    % Implicitly input array. Duplicate twice
Ys    % Cumulative sum
Ym    % Arithmetic mean
<     % Less than? (element-wise). Gives an array containing true / false
)     % Reference indexing : use that array as a mask to select entries 
      % from the input. Implicitly display

Answer 2

05AB1E , 9 8 बाइट्स

मैजिक ऑक्टोपस Urn के लिए -1 बाइट्स धन्यवाद

ηOO¹g/‹Ï

इसे ऑनलाइन आज़माएं!

η        # Get prefixes
 O       # Sum each
  O¹g/   # Get the mean ( length(prefix list) equals length(original list) )
      ‹Ï # Keep only the value that are less than the mean

---

05AB1E , 6 बाइट्स

नई ÅAकमांड का उपयोग करना ।

ηOÅA‹Ï

इसे ऑनलाइन आज़माएं!

η      # Get prefixes
 O     # Sum each
  ÅA   # Get the mean
    ‹Ï #  Keep only the value that are less than the mean

Comments

ηOO¹g/›Ï8 के लिए; इसके साथ ही शुरू होता है nOO!।

— मैजिक ऑक्टोपस Urn

Answer 3

जाप v2.0a0, 12 11 10 बाइट्स

f<Uå+ x÷Ul

झसे आज़माओ

• 1 बाइट ने ईटीएच को एक बेमानी चरित्र की ओर इशारा करते हुए धन्यवाद को बचाया ।

---

व्याख्या

सरणी का निहित इनपुट U।

f<

फ़िल्टर ( f) की जाँच करके अगर प्रत्येक तत्व से कम है ...

Uå+

Uसमकालिक रूप से घटाया ( å) योग से ...

x

बदले में परिणामी सरणी के साथ योग से कम ...

/Ul

और लंबाई ( l) के द्वारा विभाजित है U।

परिणामी सरणी के उत्पादन को लागू करें।

Answer 4

पाइथन 3 के साथ नम्पी , 48 बाइट्स

lambda x:x[x<mean(cumsum(x))]
from numpy import*

इनपुट और आउटपुट Numpy सरणियाँ हैं। इसे ऑनलाइन आज़माएं!

Comments

+1 अंत में, कोई उपयोग करता है cumsum!

— बजे मिस्टर एक्सकोडर

Answer 5

जेली , 9 बाइट्स

+\S÷L<Ðf@

इसे ऑनलाइन आज़माएं!

Comments

शायद <Ðf@इसके बजाय होना चाहिए <Ðḟ@?

— आउटगोल्फर

@EriktheOutgolfer लेकिन यह सभी टेस्टकेस को पास करता है।

— लीक

फिर भी कुछ मेरे लिए अच्छा प्रतीत होता है नहीं ... सब से पहले +\S÷Lगणना अति औसत है, तो <Ðf@यह सही तर्क के रूप में कहते हैं यह और <वापस आ जाएगी 1अगर एक तत्व एक छद्म तत्व है, अनिवार्य रूप से छानने के बजाय छद्म तत्वों के लिए फ़िल्टरिंग उन्हें बाहर।

— आउटगॉल्फ

@EriktheOutgolfer इस संदर्भ में, फ़िल्टरिंग का अर्थ है फ़िल्टर करना।

— लीक

Answer 6

पायथन 2 , 78 76 71 66 बाइट्स

-7 बाइट्स मिस्टर एक्सकोडर की बदौलत।

lambda l:[x for x in l if x<sum(sum(l[:i])for i in range(len(l)))]

इसे ऑनलाइन आज़माएं!

Comments

मुझे लगता है कि आप कर सकते हैं range(len(l))और l[:i+1]-2 बाइट्स के लिए (परीक्षण नहीं किया गया)

— श्री एक्सकोडर

गोल्फ और बाधित। ;) धन्यवाद!

— totallyhuman

आपका समाधान यद्यपि अमान्य है। बदलें x>sum(...)करने के लिए x<sum(...)यह मान्य होने के लिए, अभी भी 76 बाइट्स

— श्री Xcoder

Wherps ... फिक्स्ड। >>।

— totallyhuman

मुझे आश्चर्य है कि किसी ने भी स्पष्ट <s>68</s>66 बाइट समाधान नहीं चुना : पी

— श्री एक्सकोडर

Answer 7

हास्केल, 39 बाइट्स

f l=filter(<sum(scanl1(+)l)/sum(1<$l))l

इसे ऑनलाइन आज़माएं!

दुर्भाग्य से lengthइस प्रकार का है Int, तो मैं चल बिन्दु विभाजन के साथ उपयोग नहीं कर सकते /और मैं एक तरीके का उपयोग करने के लिए है: sum(1<$l)।

Answer 8

भूसी , 10 9 बाइट्स

1 बाइट को बंद करने के लिए धन्यवाद @Zgarb!

f</L⁰Σ∫⁰⁰

इसे ऑनलाइन आज़माएं!

Ungolfed / स्पष्टीकरण

           -- argument is ⁰ (list) 
f       ⁰  -- filter the original list with
 <         --   element strictly smaller than
     Σ∫⁰   --   sum of all prefixes
  /L⁰      --   averaged out

Comments

f</L⁰Σ∫⁰⁰9 बाइट्स है, लेकिन तीन लैम्ब्डा तर्कों को भद्दा लगता है।

— ज़गारब

Answer 9

जावास्क्रिप्ट (ईएस 6), 56 55 52 बाइट्स

a=>a.filter(x=>x<t/a.length,a.map(x=>t+=s+=x,s=t=0))

---

झसे आज़माओ

o.innerText=(f=

a=>a.filter(x=>x<t/a.length,a.map(x=>t+=s+=x,s=t=0))

)(i.value=[1,4,-3,10]);oninput=_=>o.innerText=f(i.value.split`,`.map(eval))

<input id=i><pre id=o>

Answer 10

जावा 8, 81 बाइट्स

यह लंबोदर अभिव्यक्ति स्वीकार करता है List<Float>और इसे उत्परिवर्तित करता है। इनपुट सूची के इटरेटर को हटाने का समर्थन करना चाहिए ( ArrayListउदाहरण के लिए, एस)। को सौंपा Consumer<List<Float>>।

a->{float l=0,t=0,u;for(float n:a)t+=n*(a.size()-l++);u=t/l;a.removeIf(n->n>=u);}

अघोषित लंबोदर

a -> {
    float l = 0, t = 0, u;
    for (float n : a)
        t += n * (a.size() - l++);
    u = t / l;
    a.removeIf(n -> n >= u);
}

यह ऑनलाइन की कोशिश करो

स्वीकृतियाँ

• -3 बाइट्स केविन क्रूज़सेन को धन्यवाद
• -17 बाइट्स नेवी के लिए धन्यवाद

Comments

आप को हटाने के द्वारा 3 बाइट्स बचा सकता है t/=l;और परिवर्तन if(n<t)करने के लिए if(n<t/l)।

— केविन क्रूज़सेन

आप परिणामी मानों a->{float l=0,t=0,u;for(float n:a)t+=n*(a.size()-l++);u=t/l;a.removeIf(n->n>=u);}(81 बाइट्स) को प्रिंट करने के बजाय प्रदान किए गए तर्क को संशोधित करने में सक्षम होने के लिए एक सरणी के बजाय एक सूची का उपयोग कर सकते हैं ।

— नेवले

Answer 11

सी # (मोनो) , 95 बाइट्स

using System.Linq;a=>a.Where(d=>d<new int[a.Length].Select((_,i)=>a.Take(i+1).Sum()).Average())

इसे ऑनलाइन आज़माएं!

Answer 12

पायथन 3 , 72 बाइट्स

lambda x:[*filter((sum(-~a*b for a,b in enumerate(x))/len(x)).__gt__,x)]

इसे ऑनलाइन आज़माएं!

Comments

बहुत चतुर समाधान! मैंने कभी नहीं सोचा था filterकि सामान्य सूची की समझ पर जीत होगी।

— बजे मिस्टर एक्सकोडर

Answer 13

पायथन 3 , 76 बाइट्स

lambda x:[w for w in x if w<sum(u*v+v for u,v in enumerate(x[::-1]))/len(x)]

इनपुट और आउटपुट संख्याओं की सूची है। इसे ऑनलाइन आज़माएं!

यह पायथन 2 में भी काम करता है ( printपाद में वाक्य रचना के लिए स्पष्ट प्रतिस्थापन के साथ )।

Comments

क्या आपको सूची को उलटने की आवश्यकता है?

— आधिकारिक

@officialaimm मुझे ऐसा लगता है, क्योंकि गणन मान 1,2,3, ... x [0], x [-1], x [-2] के साथ जाना चाहिए। लेकिन सभी मामलों में परिणाम एक ही है, हम्म ...

— लुइस मेंडो

मुझे एक प्रतिश्रवण मिला, जो दिखाता है कि वास्तव में आवश्यक है

— लुइस मेंडो

आह, कोई बात नहीं .. मैंने सिर्फ इसलिए सोचा क्योंकि यह सभी परीक्षण मामलों को पारित कर दिया ...: पी

— आधिकारिक

Answer 14

पर्ल 6 , 31 बाइट्स

{.grep(flat([\,] $_).sum/$_>*)}

इसे ऑनलाइन आज़माएं!

Answer 15

पायथ - 10 बाइट्स

<#.OsM._QQ

इसे यहाँ ऑनलाइन आज़माएँ ।

Answer 16

पायथ, 12 11 बाइट्स

f<T.OsM._QQ

-1 बाइट श्री एक्सकोडर का धन्यवाद

इसे ऑनलाइन आज़माएं!

Comments

11 बाइट्स:f<T.OsM._QQ

— श्री एक्सकोडर

Answer 17

पर्ल 5 , 51 + 1 (-ए) = 52 बाइट्स

$a+=$_*(@F-$c++)for@F;for(@F){print$_,$"if$_<$a/@F}

इसे ऑनलाइन आज़माएं!

Answer 18

PHP, 84 बाइट्स

for($i=--$argc;$i;)$s+=$i--/$argc*$r[]=$argv[++$k];foreach($r as$x)$x<$s&&print$x._;

कमांड लाइन तर्कों से इनपुट लेता है। इसे ऑनलाइन चलाएं -nrया इसके लिए प्रयास करें ।

---

आंशिक सूचियों को सम्‍मिलित करें प्रत्येक तत्व को सम्‍मिलित करने के लिए निम्‍नलिखित तत्‍वों की संख्‍या +1 है → भारी सारणी वाले कार्यों के साथ जुगाड़ करने की कोई आवश्‍यकता नहीं है। यह अभी भी लंबा है, हालांकि।

Answer 19

रोड़ा , 46 41 39 बाइट्स

f l{l|[_]if[_1*#l<seq(1,#l)|l[:_]|sum]}

इसे ऑनलाइन आज़माएं!

Answer 20

जे, 15 बाइट्स

#~[<[:(+/%#)+/\

इसे ऑनलाइन आज़माएं! एक जे-स्टाइल ऐरे की अपेक्षा करता है ( रिक्त स्थान द्वारा अलग किए गए तत्वों के _बजाय उपयोग किए जाने वाले नकारात्मक -- उदाहरण के लिए टीआईओ लिंक देखें)।

मुझे नहीं पता कि क्या माध्य के आसपास कोष्ठक हटाने का कोई तरीका है (+/%# ) के लेकिन इसे हटाने और कैप पहली बात होगी जो मैं इसे आगे गोल्फ में करने की कोशिश करूंगा।

व्याख्या

कभी-कभी J अंग्रेजी (obfuscated) की तरह पढ़ता है।

#~ [ < [: (+/ % #) +/\
                   +/\  Sum prefixes
                     \   Get prefixes
                   +/    Sum each
          (+/ % #)      Mean
           +/            Sum of array
              %          Divided by
                #        Length of array
   [ <                  Input array is less than?
                         (gives boolean array of pairwise comparisons)
#~                      Filter by

Comments

आपने मुझे इसे 3 मिनट तक हरा दिया :)

— जोनाह

12 बाइट्स#~]<1#.+/\%#

— मील

@ मीलों जब तक आपको लगता है कि यह काफी समान है, मुझे लगता है कि आपकी टिप्पणी अपने स्वयं के उत्तर को वारंट कर सकती है। संपादित करें: मुझे लगता है कि यह अपने आप में बहुत चालाक है।

— Cole

Answer 21

आर , 31 बाइट्स

function(l)l[l<mean(cumsum(l))]

इसे ऑनलाइन आज़माएं!

Answer 22

गणितज्ञ, 35 बाइट्स

Cases[#,x_/;x<#.Range[#2,1,-1]/#2]&

Functionजो पहले तर्क के रूप में संख्या #की सूची और दूसरे तर्क के रूप में सूची की लंबाई की अपेक्षा करता है #2। #.Range[#2,1,-1]/#2इनपुट सूची #और सूची का डॉट उत्पाद लेता है Range[#2,1,-1] == {#2,#2-1,...,1}, फिर लंबाई से विभाजित होता है #2। फिर हम Cases x_इनपुट सूची में वापस आते हैं# हैं जो हाइपर-एवरेज से कम हैं।

दूसरे तर्क के रूप में लंबाई के बिना, हमें 6अधिक बाइट्स की आवश्यकता है :

Cases[#,x_/;x<#.Range[h=Tr[1^#],1,-1]/h]&

Answer 23

के (ओके) , 26 बाइट्स

समाधान:

x@&x<(+/+/'x@!:'1+!#x)%#x:

इसे ऑनलाइन आज़माएं!

उदाहरण:

> x@&x<(+/+/'x@!:'1+!#x)%#x:1 4 -3 10
1 4 -3
> x@&x<(+/+/'x@!:'1+!#x)%#x:-289.93 912.3 -819.39 1000
-289.93 -819.39

स्पष्टीकरण:

सही-से-बाएँ व्याख्या की गई। उपसर्ग निकालने के लिए एक छोटे तरीके के साथ संघर्ष:

x@&x<(+/+/'x@!:'1+!#x)%#x: / the solution
                        x: / store input in x, x:1 4 -3 10
                       #   / count, return length of x, #1 4 -3 10 => 4
     (               )     / do everything in the brackets together
                   #x      / count x
                  !        / til, range 0..x, !4 => 0 1 2 3
                1+         / add 1 vectorised, 1+0 1 2 3 => 1 2 3 4
             !:'           / til each, e.g. !1, !2, !3, !4
           x@              / index into x at these indices (now we have the prefixes)
        +/'                / sum (+ over) each, e.g. 1 5 2 12
      +/                   / sum over, e.g. 20
                      %    / right divided by left, 20%4 => 5 (now we have the hyper average)
   x<                      / boolean list where x less than 5
  &                        / indices where true, &0111b => 1 2 3
x@                         / index into x at these indices (now we have the filtered list)

टिप्पणियाँ:

पैरामीटर ( 25 बाइट समाधान) के रूप में इनपुट की लंबाई लेने वाला वैकल्पिक संस्करण :

> {x@&x<(+/+/'x@!:'1+!y)%y}[1 4 -3 10;4]
1 4 -3

Answer 24

टीआई-बेसिक, 9 बाइट्स

Ans*(Ans<mean(cumSum(Ans