10

बहु-स्तरीय विपणन संबंधी चुनौती।

एक सहकर्मी पुरस्कृत होना चाहता है। इसलिए इसने Nनिवेशकों को आकर्षित किया ( N>=1), प्रत्येक i-th निवेशक ने निवेश किया x[i]। जब कुल राशि सीमा से अधिक होती है तो x[0]+x[1]+...+x[N-1] >= Tएक सहकर्मी को पुरस्कृत किया जा सकता है। लेकिन केवल तभी जब निम्न स्थितियां संतुष्ट हों:

निवेशकों की न्यूनतम राशि M( M<=N) से अधिक होनी चाहिए
कम से कम एक पूर्णांक के लिए k, जहां k>=Mऔर k<=N, किसी भी kनिवेशक को कम से कम T/kप्रत्येक निवेश करना होगा ;

यह देखते हुए N, x[], T, Mकि आपको यह निर्धारित करना चाहिए कि सहकर्मी का पुरस्कार उत्पन्न हुआ है या नहीं (बूलियन परिणाम, "हाँ" या "नहीं")। सबसे छोटा कोड जीतता है।

उदाहरण:

N=5; M=3; T=10000, सहकर्मी के इनाम को उत्पन्न करने के लिए निम्नलिखित में से एक को संतुष्ट होना चाहिए:

किसी भी 3 ने कम से कम 3334 निवेश किया
किसी भी 4 ने कम से कम 2500 का निवेश किया है
सभी 5 ने कम से कम 2000 का निवेश किया

N=6; M=2; T=5000:

किसी भी 2 ने कम से कम 2500 का निवेश किया है
किसी भी 3 ने कम से कम 1667 का निवेश किया
किसी भी 4 ने कम से कम 1250 का निवेश किया
किसी भी 5 ने कम से कम 1000 निवेश किए
सभी 6 ने कम से कम 834 निवेश किए

सामान्यीकृत: किसी भी k, जहां k>=Mऔर k<=N:

निवेशकों में से किसी kने Nकम से कम T/kप्रत्येक में निवेश किया है

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

प्रारूप:

N, x[], T, M -> correct answer

6, [999, 999, 59, 0, 0, 0], 180, 3 -> 0
6, [0, 60, 0, 60, 60, 0], 180, 3 -> 1
6, [179, 89, 59, 44, 35, 29], 180, 3 -> 0
6, [179, 89, 59, 44, 35, 30], 180, 3 -> 1
6, [179, 89, 59, 44, 36, 29], 180, 3 -> 1
6, [179, 90, 59, 44, 35, 29], 180, 3 -> 0
6, [30, 30, 30, 30, 29, 30], 180, 3 -> 0
6, [30, 30, 30, 30, 30, 30], 180, 3 -> 1

code-golf decision-problem

— xakepp35
स्रोत

1

@JonathanAllan ज़रूर, अगर आपकी भाषा इसे अनुमति देती है, और लेखन लेखन len(x)से छोटा होगा N। यह बनाया गया है, क्योंकि xसी में गतिशील रूप से आवंटित सरणी के लिए कोई प्रत्यक्ष len(x)कार्य नहीं है - इसलिए आप हमेशा लंबाई का उल्लेख कर सकते हैं N। सुविधा के लिए, आप सभी इनपुट डेटा N, x[], T, Mको कुछ बाहरी रूप से परिभाषित स्थिरांक या कुछ भाषा में निर्मित इन्स के रूप में मान सकते हैं ।

— xakepp35

1

मुझे नहीं लगता कि वे सूचनाएँ उन तक पहुँची थीं (हाइफ़न के साथ) जैसा कि मैंने उन्हें अपने इनबॉक्स में प्राप्त किया है।

— जोनाथन एलन

1

@JonathanAllan पिंग सिंटेक्स और नॉन-लैटिन नामों के साथ काफी फेमस नहीं हैं .. शायद वे किसी दिन लौटेंगे :)

— xakepp35

1

इसके अलावा, क्या आउटपुट को उलटा किया जा सकता है? के लिए एक गलत मूल्य trueऔर सत्य मूल्य के लिए false?

— झबरा

1

@ W @tWisarhd कोड गोल्फ एक विजेता मानदंड है ... टैग देखें।

— mbomb007

4

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

ṢṚ×J$ṫ⁵<Ṃ

एक पूर्ण कार्यक्रम जो स्वीकार करता है x T Mऔर प्रिंट करता है 0अगर सहकर्मी को पुरस्कृत किया जाता है और 1यदि नहीं।

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

कैसे?

