कोडगॉल्फ इंद्रधनुष: प्रतिबिंब के साथ छंटाई रंग


9

परिचय:

बाद में मैंने दो इंद्रधनुष से संबंधित चुनौतियों को पोस्ट किया: कोडगॉल्फ रेनबो: फन विथ इंटेगर- एरेस 1 और कोडगॉल्फ इंद्रधनुष: ड्रा इन ब्लैक-एंड-व्हाइट 2 , ASCII में @ChrisM द्वारा निम्नलिखित टिप्पणी की गई थी ( ब्लैक-एंड-व्हाइट में ड्रा) ) चुनौती :

हो सकता है कि आप यह जानते हों और यह डिजाइन के द्वारा हो (मुझे पता है कि इंद्रधनुष इंद्रधनुषी या असिसी नहीं होते हैं, और उच्चतर आदेशों की स्थिति अधिक जटिल होती है), लेकिन क्या दूसरे इंद्रधनुष में रंग उलटे नहीं हैं?

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

तो, चलो उस तथ्य का उपयोग करके एक तीसरी संबंधित चुनौती बनाते हैं।

चुनौती:

इनपुट्स: एक सकारात्मक पूर्णांक nजो होता है >=2, और पूर्णांकों के आकार की एक सूची >= n+1
आउटपुट: एक ही सूची इस प्रकार है:

  1. पहले आकार की उप-सूचियों में इनपुट सूचियों को विभाजित करें n(जहां अनुगामी उप-सूची सीमा में किसी भी आकार की हो सकती है [1,n])।
  2. फिर हम उप-सूचियों की मात्रा के आधार पर निम्नलिखित करते हैं m:
    • m - m//2उप-सूचियों की पहली राशि को निम्नतम से उच्चतम (जहां //पूर्णांक-विभाजन) सॉर्ट करें । (यानी 6 उप-सूचियों के साथ पहले तीन को सबसे कम से उच्चतम तक क्रमबद्ध किया जाएगा। 5 उप-सूचियों के साथ मुट्ठी तीन को सबसे कम से उच्चतम तक क्रमबद्ध किया जाएगा।)
    • m//2उप-सूचियों की अंतिम राशि को उच्चतम से निम्नतम (जहां //पूर्णांक-विभाजन) सॉर्ट करें । (यानी 6 उप-सूचियों के साथ अंतिम तीन को उच्चतम से सबसे कम क्रमबद्ध किया जाएगा। 5 उप सूचियों के साथ अंतिम दो को उच्चतम से सबसे कम क्रमबद्ध किया जाएगा।)
  3. फिर से एक सूची बनाने के लिए सभी उप-सूचियों को एक साथ मिलाएं

उदाहरण:

इनपुट्स: n=7और [3,2,1,-4,5,6,17,2,0,3,5,4,66,-7,7,6,-5,2,10]
चरण 1: [[3,2,1,-4,5,6,17],[2,0,3,5,4,66,-7],[7,6,-5,2,10]]
चरण 2: [[-4,1,2,3,5,6,17],[-7,0,2,3,4,5,66],[10,7,6,2,-5]]
चरण 3 / आउटपुट:[-4,1,2,3,5,6,17,-7,0,2,3,4,5,66,10,7,6,2,-5]

इनपुट्स: n=4और [7,4,-8,9,3,19,0,-23,-13,13]
चरण 1: [[7,4,-8,9],[3,19,0,-23],[-13,13]]
चरण 2: [[-8,4,7,9],[-23,0,3,19],[13,-13]]
चरण 3 / आउटपुट:[-8,4,7,9,-23,0,3,19,13,-13]

चुनौती नियम:

  • पूर्णांक इनपुट n1 से बड़ा होने की गारंटी है।
  • पूर्णांक-सूची का आकार इससे बड़ा होने की गारंटी है n
  • अनुगामी उप-सूची से छोटी हो सकती है n(जैसा कि उदाहरणों और परीक्षण मामलों में देखा जा सकता है)।
  • I / O प्रारूप किसी भी उचित प्रारूप में लचीला है। एक पूर्णांक या दशमलव की एक सूची / सरणी हो सकती है, एक अल्पविराम / अंतरिक्ष / न्यूलाइन सीमांकित स्ट्रिंग, पूर्णांक की धारा, आदि (आउटपुट चरण 2 की सूची की 2 डी सूची नहीं हो सकती है। चरण 3 इसे एक सूची में वापस समतल करने के लिए हो सकता है। इस चुनौती के लिए आवश्यक है।)

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

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

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

Inputs: n=7 and [3,2,1,-4,5,6,17,2,0,3,5,4,66,-7,7,6,-5,2,10]
Output: [-4,1,2,3,5,6,17,-7,0,2,3,4,5,66,10,7,6,2,-5]

Inputs: n=4 and [7,4,-8,9,3,19,0,-23,-13,13]
Output: [-8,4,7,9,-23,0,3,19,13,-13]

