क्या मैं एक गोल्फ की सरणी हूँ?


18

परिभाषा और नियम

एक गोल्फ सरणी पूर्णांक का एक सरणी है, जहां प्रत्येक तत्व पिछले सभी तत्वों के अंकगणितीय माध्य से अधिक या बराबर है । आपका कार्य यह निर्धारित करना है कि इनपुट के रूप में दिए गए सकारात्मक पूर्णांक की एक सरणी गोल्फ की है या नहीं।

परीक्षण के मामले और उदाहरण

उदाहरण के लिए निम्न सरणी:

[1, 4, 3, 8, 6]

एक गोल्फ ऐरे है, क्योंकि प्रत्येक शब्द इसके पूर्ववर्ती अंकगणित माध्य से अधिक है। चलो इसे चरण-दर-चरण काम करते हैं:

संख्या -> पूर्ववर्ती तत्व -> औसत -> नियम का पालन करता है?

1 -> [] -> 0.0 -> 1 True 0.0 (सच)
4 -> [1] -> 1.0 -> 4 True 1.0 (सच)
3 -> [1, 4] -> 2.5 -> 3 True 2.5 (सच)
8 -> [1, 4, 3] -> 2. (6) -> 8 6 2. (6) (सच)
6 -> [1, 4, 3, 8] -> 4.0 -> 6 True 4.0 (सच)

सभी तत्व स्थिति का सम्मान करते हैं, इस प्रकार यह एक गोल्फ की सरणी है। ध्यान दें कि इस चुनौती के उद्देश्य के लिए, हम मान लेंगे कि एक खाली सूची का औसत ( []) है 0

अधिक परीक्षण के मामले:

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

[३] -> सच
[२, १२] -> सच है
[१, ४, ३, 3, ६] -> सत्य
[१, २, ३, ४, ५] -> सत्य
[६, ६, ६, ६, ६] -> सत्य
[३, २] -> मिथ्या
[४, ५, ६, ४] -> असत्य
[४, २, १, ५, 1] -> मिथ्या
[४५, ४५, ४६, ४३] -> असत्य
[३२, ९, १५, १ ९, १०] -> असत्य

ध्यान दें कि यह है पहेली 1 से CodeGolf-Hackathon और भी पर पोस्ट किया जाता है अराजकता गोल्फ (है कि एक टूटी हुई है) - फिर से पोस्ट किया द्वारा histocrat , लेकिन मैं दोनों साइटों पर मूल लेखक हूँ, और इस प्रकार उन्हें यहाँ repost करने के लिए अनुमति दी।


क्या इनपुट हमेशा सकारात्मक पूर्णांक की सूची है?
केली लोल्डर

@ केलीलॉडर हाँ।
श्री एक्सकोडर

यह एक मजेदार समस्या है, मैं इसे और अधिक परीक्षण मामलों के साथ अराजकता गोल्फ पर फिर से लागू करने के बारे में सोच रहा था, लेकिन सोचा कि आप उस पर काम कर रहे होंगे।
हिस्टोक्रेट

@ हिस्टोक्रेट आगे बढ़ो और इसे अनार्की गोल्फ पर रिपॉजिट करो, मुझे उन चीजों के बारे में सोचना चाहिए जो पहले शोषित की जा सकती थीं। मुझे खुशी है कि आप इसे दिलचस्प पाते हैं (Btw कृपया मुझे यहाँ पिंग करें और एक लिंक दें यदि आप इसे रीपोस्ट करते हैं)।
श्री एक्सकोडर १।

3
@streetster वे समतुल्य हैं। Sum / i> x वही है जो Sum> xi के समान है Sum + x> x (i + 1) के समान है (Sum + x) / (i + 1)> x।
हिस्टोक्रेट

जवाबों:


13

पायथन 2 , 37 बाइट्स

def g(a):sum(a)>len(a)*a.pop()or g(a)

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

बाहर निकलने के कोड के माध्यम से आउटपुट: गोल्डी सरणियों के लिए क्रैश (बाहर निकलें कोड 1), गैर-गोल्फ सरणियों के लिए निकास कोड 0 से बाहर निकलता है। अंडा और जोनाथन फ्रेच ने 3 बाइट बचाए।

