सोने की चेन काटो

Question

एक यात्री को शहर के बाहर एक होटल में n दिनों तक रुकना पड़ता है। वह नकदी से बाहर है और उसका क्रेडिट कार्ड समाप्त हो गया है। लेकिन उसके पास n लिंक वाली सोने की चेन है ।

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

एक लिंक को काटने से तीन उपचिन बनते हैं: एक जिसमें केवल कट लिंक होता है, और प्रत्येक तरफ एक। उदाहरण के लिए, लंबाई 8 की श्रृंखला की तीसरी कड़ी को काटने से लंबाई के उपचिन पैदा होते हैं [2, 1, 5]। प्रबंधक परिवर्तन करने के लिए खुश है, इसलिए यात्री पहले दिन का भुगतान लंबाई 1 की श्रृंखला के साथ कर सकता है, फिर दूसरे दिन लंबाई 2 की श्रृंखला के साथ, पहली श्रृंखला वापस प्राप्त कर सकता है।

आपके कोड को लंबाई इनपुट करनी चाहिए n , और न्यूनतम लंबाई में कटौती के लिए लिंक की एक सूची का उत्पादन ।

नियम :

• n एक पूर्णांक है> 0।
• आप लिंक के लिए 0-आधारित या 1-आधारित अनुक्रमण का उपयोग कर सकते हैं।
• कुछ नंबरों के लिए, समाधान अद्वितीय नहीं है। उदाहरण के लिए, यदि n = 15दोनों [3, 8]और[4, 8] वैध outputs हैं।
• आप या तो सूची वापस कर सकते हैं, या किसी उचित विभाजक के साथ प्रिंट कर सकते हैं।
• यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कोड जीत जाता है।

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

Input          Output (1-indexed)
1              []
3              [1]
7              [3]
15             [3, 8]
149            [6, 17, 38, 79]

विस्तृत उदाहरण

के लिए n = 15, लिंक 3 और 8 परिणाम लंबाई की subchains में काटने [2, 1, 4, 1, 7]। यह एक मान्य समाधान है क्योंकि:

 1 = 1
 2 = 2
 3 = 1+2
 4 = 4
 5 = 1+4
 6 = 2+4
 7 = 7
 8 = 1+7
 9 = 2+7
10 = 1+2+7
11 = 4+7
12 = 1+4+7
13 = 2+4+7
14 = 1+2+4+7
15 = 1+1+2+4+7

केवल एक कट के साथ कोई समाधान मौजूद नहीं है, इसलिए यह एक इष्टतम समाधान है।

परिशिष्ट

ध्यान दें कि यह समस्या पूर्णांक विभाजन से संबंधित है। हम n के एक विभाजन P की तलाश कर रहे हैं, ताकि 1 से n तक के सभी पूर्णांकों में कम से कम एक पेटेंट हो, जो P का सबसेट है ।

इस समस्या के लिए एक संभव एल्गोरिथ्म के बारे में YouTube वीडियो यहां दिया गया है।

Comments

मैं आपके "परिवर्तन करने" संदर्भ को नहीं समझता। अपने पोस्ट किए गए उदाहरण में, दूसरे दिन आप 2-लिंक श्रृंखला के साथ भुगतान करते हैं (और 1-लिंक-चेन प्राप्त करते हैं (जो आपने पहले दिन के साथ भुगतान किया था) अपने विवरण के अनुसार, परिवर्तन के रूप में वापस करें। लेकिन तीसरे दिन, आप के साथ भुगतान करते हैं 1+2। दूसरा 2-लिंक-चेन कहां से आया?

— फ्लैटर

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

— polfosol ఠ_ the

Answer 1

05AB1E , 23 11 8 बाइट्स

ΔÍN-;иg=

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

0-आधारित अनुक्रमण का उपयोग करता है।

स्पष्टीकरण:

             # start from the implicit input
Δ            # loop forever
 Í           # subtract 2
  N-         # subtract the current iteration number
    ;        # divide by 2
     и       # create a list of length x
      g      # get the length of the list
       =     # print

иgएक नोप की तरह दिखता है, लेकिन यह वास्तव में दो उपयोगी चीजें करता है: यह एक पूर्णांक ( ;एक फ्लोट देता है) को काटता है, और यदि एक्स नकारात्मक है (यह एकमात्र निकास स्थिति है) दुभाषिया को क्रैश करता है।

---

23 बाइट समाधान ने एक बहुत अलग दृष्टिकोण का उपयोग किया, इसलिए यहां यह पश्चात के लिए है: ÅœʒR2äθP}ʒæOê¥P}θ2äθη€O( टीआईओ , स्पष्टीकरण )।