Inputs: n=2 and [7,-3,1]
Output: [-3,7,1]

Inputs: n=3 and [1,6,99,4,2]
Output: [1,6,99,4,2]

Inputs: n=2 and [5,2,9,3,-5,-5,11,-5,4,12,9,-2,0,4,1,10,11]
Output: [2,5,3,9,-5,-5,-5,11,4,12,9,-2,4,0,10,1,11]

Inputs: n=3 and [5,2,9,3,-5,-5,11,-5,4,12,9,-2,0,4,1,10,11]
Output: [2,5,9,-5,-5,3,-5,4,11,12,9,-2,4,1,0,11,10]

जवाबों:


5

ब्रेकीलॉग , 18 17 16 बाइट्स

ġ₎↔ḍ↔{izo₎ᵐ↔}ᶠcc

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

-1 बाइट @ शुंदर को धन्यवाद

के रूप में इनपुट की उम्मीद है [<integer list>, n]। ध्यान दें कि ऋणात्मक पूर्णांकों का प्रतिनिधित्व किया जाता है _, ब्राचीलॉग "कम माइनस"। आउटपुट वेरिएबल है R

पहली बार ब्राचीलॉग का प्रयास करना, इसलिए मुझे लगता है कि यह उप-इष्टतम है और बाइट्स में कमी के लिए परिपक्व है।

व्याख्या

विभाजन, द्विभाजित, अनुक्रमणिका के आधार पर सॉर्ट (0: asc, 1: desc), समतल।

ġ₎               | split head of input into groups of length n (last of list)
  ↔              | reverse so that...
   ḍ             | dichotomize splits in two, attaching any additional element to the second list
    ↔            | reverse so first half of partitions corresponds to the 0 index
     {      }    | apply
      i          | : append index
       z         | : zip each sublist with the index of its parent
        o₎ᵐ      | : map over sublists, ordering by the zipped index
           ↔     | : undo earlier reverse
             ᶠ   | find all outputs
              cc | flatten two levels

17 बाइट्स प्राप्त करने के लिए अपने दूसरे समाधान के लिए एक छोटा सा ट्वीक: इसे ऑनलाइन आज़माएं!
सूंदर -

@ सूंदर मुझे एक शक था, मैं एक बहुत से मैप कर रहा था, धन्यवाद!
अतिरेक

यह किस भाषा के लिए है?
सैम ओरोज्को

@SamOrozco ट्रिक डिक्लेक्टिव लॉजिक प्रोग्रामिंग। भाषा के नाम पर क्लिक करने का प्रयास करें!
एडम

3

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

sṢ€ŒHUÐeF

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


1
मुझे समझ नहीं आता कि यह प्रोग्रामिंग भाषा क्यों मौजूद है।
सैम ओरोज़्को

@SamOrozco यह एकमात्र उद्देश्य है कि समस्याओं को यथासंभव कम कोड के साथ हल करना।
आदम

क्या सचमे। यह अच्छा है।
सैम ओरोज्को



2

05AB1E (विरासत) , 9 बाइट्स

ô€{2ä`í«˜

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

इसे ऑनलाइन आज़माएं! में 05AB1E (अमृत पुनर्लेखन) - उम्मीद इनपुट ढेर, एक डिफ़ॉल्ट आई / ओ पद्धति पर किया जाना है।

केविन अपने स्वयं के 11-बटर के साथ आया था जो मुझे 10. पर मिलता था और फिर मैं 9 बाइट्स के लिए कुछ और लेकर आया था।


अच्छा है। यहाँ 11-बाइट विकल्प के रूप में मेरा प्रारंभिक समाधान था ô€{2äRć€R)˜:।
केविन क्रूजसेन

1
@KevinCruijssen अपने दृष्टिकोण हाहा का उपयोग करके 10 पर पहुंच गया। संपादित करें : 9 अब!
मिस्टर एक्सकोडर १18 ’१

बहुत सुंदर। पूरी तरह से भूल गया í। और अच्छा अतिरिक्त गोल्फ।
केविन क्रूज़सेन

2

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

@ ब्रेड के लिए 1 बाइट का धन्यवाद सहेजा गया

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

a=>n=>(g=z=>a+a?[...a.splice(0,n).sort((x,y)=>1/z?x-y:y-x),...g(a[i+=n])]:a)(i=0)

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


के बाद से aएक आयामी है, मेरा मानना है कि आप की जगह ले सकता a>[]साथ a+aगैर खाली मामले की जांच करने के लिए और बचाने 1 बाइट। विभाजन के लिए वास्तव में चतुर पुनरावृत्ति रणनीति और क्रमबद्ध करने के लिए निर्धारित करने के लिए, साथ ही साथ!
अतिरेक

@redundancy जो वास्तव में सुरक्षित होनी चाहिए। धन्यवाद!
अरनुलड
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.