पायथन 2 , 44 बाइट्स

f=lambda a:a and sum(a)<=len(a)*a.pop()*f(a)

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

एक और पारंपरिक संस्करण, जो Trueकि गोल्फ ऐरे के लिए वापस आता है, और False। जोनाथन फ्रेच ने 2 बाइट बचाए।


1
मुझे लगता है कि a==[]orहो सकता है a and
जोनाथन फ्रेच

2
यह वास्तव में चालाक है - यह sum(a)<=len(a)*a.pop()*[]आधार मामले के लिए निकलता है , जो हमेशा की तरह सच है int < list!
लिन

3
39 बाइट्स एक फ़ंक्शन के रूप में जो सत्य इनपुट के लिए क्रैश हो जाता है।
२०

1
@ovs 37 एक आवश्यक फ़ंक्शन का उपयोग करके बाइट करता है।
जोनाथन फ्रीच

11

जेली , 6 5 बाइट्स

<ÆmƤE

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

यह काम किस प्रकार करता है

<ÆmƤE  Main link. Argument: A (integer array)

 ÆmƤ   Compute the arithmetic means (Æm) of all prefixes (Ƥ) of A.
<      Perform element-wise comparison. Note that the leftmost comparison always
       yields 0, as n is equal to the arithmetic mean of [n].
    E  Test if all elements of the resulting array are equal, which is true if and
       only if all comparisons yielded 0.

cairdcoinheringaahing 6-byter (वैकल्पिक):ÆmƤµ⁼Ṣ
मिस्टर एक्सकोडर

@ Mr.Xcoder गोल्फ!
डेनिस

वाह यह शानदार है :-)
श्री Xcoder

5

जावास्क्रिप्ट (ईएस 6), 33 32 बाइट्स

a=>a.some(e=>e*++i<(s+=e),s=i=0)

कोड जैसे नकारात्मक मूल्यों पर भी काम करता है [-3, -2]। अन्य सरणियों के falseलिए एक गोल्फ ऐरे के लिए रिटर्न true। संपादित करें: @JustinMariner के लिए 1 बाइट धन्यवाद सहेजा गया।


1
आप ड्रॉप कर सकते हैं !क्योंकि कल्पना केवल दो अलग-अलग मूल्यों के लिए पूछती है, इसलिए falseजब यह एक गोल्फ की सरणी ठीक हो तो वापस लौटना ।
जस्टिन मेरिनर

4

वोल्फ्राम भाषा (गणितज्ञ) , 35 बाइट्स

Max[Accumulate@#-Range@Tr[1^#]#]>0&

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

Falseगोल्फ सरणियों के लिए आउटपुट और Trueअन्यथा।


1
मैं देख रहा हूं कि झूठे / सच्चे रिश्ते को उलट दिया गया है, लेकिन यह ठीक है
केली लोल्डर

4

MATL , 9 8 बाइट्स

tYstf/<a

0गोल्फ सरणियों के लिए आउटपुट , 1अन्यथा।

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

व्याख्या

इनपुट पर विचार करें [1, 4, 3, 8, 6]

t    % Implicit input. Duplicate
     % STACK: [1, 4, 3, 8, 6], [1, 4, 3, 8, 6]
Ys   % Cumulative sum
     % STACK: [1, 4, 3, 8, 6], [1, 5, 8, 16, 22]
t    % Duplicate
     % STACK: [1, 4, 3, 8, 6], [1, 5, 8, 16, 22], [1, 5, 8, 16, 22]
f    % Find: indices of nonzeros. Gives [1, 2, ..., n], where n is input size
     % STACK: [1, 4, 3, 8, 6], [1, 5, 8, 16, 22], [1, 2, 3, 4, 5]
/    % Divide, element-wise
     % STACK: [1, 4, 3, 8, 6], [1, 2.5, 2.6667, 4, 4.4]
<    % Less than?, element-wise
     % STACK: [0, 0, 0, 0, 0]
a    % Any: true if and only there is some nonzero. Implicit display
     % STACK: 0

4

हास्केल , 53 50 48 बाइट्स

and.(z(<=).scanl1(+)<*>z(*)[1..].tail)
z=zipWith

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

संपादित करें: ज़र्ब के लिए -3 बाइट्स धन्यवाद!

व्याख्या

उपरोक्त बिंदु मुक्त संस्करण निम्नलिखित कार्यक्रम के बराबर है:

f s = and $ zipWith(<=) (scanl1(+)s) (zipWith(*)[1..](tail s))

एक इनपुट को देखते हुए s=[1,4,3,8,6], scanl1(+)sउपसर्ग राशि की गणना करता है [1,5,8,16,22]और zipWith(*)[1..](tail s)पहले तत्व को छोड़ता है और अन्य सभी तत्वों को उनके सूचकांक के साथ गुणा करता है [4,6,24,24]:। सूची अब गोल्फ की है यदि उपसर्ग उपसर्ग छोटे हैं या तत्वों समय सूचकांक के बराबर हैं, जिन्हें दोनों सूचियों के साथ ज़िप (<=)करके और जाँच कर देखा जा सकता है कि सभी परिणाम किसकेTrue साथ हैं and


1
आप इस तरह टाइप एरर से बच सकते हैं ।
ज़गारब

@Zgarb hindsight में यह स्पष्ट समाधान है। इशारा करने के लिए धन्यवाद!
लैकोनी

3

सी # (विजुअल सी # कंपाइलर) , 71 + 18 = 89 बाइट्स

x=>x.Select((n,i)=>new{n,i}).Skip(1).All(y=>x.Take(y.i).Average()<=y.n)

के लिए अतिरिक्त 18 बाइट्स using System.Linq;

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


2
साइट पर आपका स्वागत है! :)
डीजेमेकमेम

