15

मानो या न मानो, सेक्स बॉब-ओम एक विश्व प्रसिद्ध बैंड बन गया है और वर्तमान में विश्व दौरे पर है! उनके मुनीम के रूप में आपको उनके दिन-प्रतिदिन के वित्त की देखरेख करनी चाहिए और नियमित रिपोर्ट प्रदान करनी चाहिए।

प्रत्येक कुछ सप्ताह में आप उनके खर्चों की सूची (संपूर्ण USD में ) उस क्रम में संकलित करते हैं जो वे खर्च किए गए थे।

उदाहरण के लिए, सूची

378
-95
2234

इसका मतलब है कि $ 378 उनके खाते में जमा किया गया था, और उसके बाद $ 95 वापस ले लिया गया था, और उसके बाद $ 2234 जमा किया गया था।

आप यह सुनिश्चित करना चाहते हैं कि इन मूल्यों का चल योग कभी भी कुछ सीमा मूल्य T से नीचे नहीं जाता है । आप यह करने के लिए एक कार्यक्रम लिखने का निर्णय लेते हैं।

चुनौती

एक प्रोग्राम या फ़ंक्शन लिखें जो एकल पूर्णांक T और पूर्णांकों की सूची में लेता है । यदि पूर्णांकों की सूची का रनिंग योग कभी T से कम है , तो एक गलत मान प्रिंट करें या वापस करें, अन्यथा एक सत्य मान प्रिंट या वापस करें।

आप किसी भी सामान्य इनपुट विधियों का उपयोग कर सकते हैं (फ़ाइल, कमांड लाइन, फ़ंक्शन के तर्क से स्टड)।

सूची की शुरुआत में रनिंग योग 0. है। तो एक सकारात्मक टी का मतलब है परिणाम हमेशा गलत है।
+ सकारात्मक पूर्णांक के सामने कभी नहीं होगा।
सूची में 0 हो सकते हैं।
सूची खाली हो सकती है।

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

इन सभी में T -5 है।

Falsy:

-6

200
-300
1000

Truthy:

[empty list]

-5

4
-3
-6

स्कोरिंग

सबसे कम बाइट्स के साथ सबमिशन जीत जाता है। टाईब्रेकर जल्द से जल्द प्रस्तुत करने के लिए जाता है।

^{खेदजनक टिप्पणी जिसने मुझे यह बनाने के लिए मजबूर किया।}

code-golf number array-manipulation

— केल्विन के शौक
स्रोत

1

टेस्ट केस में T = 5, L = [10] की जरूरत थी। शायद मैं पूरी तरह से चूक गया

— edc65

1

@ edc65 "सूची की शुरुआत में रनिंग योगा 0. है (इसलिए एक सकारात्मक T का अर्थ है परिणाम हमेशा गलत है।)"

— मार्टिन एंडर

@ दत्तक लेने वाला दुखी न हो, मुझे आपका संदर्भ मिला <3

— भूमिगत

@undergroundmonorail बहुत देर से। और वहां एक लिंक है।

— ऑप्टिमाइज़र

2

gs2 - 6 बाइट्स

मान लें कि सूची स्टैक के शीर्ष पर है, और दहलीज रजिस्टर ए में है।

inits
sum get-a lt filter3
not

बायटेकोड में:

78 64 D0 70 F2 22

— लिन
स्रोत

क्या यह वास्तव में फ़ंक्शन gs2 के बराबर है? असल में, क्या आप अपनी मान्यताओं को थोड़ा और सही ठहरा सकते हैं? (यदि आप करते हैं तो मैं इसे अवश्य स्वीकार करूँगा।)

— केल्विन के शौक