Comments

मैंने अपना उत्तर हटा दिया है। मेरा ४२ का होना और तुम्हारा ११ का होना मेरे लिए शर्मिंदगी नहीं, हाहा, बहुत बड़ा अंतर है। ;) अच्छा जवाब हालांकि, और योग्य पर Ø.Ø। क्या आपने फ्लोर और मैप सभी नकारात्मक दोनों के क्रम में कुछ यादृच्छिक चीजों की कोशिश की -1? भले ही, बहुत अच्छा जवाब और मैं प्रत्याशित की तुलना में बहुत कम। मैं अपना बुरा 42-बटर पोस्ट करने के बाद लगभग 20 बाइट्स सोच रहा था।

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

@ केविनक्रूजसेन ननोप, Ø.Øवास्तव में मेरा पहला विचार था। आपकी टिप्पणी मुझे यादृच्छिक चीजों की कोशिश करने के लिए प्रेरित: मैंने पाया ®Ÿà, ï®Mऔर अधिक महत्वपूर्ण बात यह иgहै, जो इस अच्छा 8 byter अर्जित करता है। मैंने हमेशा यह कष्टप्रद पाया कि ओसाबी कई मामलों में दुर्घटनाग्रस्त होने से पहले (0, गलत प्रकार, आदि) से कुछ भी नहीं करना चाहता है, इसलिए यह दुर्घटना काम आएगी।

— ग्रैमी

Hehe, 05AB1E को कभी भी क्रैश नहीं करना चाहिए, लेकिन आप सही हैं कि यह कभी-कभी थोड़ा कष्टप्रद होता है, ऐसा कभी नहीं होता है। विरासत में मुझे यह भी नहीं पता होगा कि दुर्घटना कैसे होती है, और अतीत में हमारे पास एक स्पष्ट विभाजन भी था शून्य त्रुटि हम मैन्युअल रूप से कह सकते हैं। xD नए संस्करण में यह अभी भी कुछ बिल्डरों को गलत तर्क देते समय एक त्रुटि के साथ बहुत बार दुर्घटनाग्रस्त हो जाता है। और अच्छा -3 फिर से।

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

"एक्स नेगेटिव होने पर दुभाषिया को क्रैश कर देता है (यह एकमात्र निकास स्थिति है)।" - मुझे अच्छा लगता है कि

— जॉन ड्वोरक

Answer 2

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

f=lambda n,i=0:n>=i<<i and f(n,i+1)or[min(n,2**j*i-i+j)for j in range(1,i)]

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

---

स्पष्टीकरण:

'बाइनरी' विखंडू का एक क्रम बनाता है, जिसमें आधार संख्या में कटौती की संख्या का मिलान होता है।

उदाहरण के लिए:

63 3 कट्स में किया जा सकता है, जिसका मतलब बेस -4 में विभाजन है (जैसा कि हमारे पास 3 सिंगल रिंग हैं):

कट्स: 5, 14, 31(जो 4 1 8 1 16 1 32क्रमबद्ध :) की श्रृंखला देता है 1 1 1 4 8 16 32।

सभी संख्याएँ बनाई जा सकती हैं:

1       1
2       1 1
3       1 1 1
4       4
...
42      1 1 8 32
...
62      1 1 4 8 16 32
63      1 1 1 4 8 16 32

अन्य उदाहरण:

18: 4,11        ->  3 1 6 1 7
27: 5,14,27     ->  4 1 8 1 13 1
36: 5,14,31     ->  4 1 8 1 16 1 5
86: 6,17,38,79  ->  5 1 10 1 20 1 40 1 7

Comments

क्या आपको f=शुरुआत में नहीं जोड़ना चाहिए ? चूंकि आप fलैम्बडा फ़ंक्शन में कॉल का उपयोग करते हैं, और मैं केवल यह मान सकता हूं कि आप उसी लैम्ब्डा का संदर्भ देते हैं जिसे आप परिभाषित कर रहे हैं।