आमतौर पर, कोड गोल्फ में आयात विवरण को मुफ्त नहीं माना जाता है। क्योंकि यह कथन की आवश्यकता है using System.Linq;यह वास्तव में 89 बाइट्स होगा, कभी-कभी "71 + 18 = 89" के रूप में व्यक्त किया जाता है यह दिखाने के लिए कि 18 बाइट्स की आवश्यकता है, लेकिन समाधान का हिस्सा नहीं है, जबकि अभी भी अंतिम गिनती शीर्षक पंक्ति में अंतिम संख्या है ( जो कुछ स्वचालित पार्सर्स के लिए सहायक है)।
कामिल दकरी

3

APL (Dyalog) , 10 बाइट्स

यह एक अनाम टैसिट उपसर्ग फ़ंक्शन (एपीएल शब्दों में एक मोनडिक ट्रेन) है।

∧/⊢≥+⍳∘≢

TIO पर सभी परीक्षण मामलों की कोशिश करो!

क्या यह

∧/ सच है कि

 अवयव

 से अधिक या बराबर हैं

+\ संचयी रकम

÷ द्वारा विभाजित

   पूर्णांक 1 के माध्यम से

   the

   तत्वों की संख्या

?


एपीएल के लिए "द" का प्रतीक है ??
user2390246

1
@ user2390246 एक ही तरह से चीजों को एक साथ बांधता है "" "बिल्लियों को एक साथ बांधता है"। इसे वास्तव में कम्पोज कहा जाता है ।
आदम


3

05AB1E , 5 बाइट्स

ηÅA÷W

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

डेनिस और अदनान से व्यापक मदद इस कम किए गए संस्करण को मिली। इसके अलावा यह संभव बनाने के लिए एक बग तय किया गया था, फिर से धन्यवाद आप लोग। मैं इस जवाब के लिए बहुत कम श्रेय लेता हूं।


05AB1E , 10 बाइट्स

ηεÅA}ü.S_P

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


लंबे समय से क्योंकि DgsO/05AB1E में "माध्य" के बराबर है।

स्पष्ट रूप ÅAसे अंकगणितीय माध्य है।


साधनों की गणना करने के लिए, मैं +\÷Jजेली में (सूचकांकों द्वारा संचयी राशि को विभाजित) का उपयोग करूंगा । क्या यह आसान नहीं है 05AB1E में? संपादित करें: कोई बात नहीं।
डेनिस

