परिचय:

कुछ दिनों पहले मैंने इस पोस्ट को उसी शीर्षक के साथ पढ़ा था जब मैं HNQ में आया था। इस प्रश्न पर चर्चा की जा रही है यदि राष्ट्रपति-उम्मीदवार बर्नी सैंडर्स का दावा, जिन्होंने निम्नलिखित का दावा किया है:

आज दुनिया के सबसे अमीर 26 अरबपति, 26, अब ग्रह पर सबसे गरीब 3.8 अरब लोगों के रूप में, दुनिया की आधी आबादी के पास है।
^{वीडियो का लिंक}

सच है या नहीं। कृपया उत्तर और चर्चा के लिए स्वयं प्रश्न पर जाएँ।

इस दावे के आधार पर वास्तविक चुनौती के लिए:

चुनौती:

दो आदानों: एक अवरोही अनुसार क्रमबद्ध नंबर-सूची $L$ और एक नंबर $n$ (जहाँ है )। आउटपुट: की सबसे लंबी संभव प्रत्यय उप-सूची जिसके लिए कुल योग है सूची में पहले मानों का योग । $n$ $1\leq n\lt \text{length of }L$
$L$ $\leq$ $n$ $L$

उदाहरण:

इनपुट्स: = और । आउटपुट: $L$ [500,200,150,150,125,100,75,75,55,50,40,30,30,20,10,10,8,5,5,5,3,2,2,1,0,-2,-3] $n=2$
[125,100,75,75,55,50,40,30,30,20,10,10,8,5,5,5,3,2,2,1,0,-2,-3]

क्यूं कर?

सूची ( ) योग के पहले मान । यदि हम शेष संख्याओं के सभी प्रत्ययों और साथ ही उनके योगों को लेते हैं: $n=2$ $L$ [500,200]700

Suffix:                                                                  Sum:

[-3]                                                                     -3
[-2,-3]                                                                  -5
[0,-2,-3]                                                                -5
[1,0,-2,-3]                                                              -4
[2,1,0,-2,-3]                                                            -2
[2,2,1,0,-2,-3]                                                          0
[3,2,2,1,0,-2,-3]                                                        3
[5,3,2,2,1,0,-2,-3]                                                      8
[5,5,3,2,2,1,0,-2,-3]                                                    13
[5,5,5,3,2,2,1,0,-2,-3]                                                  18
[5,5,5,5,3,2,2,1,0,-2,-3]                                                23
[10,5,5,5,5,3,2,2,1,0,-2,-3]                                             33
[10,10,5,5,5,5,3,2,2,1,0,-2,-3]                                          43
[20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]                                       63
[30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]                                    93
[30,30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]                                 123
[40,30,30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]                              163
[50,40,30,30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]                           213
[55,50,40,30,30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]                        268
[75,55,50,40,30,30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]                     343
[75,75,55,50,40,30,30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]                  418
[100,75,75,55,50,40,30,30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]              518
[125,100,75,75,55,50,40,30,30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]          643
[150,125,100,75,75,55,50,40,30,30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]      793
[150,150,125,100,75,75,55,50,40,30,30,20,10,10,5,5,5,5,3,2,2,1,0,-2,-3]  943

सबसे लंबे समय तक प्रत्यय एक राशि से कम या बराबर है जो 700है [125,100,75,75,55,50,40,30,30,20,10,10,8,5,5,5,3,2,2,1,0,-2,-3]की राशि के साथ 643इतना है कि हमारे परिणाम है,।

चुनौती नियम:

पहले उपसर्ग में मान आउटपुट-प्रत्यय की ओर नहीं गिना जाता है। Ie इनपुट = और परिणाम होगा , और नहीं । $n$ $L$ [10,5,5,3] $n=2$ [5,3][5,5,3]
I / O लचीला है। आप को एक सूची / स्ट्रीम / सरणी ऑफ पूर्णांक / डेसीमल / स्ट्रिंग्स के रूप में इनपुट कर सकते हैं, एक एकल सीमांकित स्ट्रिंग, STDIN के माध्यम से एक-एक करके, आदि। आप एक सूची / पूर्णांक / दशमलव / स्ट्रिंग्स के सरणी / साथ ही साथ आउटपुट कर सकते हैं, आदि। एक सीमांकित स्ट्रिंग को प्रिंट / वापस करें, प्रत्येक न्यूलाइन पर एक नंबर प्रिंट करें, आदि आपका कॉल। $L$
आउटपुट गैर-रिक्त होने की गारंटी देता है। तो आपको = जैसे परीक्षण मामलों से निपटना नहीं पड़ेगा $L$ [-5,-10,-13] और में जिसके परिणामस्वरूप । $n=2$ []
यदि आप चुनते हैं तो दोनों या (या तो) इनपुट और / या आउटपुट अवरोही क्रम के बजाय आरोही क्रम में भी हो सकते हैं।

सामान्य नियम:

ये है कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव संक्षिप्त उत्तर के साथ आने का प्रयास करें।
आपके जवाब के लिए मानक नियम लागू होते हैं डिफ़ॉल्ट I / O नियमों के हैं , इसलिए आपको उचित पैरामीटर और रिटर्न-प्रकार, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति है। तुम्हारा कॉल।
डिफ़ॉल्ट कमियां निषिद्ध हैं।
यदि संभव हो तो, कृपया अपने कोड के लिए एक परीक्षण के साथ एक लिंक जोड़ें (यानी TIO ) के ।
साथ ही, आपके उत्तर के लिए स्पष्टीकरण जोड़ने की अत्यधिक अनुशंसा की जाती है।

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

