सबसे बड़ी और सबसे छोटी संख्या बनाओ

Question

Puzzling पर इस पोस्ट से प्रेरित है । उस पहेली के लिए स्पॉयलर नीचे हैं।

इनपुट के रूप में तीन सकारात्मक पूर्णांकों को देखते हुए (x, y, z), समावेशी रेंज का निर्माण करें [x, y], उस सीमा को एक साथ मिलाएं, फिर zसबसे बड़े और सबसे छोटे सकारात्मक पूर्णांक को संभव बनाने के लिए जरूरी नहीं कि लगातार अंकों को हटा दें । अग्रणी शून्य की अनुमति नहीं है (यानी, संख्याएं शुरू होनी चाहिए [1-9])। या तो क्रम में उन दो नंबरों को आउटपुट करें।

Puzzling पोस्ट से उदाहरण के लिए, इनपुट के लिए (1, 100, 100), सबसे बड़ी संख्या संभव है 99999785960616263646566676869707172737475767778798081828384858687888990919293949596979899100,
और सबसे छोटी संख्या है 10000012340616263646566676869707172737475767778798081828384858687888990919293949596979899100,
जो कि वहां पोस्ट किए गए jafe के जवाब से नीचे के तर्क के बाद है:

• हम संख्या की लंबाई (अंकों की एक निश्चित संख्या) को प्रभावित नहीं कर सकते हैं, इसलिए अधिकतम मान लेने के लिए हम अधिकतम पहला अंक लेते हैं, फिर दूसरा अंक आदि।
• 84 पहले नॉन-नाइन (16 अंकों को हटाने के लिए छोड़ दिया गया) निकालें: 999995051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100
• अगले 17 अंकों के भीतर सबसे बड़ी संख्या 7 है, इसलिए यहां से, उत्तर में अगला अंक 7 पर हो सकता है (हम 16 अंकों से अधिक नहीं निकाल सकते हैं)। तो हटाएं 15 गैर -7 का ... (1 अंक निकालने के लिए छोड़ दिया गया है):999997585960616263646566676869707172737475767778798081828384858687888990919293949596979899100
• यहां से, अगला अंक अधिकतम 8 पर हो सकता है, इसलिए बीच से एक गैर -8 हटा दें: 99999785960616263646566676869707172737475767778798081828384858687888990919293949596979899100
• इसी तरह के तर्क, लेकिन उलट (यानी, हम अग्रणी 1एस के बजाय अग्रणी एस चाहते हैं 9) सबसे छोटी संख्या के लिए।

यहाँ एक छोटा उदाहरण है (1, 10, 5):।

हम सीमा का निर्माण करते हैं 12345678910और निर्धारित करते हैं कि 5हम किन अंकों को हटाकर सबसे बड़ी संख्या को छोड़ सकते हैं। जाहिर है, इसका मतलब है कि हम अग्रणी अंक को अधिकतम करना चाहते हैं, क्योंकि हम आउटपुट की लंबाई को प्रभावित नहीं कर सकते हैं। इसलिए, यदि हम हटाते हैं, तो हम 12345साथ रह जाते हैं 678910, और हम सबसे बड़ा बना सकते हैं। सबसे छोटा बनाना थोड़ा मुश्किल है, क्योंकि हम इसके बजाय संख्याओं को बीच से बाहर निकाल सकते हैं, 123410ताकि सबसे छोटा संभव हो सके।

के लिए (20, 25, 11), परिणाम बल्कि उबाऊ है, के रूप में 5और 1।

अंत में, जवाब है कि अग्रणी शून्य की कोशिश से इनकार करने के लिए, (9, 11, 3)देता है 91011जो बदले की पैदावार में 91और 10सबसे बड़ी और छोटी से छोटी के रूप में।

I / O और नियम

• यदि यह आसान / छोटा है, तो आप दो कार्यक्रमों / फ़ंक्शन को कोड कर सकते हैं - एक सबसे बड़ा और दूसरा सबसे छोटा - जिस स्थिति में आपका स्कोर दोनों भागों का योग है।
• इनपुट और आउटपुट किसी भी सुविधाजनक विधि द्वारा दिया जा सकता है ।
• इनपुट को आपकी भाषा के मूल नंबर प्रकार में फिट करने के लिए माना जा सकता है, हालांकि , ऐसा करने के लिए न तो समवर्ती संख्या और न ही आउटपुट ग्रहण किया जा सकता है।
• या तो एक पूर्ण कार्यक्रम या एक समारोह स्वीकार्य हैं। यदि कोई फ़ंक्शन है, तो आप इसे प्रिंट करने के बजाय आउटपुट वापस कर सकते हैं।
• मानक खामियों को मना किया जाता है।
• यह कोड-गोल्फ है इसलिए सभी सामान्य गोल्फिंग नियम लागू होते हैं, और सबसे छोटा कोड (बाइट्स में) जीतता है।