ṢṚ×J$ṫ⁵<Ṃ - Main Link: list of numbers, x; number, T   e.g. [100, 50, 77, 22, 14, 45], 180
Ṣ         - sort x                                          [ 14, 22, 45, 50, 77,100]
 Ṛ        - reverse                                         [100, 77, 50, 45, 22, 14]
    $     - last two links as a monad:
   J      -   range of length                               [  1,  2,  3,  4,  5,  6]
  ×       -   multiply                                      [100,154,150,180,110, 84]
     ṫ    - tail from index:
      ⁵   -   5th argument (3rd input), M   (e.g. M=3)      [        150,180,110, 84]
       <  - less than T?                                    [          1,  0,  1,  1]
        Ṃ - minimum                                         0

— जोनाथन एलन
स्रोत

लगता है कि काम नहीं कर रहा है: tio.run/##0rNyan8///hzkWHp/uoHJ5wbMnDnasfNW61ebiz6dCah7sW/P//…

— xbpp3535

उदाहरण में तीसरे निवेशक ने 1 / 3rd T (33 से कम) से कम का निवेश किया, लेकिन परिणाम अभी भी सकारात्मक के रूप में गिना जाता है ("किसी भी k ने कम से कम T / k में निवेश किया" विफल)

— xakepp35

हाँ, मैंने इसे रिवर्स-सॉर्ट किए गए मानों के उपसर्गों का उपयोग करके बनाया और सोचा कि मैं इसे सॉर्ट किए गए पोस्टफ़िक्स में बदल सकता हूं, लेकिन वास्तव में इसलिए नहीं कर सकता क्योंकि मैं फिर से पूंछ रहा हूं ... उलटा :)

— जोनाथन एलन

1

हाँ, अब मैंने गोल्फ को समाप्त कर दिया है और मैं एक स्पष्टीकरण लिख रहा हूँ।

— जोनाथन एलन

1

यह अब "प्रिंट करता है 0अगर सहकर्मी को पुरस्कृत किया जाता है और 1यदि नहीं"। (यानी 0"हाँ" है)। यह 1 बाइट बचाता है :)

— जोनाथन एलन

3

05AB1E , 9 बाइट्स

{Rƶ.ssè›ß

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

@JonathanAllan के जेली उत्तर का पोर्ट , इसलिए इनपुट x T Mऔर आउटपुट 0को भी "yes"और इसके 1लिए लेता है "no"। यदि यह अनुमति नहीं है, और इसे उलटा होना चाहिए, तो एक अनुगामी _जोड़ा जा सकता है।

स्पष्टीकरण:

{           # Sort the (implicit) input `x`
            #  i.e. `x`=[100,50,77,22,14,45] → [14,22,45,50,77,100]
 R          # Reverse it
            #  i.e. [14,22,45,50,77,100] → [100,77,50,45,22,14]
  ƶ         # Multiply it by it's 1-indexed range
            #  i.e. [100,77,50,45,22,14] → [100,154,150,180,110,84]
   .s       # Get all the suffices of this list
            #  i.e. [100,154,150,180,110,84]
            #   → [[84],[110,84],[180,110,84],[150,180,110,84],[100,154,150,180,110,84]]
     s      # Swap to take the (implicit) input `T`
      è     # Get the prefix at index `T`
            #  i.e. [[84],[110,84],[180,110,84],[150,180,110,84],[100,154,150,180,110,84]]
            #   and `T=3` → [150,180,110,84]
       ›    # Check for each list-value if the (implicit) input `M` is larger than it
            #  i.e. [150,180,110,84] and `M`=180 → [1,0,1,1]
        ß   # And pop and push the minimum value in the list (which is output implicitly)
            #  i.e. [1,0,1,1] → 0

इसके लिए वैकल्पिक .ssè:

sG¦}

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

स्पष्टीकरण:

s       # Swap to take the (implicit) input `T`
 G }    # Loop `T-1` times:
  ¦     #  Remove the first item from the list that many times
        #   i.e. [100,154,150,180,110,84] and `T=3` → [150,180,110,84]

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

1

मैंने "आपको आउटपुट कैसे करना चाहिए" पर कहा नहीं था, बस यह बूलियन होना चाहिए (केवल 2 राज्यों के लिए)। तो हाँ, निश्चित रूप से आप "हां" के लिए 0 और "नहीं" :) के लिए 1 का उपयोग कर सकते हैं :)

— xakepp35

2

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

(x,t,m,n)=>x.sort((a,b)=>a-b).some(i=>i*n-->=t&n>=m)

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

— झबरा
स्रोत

