जितना संभव हो उतना बुरा हो

Question

परिचय

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

आप दूसरों को यह बताने जा रहे हैं कि आप अपने भाई-बहन की तरह निष्पक्ष होना चाहते हैं और इस तरह आप पूर्णांक को समान लंबाई के टुकड़ों में विभाजित करने जा रहे हैं। तो प्रत्येक पूर्णांक के लिए आप सही मात्रा में लोगों के साथ आएंगे जैसे कि सबसे बड़े और सबसे छोटे टुकड़े के बीच का अंतर अधिकतम है।

उदाहरण के लिए यदि आपको पूर्णांक दिया गया है तो आप 6567इसे छोड़ सकते हैं, इसे दो टुकड़ों 65,67या चार में विभाजित करें 6,5,6,7। यह आपको निम्नलिखित अधिकतम अंतर देता है:

6567    -> max() = 0
65,67   -> max(|65-67|) = 2
6,5,6,7 -> max(|6-5|,|6-5|,|6-6|,|6-7|,|5-6|,|5-7|,|6-7|) = 2

चूंकि आप केवल बुराई होना चाहते हैं, आप 67अधिक पसंद नहीं करते हैं 7और इस प्रकार आप 2या तो आउटपुट करेंगे 4।

---

एक और (कम विशेष मामला); पूर्णांक को देखते हुए 121131आप इसे इस तरह विभाजित कर सकते हैं:

121131      -> max() = 0
121,131     -> max(|121-131|) = 10
12,11,31    -> max(|12-11|,|12-31|,|11-31|) = 20
1,2,1,1,3,1 -> max(…) = 2

इस बार केवल एक ही समाधान है - अर्थात् 3- चूंकि तीन लोगों के साथ अंतर अधिकतम है।

चुनौती

पूर्णांक को देखते हुए अधिकतम बुराई होने के किसी भी संभावित तरीके को निर्धारित करते हैं और इसे प्राप्त करने के लिए आवश्यक लोगों की संख्या की रिपोर्ट करते हैं ।

नियम

• इनपुट हमेशा ≥ 1 होगा
• इनपुट या तो पूर्णांक, अंकों की सूची या स्ट्रिंग हो सकता है
• आपको अमान्य इनपुट को संभालना नहीं है

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

आपको केवल आवश्यक परिणामी लोगों की रिपोर्ट करने की आवश्यकता है, संभावित विभाजन केवल चित्रण के लिए हैं:

In -> splits (difference) -> Out
1 -> [1] (0) -> 1
10 -> [1,0] (1) -> 2
11 -> [11] or [1,1] (0) -> 1 or 2
12 -> [1,2] (1) -> 2
42 -> [4,2] (2) -> 2
101 -> [1,0,1] (1) -> 3
2222 -> [2222] or [22,22] or [2,2,2,2] (0) -> 1 or 2 or 4
6567 -> [65,67] or [6,5,6,7] (2) -> 2 or 4
123000 -> [123,000] (123) -> 2
123001 -> [123,001] (122) -> 2
121131 -> [12,11,31] (20) -> 3
294884 -> [294,884] (590) -> 2
192884729 -> [192,884,729] (692) -> 3
123456189012 -> [123456,189012] (65556) -> 2
123457117346 -> [1234,5711,7346] (6112) -> 3

Comments

मुझे आश्चर्य है कि क्या कोई प्रोग्रामिंग भाषा की बुराई में समाधान प्रस्तुत करेगा? : डी

— एसके

Answer 1

जेली ,  16  14 बाइट्स

Ṁ_Ṃ
sLÆD$ḌÇÞṪL

पूर्णांक (अंकों) की एक सूची लेने और एक पूर्णांक वापस करने के लिए एक विवादास्पद लिंक।

इसे ऑनलाइन आज़माएं! या एक परीक्षण-सूट देखें

कैसे?

Ṁ_Ṃ - Link 1, maximal difference: list of numbers
Ṁ   - maximum
  Ṃ - minimum
 _  - subtract

sLÆD$ḌÇÞṪL - Main link: list of numbers, theDigits  e.g. [1,2,3,0,0,1]
    $      - last two links as a monad:
 L         -   length                                    6
  ÆD       -   divisors                                  [1,2,3,6]
s          - split into chunks (vectorises)              [[[1],[2],[3],[0],[0],[1]],[[1,2],[3,0],[0,1]],[[1,2,3],[0,0,1]],[[1,2,3,0,0,1]]]
     Ḍ     - from decimal (vectorises)                   [[1,2,3,0,0,1],[12,30,1],[123,1],[123001]]
       Þ   - sort by:
      Ç    -   call last link (1) as a monad              3             29        122     0
           -                                         ... [[123001],[1,2,3,0,0,1],[12,30,1],[123,1]]
        Ṫ  - tail                                        [123,1]
         L - length                                      2

Comments