Comments

आउटपुट के रूप में अंकों की एक सूची स्वीकार्य है?

— रॉड

एक परीक्षण का मामला जो प्रमुख शून्य के साथ मूल्यांकन करते समय न्यूनतम फर्जी निकलेगा वह सार्थक हो सकता है - मुझे लगता है कि 9, 11, 3वह करेगा।

— जोनाथन एलन

@Rod Yep, आउटपुट के लिए अंकों की एक सूची ठीक है।

— AdmBorkBork

@Rod मुझे पता है कि आप किस बारे में बात कर रहे हैं, मैंने स्पष्ट रूप से ऊपर "आउटपुट" टाइप किया है। ;-)

— AdmBorkBork

@JonathanAllan अच्छा कॉल। जोड़ा गया।

— AdmBorkBork

Answer 1

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

l=length
((m,f)%n)s|n>=l s=[]|n>0,(p,c:r)<-span(/=m(f$take(n+1)s))s=c:((m,id)%(n-l p)$r)|1>0=s
(x#y)z=[p%z$show=<<[x..y]|p<-[(maximum,id),(minimum,filter(>'0'))]]

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

Jafe द्वारा वर्णित एल्गोरिथ्म का उपयोग करता है। एक कम कुशल विधि का उपयोग करने के लिए कम हो सकता है, लेकिन यह लिखने में अधिक मजेदार था :)

%आपरेशन 4 तर्क (वास्तव में 3, लेकिन जो कुछ भी) लेता है: mएक समारोह है जो कि एक सूची से चयन "इष्टतम" सदस्य (या तो maximumया minimumहम क्या चाहते हैं पर निर्भर करता है); fजो एक "फिल्टर" फ़ंक्शन है; nछोड़ने के लिए छोड़े गए अंकों की संख्या; और sस्ट्रिंग। पहले हम जांचते हैं कि क्या n स्ट्रिंग में छोड़े गए अंकों की संख्या के बराबर है (मैंने >=सुरक्षा के लिए उपयोग किया है) और sयदि ऐसा है तो बाकी को छोड़ दें। अन्यथा हम जांचते हैं कि क्या हमें अभी भी अंकों को गिराने की आवश्यकता है ( n>0), तो हम spanअपने स्ट्रिंग को तीन टुकड़ों में तोड़ने के लिए उपयोग करते हैं: pड्रॉप करने के लिए अंक, cइष्टतम पहुंच योग्य अंक, औरrशेष स्ट्रिंग। हम एक विधेय को पारित करके ऐसा करते हैं जो हमारे इष्टतम अंक के खिलाफ समानता की जांच करता है। उस अंक को खोजने के लिए हम n+1स्ट्रिंग के पहले अंक लेते हैं , इसे फ़िल्टर करते हैं, फिर इसे हमारे "चयनकर्ता" फ़ंक्शन में पास करते हैं। अब हम सिर्फ अपने इष्टतम अंक और पुनरावृत्ति करते हैं, से लंबाई p( घटाए गए अंकों की संख्या) को घटाते हुए n। ध्यान दें कि हम अपने फ़िल्टरिंग फ़ंक्शन को पुनरावर्ती कॉल के लिए पास नहीं करते हैं, और, इसके बजाय, हम इसके साथ प्रतिस्थापित करते हैं id। ऐसा इसलिए है क्योंकि फ़िल्टर केवल उस minimumमामले में अग्रणी 0s के चयन से बचने के लिए है जो केवल पहली पुनरावृत्ति पर प्रासंगिक है। उसके बाद हमें अब किसी फिल्टर की जरूरत नहीं है।

%के लिए वास्तव में केवल एक सहायक समारोह है #जो हमारे "असली" समारोह है, लेने x, y, और z। हम पुनरावृत्ति की एक बिट से बचने के लिए एक सूची समझ का उपयोग करते हैं, हमारे कार्य ट्यूपल्स पर पुनरावृत्ति करते हैं और उन्हें और समवर्ती स्ट्रिंग %के साथ गुजरते हैं z। वह स्ट्रिंग मैजिक मोनाड ऑपरेटर का उपयोग करके बनाया गया है (=<<), जो इस संदर्भ में काम करता है concatMap।