@ डेनिस आह, 05AB1E में संचयी योग ü+तो वास्तव में सूचक gलंबाई के अलावा अन्य सूचकांकों द्वारा कोई डिवाई नहीं है, मतलब प्राप्त करने के Lलिए धक्का 1,2,...,nऔर विभाजित करने के लिए, जो अभी भी अनिवार्य रूप से 5 बाइट्स है।
मैजिक ऑक्टोपस यूरिन

.S_किसी के लिए जाने के लिए एक लंबा रास्ता है <=, अगर किसी को कोई विचार है lmk।
मैजिक ऑक्टोपस यूरिन

÷Wइसके बजाय काम करेंगे ü.S_P?
डेनिस

1
ओह, @ अदनान ने बस के वैश्वीकरण को तय किया ÅA, इसलिए ηÅA÷Wअब काम करता है।
डेनिस


2

पॉवरशेल , 60 बाइट्स

param($a)$o=1;$a|%{$o*=$_-ge($a[0..$i++]-join'+'|iex)/$i};$o

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

इनपुट को शाब्दिक सरणी (उदाहरण के लिए @(1, 4, 3, 8, 6)) के रूप में लेता है $a। सेट करने के लिए हमारे $oविवाद चर 1। फिर के माध्यम से छोरों $a। प्रत्येक पुनरावृत्ति, हम (एब) पावरशेल के अंतर्निहित कास्टिंग का उपयोग करके *=हमारे $oबर्तनों के खिलाफ बूलियन तुलना के परिणाम के लिए उपयोग कर रहे हैं । बूलियन है कि मौजूदा मूल्य है $_है -greater-से-या- eपिछले नियमों को qual $a[0..$i++]एक साथ जोड़ा ( -join'+'|iex) कितने शर्तों हम पहले से ही देखा है से विभाजित $i। इसलिए, अगर रास्ते में कोई भी कदम झूठा है, तो $oइससे गुणा हो जाएगा 0। अन्यथा, यह 1पूरे समय बना रहेगा ।

हम तो बस $oपाइपलाइन पर जगह और उत्पादन निहित है। सत्य के लिए 1और 0मिथ्या के लिए।



2

सी # (.NET कोर) , 74 बाइट्स

x=>{for(int i=1,s=0;i<x.Count;)if(x[i]<(s+=x[i-1])/i++)return 0;return 1;}

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

झूठे के लिए 0 और सच्चे के लिए 1 रिटर्न देता है।

3 chryslovelaces के कोर से बाइट्स जवाब । लेकिन कुल मिलाकर कई बाइट्स कम हैं क्योंकि मेरे वेरिएंट को किसी भी usingबयान की आवश्यकता नहीं है।


2

क्यूबिक्स , 35 बाइट्स

/I?/\+psu0^.\)*sqs;-\;;U;O1.....?@^

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

अंतरिक्ष का सबसे कुशल उपयोग नहीं (कोड में 6 ऑप्स) एक गोल्फ 1-ग्राउंड के लिए कोई आउटपुट नहीं, न कि गोल्फ-ग्राउंड सरणी के लिए।

निम्नलिखित घन के विस्तार:

      / I ?
      / \ +
      p s u
0 ^ . \ ) * s q s ; - \
; ; U ; O 1 . . . . . ?
@ ^ . . . . . . . . . .
      . . .
      . . .
      . . .

आगामी स्पष्टीकरण, लेकिन यह मूल रूप से लुइस मेंडो के MATL उत्तर या डेनिस जूलिया जवाब की तरह कुछ पोर्ट करता है ।

इसे देखो!


2

मतलाब और ऑक्टेव, 41 36 बाइट्स

5 बाइट्स ने लुक्स मेंडो को बचाया

all([a inf]>=[0 cumsum(a)./find(a)])

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


@LuisMendo अगर किसी भी तत्व का aशून्य हो तो उसे तोड़ देगा । लेकिन फिर भी समान परिस्थितियों में एक आसान चाल है, उस एक को ध्यान में रखना है।
लिएंडर मॉसिंजर

पढ़ना मुश्किल है! धन्यवाद!
लिएंडर मॉसिंजर

मेरे लिए हर समय होता है :-)
लुइस मेंडो

2

SQL (MySQL), 68 बाइट्स

select min(n>=(select ifnull(avg(n),1)from t s where s.i<t.i))from t

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