Inputs: L=[500,200,150,150,125,100,75,75,55,50,40,30,30,20,10,10,8,5,5,5,3,2,2,1,0,-2,-3], n=2
Output: [125,100,75,75,55,50,40,30,30,20,10,10,8,5,5,5,3,2,2,1,0,-2,-3]

Inputs: L=[10,5,5,3], n=2
Output: [5,3]

Inputs: L=[7,2,1,-2,-4,-5,-10,-12], n=7
Output: [-12]

Inputs: L=[30,20,10,0,-10,-20,-30], n=1
Output: [20,10,0,-10,-20,-30]

Inputs: L=[100,35,25,15,5,5,5,5,5,5,5,5,5,5,5,5,5], n=1
Output: [15,5,5,5,5,5,5,5,5,5,5,5,5,5]

Inputs: L=[0,-5,-10,-15], n=2
Output: [-10,-15]

Inputs: L=[1000,999,998,900,800,766,525,525,400,340,120,110,80,77,33,12,0,-15,-45,-250], n=2
Output: [525,525,400,340,120,110,80,77,33,12,0,-15,-45,-250]

Inputs: L=[10,5,5], n=1
Output: [5,5]

code-golf number integer

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

क्या मैं एक उत्तर लिख सकता हूं जो केवल सकारात्मक के साथ काम करता है (या शायद गैर-सकारात्मक? मैंने इसे अभी तक नहीं लिखा है) पूर्णांक भाषा में पूर्णांक प्रकार की कमी के कारण पूर्णांक?

— नील

3

@ क्या मुझे लगता है कि आप रेटिना के बारे में बात कर रहे हैं? लेकिन यकीन है, आप मान सकते हैं कि सभी मामले उस मामले में गैर-नकारात्मक हैं। हालांकि, क्या आपके पास एक दूसरा संस्करण भी है जो नकारात्मक मूल्यों के लिए काम करता है, क्योंकि मुझे लगता है कि वास्तव में प्राप्त हो सकता है (बाइट-काउंट में भारी वृद्धि और कुछ काम के आसपास); जो वास्तविक तथ्य की तुलना में एक सामान्य भावना से अधिक है, यह सुनिश्चित नहीं है कि क्या वास्तव में काम करना संभव है - नकारात्मक मूल्यों के आसपास)।

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

6

असली परीक्षा का मामला इस तरह दिखेगा [131000000000, 96500000000, 82500000000, 76000000000, (7.7 billion more entries)]: p

— Arnauld

2

उस परिदृश्य के बारे में जहां कोई भी मानदंड मानदंडों को पूरा नहीं करता है: [1,2,3] n = 1? आप आउटपुट के लिए क्या चाहते हैं?

— उलफाक