Answer 2

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

r/VDœcL_¥¥ḷ/ƇVṢ.ị

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

सभी संभावनाओं की गणना करता है फिर सबसे बड़ा और सबसे छोटा रखता है।

वाम तर्क: x,yसीमा का निर्माण करने के लिए। सही तर्क: zहटाए जाने वाले अंक।

r/VDœcL_¥¥ḷ/ƇVṢ.ị
r/                 Inclusive range from x to y
  V                Concatenate the digits together
   D               Get the resulting digits
         ¥         Dyad:
        ¥            Dyad:
      L                Length of the list of digits in the concatenated number.
       _               Subtract the number of digits to be removed.
    œc               Combinations without replacement. (remove z digits)
            Ƈ      Keep lists of digits that:
          ḷ/       have a positive first element (no leading zeros).
             V     Combine digits into integers. (vectorizes to ldepth 1)
              Ṣ    Sort the numbers
               .ị  Indexes at value 0.5 which yields the first and last elements.

Answer 3

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

import itertools
s,e,r=input()
l=''.join(map(str,range(s,e+1)))
L=[i for i in itertools.combinations(l,len(l)-r)if'0'<i[0]]
print min(L),max(L)

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

यह लक्ष्य आकार (तत्व आदेश संरक्षित है) के सभी संयोजनों की गणना करके और उससे सबसे छोटी / सबसे बड़ी संख्या प्राप्त करके काम करता है

Comments

ओह ... मुझे लगता है कि काम करता है योग्य। मैं वास्तव में एक कार्यक्रम बनाने के लिए बहुत कोशिश कर रहा था जो वास्तव में इसे निर्धारित करता है।

— डॉन थाउजेंड

@RushabhMehta क्रूर बल गणना अभी भी निर्धारक है, बस धीमी है।

— dylnan

Answer 4

चारकोल , 56 बाइट्स या 21 + 46 35 = 67 56 बाइट्स

≔⪫…·ＮＮωθＦＮ≔⌈ＥθΦθ⁻λνθθ

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

≔⪫…·ＮＮωθ

इनपुट xऔर y, एक समावेशी रेंज बनाएं और संख्याओं को एक स्ट्रिंग में शामिल करें।

ＦＮ

प्रत्येक अंक को निकालने के लिए एक बार लूप करें।

≔⌈ＥθΦθ⁻λνθ

वर्तमान स्ट्रिंग से प्रत्येक संभावित चरित्र को हटाकर बनाई गई स्ट्रिंग्स की एक सूची बनाएं और अधिकतम लें।

θ

परिणाम प्रिंट करें।

≔⪫…·ＮＮωθＦ⊕Ｎ⊞υωΦθ∧⁼ι⌊Φ✂θκＬυ¹∨κＩλ⊞Ｏυω

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

≔⪫…·ＮＮωθ

इनपुट xऔर y, एक समावेशी रेंज बनाएं और संख्याओं को एक स्ट्रिंग में शामिल करें।

Ｆ⊕Ｎ⊞υω

इनपुट करें zऔर इसे बढ़ाएँ। फिर मैं उस लंबाई की एक सूची बनाता हूं: मुझे zनिम्नलिखित फिल्टर के अंदर वृद्धि करने में सक्षम होना चाहिए , लेकिन केवल आदेशों को चर बढ़ाने की अनुमति है; वहाँ है कि PushOperatorसूची की लंबाई में वृद्धि में एक खामी है ।

 θ                      String of digits
Φ                       Filter over characters
         κ              Current index
          Ｌυ            Length of list i.e. current `z` value
            ¹           Literal 1
       ✂θ               Slice string of digits
      Φ                 Filter over characters
              κ         Outer index
               Ｉλ       Cast inner character to number
             ∨          Logical OR
     ⌊                  Minimum
   ⁼ι                   Equals the outer character
  ∧              ⊞Ｏυω   And also push to list i.e. increment `z`
                        Implicitly print