इसके अलावा 35-40% अधिक प्रदर्शन करने वाला 72-समाधान है। लवली कोड, उत्पादन एमएलएम से संबंधित वेब परियोजनाओं में एम्बेड किए जाने के लिए तैयार होने जैसा महसूस हुआ: ^)

— xakepp35

अभी ध्यान दिया। टेस्ट मामले # 2 [0, 60, 0, 60, 60, 0], 180, 3 -> trueकिया जा रहा है काम नहीं कर रहा! 72 बाईटेड ब्रोज इसे ठीक करता है। बग या सुविधा?)

— xakepp35

2

रेटिना , 79 बाइट्स

\d+
*
O^`_+(?=.*])
_+(?=.*])(?<=(\W+_+)+)
$#1*$&
+`\W+_+(.*_)_$
$1
(_+).*], \1,

इसे ऑनलाइन आज़माएं! प्रारूप में इनपुट लेता है [x], T, M। लिंक में परीक्षण के मामले शामिल हैं। स्पष्टीकरण:

\d+
*

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

O^`_+(?=.*])

[x]अवरोही क्रम में क्रमबद्ध करें ।

_+(?=.*])(?<=(\W+_+)+)
$#1*$&

[x]इसके सूचकांक द्वारा प्रत्येक तत्व को गुणा करें ।

+`\W+_+(.*_)_$
$1

के पहले M-1तत्वों को हटा दें [x]।

(_+).*], \1,

परीक्षण करें कि कोई भी शेष तत्व [x]अधिक या बराबर है T।

— नील
स्रोत

2

पर्ल 6 , 46 33 29 बाइट्स

{$^b>all $^a.sort Z*[...] @_}

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

अनाम कोड ब्लॉक करता है जो फ़ॉर्म में इनपुट लेता है list, amount, length of list, minimum amount of investorsऔर एक सत्य / फ़ॉल्सी allजंक्शन देता है, जहां ट्रू फ़ेल हो जाता है और फ़ॉसी सफलता है।

स्पष्टीकरण:

{                           }  # Anonymous code block
     all                       # Are all of
         $^a.sort                # The sorted list
                  Z*             # Zip multiplied by
                     [...] @_    # The range from length of list to the minimum amount
 $^b>                          # Not smaller than the given amount?

— मजाक कर रहा है
स्रोत

2

05AB1E , 6 बाइट्स

आदेश में लिया इनपुट T, N, x[], M
आउटपुट है 0सहकर्मी इनाम के लिए और 1नहीं तो

Ÿs{*›W

इसे ऑनलाइन आज़माएं! या टेस्ट सूट के रूप में

व्याख्या

Ÿ        # push the range [N ... T]
 s{      # push the list x[] sorted ascending
   *     # elementwise multiplication (crops to shortest list)
    ›    # for each element, check if M is greater than it
     W   # push min of the result
         # output implicitly

— Emigna
स्रोत

*सीमा के साथ उपयोग करने की अच्छी चाल संक्षेप में सूची फसल!

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

2

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

EDIT: मैकेनिक्स को क्यों समझाते हुए केविन क्रूजेसेन को 40 बाइट से दूर करने के लिए धन्यवाद!

(n,q,t,m)=>{int c=0,j;for(;m<=n&c<1;c=c<m++?0:1)for(j=n;j-->0;)c+=q[j]<t/m?0:1;return c;}

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

— Destroigo
स्रोत

1

106 बाइट्स कुछ चीजें जो मैंने बदली हैं: इनपुट हटा दिया nक्योंकि आप इसे कहीं भी उपयोग नहीं करते हैं; kआप mखुद का उपयोग कर सकते हैं के बाद से हटाया ; दो बार उपयोग करने के बाद से आपके lलिए एक चर जोड़ा गया q.Length; चरों को संयोजित किया int c=0,l=q.Length,j;ताकि आपको अतिरिक्त की आवश्यकता न हो var; फॉर-लूप बॉडी में सब कुछ डालकर अनावश्यक कोष्ठक हटा दिए; c>=kचेक को बदल दिया c<k; और बदल if(c>0)break;करने के लिए m=c>0?l+1:m;, के बाद से पाश अगर बंद हो जाता है m<=l, को बदलने mके लिए l+1ऊपर एक बाइट की बचत होती है break(और यह भी 2 कोष्ठक पर बचाता है)। :)

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

1

यदि आपने इसे अभी तक नहीं देखा है, तो सी # में गोल्फिंग के लिए टिप्स और गोल्फिंग के लिए टिप्स <सभी भाषाओं> के माध्यम से पढ़ना दिलचस्प हो सकता है।

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

1

89 बाइट्स मेरी पहली टिप्पणी में गोल्फ के लिए कुछ अतिरिक्त। m=c>0?l+1:mपूरी तरह से हटाया जा सकता है और एक &c<1जांच के बजाय पाश करने के लिए जोड़ा जा सकता है। और इनपुट nफिर से लेने से, आपको q.Lengthअब और आवश्यकता नहीं है, बल्कि nइसके बजाय उपयोग कर सकते हैं ।

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

2

फ्लैग के साथ C # (विजुअल C # इंटरएक्टिव कंपाइलर)`/u:System.Linq.Enumerable` , 69 बाइट्स

(n,x,t,m)=>Range(0,n-m+1).Where(b=>x.Count(a=>a>=t/(b+m))>=b+m).Any()

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

// Takes in 4 parameters as input
(n,x,t,m)=>
// Create a new array with the length of all the numbers from m to n, inclusive
Range(0,n-m+1)
// And filter the results by
.Where((_,b)=>
// If the number of people that invested more than the total amount divided by the index plus m
x.Count(a=>a>=t/(b+m))
// Is greater than the index plus m
>= b+m)
// And check if there is at least one value in the filtered IEnumerable<int>, and if there is, return true
.Any()

बिना किसी झंडे के, 73 बाइट्स

(n,x,t,m)=>new int[n-m+1].Where((_,b)=>x.Count(a=>a>=t/(b+m))>=b+m).Any()

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

— अज्ञान का अवतार
स्रोत

मैंने ऐसा सोचा था, और वर्णन में कहा गया था कि एन> = 1, और एम <= एन तो आप अपने समाधान को थोड़ा छोटा कर सकते हैं :)