@ouflak तीसरी चुनौती नियम देखें: " आउटपुट गैर-रिक्त होने की गारंटी है। इसलिए आपको परीक्षण मामलों से निपटना नहीं पड़ेगा जैसे कि L = [-5,-10,-13]औरn=2[] इसके परिणामस्वरूप । " इसके अलावा, इनपुट-सूची को अवरोही क्रमबद्ध होने की गारंटी है (या यदि आप चुनते हैं तो आरोही, इसलिए [1,2,3]शुरू करने के लिए एक वैध इनपुट-सूची नहीं है (जब तक आप आरोही इनपुट नहीं चुनते हैं, जिस स्थिति [1,2]में परिणाम होगा)।

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

17

सी # (विज़ुअल सी # इंटरएक्टिव कंपाइलर) , 88 81 69 68 63 बाइट्स

-4 बाइट्स के लिए धन्यवाद LiefdeWen

a=>b=>a.Skip(b).Where((x,i)=>a.Skip(i+b).Sum()<a.Take(b).Sum())

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

— समय सीमा समाप्त डेटा
स्रोत

मैं तुम्हें नष्ट करने से अधिक दो बंद दाढ़ी सकता है सोच रहा हूँ +bमें Skipकॉल; यह पहली nसूची की जांच करने के लिए बेमानी है , लेकिन मुझे लगता है कि यह अभी भी सही है।

— TheRubberDuck

3

@ TheRubberDuck नोप, इसे उस मामले के लिए जोड़ना था जहां उपसर्ग और प्रत्यय ओवरलैप होते हैं। Ie [१०,५,५,३], n = २

— डाटा

64 बाइट्स

— LiefdeWen

@LiefdeWen अच्छा है! यह वास्तव में बहुत कम है अगर हम एक curried फ़ंक्शन का उपयोग करते हैं

— समय सीमा समाप्त डेटा

@ExpiredData अरे हाँ, भूल गया कि मैंने इसे हटा दिया है।

— LiefdeWen

12

EXAPUNKS (2 EXAs, 30 निर्देश, 594-बाइट समाधान फ़ाइल)

मैं कुछ समय के लिए EXAPUNKS में एक कोड गोल्फ चुनौती का प्रयास करना चाहता था, और आप सबसे अच्छे लग रहे थे जो मुझे मिल सकता था, इसलिए, बधाई!

क्रमशः एल और एन के लिए फाइल 200 और 201 के माध्यम से इनपुट करें। एक नई फ़ाइल के माध्यम से आउटपुट। एल और आउटपुट आरोही क्रम में हैं।

मूल रूप से, XA, L में अंतिम n मान रखता है, फिर इसे XB को भेजता है। यह तब L की शुरुआत की तलाश करता है और XB को एक-एक मूल्य भेजता है। XB पहले XA से कुल प्राप्त करता है और इसे रजिस्टर X में संग्रहीत करता है। इसके बाद XA से एक-एक करके मान प्राप्त करता है, X से नया मान घटाता है, और उन मानों को X <0 तक आउटपुट फ़ाइल में लिखता है।

XA

GRAB 201
SUBI T F T
DROP
GRAB 200
SEEK 9999
SEEK T
MARK FIRST_SUM
ADDI F X X
ADDI T 1 T
SEEK -1
VOID F
TJMP FIRST_SUM
COPY X M
SEEK -9999
MARK SECOND_SUM
COPY F M
TEST EOF
FJMP SECOND_SUM
KILL

एक्सबी

MAKE
COPY M X
MARK LOOP
COPY M T
COPY T F
SUBI X T X
TEST X > 0
TJMP LOOP
SEEK -1
VOID F
KILL

यहाँ स्तर के लिए जावास्क्रिप्ट

— ymbirtt
स्रोत

IIRC समाधानों को बचाने का एक तरीका नहीं है? यदि ऐसा है तो आपको खेल निर्देशों के बजाय बाइट काउंट का उपयोग करना चाहिए।

— गेहूं जादूगर

1

@ SriotchilismO'Zaic, हाँ, मुझे नहीं लगता कि फ़ाइलों को आसानी से सुलभ माना जाता था, लेकिन मैंने उन्हें ढूंढ लिया है। मैं आकार-ऑन-डिस्क जोड़ दूंगा। मेटाडेटा का एक गुच्छा जो मैंने नहीं लिखा था, उसके साथ संग्रहीत हो जाता है, लेकिन मुझे लगता है कि यह वास्तव में इस गेम से एक सिंगल "बाइट काउंट" प्राप्त करने का सबसे अच्छा तरीका है।

— २०:५० पर ymbirtt

मुझे इन फाइलों को देखने के लिए समय निकालना पसंद है और देखना होगा कि क्या मेटाडाटा नीचे गोल्फ को सॉर्ट करने का एक तरीका है। मुझे यह भी आश्चर्य है कि अगर कुछ निर्देश दूसरों की तुलना में अधिक स्मृति लेते हैं।

— गेहूं जादूगर

@ SriotchilismO'Zaic, वे वास्तव में करते हैं। सभी निर्देश प्लेनटेक्स्ट के रूप में संग्रहीत किए जाते हैं, इसलिए एक शुरुआत के लिए हम सभी अक्षरों को एकल-अक्षर पहचानकर्ताओं में बदल सकते हैं। आपके समाधान का नाम वहां है, इसलिए हम समाधान 'a' कहकर कुछ बाइट्स निकाल सकते हैं। हालाँकि, यह कुछ भाग EXA के लिए आपके द्वारा बनाए गए वर्चुअल नेटवर्क से संबंधित है। ईमानदारी से, मुझे लगता है कि EXAPUNKS समाधान स्कोर करने के लिए "उचित" तरीका या तो वास्तविक कोड की बाइट गिनती का उपयोग करना है, या निर्देशों की संख्या। यह एक मेटा पोस्ट के लायक हो सकता है ...

— ymbirtt

2

@ymbirtt मैं मान लेता हूं कि प्रश्न नीचे आया है तो क्या आप एक दुभाषिया लिख सकते हैं जो निर्देशों को देखेगा और सहेजे गए डेटा में परिवर्तित होगा? अच्छी तरह से, हाँ, बस एक प्रोग्राम लिखें जो आपके लिए स्रोत से इनपुट करे .. यह एक अलग भाषा के रूप में गिना जाएगा।

— डेटा

11

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

l,n=input()
s=sum(l[:n])
while sum(l[n:])>s:n+=1
print l[n:]

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

स्पष्टीकरण:

पहले पहले nवस्तुओं का योग लेता है ।

फिर प्रत्येक राशि के योग की तुलना इस राशि से की जाती है। जैसे ही कोई बड़ा नहीं होता, हम रुक जाते हैं।

फिर परिणामस्वरूप (सबसे लंबा) सबलिस्ट मुद्रित होता है।

— TFeld
स्रोत

2

वास्तव में सबसे पठनीय एक +1

— Kryštof heháček

10

05AB1E , 14 12 बाइट्स

2 बाइट्स ग्रिम के लिए धन्यवाद बचा लिया

.$ΔDOI¹£O›.$

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

व्याख्या

.$               # drop the first n entries of the list
  Δ              # repeat the following code until the result doesn't change
   DO            # duplicate and sum the copy
     I¹£O        # calculate the sum of the first n items of the input
         ›.$     # if the current sum is greater than the sum of the first n items
                 # remove the first item of the current list

— Emigna
स्रोत

2

'बिल्कुल' वही है जो मैंने समाधान के रूप में तैयार किया था। और 'बिल्कुल' से मेरा मतलब है मेरा था .$.sʒO²¹£O>‹}θ। :)

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

2

@KevinCruijssen यहाँ 12 है

— ग्रिमी

1

ASCII- केवल 12 (एक अलग इनपुट विधि का उपयोग करके)।

— जूल

1

@ जिमी: हुह। मैं कभी नहीं पता था कि |अधिलेखित कर दिया last-input, दिलचस्प।

— एमिगा जूल

2

@Grimy: देखें इस बनाम यह । आम तौर पर जब सभी इनपुट का उपभोग किया जाता है, तो अंतिम इनपुट का उपयोग अगले इनपुट के सभी उदाहरणों के लिए किया जाता है। |यहां उपयोग |करने से अंतिम इनपुट के बजाय अंतिम इनपुट बन जाता है।

— एमिगा जूल

7