उन वर्णों पर फ़िल्टर करें जो यह जाँच कर चाहते हैं कि स्लाइस योग्य क्षेत्र में कोई निम्न वर्ण नहीं हैं। यह क्षेत्र पहले z+1वर्णों के साथ शुरू होता है (क्योंकि zयदि आवश्यक हो तो पहले दूर स्लाइस करना संभव है) और प्रत्येक पात्र के लिए अंतिम बिंदु वेतन वृद्धि जो रखी गई है। ध्यान रखा जाता है कि पहले पात्र के लिए शून्य का चयन न किया जाए।

सबसे तेज़ संभावित संख्या की गणना करने के लिए उपयोग किए जाने पर तेज़ एल्गोरिथम 30 बाइट्स है:

≔⪫…·ＮＮωθＦ⊕Ｎ⊞υωΦθ∧⁼ι⌈✂θκＬυ¹⊞Ｏυω

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। संपादित करें: मैं तब से उपरोक्त दोनों को एक दूसरे 56 बाइट समाधान में संयोजित करने में सक्षम हूं जो दोनों परिणाम उत्पन्न करता है:

≔⪫…·ＮＮωθＦ⊕Ｎ⊞υω≔⮌υη⟦Φθ∧⁼ι⌈✂θκＬυ¹⊞ＯυωΦθ∧⁼ι⌊Φ✂θκＬη¹∨κＩλ⊞Ｏηω

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

≔⪫…·ＮＮωθ

प्रारंभिक स्ट्रिंग उत्पन्न करें।

Ｆ⊕Ｎ⊞υω

z+1सूची की लंबाई के रूप में प्रतिनिधि ।

≔⮌υη

सूची को इस प्रकार उलट दें और परिणाम को बचाएं।

⟦

दो परिणामों को अलग-अलग लाइनों पर प्रिंट करें। (ऐसा करने का एक अन्य तरीका शाब्दिक \rचरित्र के साथ परिणामों को अलग करना है ।)

Φθ∧⁼ι⌈✂θκＬυ¹⊞Ｏυω

सबसे बड़ी संभव संख्या उत्पन्न करें।

Φθ∧⁼ι⌊Φ✂θκＬη¹∨κＩλ⊞Ｏηω

का ट्रैक रखने के लिए क्लोन सूची का उपयोग करके सबसे छोटी संभव संख्या उत्पन्न करें z।

Answer 5

जेली ,  19  18 बाइट्स

rDẎœcL_⁵Ɗ$ị@Ƈ1ḌṢ.ị

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

बहुत अकुशल, निश्चित रूप से कोई बिंदु नहीं है, जो 1, 100, 100कि$\binom{192}{92}=305812874887035355118559193163641366325011573739619723360$

Answer 6

05AB1E , 16 बाइट्स

ŸSDg³-.Æʒ¬Ā}{Ć`‚

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

पूरा कार्यक्रम, इसी क्रम में आदानों पढ़ने: y, x, जेड । दो वर्णों की एक सूची को आउटपुट करता है।

व्याख्या

ŸSDg³-.Æʒ¬Ā}{Ć`‚    Full program. Inputs: y, x, z.
Ÿ                   Inclusive binary range from x to y. Push [x ... y].
 S                  Dump the digits separately in a list.
  Dg                Duplicate, and use the second copy to get its length.
    ³-              Subtract z from the length.
      .Æ            Retrieve all combinations of length - z elements from the digits.
        ʒ  }        Keep only those that...
         ¬Ā         Don't start with a 0 (head, then Python-style boolean).
            {       Sort the remaining elements.
             Ć      Enclose. Pushes list + list[0] (appends its tail to itself)
              `     Dump all elements separately on the stack.
               ,    Pair, to get the last two, min and max (after enclosing)

Comments

ओह, Ć`‚बहुत स्मार्ट है, अच्छा जवाब!

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

Answer 7

मतलाब, 95 बाइट्स

function[m]=f(s,e,c),a=sprintf('%d',s:e);x=str2num(combnk(a,length(a)-c));m=[min(x),max(x)];end

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

मिनट और अधिकतम के साथ 1x2 मैट्रिक्स लौटाता है।

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

% Full code
function[m]=f(s,e,c),a=sprintf('%d',s:e);x=str2num(combnk(a,length(a)-c));m=[min(x),max(x)];end

% The function
function[m]=f(s,e,c),                                                                       end

                     % Creates the range in a single string
                     a=sprintf('%d',s:e);

                                                   % Gets all the combinations
                                                   combnk(a,length(a)-c)

                                         % Converts the string combinations to integers
                                         x=str2num(                     );

                                                                          % Finds min and max
                                                                          m=[min(x),max(x)];