— xakepp35

1

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

कोड

(x,T,M)=>x.sort(t=(d,e)=>e-d).map((s,i)=>s*i+s).slice(M-1).sort(t)[0]>=T

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

प्रारूप में इनपुट स्वीकार करता है (x [], टी, एम)

व्याख्या

x.sort(t=(d,e)=>e-d)     \\sort numbers in reverse numerical order
.map((s,i)=>s*i+s)       \\Multiply each number in array by position(1 indexed) in array
.slice(M-1)              \\Remove the first M-1 elements (at least M people)
.sort(t)[0]              \\Get the maximum value in the array
>=T                      \\True if the maximum value is >= the threshold

— fənɛtɪk
स्रोत

54 बाइट्स ?

— अरण्युलड

1

(या 53 बाइट्स यदि बूलियन मान का अर्थ उलटा हो सकता है।)

— अरनौलड

@ अरनॉल्ट, 52 बाइट्स ;)

— झबरा

(वैसे, मैं आपकी टिप्पणी से स्वतंत्र रूप से अपने समाधान के साथ आया था, अगर आप सोच रहे थे - यह मेरे Japt समाधान का एक बंदरगाह है। मोबाइल पर तो टाइमस्टैम्प को ठीक से नहीं बता सकता कि कौन पहले पोस्ट किया है।)

— झबरा

1

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

बस यह सुनिश्चित करने के लिए शर्तों का परीक्षण करता है कि वे मिले हुए हैं। 1 अगर इनाम दिया जाता है, तो 0 नहीं।

lambda N,x,T,M:(sum(x)>=T)*(M<=N)*any(any(all(j>=T/k for j in i)for i in combinations(x,k))for k in range(M,N+1))
from itertools import*

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

— नील ए।
स्रोत

1

पायथन , 71 65 बाइट्स

lambda x,T,M:all(i*v<T for i,v in enumerate(sorted(x)[-M::-1],M))

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

एक अनाम फ़ंक्शन; मेरे जेली उत्तर का पोर्ट। जैसे कि "हाँ" है Falseऔर "नहीं" है True। यहां, हालांकि, हम परीक्षण-मामलों को उलट के एक भाग के रूप में त्याग देते हैं और enumerateगिनती शुरू करने की क्षमता का लाभ उठाते हैं M। ( minइसके स्थान पर भी काम करेगा all)

— जोनाथन एलन
स्रोत

1

आर , 43 42 बाइट्स

-1 बाइट दृष्टिकोण को और अधिक बारीकी से लागू करके

function(N,x,S,M)min(sort(x,T)[M:N]*M:N<S)

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

जोनाथन के जेली दृष्टिकोण का सरल आर कार्यान्वयन। मैंने विविधताओं की एक गुच्छा की कोशिश की लेकिन यह सबसे अच्छा है जो मैं कुछ बाइट्स के बारे में सोच सकता हूं।

1 का मतलब है असफलता, 0 का मतलब है सफलता।

— CriminallyVulgar
स्रोत

1