gs2 में वास्तव में फ़ंक्शंस नहीं हैं, लेकिन आप कुछ कोड को एक ब्लॉक में रख सकते हैं, इसे स्टैक के शीर्ष पर धकेल सकते हैं, और इस पर कॉल कर सकते हैं, जैसे कि GolfScript में। यदि आप इन छह बाइट्स को एक ब्लॉक में डालते हैं और मुझे बताई गई स्थिति में उन्हें बाहर निकालते हैं, तो स्टैक के ऊपर की सूची को उत्तर के साथ बदल दिया जाएगा (0 झूठे के लिए, 1 सच के लिए)। इसी तरह यदि आप इस कोड को कुछ कोड के साथ उपसर्ग करते हैं जो एक सूची को धक्का देता है और ए को पंजीकृत करने के लिए एक सीमा प्रदान करता है, तो आपको सही परिणाम मिलेगा।

— लिन

यह अन्य समाधानों की तरह ही काफी काम करता है। initsहास्केल की तरह है: "abcd" inits→ ["" "a" "ab" "abc" "abcd"]हमें सभी उपसर्ग मिलते हैं। फिर हम तीन आदेशों के एक "लैंबडा" के साथ फ़िल्टर करते हैं, जो कि __ __ __ F2बाइटकोड में है: हम उन सभी उपसर्गों की तलाश करते हैं जिनमें योग जो कुछ भी है उससे कम है A। फिर notनिर्धारित करता है कि सूची खाली है या नहीं।

— लिन

11

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

f t=all(>=t).scanl(+)0

उपयोग: f (-5) [4,-3,-6]जो आउटपुट True।

उप-योगों की एक सूची बनाएं और जांचें कि क्या सभी तत्व> = टी हैं।

संपादित करें: खाली सूची और सकारात्मक tएस के लिए बगफिक्स

— nimi
स्रोत

@ मार्टिनबटनर: प्रारंभिक 0सूची में नहीं है, क्योंकि scanl1खाली सूची के साथ खिलाए जाने पर खाली सूची लौटाती है, लेकिन allउस मामले को पकड़ लेती है। f (-5) []लौटता है True।

— 22

@ मार्टिनबटनर: उफ़, आप सही कह रहे हैं। उस मामले को याद किया और इसे ठीक किया। धन्यवाद!

— nimi

7

अजगर 2, 41

f=lambda a,t:t<=0<(a and f(a[1:],t-a[0]))

पहला तर्क सरणी है; दूसरा न्यूनतम चलने वाला कुल है।

— feersum
स्रोत

6

जे, 11 बाइट्स

   */@:<:0,+/\

टेस्ट

   _5 (*/@:<:0,+/\)  1 2 3 _20
0
   _5 (*/@:<:0,+/\)  >a: NB. empty list
1

1-बाइट सुधार FUZxxl के लिए धन्यवाद ।

मूल संस्करण के लिए स्पष्टीकरण (*/@(<:0,+/\))

+/\एक रनिंग योग ( +/उपसर्गों का योग \) बनाता है
0,+/\ चल रहे राशि के लिए एक 0 जोड़ता है
(<:0,+/\)बाईं ओर इनपुट छोटा या बराबर <:(के के तत्वों) से की परिणाम 0,+/\दाईं ओर इनपुट पर
@ पिछले परिणाम के साथ
*/ सभी तत्वों के उत्पाद (1 यदि सभी तत्व 1 हैं, 0 यदि कोई तत्व 0 है)

— randomra
स्रोत

*/@:<:0,+/\ मुझे लगता है कि आप एक चरित्र के लिए कर सकते हैं ।

— फ़ूजएक्सएक्सएल

6

एपीएल, 8 10

∧.≤∘(0,+\)

यह एक ऐसा फंक्शन है जो Tअपने लेफ्ट लॉजिक और लिस्ट को अपने राइट आर्ग्यूमेंट के रूप में लेता है।

0,+\: सही तर्क का योग, 0 में जोड़ा गया
∧.≤: बाएँ तर्क छोटे या बराबर (≤) सही तर्क में सभी (equal) आइटम की तुलना में

— मारीनस
स्रोत

मैंने यह भी कोशिश की लेकिन, "तो एक सकारात्मक टी का मतलब है परिणाम हमेशा गलत है।"

— jimmy23013

@ user23013: लानत है। खैर, यह अब तय हो गया है लेकिन यह नहीं जीतेगा।