हाँ, मैं जानता हूँ कि आप पायथ को नहीं जानते हैं! +1 क्योंकि जेली के दिमाग एक जैसे लगते हैं! बहुत बुरा ŒṖऔर ./दोनों लंबे समय तक हैं

— श्री एक्सकोडर

Answer 2

अजगर , 20 बाइट्स

leoeSaM^N2vcRQ*M{yPl

यहाँ यह कोशिश करो!

मैं अब विभाजन का उपयोग नहीं करता, क्योंकि यह लंबे समय तक चलता है !!! मैंने लंबाई के विभाजकों के बराबर लंबाई के विभाजकों में विभाजित किया।

Answer 3

05AB1E , 12 बाइट्स

gDÑΣôDδαà}θ÷

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

05AB1E , 12 बाइट्स

gDÑΣôàsß-}θ÷

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

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

gD gôDÑΣαà} δ δ | पूरा कार्यक्रम।

जी | लंबाई (अंकों की गिनती)।
 डी | डुप्लिकेट (स्टैक के लिए लंबाई की दो प्रतियां धक्का)।
  Ñ ​​| भाजक प्राप्त करें (ढेर के शीर्ष पर)।
   Σ} | एक प्रमुख कार्य के आधार पर छाँटें।
-------------------------------------------------- ------------
    ôDδαà | मुख्य समारोह # 1।
    ô | स्प्लिट (इनपुट) उस आकार के विखंडू में।
     डी | डुप्लिकेट।
      δα | पूर्ण अंतर का बाहरी उत्पाद।
        आ | अधिकतम प्राप्त करें।
    ôàsß- | मुख्य समारोह # 2 (वैकल्पिक)।
    ô | स्प्लिट (इनपुट) उस आकार के विखंडू में।
     आ | ज्यादा से ज्यादा।
      s | शीर्ष दो तत्वों को स्वैप करें।
       ß | न्यूनतम।
        - | घटाएं।
-------------------------------------------------- ------------
          ÷ ÷ | कस्टम छँटाई का उपयोग करके अधिकतम तत्व द्वारा लंबाई को विभाजित करें।

इस चुनौती के लिए 05AB1E सिर्फ अविश्वसनीय रूप से प्रचलित है।

Answer 4

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

सहेजे गए 3 बाइट @ edc65 की बदौलत

एक स्ट्रिंग के रूप में इनपुट लेता है।

f=(s,k=l=s.length,m)=>k?f(s,k-1,l%k||(d=Math.max(...a=s.match(eval(`/.{${l/k}}/g`)))-Math.min(...a))<m?m:(r=k,d)):r

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

f=(s,k=l=s.length,m)=>k?f(s,k-1,l%k||(d=Math.max(...a=s.match(eval(`/.{${l/k}}/g`)))-Math.min(...a))<m?m:(r=k,d)):r

console.log(f('1')) // [1] (0) -> 1
console.log(f('10')) // [1,0] (1) -> 2
console.log(f('11')) // [11] or [1,1] (0) -> 1 or 2
console.log(f('12')) // [1,2] (1) -> 2
console.log(f('42')) // [4,2] (2) -> 2
console.log(f('101')) // [1,0,1] (1) -> 3
console.log(f('2222')) // [2222] or [22,22] or [2,2,2,2] (0) -> 1 or 2 or 4
console.log(f('6567')) // [65,67] or [6,5,6,7] (2) -> 2 or 4
console.log(f('123000')) // [123,0] (123) -> 2
console.log(f('123001')) // [123,1] (122) -> 2
console.log(f('121131')) // [12,11,31] (20) -> 3
console.log(f('294884')) // [294,884] (590) -> 2
console.log(f('192884729')) // [192,884,729] (692) -> 3
console.log(f('123456189012')) // [123456,189012] (65556) -> 2
console.log(f('123457117346')) // [1234,5711,7346] (6112) -> 3

Comments

क्या आपने RegExp के बजाय eval की कोशिश की?

— edc65

@ edc65 मैं उस एक के बारे में भूल रहा हूँ। धन्यवाद!

— अरनौलड

Answer 5

अजगर 2 , 138 132 बाइट्स

n=input()
l=len(n)
print len(max([[int(n[l/i*j:][:l/i])for j in range(i)]for i in range(1,l+1)if l%i<1],key=lambda a:max(a)-min(a)))

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

Answer 6

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

f n|l<-length n=snd$maximum[(a-b,div l i)|i<-[1..l],mod l i<1,a<-i%n,b<-i%n]
i%[]=[]
i%n=read(take i n):i%drop i n

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

Answer 7

पर्ल 5 , 70 बाइट्स

s%.%/A/g;/$/,map$;[$-=$`-$_]=@1,@1for@1=(/.{@{+}}/gc)x!/./g%eg;$_=pop@

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

Answer 8

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

ŒṖL€E$ÐfḌạþ`ẎṀ$$ÐṀḢL

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