जाप, १६ १४ १३ ११ बाइट्स

ñ í*WõX)d¨V

कोशिश करो

ñ í*WõX)d¨V
                  :Implicit input of array U=x and integers V=T, W=M & X=N
ñ                 :Sort U
  í               :Interleave with
    WõX           :  Range [W,X]
   *              :  And reduce each pair of elements by multiplication
       )          :End interleaving
        d         :Any
         ¨V       :  Greater than or equal to V

— झबरा
स्रोत

0

जावा 8, 91 (या 89?) बाइट्स

(N,x,T,M)->{int c=0,j;for(;M<=N&c<1;c=c<M++?0:1)for(j=N;j-->0;)c+=x[j]<T/M?0:1;return c;}

पोर्ट ऑफ @ डस्ट्रोइगो सी # .NET उत्तर (बाद में मैंने इसे कुछ और घूमा दिया), इसलिए उसे सुनिश्चित करना सुनिश्चित करें!

क्रमशः इनपुट N,x,T,Mऔर आउटपुट true/ के falseलिए "yes"/ लेता "no"है।

चूंकि चुनौती विशेष रूप से booleanपरिणामों के लिए पूछती है , मैं 1/ के 0रूप में वापस नहीं कर सकता / सकती हूं , क्योंकि वे जावा में वैध सत्य / गलत मान नहीं हैं । यदि इसके बजाय इस चुनौती के लिए "yes"/ के लिए कोई दो अलग-अलग आउटपुट मान "no"मान्य हैं, >0तो वापसी में दो बाइट्स बचाने के लिए गिराया जा सकता है, जिस स्थिति में यह / क्रमशः 1/ के 0लिए वापस आ जाएगा ।"yes""no"

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

स्पष्टीकरण:

(N,x,T,M)->{           // Method with the four parameters and boolean return-type
  int c=0,             //  Count integer, starting at 0
      j;               //  Temp index integer
  for(;M<=N            //  Loop as long as `M` is smaller than or equal to `N`
       &c<1            //  and `c` is not 1 yet:
      ;                //    After every iteration:
       c=c<M++?        //     If `M` is smaller than `c`:
                       //     (and increase `M` by 1 afterwards with `M++`)
          0            //      Set `c` to 0
         :             //     Else:
          1)           //      Set `c` to 1
    for(j=N;j-->0;)    //   Inner loop `j` in the range (`N`,0]:
       c+=             //    Increase the counter `c` by:
          x[j]         //     If the `j`'th value in `x`
              <T/M?    //     is smaller than `T` divided by `M`:
                   0   //      Leave the counter `c` unchanged by adding 0
                  :    //     Else:
                   1;  //      Increase the counter `c` by 1
  return c>0;}         //  Return whether the counter `c` is 1

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

0

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 66 बाइट्स

(n,x,t,m)=>Enumerable.Range(m,n-m+1).Any(k=>x.Count(y=>y>=t/k)>=k)

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

@ EmbodimentOfIgnorance के जवाब से प्रेरित।

मैंने पहले भी इसका उल्लेख किया है, लेकिन C # 8 में एक श्रेणी शाब्दिक है जो इस उत्तर को कुछ इस तरह बना सकता है:

(n,x,t,m)=>[m..n-m+1].Any(k=>x.Count(y=>y>=t/k)>=k)

मैंने एक उदाहरण के साथ शार्पलैब का लिंक देखा , लेकिन मैं इसे खुद काम करने में सक्षम नहीं था।

एक चीज जो मैंने बदली, वह थी xऔर tमूल्य दशमलव हैं। यह उस मामले को संभालता है जहां थोड़ा बेहतर से tविभाज्य नहीं kहै।

— दाना
स्रोत

बहु-स्तरीय विपणन "पैर" निवेश नियम

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

कैसे?

05AB1E , 9 बाइट्स

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

रेटिना , 79 बाइट्स

पर्ल 6 , 46 33 29 बाइट्स

स्पष्टीकरण:

05AB1E , 6 बाइट्स

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

फ्लैग के साथ C # (विजुअल C # इंटरएक्टिव कंपाइलर)/u:System.Linq.Enumerable , 69 बाइट्स

बिना किसी झंडे के, 73 बाइट्स

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

कोड

व्याख्या

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

पायथन , 71 65 बाइट्स

आर , 43 42 बाइट्स

जाप, १६ १४ १३ ११ बाइट्स

जावा 8, 91 (या 89?) बाइट्स

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 66 बाइट्स

फ्लैग के साथ C # (विजुअल C # इंटरएक्टिव कंपाइलर)`/u:System.Linq.Enumerable` , 69 बाइट्स