गोल्डी सरणियों के लिए 1 रिटर्न , और 0 अन्यथा। एक से इनपुट लेता नामित मेज , t। बनाने t, चलाने के लिए:

CREATE TABLE t(i SERIAL,n INT)

और मूल्यों को लोड करने के लिए:

truncate table t;insert into t(n)values(3),(2);


1

पायथन 2 , 52 बाइट्स

lambda A:all(k*j>=sum(A[:j])for j,k in enumerate(A))

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

पायथन 2 , 50 48 44 42 बाइट्स

  • टोलिंग और उपयोग करके दो बाइट्स को बचाया and
  • असाइनमेंट का पीछा करते हुए श्री Xcoder के लिए दो बाइट्स का धन्यवाद S=k=0
  • का उपयोग करके दो बाइट्स को बचाया orऔर तुलना के बूलियन मूल्य में kवृद्धि मूल्य के रूप में।
  • ओवन को धन्यवाद दो बाइट्स सहेजे ; के NameErrorबजाय एक अपरिभाषित चर का उपयोग करके बढ़ा ZeroDivisionError
S=k=0
for j in input():k+=S<=j*k or J;S+=j

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


आपके वैकल्पिक संस्करण के लिए 46 बाइट्स
श्री एक्सकोडर

@ Mr.Xcoder धन्यवाद।
जोनाथन फ्रेच


@ ओव्स थैंक्स; एक अपवाद को बढ़ाने के लिए स्वच्छ एक-बाइट तरीका है।
जोनाथन फ्रीच

1

क्यू / केडीबी + , १४ बाइट्स

समाधान:

min x>=avgs x:

उदाहरण:

q)min x>=avgs x:1 4 3 8 6
1b                           / truthy
q)min x>=avgs x:4 2 1 5 7
0b                           / falsey

स्पष्टीकरण:

avgsबिल्ट-इन के साथ काफी सरल :

min x>=avgs x: / solution
            x: / store input in variable x
       avgs    / calculate running averages
    x>=        / array comparison, x greater than running average
min            / take minimum of list of booleans


1

आर , 38 34 बाइट्स

function(x)any(cumsum(x)/seq(x)>x)

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


बहुत अच्छा। डननो क्यों पहले एक आर उत्तर नहीं था ...
Giuseppe

आप सभी मेरे लिए एक आसान बचत कर रहे थे।
एनसी

yफ़ंक्शन तर्कों में परिभाषित करने के बजाय , cumsum(x)सीधे 4 बाइट्स का उपयोग करना कम होता है। यह शर्म की cummeanबात नहीं है आधार आर में मौजूद नहीं है
Giuseppe

1

++ , 54 बाइट्स जोड़ें

D,g,@@#,BFB
D,k,@,¦+AbL/
D,f,@,dbLR$€g€k0b]$+ABcB]£>ª!

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

अपरंपरागत संस्करण, 30 बाइट्स

D,f,@,¬+AbLRBcB/@0@B]ABcB]£>ª!

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

दोनों गोल्फ एरे और 0 के लिए आउटपुट 1 अन्यथा

वे कैसे काम करते हैं

पहला संस्करण मेरे द्वारा बनाया गया था, बिना किसी अन्य समाधान की जाँच के। दूसरा डेनिस की टिप्पणी से प्रेरित था , इसलिए मैं इससे कम खुश हूं।

पहला संस्करण

यहाँ, हम अपने मुख्य कार्य को परिभाषित करते हैं यह हमारे इनपुट ऐरे की गुरुता की गणना करता है ,। सबसे पहले, हमें प्रत्यय की उपज चाहिए, जो पहले रेंज को जेनरेट करके किया जाता है बी: =[1,||], कहाँ पे || की लंबाई दर्शाता है । यह कोड के साथ किया जाता है dbLR$, जो छोड़ देता है[बी,]ढेर के रूप में। हम फिर डाइएडिक फ़ंक्शन को पुन: व्यवस्थित करते हैंजीइन दो सूचियों पर। रंगादिक होने के नाते, फ़ंक्शन इसके बाएं तर्क को बांधता हैप्रत्येक पुनरावृत्त तत्व के लिए। यह फिर सीमा पर पुनरावृत्त करता हैबी, जिसमें से प्रत्येक तत्व बी प्रदान किया जा रहा सही तर्क जीजी की तरह परिभाषित किया गया है