— randomdude999

@ randomdude999, हाँ, मैं भूल गया ...

— TFeld

@ randomdude999 क्या यह नियम सभी भाषाओं पर लागू होता है, या सिर्फ अजगर? क्योंकि मुझे एक जावास्क्रिप्ट उत्तर दिखाई देता है जो इस चुनौती में एक शुद्ध मेमना है ...

— छाया

@ शादो यह सभी भाषाओं पर लागू होता है, लेकिन केवल पुनरावर्ती लंबों के लिए।

— TFeld

@ शादो एक अधिक सामान्य नियम यह है कि आप किसी ऐसी चीज़ का संदर्भ नहीं दे सकते हैं जो न तो आपके कोड में परिभाषित है और न ही आपकी भाषा में विश्व स्तर पर परिभाषित है, जब तक कि इसे स्पष्ट रूप से चुनौती नहीं दी जाती है। सबसे आम मामला एक पुनरावर्ती कार्य है, लेकिन यह अन्य स्थितियों पर लागू होता है। यह उत्तर एक और उदाहरण है: fपुनरावर्ती नहीं है, लेकिन यह कोड में संदर्भित है और इसलिए इसे नाम दिया जाना है।

— अरनुलद

Answer 3

आर , 77 69 बाइट्स

-8 बाइट्स आरोन हेमैन को धन्यवाद

pmin(n<-scan(),0:(k=sum((a=2:n)*2^a<=n))+cumsum((k+2)*2^(0:k))+1)[-n]

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

$k$$k$$(k+1)\cdot2^k\geq n$$1,1,\ldots,1$$k$$(k+1), 2(k+1), 4(k+1), 8(k+1), \ldots, (k+1)\cdot 2^{k-1}$

(यदि हम श्रृंखला की कुल लंबाई से अधिक है तो अंतिम उपचैन को छोटा किया जा सकता है।)

Ungolfed (पिछले, समान संस्करण पर आधारित):

n = scan()                            # read input
if(n - 1){                            # If n==1, return NULL
  k = match(F, (a = 2:n) * 2 ^ a > n) # compute k
  b = (k + 1) * 2 ^ (1:k - 1)         # lengths of subchains
  c = 1:k + cumsum(b)                 # positions of cuts
  pmin(c, n )                         # if last value is >n, coerce it to n
}

$k$$k$$k$$k+1$$2k+1$$2k+2$$4k+4$$k$$(k+1)\cdot 2^k-1$।)

$a(k)$$n$$k$$a(k)$

Comments

मुझे संदेह है कि यह विशेष मामले के लिए मदद करेगा n=1, लेकिन कटऑफ उत्पन्न करने का एक वैकल्पिक तरीका पुनरावृत्ति है 1, 4, 4a(n-1)-4a(n-2)।

— पीटर टेलर

@PeterTaylor मैं कंप्यूटिंग के लिए एक समान पुनरावृत्ति था k; यह OEIS A134401: oeis.org/A134401 से मेल खाता है, लेकिन पुनरावृत्ति संबंध के मेरे कार्यान्वयन में वर्तमान कोड की तुलना में अधिक बाइट्स होते हैं।

— रॉबिन राइडर

थोड़ा पुनर्व्यवस्थापन मैं इसे 73 पर ले गया। इसे ऑनलाइन आज़माएं!

— आरोन हेमैन

@AaronHayman धन्यवाद! के sumबजाय का उपयोग कर स्मार्ट चाल match।

— रॉबिन राइडर

69 बाइट्स और उस से छुटकारा पा लिया अगर वह बयान जो आपको परेशान कर रहा था: इसे ऑनलाइन आज़माएं!

— आरोन हेमैन

Answer 4

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

’_‘ɼ:2»-µƬṖḊ

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

ग्रैमी के 05AB1E उत्तर का अनुवाद तो यह सुनिश्चित करना है कि एक भी! थोड़ा निराश यह एक बाइट में आता है, लेकिन कम से कम पहले तीन बाइट्स के रूप में एक इमोटिकॉन जैसा कुछ है!

Answer 5

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

यह TFeld के उत्तर का एक बंदरगाह है ।

n=>(g=a=>n<++i<<i?a.map(j=>(j+=(i<<j)-i)>n?n:j):g([...a,i]))(i=[])

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