जे , 18 बाइट्स

}.#~+/@{.>:+/\.@}.

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

स्पष्टीकरण:

एक डाईएडिक क्रिया, nइसके बाएं तर्क के Lरूप में और - इसके सही तर्क के रूप में।

                }.  drop the first n items from L 
               @    and
             \.     for each suffix (starting from the longest)
           +/       find its sum
         >.         is this sum smaller or equal than (results in a boolean vector)
    +/              the sum 
      @             of
       {.           the first n items of L
  #~                use the 1s in the boolean vector to copy the respective
}.                  elements of L (without the first n)

— गैलेन इवानोव
स्रोत

7

रूबी , 47 43 बाइट्स

$n$

-4 बाइट्स कल्पना को अधिक बारीकी से पढ़कर।

->a,n{s=a.pop(n).sum;a.pop while a.sum>s;a}

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

— मूल्य स्याही
स्रोत

7

आर , 53 55 बाइट्स

@Giuseppe ने मुझे 2 बाइट्स को हटाने के तरीके को बदलने से बचाया

function(n,L,Y=rev(L[0:-n]))Y[cumsum(Y)<=sum(L[1:n])]

इसे ऑनलाइन आज़माएं! अवरोही के रूप में इनपुट लेता है और नियम 4 के अनुसार आरोही में आउटपुट करता है।

Yका राजस्व है L1 साथ: n का उपयोग करके हटाया0:-n
से रिटर्न Yजहां संचयी योग से कम है की राशि के बराबरL[X]

— MickyT
स्रोत

@Giuseppe हमेशा की तरह धन्यवाद। Xउपयोग को हटाने की कोशिश की -(1:n)लेकिन निश्चित रूप से वही आकार था, इसलिए इसे छोड़ दिया

— मिकी जूल

6

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

(a)(n)आरोही क्रम में सूची के साथ इनपुट लेता है ।

a=>n=>(g=s=>n?g(s+a.pop(n--)):eval(a.join`+`)>s?g(s,a.pop()):a)(0)

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

टिप्पणी की गई

a => n =>               // a[] = list, n = number of richest guys
  ( g = s =>            // g is a recursive function taking a sum s
    n ?                 // if n is not equal to 0:
      g(s + a.pop(n--)) //   recursive call: add the last entry to s and decrement n
    :                   // else:
      eval(a.join`+`)   //   if the sum of the remaining entries
      > s ?             //   is greater than s:
        g(s, a.pop())   //     recursive call with the last entry removed
      :                 //   else:
        a               //     stop recursion and return a[]
  )(0)                  // initial call to g with s = 0

— Arnauld
स्रोत

1

@ केविनक्रूजसेन लगता है जैसे मैंने आवश्यकता को गलत बताया। अब तय होना चाहिए।

— अरनुलद

\leq

$\leq$

5

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

पायथन 3 के साथ भी संगत

f=lambda l,n:l[n:]*(sum(l)/2>=l.pop(n)+sum(l[n:]))or f(l,n)

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

व्याख्या

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

— Jitse
स्रोत

4

पायथ , 16 15 बाइट्स

efgs>vzQsT._<vz

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

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

यह कई बार ऐसा होता है जब मैं चाहता हूं कि पाइथ के पास एक से अधिक बार एक्सेस करने के लिए एक एकल टोकन ऑपरेटर था ( Eइनपुट की अगली पंक्ति का मूल्यांकन करता है, लेकिन बार-बार कॉल पिछले मूल्य पढ़ने को छोड़ देता है)।

efgs>vzQsT._<vzQ   Implicit: Q=eval(input()), z=input() - that is, Q is list, z is string n
                   Trailing Q inferred
             vz    Evaluate z as integer
            <  Q   Remove the above number of elements from the end of Q
          ._       Generate a list of all prefixes of the above
 f                 Filter keep elements of the above, as T, where:
    >vzQ             Take the last z elements of Q
   s                 Sum
  g                  Is the above greater than or equal to...
        sT           ... the sum of T?
e                  Take the last remaining element, implicit print

संपादित करें: MrXcoder के लिए 1 बाइट का धन्यवाद सहेजा गया

— सोक
स्रोत

@ Mr.Xcoder अच्छा दु: ख, क्या एक स्पष्ट बचाने के लिए! धन्यवाद Thanks

— सोक

4

जावास्क्रिप्ट, 64 बाइट्स

f=(a,n,s=0,[h,...t]=a)=>n<1?f(a)>s?f(t,0,s):a:1/h?f(t,n-1,s+h):s

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

f=(
  a,               // remaining array
  n,               // if n >= 0: we try to find suffix <= s + a[0..n]
                   // if n is NaN (or undefined): we calculate sum(a) + s
  s = 0,           // previous sum
  [h, ...t] = a    // split array (a) into head (h) and tail (t)
) => (n < 1 ?      // if n == 0
  f(a) > s ?       //   if sum(a) > s
    f(t,0,s) :     //     drop head and test tail again
    a :            //   otherwise, a is the answer
  1 / h ?          // if a is not empty
    f(t,n-1,s+h) : //   add head to sum and recurse
    s              //   we only reach here if n is NaN, return the sum
)

— TSH
स्रोत

4

स्टैक्स , 12 बाइट्स

îo╧╫Σ↑>'qµΣº

भागो और इसे staxlang.xyz पर डीबग करें!

अच्छे संस्करण

अनपैक्ड (14 बाइट्स) और स्पष्टीकरण:

:/|]{|+n|+>!}j
:/                Split array at index.
  |]              Suffixes. The bit after the split (the poor) is on top for this.
    {       }j    First item in array that yields truthy under the block:
     |+             Sum array (collective wealth of the many).
       n            Copy second item to top of stack.
        |+          Sum again. Wasted computation, but this location saves a byte.
          >!        Second item on stack less than or equal to first?

तक आम सहमति , मैं ढेर में इस परिणाम को छोड़ सकते हैं। Stax एक अंतर्निहित प्रिंट का प्रयास करेगा, जो विफल हो सकता है, लेकिन एक mअनपैक किए गए प्रोग्राम में संलग्न होने से आप आउटपुट को अच्छी तरह से देख सकते हैं।

जैसा दिखता { ... }jहै वैसा ही होता है { ... fh। हुह। संपादित करें: यह काफी मामला नहीं है; सत्य परिणाम प्राप्त होने पर एकमात्र पूर्व बंद हो जाएगा, संभवतः दुष्प्रभावों से बचने या बाद में एक घातक त्रुटि।

— खुल्द्रेसथ न’बैरी
स्रोत

3

एपीएल + विन, 27 बाइट्स

L के इनपुट के लिए संकेत तब n।

⌽((+/n↑v)≥+\m)/m←⌽(n←⎕)↓v←⎕

इसे ऑनलाइन आज़माएं! दरोगल क्लासिक के सौजन्य से

— ग्राहम
स्रोत

3

जाप , 16 बाइट्स

£sV+YÃæ_x §U¯V x

कोशिश करो

£sV+YÃæ_x §U¯V x     :Implicit input of U=L and V=n
£                    :Map U, with Y being the 0-based indices
 sV+Y                :  Slice U from index V+Y
     Ã               :End map
      æ              :First element that returns true
       _             :When passed through the following function
        x            :  Reduce by addition
          §          :  Less than or equal to
           U¯V       :    Slice U to index V
               x     :    Reduce by addition

— झबरा
स्रोत

3

जेली , 13 12 बाइट्स

ṫḊÐƤS>¥ÞḣS¥Ḣ

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

एक बाइट को बचाने के लिए @JonathanAllan को धन्यवाद!

$L$ $n$

व्याख्या

ṫ            | Tail: take all values of L from the nth onwards (which is actually one too many; dealt with below)
 ḊÐƤ         | Take all suffixes, removing the first value from each. This will yield a list of all possible suffixes of L that exclude the first n values
       Þ     | Sort by:
    S>¥ ḣS¥  | - The sum is greater than the sum of the first n values of L
           Ḣ | Take the first resulting list and return from link (implicitly output when called as a full program)

— निक केनेडी
स्रोत

आप फ़िल्टर करने के बजाय छँटाई करके एक बाइट बचा सकते हैं:ṫḊÐƤS>¥ÞḣS¥Ḣ

— जोनाथन एलन

3

गैया , 12 बाइट्स

eSe¤Σ¤┅⟪Σ⊃⟫∇

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

मुझे लगता है कि अगर मैं स्टैक सही हूं तो मुझे बाइट मिल सकती है।

e	| eval first input as Gaia code
S	| Split into a list of ["first n elements" "rest of elements"]
e	| dump onto stack
¤Σ	| swap and take the sum (sum of first n elements)
¤┅	| swap and take suffixes
⟪  ⟫∇	| return the first element of suffixes where:
 Σ⊃	| the sum(first n elements) ≥ sum(suffix)

— ग्यूसेप
स्रोत

3

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

यह कैसा लग रहा है से नाराज; उम्मीद है कि मुझे कुछ स्पष्ट गोल्फ याद आ रहे हैं।

n#l=until(((sum$take n l)>=).sum)tail$drop n l

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

मैंने उपसर्ग और प्रत्यय प्राप्त करने की कोशिश की और splitAtएक गार्ड में पैटर्न का मिलान किया, लेकिन यह 3 बाइट्स निकला। बाद में यह देखने के लिए कि क्या बाइट की संख्या कम है, गार्ड के साथ एक पुनरावर्ती समारोह में बदलने की कोशिश कर रहा है।

व्याख्या

n # l = until (((sum $ take n l) >= ) . sum) tail $ drop n l
n # l =                                                        -- define infix operator
n                                                              --  the number of elements
    l                                                          --  the list
        until                                                  -- until
                                        sum                    --  the sum of the suffix
               ((sum $ take n l) >=)                           --  is <= the sum of the prefix
                                             tail              --  remove the first element
                                                    drop n l   -- the suffix

मैं "उपसर्ग" के रूप में संदर्भित करता हूं पहला nतत्व है और "प्रत्यय" बाकी की सूची है।

— गोभी
स्रोत

3

एपीएल (डायलॉग यूनिकोड) , २३ २१ बाइट्स ^{एसबीसीएस}

$n$ $L$

{⍵↓⍨⍺⌈⊥⍨(+/⍺↑⍵)<+\⌽⍵}

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

{} $n$ ⍺ $L$ ⍵ (दायीं ग्रीक अक्षर):

⌽⍵ $L$

+\ उस के उपसर्ग रकम

(...)< बूलियन मास्क जहां से कम:

⍺↑⍵ $n$ $L$

+/ उन राशि

⊥⍨ अनुगामी सत्य की गिनती करें

⍺⌈ की अधिकतम $n$ और वह

⍵↓⍨ के सामने से कई तत्वों को गिराएं $L$

— एडम
स्रोत

1

@KevinCruijssen अच्छी तरह से देखा। फिक्स्ड।

— एडम जूल

3

MATL , 13 12 बाइट्स

1 बाइट के लिए धन्यवाद बचाया @Giuseppe , द्वारा उत्तर के आधार पर @MickyT ।

:&)PtYsbs>~)