D,g,@@#,BFB

जो एक डाइएडिक फ़ंक्शन है (यानी लेता है 2तर्क), और #निष्पादन से पहले उल्टे क्रम ( ) में स्टैक के लिए अपने तर्कों को आगे बढ़ाता है । BFफिर दो तर्कों को समतल करता है। हम मान लेंगे कि तर्क हैं तथा एक्स। यह ढेर को छोड़ देता है[,], कहाँ पे एक सरणी स्प्लिट का प्रतिनिधित्व करता है । अंत में, Bपहली बार लेता है के तत्व और उन तत्वों से युक्त एक सूची देता है।

नोट : फ़ंक्शन नामजी तथा यादृच्छिक रूप से नहीं चुना जाता है। यदि किसी ऑपरेटर को दी गई कमांड (जैसे ) में वर्तमान में कोई फ़ंक्शन नहीं है (जो है gऔर kनहीं ), तो नामित फ़ंक्शन को मिलान फ़ंक्शन के लिए खोजा जाता है। यह बचाता है2बाइट्स, आम तौर पर फ़ंक्शन को {...}उपयोगकर्ता-परिभाषित फ़ंक्शन के रूप में पहचाने जाने के लिए लपेटना होगा । लेखन के समय, वर्तमान में अप्रयुक्त एकल बाइट आदेशों हैं I, K, U, Y, Z, g, k, l, uऔरw

कब जी एक सीमा के तत्वों पर लागू किया जाता है एक्स, इसके लिए उपसर्गों की सूची देता है । फिर हम अपने दूसरे हेल्पर फंक्शन को मैप करते हैं इनमें से प्रत्येक उपसर्ग पर। की तरह परिभाषित किया गया है

D,k,@,¦+AbL/

जो अंकगणितीय माध्य का मानक कार्यान्वयन है¦+तर्क की राशि की गणना करता है, AbLइसकी लंबाई की गणना /करता है , फिर लंबाई से योग को विभाजित करता है। यह प्रत्येक उपसर्ग के अंकगणितीय माध्य की गणना करता है, एक नया सरणी देता है,सी

दुर्भाग्य से, सी का मतलब होता है इसके अंतिम तत्व के रूप में, और खाली सूची का मतलब शामिल नहीं है, 0। इसलिए, हमें अंतिम तत्व को निकालना होगा, और प्रिपेंड करना होगा0, लेकिन पॉपिंग को छोड़ दिया जा सकता है, दो बाइट्स बचाते हुए, एक दूसरे में बताए गए कारणों के लिए। इसके बजाय, हम धक्का देते हैं[0] नीचे सीसाथ 0b]$, फिर जोड़ दो सरणियों एक नई सरणी बनाने,सी+

अब, हमें प्रत्येक तत्व को उसके संबंधित तत्व से कम होने के रूप में जांचना होगा । हम धक्का देते हैंएक बार फिर से और दो सरणियों को एक साथ जिप करें ABcB]। यही कारण है कि हमें अंतिम तत्व को पॉप करने की आवश्यकता नहीं है: Bcपायथन के zipफ़ंक्शन के साथ कार्यान्वित किया जाता है , जो सबसे छोटी सरणी की लंबाई को फिट करने के लिए लंबी सरणियों को काटता है। यहाँ, यह अंतिम तत्व को हटा देता हैसी+ जोड़े बनाते समय।

अंत में, हम starmap पी,क्षसी+;पी<क्ष¬(पीक्ष) प्रत्येक जोड़ी पर पी,क्ष सभी की एक सरणी प्राप्त करने के लिए 0अगर सरणी गोल्फ है, और सरणी कम से कम एक है 1यदि अन्यथा। हम फिर जाँचते हैं कि सभी तत्व गलत हैं अर्थात समान हैं0 साथ में ª!उस मान के और वापस लौटें।

दूसरा संस्करण