— मारिनस

4

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

FreeQ[Accumulate@{0,##2},n_/;n<#]&

यह एक अनाम वैरिएबल फ़ंक्शन को परिभाषित करता है जो Tपहले पैरामीटर और शेष मापदंडों के रूप में लेनदेन को लेता है , और एक बूलियन देता है:

FreeQ[Accumulate@{0,##2},n_/;n<#]&[-5, 1, 2, 3, -20]
(* False *)

मुझे यह पसंद है क्योंकि मैं ##2सूची में दूसरे से सभी तर्कों के बजाय दुर्लभ " का उपयोग " कर सकता हूं । अधिक जानकारी के लिए इस गोल्फिंग टिप में अंतिम खंड देखें ।

— मार्टिन एंडर
स्रोत

4

k, 8 चार

पहले तर्क के रूप में दहलीज और दूसरी के रूप में सूची के रूप में एक रंग क्रिया। उल्लेखनीय रूप से, यह k के हर संस्करण में काम करता है, जिसमें ओपन-सोर्स कोना भी शामिल है।

&/~0<-\,

K में, फ़ंक्शंस की रचना केवल एक और फिर दूसरे को लिखकर की जाती है, इसलिए हम इसे फ़ंक्शन द्वारा तोड़ सकते हैं। दांये से बांये तक:

-\,क्रमिक रूप से चलने वाली रकम लेता है और उन्हें दहलीज से घटाता है। (यदि fडायडिक है, तो f\ (a; b; c; ...) विस्तार हो जाता है (a; a f b; (a f b) f c; ...)। ,बस सूचियों को एक साथ जोड़ देता है।) ब्रेकिंग तब भी होती है जब कुछ 0 के बराबर होता है, और ओवरड्राइविंग सख्ती से सकारात्मक मान देता है।
~0<0 से कम नहीं है। k वास्तव में अधिक से अधिक-या-समान-समान <=ऑपरेटर के पास नहीं है, इसलिए हमें बूलियन NOT को कम से कम पर फेंकना होगा, लेकिन यह परीक्षण इस बात के लिए है कि क्या परिणाम असंवेदनशील है। यह सूची में प्रत्येक परमाणु पर स्वचालित रूप से लागू होता है।
&/तार्किक और एक सूची पर गुना है। ( fडायडिक के लिए) इसलिए यह परीक्षण करता है कि सूची में प्रत्येक बूलियन सही है या नहीं।

उदाहरण:

  (&/~0<-\,)[-5; 1 2 3 -20]
0
  f:&/~0<-\,  /assign to a name
  f[-5; 4 -3 -6]
1

— algorithmshark
स्रोत

मैं शायद parantheses के लिए 2 आकर्षण जोड़ सकते हैं। और तुम अगर तुम क्या बंद 1 वर्ण दाढ़ी कर सकते हैं~|/>+\,

— tmartin

@tmartin Monadic >"अवरोही क्रम क्रमबद्धता" है, इसलिए ~|/>+\,यह तभी सत्य है जब इनपुट सूची रिक्त हो ...

— एल्गोरिथमशार्क

आह तुम सही हो, मेरी गलती है।

— tmartin

3

CJam, 17 बाइट्स

l~0\{1$+}%+\f<:+!

एक पूर्णांक के रूप में इनपुट लेता है और STDIN पर एक CJam- शैली सरणी:

-5 [1 2 3 -20]

इसका परीक्षण यहां करें।

— मार्टिन एंडर
स्रोत

3

अजगर, १६ १५

!sm>vzs+0<QdhlQ

इनपुट के साथ इसे ऑनलाइन आज़माएं

-5
[4, -3, 6]

स्पष्टीकरण:

                   Implicit: z and Q read 2 line from input
                   z = "-5" (this is not evaluated, it's a string)
                   Q = [4, -3, 6] (this is a list though)
 m         hlQ     map each number d in [0, 1, 2, ..., len(Q)] to:
  >vz                 the boolean value of: evaluated z > 
     s+0<Qd                                 the sum of the first d elements in Q 
!s                  print the boolen value of: 1 > sum(...)

और फिर से बेवकूफ sफ़ंक्शन दो बाइट्स को बर्बाद करता है। मुझे लगता है कि मैं इसे पायथ रेपो के बग के रूप में रिपोर्ट करने वाला हूं।

संपादित करें: 13 (मान्य नहीं)

एक बाइट बचा (के >1लिए !) के लिए sisaacg और पायथ रेपो में कार्यान्वयन को बदलने के लिए धन्यवाद। अब निम्नलिखित कोड संभव है (लेकिन निश्चित रूप से इस चुनौती के लिए मान्य नहीं है)।

!sm>vzs<QdhlQ

— Jakube
स्रोत

मैं अक्सर उनका उपयोग करता हूं। यहाँ देखें: codegolf.stackexchange.com/questions/45264/fill-in-the-blank// । यह इस मामले में 2 वर्णों को बचाएगा, लेकिन सूचियों के मामले की सूची में 5 वर्ण खो देगा। मैं देखता हूं कि क्या इन दोनों को अलग-अलग कार्यों में अलग करने के लिए अप्रयुक्त पत्र है, हालांकि। इसके अलावा, आप के !बजाय का उपयोग करके एक चरित्र को बचा सकता है >1।

— isaacg

@isaacg 0 (लगभग) के रूप में एक खाली सूची के योग को परिभाषित करना किसी भी मौजूदा पायथ कोड को नहीं तोड़ता है। एकमात्र कोड यह टूट जाएगा #sY। और 1 बाइट बचाने के लिए धन्यवाद।

— जक्यूब

मुझे लगता है कि यह उचित है - अपवादों को फेंकना किसी की मदद नहीं करता है। फिक्स्ड।

— 23

3

आर, 35

function(t,l)all(cumsum(c(0,l))>=t)

इसे यहाँ आज़माएँ

— MickyT
स्रोत

3

जूलिया, 33 बाइट्स

(T,l)->all(i->i>=T,cumsum([0,l]))

यह एक अनाम समारोह है कि दो पैरामीटर स्वीकार बनाता है, Tऔर l, और एक बूलियन देता है।

all()समारोह यहाँ सभी भारी उठाने का काम करता है। यह दो तर्क लेता है: एक विधेय और एक पुनरावृत्ति। विधेय के लिए, हम यह बताते हैं कि iएक अनाम फ़ंक्शन का उपयोग करके पुनरावृत्त के वर्तमान मूल्य का प्रतिनिधित्व करता है, द्वारा निर्दिष्ट i->। फिर प्रत्येक पुनरावृत्ति पर हम उपयोग iकरने की तुलना Tकरते हैं i>=T।

यह सुनिश्चित करने के लिए कि जूलिया cumsum()एक खाली सूची का उपयोग करने के बारे में गलत नहीं है , हम उपयोग करने पर एक शून्य से निपट सकते हैं [0, l]।

— एलेक्स ए।
स्रोत

3

प्रस्तावना , 144 136 बाइट्स

यह था ... कठिन ...

?
?(1- )v1+(1-
 ^    #       1) v #  -)1+(#
  v#         vv (##^v^+
   ^?+     v-(0## ^ #   01 #)(#)#
1         v#                  # )!

मुझे लगता है कि 6 आवाजें मेरे लिए एक नया रिकॉर्ड है, हालांकि मुझे यकीन है कि इसे कम करने और उस कष्टप्रद व्हाट्सएप से बहुत कुछ छुटकारा पाने का एक तरीका है। मान के चिह्न की जाँच करना (और इसलिए, जाँचना कि क्या एक मान दूसरे से अधिक है) Prelude में काफी पेचीदा है।

इनपुट और आउटपुट बाइट मान के रूप में दिया गया है। जब आप पायथन इंटरप्रेटर का उपयोग करते हैं , तो आप सेट कर सकते हैं NUMERIC_OUTPUT = True, ताकि आपको वास्तव में ASCII प्राप्त हो 0या 1। संख्यात्मक इनपुट के लिए, आपको एक और NUMERIC_INPUTध्वज जोड़ना होगा (मुझे कुछ बिंदु पर अपने tweaked दुभाषिया को प्रकाशित करना चाहिए)।

यह भी ध्यान दें कि प्रस्तावना वास्तव में किसी सूची के अंत को सूची के 0भीतर से अलग नहीं कर सकती है । तो शून्य लेनदेन की अनुमति देने के लिए, मैं पढ़ रहा हूं T, फिर Lसूची की लंबाई , और फिर Lलेनदेन।

— मार्टिन एंडर
स्रोत

2

सीजाम, 18 बाइट्स

अन्य बाइट्स में एक अन्य दृष्टिकोण।

q~_,),\f<1fb:)f<:&

के रूप में STDIN के माध्यम से इनपुट लेता है <threshold> <array of transactions>

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

— अनुकूलक
स्रोत

1

मुझे लगता है कि आप f>:|!इसके बजाय उपयोग कर सकते हैं:)f<:&

— एडित्सू छोड़ दें क्योंकि एसई ईवीआईएल मार 11'15

2

जावास्क्रिप्ट (ईएस 6) 38 33

निश्चित प्रारंभिक बैलेंस बग संपादित करें । Thx @martin & @rainbolt

F=(t,l)=>![r=0,...l].some(v=>(r+=v)<t)

फ़ायरफ़ॉक्स / फायरबग कंसोल में टेस्ट करें

console.log(F(-5,[-6]),F(-5,[1,2,3,-20]),F(-5,[200,-300,1000]))
console.log(F(-5,[]),F(-5,[-5]),F(-5,[4,-3,-6]))
console.log(F(5,[10]),F(5,[]))

झूठी झूठी झूठी
सच्ची सच्ची
झूठी झूठी

— edc65
स्रोत

2

प्रारंभिक संतुलन शून्य है। पहला डिपॉजिट 10 है, लेकिन हम पहले से ही हमारी सीमा से नीचे हैं, पहले डिपॉजिट कभी बैंक में करता है।

— रेनबोल्ट

2

पायथन 2.7 - 55 बाइट्स

f=lambda T,l:all(T<=sum(l[:i])for i in range(len(l)+1))

जैसे बुलाओ print f(-5,[1,2,3,-20])। इसका परीक्षण यहां करें ।

मदद करने के लिए जकुबे का शुक्रिया।

— Rainbolt
स्रोत

2

> <>, 29 + 3 = 32 बाइट्स

r0}&v >1n;n0<
&:&:<+^?=1l ^?(

दौड़ो ऐसे

py -3 fish.py bookkeep.fish -v -5 4 3 -6

जहां दहलीज पहला नंबर है।

— Sp3000
स्रोत

1

अष्टक, २,

@(t,l)all(cumsum([0,l])>=t)

— alephalpha
स्रोत

1

पर्ल 6 (21 बाइट्स)

{$^a>none [\+] 0,@^b}

यह प्रारंभिक तर्क लेने वाला एक कार्य है, और तत्वों की सूची है। यह जाँच करके काम करता है कि तत्वों में से कोई भी ( जंक्शनों का उपयोग करके ) थ्रेशोल्ड के नीचे है। [\+]उदाहरण देने के लिए, रनिंग योग बनाने के लिए उपयोग किया जाता [\+] 1, 2, 3है 1, 3, 6। 0,जोड़ने के लिए0 सूची की शुरुआत में, क्योंकि आवश्यकता है कि सकारात्मक दहलीज हमेशा असफल चाहिए की जरूरत है।

बहुत ही हस्केल समाधान के रूप में एक ही बात है, बस पर्ल 6 सिंटैक्स में (पर्ल 6 ने हॉसेल से बहुत साफ-सुथरी प्रोग्रामिंग विशेषताएं लीं)।

— कोनराड बोरोस्की
स्रोत

0

पर्ल - 20

STDINन्यूलाइन द्वारा अलग किए गए नंबरों की सूची लें और ध्वज के Tसाथ ले जाएं -i।

die if$^I>($i+=$_)

+2 -iऔर -nझंडे के लिए। निकास मान 255विफलताओं के लिए है और0 सफलता पर है।

साथ दौड़ो:

echo -e "4\n3\n-6" | perl -i0 -ne'die if$^I>($i+=$_)'

— hmatt1
स्रोत

0

लौंग, ४५

(fn[T t](every? #(<= T %)(reductions + 0 t)))

उदाहरण के लिए

((fn[T t](every? #(<= T %)(reductions + 0 t))) -5 [1 2 3 -20])
;; =>false

या एक लिल 'नेक;

(defn f[T t](every? #(<= T %)(reductions + 0 t)))

(testing
  (testing "tests from question"
    (is (false? (f -5 [-6])))
    (is (false? (f -5 [1 2 3 -20])))
    (is (false? (f -5 [200 -300 1000])))
    (is (true? (f -5 [-5])))
    (is (true? (f -5 [4 -3 -6])))
    (is (true? (f -5 []))))
  (testing "the start of the list the running sum is 0. So a positive T means the result is always falsy"
    (is (false? (f 5 [5])))
    (is (false? (f 5 [10])))
    (is (false? (f 5 [])))))

— cfrick
स्रोत

0

जावा 8 - 153 वर्ण

गोल्फ समारोह:

import java.util.stream.*;
boolean f(int t, IntStream s){int r=1;try{s.reduce(0,(a,b)->(a+b>=t)?(a+b):(a/(a-a)));}catch(Exception e){r=0;}return r==1;}

Ungolfed:

import java.util.stream.*;

boolean f(int t, IntStream s) {
    int r=1;
    try {
        s.reduce(0,(a,b) -> (a+b>=t) ? (a+b) : (a/(a-a)));
    } catch(Exception e) {
        r=0;
    }

    return r==1;
}

चालक कार्यक्रम:

import java.util.stream.*;
import java.util.*;

public class A {
    // function f as above

    public static void main(String... args) {
        int t = -5;
        IntStream s = null;

        s = Arrays.asList(-6).stream().mapToInt(i->i);
        System.out.println(new A().f(t,s));

        s = Arrays.asList(1,2,3,-20).stream().mapToInt(i->i);
        System.out.println(new A().f(t,s));

        s = Arrays.asList(200,-300,1000).stream().mapToInt(i->i);
        System.out.println(new A().f(t,s));

        System.out.println("above false, below true");

        s = IntStream.empty();
        System.out.println(new A().f(t,s));

        s = Arrays.asList(4,-3,-6).stream().mapToInt(i->i);
        System.out.println(new A().f(t,s));

        s = Arrays.asList(-5).stream().mapToInt(i->i);
        System.out.println(new A().f(t,s));
}

}

आउटपुट:

bash-3.2$ javac A.java ; java A

false
false
false
above false, below true
true
true
true

— माइकल ईस्टर
स्रोत

सेक्स बॉब-ओम्ब्स के लिए बहीखाता पद्धति (जांचें कि क्या एक चल योग कभी बहुत कम हो जाता है)

चुनौती

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

स्कोरिंग

gs2 - 6 बाइट्स

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

अजगर 2, 41

जे, 11 बाइट्स

एपीएल, 8 10

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

k, 8 चार

CJam, 17 बाइट्स

अजगर, १६ १५

स्पष्टीकरण:

संपादित करें: 13 (मान्य नहीं)

आर, 35

जूलिया, 33 बाइट्स

प्रस्तावना , 144 136 बाइट्स

सीजाम, 18 बाइट्स

जावास्क्रिप्ट (ईएस 6) 38 33

पायथन 2.7 - 55 बाइट्स

> <>, 29 + 3 = 32 बाइट्स

अष्टक, २,

पर्ल 6 (21 बाइट्स)

पर्ल - 20

लौंग, ४५

जावा 8 - 153 वर्ण