आउटपुट आरोही क्रम में है।

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

व्याख्या

आदानों पर विचार करें 2और [500,200,150,150,125,100,75,75,55,50,40,30,30,20,10,10,8,5,5,5,3,2,2,1,0,-2,-3]।

:      % Implicit input: n. Push [1 2 ... n]
       % STACK: [1 2]
&)     % Implicit input: array. Two-output indexing: pushes the subarray
       % indexed by [1 2 ... n] and the remaining subarray
       % STACK: [500 200], [150 150 125 ... -2 -3]
P      % Flip
       % STACK: [500 200], [-3 -2 ... 125 150 150]
t      % Duplicate top of the stack
       % STACK: [500 200], [-3 -2 ... 125 150 150], [-3 -2 ... 125 150 150]
Ys     % Cumulative sum
       % STACK: [500 200], [-3 -2 ... 125 150 150], [-3 -5 ...646 796 946]
b      % Bubble up in the stack
       % STACK: [-3 -2 ... 125 150 150], [-3 -5 ...646 796 946], [500 200]
s      % Sum
       % STACK: [-3 -2 ... 125 150 150], [-3 -5 ...646 796 946], 7
>~     % Greater than, negate; element-wise
       % STACK: [-3 -2 ... 125 150 150], [1 1 ... 1 0 0]
)      % Index. Implicit display
       % STACK: [-3 -2 ... 125]

— लुइस मेंडो
स्रोत

3

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

param($n,$l)do{$a+=$l[$i++]}until($a-gt($l[-1..-$n]-join'+'|iex)-or$i-gt$l.count-$n)$l[($i-2)..0]

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

आरोही क्रम में सूची लेता है, आउटपुट घट रहा है (क्योंकि परीक्षण मामलों की तुलना करना आसान था: ^)

सूची में ~~पीछे की ओर से~~ आगे की ओर जाता है , संचायक की पिछली nप्रविष्टियों की तुलना एक साथ जोड़कर (उन्हें gluing के साथ +s और परिणामी स्ट्रिंग को पास करते हुए invoke-expression) करता है। जब तक लूप को रिच नेबरहुड में जाने के लिए अतिरिक्त तर्क की आवश्यकता होती है क्योंकि यह तब तक नहीं रुकेगा जब तक कि हम पूरी सूची के माध्यम से मंथन न कर लें, तब तक हम अमीर लोगों की तुलना में अधिक अमीर नहीं होंगे।

unrolled:

param($n,$list)
do{
  $acc+=$list[$i++]
}until($acc -gt ($list[-1..-$n] -join '+'|invoke-expression) -or ($i -eq $list.count-$n))
$list[($i-2)..0]

— Veskah
स्रोत

3

रेटिना 0.8.2 , 99 बाइट्स

\d+
$*
^
;,
+`;,(1+)(,.*)1$
$1;$2
,
;$'¶$`,
;.*(;.*)
$1$1
T`,`_`.*;
1G`(1+);\1;
.*;

(1*),
$.1,
,$

इसे ऑनलाइन आज़माएं! लिंक में केवल कुछ परीक्षण मामले शामिल हैं; मैं इसे 12 बाइट्स की लागत पर नकारात्मक संख्याओं के साथ कुछ मामलों में काम करने के लिए प्राप्त कर सकता हूं (विशेष रूप से अभी भी सकारात्मक होने के लिए पहली nप्रविष्टियां L; सैद्धांतिक रूप से मैं शायद केवल पहली nप्रविष्टियों के सकारात्मक होने की आवश्यकता हो सकती है)। स्पष्टीकरण:

\d+
$*

यूनीरी में बदलें।

^
;,

की शुरुआत में एक मार्कर डालें L।

+`;,(1+)(,.*)1$
$1;$2

सूची के nसमय इसे नीचे ले जाएँ , जैसा कि हम जाते हैं। यह नष्ट हो जाता है nलेकिन इसका अल्पविराम बना रहता है।

,
;$'¶$`,

प्रत्येक प्रत्यय के लिए एक प्रविष्टि बनाएँ L।

;.*(;.*)
$1$1

प्रत्यय की एक प्रति के साथ बीच की जगह।

T`,`_`.*;

प्रत्यय की प्रति।

1G`(1+);\1;

पहली प्रविष्टि लें जहां प्रत्यय राशि उपसर्ग योग से अधिक नहीं है।

.*;

रकम हटाओ।

(1*),
$.1,

दशमलव में परिवर्तित करें।

.,$

इससे पहले आए ट्रेलिंग कॉमा को हटाएं n।

— नील
स्रोत

n

$n$

1

@KevinCruijssen मेरा नकारात्मक नंबर संस्करण निषेधात्मक रूप से धीमा हो गया, लेकिन मैं rविकल्प का उपयोग करके इसे ठीक करने में कामयाब रहा , इसलिए मैंने अब इसे कुछ परीक्षण मामलों के साथ जोड़ा है।

— 22

2

चारकोल , 17 बाइट्स

ＩΦθ¬∨‹κη‹Σ…θηΣ✂θκ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

  θ                 Input `L`
 Φ ¬                Filter out elements where
      κ             Current index
     ‹              Is less than
       η            Input `n`
    ∨               Logical Or
           θ        Input `L`
          … η       First `n` terms
         Σ          Summed
        ‹           Is less than
              ✂θκ   Remainder of `L`
             Σ      Summed
Ｉ                   Cast to string
                    Implicitly print on separate lines

— नील
स्रोत

2

लाल , 63 बाइट्स