इसे हटाने के लिए डेनिस के दृष्टिकोण का लाभ लेता है 24बाइट्स, सहायक कार्यों को समाप्त करके। के हमारे इनपुट सरणी को देखते हुए, हम पहली बार संचयी योगों की गणना करते हैं ¬+, अर्थात से बनाई गई सरणी[0,0+1,0+1+2,,0++मैं]। फिर हम रेंज की गणना करके जेली के बराबर J( संकेत ) उत्पन्न करते हैंबी: =[1||] कहाँ पे || एक बार फिर से सरणी की लंबाई का मतलब है।

इसके बाद, हम प्रत्येक तत्व को विभाजित करते हैं में इसी सूचकांक द्वारा बीसाथ BcB/और prepend0के साथ @0@B]। यह एक नई सरणी में परिणाम करता है,सी+, के रूप में परिभाषित किया गया है

सी+: =[0,0,0+12,0+1+23,,0++मैंमैं+1]

अंतिम भाग पहले संस्करण के समान है: हम पुश और ज़िप करते हैं साथ में सी+, फिर प्रत्येक जोड़ी पर असमानता को जोर देकर कहें कि परिणामी सरणी में सभी तत्व मिथ्या थे।


0

अजगर , 11 10 बाइट्स

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

.A.egb.O<Q

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


7 बाइट्स: SI.OM._(एली द आउटगॉल्फ़र द्वारा जेली से केयर्डकोइनहेरिंगाहिंग के समाधान का पोर्ट), या आपके दृष्टिकोण का उपयोग करते हुए 10 बाइट्स:.A.egb.O<Q
श्री एक्सकोडर

पोर्ट को खुद के रूप में पोस्ट करें, यह पूरी तरह से अलग दृष्टिकोण है!
डेव

0

जावा (ओपनजेडके 8) , 96 बाइट्स

मुझे पता है कि यह एक अच्छी गोल्फिंग भाषा नहीं है, लेकिन मैंने फिर भी इसे दिया!

अल्पविराम के पहले तर्क के रूप में इनपुट सरणी, परीक्षण करने के लिए अलग-अलग ints।

सत्य के लिए १, झूठ के लिए ०।

a->{int i=1,j,r=1,s=0;for(;i<a.length;i++,s=0){for(j=0;j<i;s+=a[j++]);r=s/i>a[i]?0:r;}return r;}

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


0

जावा 7, 100 बाइट्स

golfed:

int g(int[]a){int i=1,m=0,s=m,r=1;for(;i<a.length;){s+=a[i-1];m=s/i;r-=a[i++]<m&&r>0?1:0;}return r;}

Ungolfed:

int golfy(int[]a)
{
    int i = 1, m = 0, s = m, r = 1;
    for (; i < a.length;)
    {
        s += a[i-1];
        m = s / i;
        r -= a[i++] < m && r>0? 1 : 0;
    }
    return r;
}

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

अनलॉगी के लिए 0 और गोल्फ के लिए 1 रिटर्न देता है। जावा 8 जवाब से थोड़ा लंबा।



0

जे, 19 बाइट्स

[:*/[>:[:}:0,+/\%#\

+/\ % #\उपसर्गों का औसत: #\1. का उत्पादन करता है

}:0, शुरुआत में 0 जोड़ें और अंतिम निकालें

[>: तत्व की मूल सूची तत्व है = औसत की स्थानांतरित सूची में =?

*/क्या सभी तत्व अधिक हैं, अर्थात, पिछली सूची सभी 1s है?

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



0

जाप , 10 बाइट्स

दो 10 बाइट समाधान के साथ आया था, उस पर सुधार करने के लिए प्रतीत नहीं कर सकते।

eȨU¯Y x÷Y

कोशिश करो


व्याख्या

               :Implicit input of array U
eÈ             :Is every element, at 0-based index Y
  ¨            :Greater than or equal to
   U¯Y         :U sliced from index 0 to index Y
        ÷Y     :Divide each element by Y
       x       :Reduce by addition

विकल्प

eÈ*°Y¨(T±X

कोशिश करो

               :Implicit input of array U
eÈ             :Is every element X (at 0-based index Y)
  *°Y          :Multiplied by Y incremented by 1
     ¨         :Greater than or equal to
      (T±X     :T (initially 0) incremented by X
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.