Answer 6

सी ++, 109 , 107 बाइट्स

-2 बाइट्स केविन की बदौलत

#include<iostream>
main(){int n,k=0;for(std::cin>>n;++k<<k<n;);for(n-=k;n>0;k*=2,n-=k+1)std::cout<<n<<',';}

एल्गोरिथ्म रॉबिन राइडर के जवाब के समान है। कोड को एक संकलन योग्य, पूरे फॉर्म में लिखा गया है। कोशिश करो!

विवरण:

std::cin>>n;               // get the value of n as input
while(++k<<k<n);           // determine k
for(n-=k;n>0;k*=2,n-=k+1)  // we don't need n, so the lengths...
    std::cout<<n<<' ';     // of links are subtracted repeatedly

यह एक ही बाइट लंबाई के साथ एक सी भिन्नता है (एक अलग उत्तर की आवश्यकता नहीं लगती है):

#include<stdio.h>
main(){int n,k=0;for(scanf("%d",&n);++k<<k<n;);for(n-=k;n>0;k*=2,n-=k+1)printf("%d,",n);}

Comments

गोल्फ के लिए दो नाबालिग बातें: =0के बाद k, हटाया जा सकता है इसके बाद से 0डिफ़ॉल्ट रूप से। std::cin>>n;while(++k<<k<n);हो सकता है for(std::cin>>n;++k<<k<n;);। मेरे पास यह भी है कि for(n-=k;n>0;k*=2,n-=k+1)सामान को मिलाकर किसी तरह से भावना को सरल बनाया जा सकता है, लेकिन यह सुनिश्चित नहीं है कि कैसे। पुनश्च: अल्पविराम को एक स्थान पर बदलना थोड़ा बेहतर लगता है क्योंकि आप एक अनुगामी को नहीं देखते हैं, लेकिन यह विशुद्ध रूप से कॉस्मेटिक है :)

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

@KevinCruijssen धन्यवाद, लेकिन कुछ संकलक गैर-स्थिर चर के लिए एक डिफ़ॉल्ट मान प्रदान नहीं करते हैं। इसलिए मुझे लगा कि =0पोर्टेबिलिटी के लिए यह आवश्यक है;) मुझे यह भी महसूस हुआ कि इसके बाद की जगह #includeजरूरी नहीं है।

— पोलफोसोल ఠ_ఠ 11

आह अच्छा। मैं C ++ को बहुत अच्छी तरह से नहीं जानता, इसलिए मैंने कुछ चीजों का परीक्षण करने के लिए आपके उत्तर में लिंक किए गए ऑनलाइन कंपाइलर का उपयोग किया है। :) आप अपनी टिप्पणी में प्रस्तावित दूसरा बदलाव भूल गए: द-लूप फॉर-लूप टू फॉर-लूप और इसके std::cin>>nअंदर डाल ।

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

103 बाइट्स

— छत

Answer 7

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

.+
11,$&$*
+`\b(1+),(\1(1*)1?\3)$
1$2¶1$1,$3
1+,
1
1A`
1+
$.&

इसे ऑनलाइन आज़माएं! @ ग्रिम के उत्तर का 1-अनुक्रमित पोर्ट। स्पष्टीकरण:

.+
11,$&$*

से शुरू करें N=2और इनपुट यूनीरी में परिवर्तित हो जाए।

+`\b(1+),(\1(1*)1?\3)$

बार-बार Nइनपुट से घटाने की कोशिश करें और फिर 2 से भाग दें।

1$2¶1$1,$3

सफल होने पर, पिछली पंक्ति पर इनपुट से 1 अधिक याद रखें, Nवर्तमान लाइन पर वेतन वृद्धि , और इनपुट को नए मूल्य पर अपडेट करें।

1+,
1

Nअंतिम मान निकालें और बढ़ाएँ ताकि यह 1-अनुक्रमित भी हो।

1A`

बढ़ा हुआ मूल इनपुट निकालें।

1+
$.&

परिणामों को दशमलव में बदलें।

Answer 8

रूबी , 62 बाइट्स

->n{(1...c=(0..n).find{|r|n<r<<r}).map{|b|[n,b-c+(c<<b)].min}}

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

ज्यादातर TFeld के पायथन जवाब से चोरी हो गए।