func[L n][s: sum take/part L n forall L[if s >= sum L[break]]L]

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

— गैलेन इवानोव
स्रोत

2

शक्ति कोशिका , 86 बाइट्स

param($n,$l)$l|?{$k++-ge$n}|?{(&{$l|%{$s+=($_,0,-$_)[($n-le$i)+(++$i-ge$k)]};$s})-ge0}

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

unrolled:

param($n,$list)
$list|?{$k++-ge$n}|?{                               # tail elements after $n only
    $sumLeftSegmentMinusSumRightSgement = &{        # calc in a new scope to reinit variables $s, $i
        $l|%{$s+=($_,0,-$_)[($n-le$i)+(++$i-ge$k)]} # sum(list[0..n-1]) - sum(list[k-1..list.Count-1])
        $s                                          # output sum to the outer scope
    }
    $sumLeftSegmentMinusSumRightSgement -ge 0       # output elements where sum >= 0
}

— Mazzy
स्रोत

2

मैथॉल्फ , 13 बाइट्स

(‼≥≤Σ\æ╞`Σ≥▼Þ

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

व्याख्या

के रूप में इनपुट लेता है n L

(               pops n and decrements (TOS is n-1)
 ‼              apply next two operators to stack simultaneously
  ≥             slice L[n-1:] (gets all elements with index >= n-1)
   ≤            slice L[:n] (gets all elements with index <= n-1)
    Σ           get sum of topmost list (this is the sum of n largest elements)
     \          swap top elements
      æ    ▼    do while false with pop using block of length 4
       ╞        discard from left of string/array
        `       duplicate the top two items on the stack
         Σ      sum the list which is on top
          ≥     is the sum of the partial list >= the desired sum?
            Þ   discard everything but TOS

यह काम करने का कारण यह है कि पहले चरण में, हम वास्तव में सूची को दो अतिव्यापी भागों में विभाजित करते हैं। एक उदाहरण के रूप में, के L = [4, 3, 2, 1], n = 2रूप में सूची को विभाजित करेगा [3, 2, 1]और [4, 3]। पहली सूची में एक अतिरिक्त तत्व होने का कारण यह है कि लूप में, पहली चीज जो होती है वह एक त्याग है। यदि एक अतिरिक्त तत्व तैयार नहीं किया गया था, तो ऐसे मामले जहां आउटपुट शेष सूची में होना चाहिए, विफल हो जाएगा।

— maxb
स्रोत

2

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

Drop@##//.{a_,b__}/;a+b>Tr@Take@##:>{b}&

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

Drop@##                     (*don't include the first n values*)
 //.{a_,b__}/;a+b>Tr@Take@##(*while the remaining values sum to greater than the sum of the first n*)
     :>{b}&                 (*drop the first element*)

— attinat
स्रोत

1

क्लोजर, 66 75 बाइट्स

#(loop[v(drop %2 %)](if(>(apply + v)(apply +(take %2 %)))(recur(rest v))v))

अफसोस की बात है कि एक अनुक्रम के कुल योग के लिए एक छोटा मुहावरा प्रतीत नहीं होता है।

संपादित करें : ओह जब यह ऑनलाइन प्रयास करने के लिए उदाहरण जोड़ रहा है !लिंक मैंने देखा कि मूल उत्तर गलत परिणाम देता था जब कई नकारात्मक संख्याएं मौजूद थीं।

doseq"कुंजी" विनाशकारी का उपयोग करता है इसलिए यह कुछ हद तक स्पष्ट होना चाहिए कि कौन सा डेटा किस प्रतीक में समाप्त होता है। #(...)एक अनाम फ़ंक्शन है, यहां मैं इसे प्रतीक से बांध रहा हूं f:

(def f #(loop[v(drop %2 %)](if(>(apply + v)(apply +(take %2 %)))(recur(rest v))v)))


(doseq [{:keys [L n]} [{:L [10,5,5,3] :n 2}
                       {:L [7,2,1,-2,-4,-5,-10,-12] :n 7}
                       {:L [30,20,10,0,-10,-20,-30] :n 1}]]
  (println (f L n)))

आउटपुट:

(5 3)
(-12)
(20 10 0 -10 -20 -30)

— NikoNyrh
स्रोत

1

क्या आप टेस्ट कोड के साथ एक TIO जोड़ना चाहेंगे (मुझे सूची में क्लोजर दिखाई देगा)? यदि यह किसी भी तरह से संभव नहीं है (संस्करण बेमेल, या बिल्डरों का उपयोग करके जो टीआईओ पर उपलब्ध नहीं हैं), तो क्या आप कुछ परीक्षण मामलों के स्क्रीनशॉट को सत्यापन के रूप में शामिल कर सकते हैं कि यह काम करता है?

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

1

एपीएल (एनएआरएस), 32 चार्ट, 64 बाइट्स

{v/⍨(+/⍺↑⍵)≥+/¨{⍵↓v}¨¯1+⍳≢v←⍺↓⍵}

परीक्षण और टिप्पणियाँ:

  q←{v/⍨(+/⍺↑⍵)≥+/¨{⍵↓v}¨¯1+⍳≢v←⍺↓⍵}
  2 q 500,200,150,150,125,100,75,75,55,50,40,30,30,20,10,10,8,5,5,5,3,2,2,1,0,¯2,¯3
125 100 75 75 55 50 40 30 30 20 10 10 8 5 5 5 3 2 2 1 0 ¯2 ¯3 
  2 q 10,5,5,3
5 3 
  ⎕fmt  7 q 7,2,1,¯2,¯4,¯5,¯10,¯12
┌1───┐
│ ¯12│
└~───┘
  2 q 0,¯5,¯10,¯15
¯10 ¯15 
  ⎕fmt 1 q 100,35,25,15,5,5,5,5,5,5,5,5,5,5,5,5,5
┌14───────────────────────────┐
│ 15 5 5 5 5 5 5 5 5 5 5 5 5 5│
└~────────────────────────────┘
  2 q 1000,999,998,900,800,766,525,525,400,340,120,110,80,77,33,12,0,¯15,¯45,¯250
525 525 400 340 120 110 80 77 33 12 0 ¯15 ¯45 ¯250 
  1 q 10,5,5
5 5 
  ⎕fmt  2 q ¯5,¯10,¯13
┌0─┐
│ 0│
└~─┘
  ⎕fmt  1 q 30,20,10,0,¯10,¯20,¯30
┌6───────────────────┐
│ 20 10 0 ¯10 ¯20 ¯30│
└~───────────────────┘


   {v/⍨(+/⍺↑⍵)≥+/¨{⍵↓v}¨¯1+⍳≢v←⍺↓⍵}
                             v←⍺↓⍵   v is ⍵[(⍺+1)..≢⍵] 
                  {⍵↓v}¨¯1+⍳≢v        build the array of array cut v of 0..((≢v)-1) elements
               +/¨                   sum each of these element of array above
      (+/⍺↑⍵)≥                       compare ≥ with the sum of ⍵[1..⍺] obtain one bolean array
                                     has the same lenght of v
   v/⍨                               return the element of v that are 1 of the boolean array above

मैंने गलत बाइट लंबाई की सूचना दी ...

— RosLuP
स्रोत

1

एमएस SQL सर्वर 2017 , 271 बाइट्स

create function f(@L nvarchar(max),@ int)returns table return
select v
from(select*,sum(iif(n<=@,v,0))over()r,sum(v)over(order by v)p
from(select row_number()over(order by-v)n,v
from STRING_SPLIT(@L,',')cross apply(select
try_parse(value as int)v)t)t)t
where p<=r and @<n

मुझे पता है कि इनपुट डेटा को संग्रहीत करने के लिए अधिक रिलेशन-जैसी तालिका का उपयोग करके कोड को अधिक संक्षिप्त बनाया जा सकता है, लेकिन संख्यात्मक सूची और STRING_SPLITफ़ंक्शन को संग्रहीत करने के लिए वर्ण डेटा प्रकार का उपयोग करके , मैं Build Schemaभाग को कम कर देता हूं :)

अधिक पठनीय संस्करण:

CREATE FUNCTION f(@L NVARCHAR(MAX), @n INT)
  RETURNS TABLE AS RETURN (
    SELECT
      v
    FROM (
      SELECT
        *,
        SUM(IIF(n<=@n, v, 0)) OVER() AS r,
        SUM(v) OVER(ORDER BY v) AS p
      FROM(
        SELECT ROW_NUMBER() OVER(ORDER BY -v) AS n, v
        FROM STRING_SPLIT(@L, ',')
        CROSS APPLY(
          SELECT TRY_PARSE(value AS INT) AS v
        ) AS t
      ) AS t
    ) AS t
    WHERE p <= r AND @n < n
  );

SQL फिडेल पर इसे आज़माएं !

— आंद्रेई ओडेगो
स्रोत

1

पायथन 3.8 (पूर्व-रिलीज़) , 59 बाइट्स

आउटपुट आरोही क्रम में है

def f(l,n):
 s=sum(l[:n])
 while(w:=l.pop())<s:yield w;s-=w

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

— OVS
स्रोत

क्या 26 सबसे अमीर अरबपति सबसे गरीब 3.8 बिलियन लोगों के पास हैं?

परिचय:

चुनौती:

चुनौती नियम:

सामान्य नियम:

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

सी # (विज़ुअल सी # इंटरएक्टिव कंपाइलर) , 88 81 69 68 63 बाइट्स

EXAPUNKS (2 EXAs, 30 निर्देश, 594-बाइट समाधान फ़ाइल)

XA

एक्सबी

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

05AB1E , 14 12 बाइट्स

जे , 18 बाइट्स

स्पष्टीकरण:

रूबी , 47 43 बाइट्स

आर , 53 55 बाइट्स

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

टिप्पणी की गई

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

पायथ , 16 15 बाइट्स

जावास्क्रिप्ट, 64 बाइट्स

स्टैक्स , 12 बाइट्स

अनपैक्ड (14 बाइट्स) और स्पष्टीकरण:

एपीएल + विन, 27 बाइट्स

जाप , 16 बाइट्स

जेली , 13 12 बाइट्स

व्याख्या

गैया , 12 बाइट्स

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

व्याख्या

एपीएल (डायलॉग यूनिकोड) , २३ २१ बाइट्स एसबीसीएस

MATL , 13 12 बाइट्स

व्याख्या

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

रेटिना 0.8.2 , 99 बाइट्स

चारकोल , 17 बाइट्स

लाल , 63 बाइट्स

शक्ति कोशिका , 86 बाइट्स

मैथॉल्फ , 13 बाइट्स

व्याख्या

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

क्लोजर, 66 75 बाइट्स

एपीएल (एनएआरएस), 32 चार्ट, 64 बाइट्स

एमएस SQL ​​सर्वर 2017 , 271 बाइट्स

पायथन 3.8 (पूर्व-रिलीज़) , 59 बाइट्स

एपीएल (डायलॉग यूनिकोड) , २३ २१ बाइट्स ^{एसबीसीएस}

एमएस SQL सर्वर 2017 , 271 बाइट्स