संकट

मान लें कि आपके पास S _{N के} माध्यम से S ₁ नाम का N ढेर है , जहां प्रत्येक S _k (k = 1 से N) में नंबर k की N प्रतियां हैं।

उदाहरण के लिए, जब N = 3 स्टैक इस तरह दिखता है:

1  2  3  <- top of stack
1  2  3
1  2  3  <- bottom of stack
=======
1  2  3  <- stack index

^{यहां 1, 2 और 3 के रूप में अनुक्रमित 3 ढेर हैं, और प्रत्येक में अपने स्वयं के सूचकांक के एन उदाहरण हैं।}

लक्ष्य N ढेर को फिर से व्यवस्थित करना है, ताकि उनमें से प्रत्येक में N से शीर्ष पर क्रम से 1 नंबर की पहचान हो।

उदाहरण के लिए N = 3 में लक्ष्य है कि स्टैक को फिर से व्यवस्थित करना:

केवल एक ही क्रिया जो आप स्टैक के साथ कर सकते हैं वह स्टैक (पॉपिंग) में से एक से शीर्ष नंबर ले रही है, फिर तुरंत इसे एक अलग स्टैक (पुशिंग) के ऊपर रखकर । यह इन शर्तों के अधीन है:

एक संख्या को केवल एक स्टैक पर धकेला जा सकता है यदि यह उस स्टैक पर शीर्ष संख्या से कम या उसके बराबर है।
- जैसे एक 1एक के साथ एक ढेर पर पुश किया जा सकता 1, 2या 3शीर्ष पर है, लेकिन एक 2ही एक साथ एक ढेर पर पुश किया जा सकता 2या 3शीर्ष पर (या अधिक)।
- इसका प्रभाव यह है कि ढेर हमेशा नीरस रूप से ऊपर से नीचे की ओर बढ़ते हैं ।
किसी भी गैर-रिक्त स्टैक को पॉप किया जा सकता है, और यह मानते हुए कि पिछली बुलेट संतुष्ट है, किसी भी स्टैक को धक्का दिया जा सकता है।
किसी भी संख्या को एक खाली स्टैक पर धकेला जा सकता है।
स्टैक की कोई अधिकतम ऊंचाई सीमा नहीं है।
ढेर को बनाया या नष्ट नहीं किया जा सकता है, उनमें से हमेशा एन होते हैं।

यह चुनौती यह तय करने के बारे में है कि स्टैक एक्सचेंज को पूरा करने के लिए कौन से पॉप और पुश करता है, जरूरी नहीं कि सबसे कम चाल में हो, लेकिन एक निश्चित तरीके से।

(कार्ड के डेक के साथ अभ्यास करना समस्या को महसूस करने का एक अच्छा तरीका है।)

चुनौती

एक प्रोग्राम या फ़ंक्शन लिखें जो एक सकारात्मक पूर्णांक एन में लेता है, 3 या उससे ऊपर की गारंटी। प्रारंभिक अवस्था से स्टैक को पुनर्व्यवस्थित करने के लिए आवश्यक सभी पॉप-पुश क्रियाओं को दर्शाने वाला स्ट्रिंग प्रिंट या वापस करें:

1  2  3  4  5
1  2  3  4  5
1  2  3  4  5
1  2  3  4  5
1  2  3  4  5
=============
1  2  3  4  5

^{(एन = 5 मामला)}

अंतिम स्थिति तक:

1  1  1  1  1
2  2  2  2  2
3  3  3  3  3
4  4  4  4  4
5  5  5  5  5
=============
1  2  3  4  5

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

उदाहरण के लिए, यहाँ N = 3 केस के लिए संभावित वैध आउटपुट है:

1 2  [move the top number on stack 1 to the top of stack 2]
1 2  [repeat]
1 2  [repeat]
3 1  [move the top number on stack 3 to the top of stack 1]
2 3  [etc.]
2 3
2 3
2 1
2 1
2 1
3 1
3 1
3 1
3 2
1 2
1 2
1 2
1 3
2 3
2 3
2 3
1 2
3 2
3 1

आपके आउटपुट को केवल सही होने की आवश्यकता नहीं है। यानी आपको पॉप और पुश की संख्या को कम करने की आवश्यकता नहीं है।
- तो यह ठीक होगा अगर, कहते हैं, कुछ कदम बार-बार किए गए और तुरंत उलट हो गए।
- एक ही चाल में एक ही स्टैक पर खिसकना और धकेलना, जैसे 2 2कि अनुमति दी जाती है (हालांकि बिल्कुल बेकार)।
आपके आउटपुट को निर्धारक और परिमित होने की आवश्यकता है।
याद रखें कि स्टैक में 1-आधारित अनुक्रमण होता है। 0-आधारित अनुक्रमण की अनुमति नहीं है।
N से अधिक 9 कोर्स के काम के साथ-साथ एकल अंक N भी होना चाहिए।
यदि आप चाहते हैं तो आप रिक्त स्थान और newlines के स्थान पर किसी भी दो अलग-अलग, गैर-अंकीय मुद्रण योग्य ASCII वर्णों का उपयोग कर सकते हैं । आउटपुट में एक अनुगामी न्यूलाइन (या न्यूलाइन विकल्प) ठीक है।

स्कोरिंग

बाइट्स में सबसे छोटा कोड जीतता है। टाईब्रेकर उच्च मतदान वाला उत्तर है।

यदि आप अपने एल्गोरिथ्म को दिखा सकते हैं तो वैधता ब्राउनी अंक इष्टतम है।

code-golf number data-structures

— केल्विन के शौक
स्रोत

छोटी चीज़ों के लिए "अतिरिक्त बिंदुओं के साथ रुकें" बकवास> _>

— user48538

@ zyabin101 आपने अभी-अभी ब्राउनी में कोई मौका गंवाया है।

— केल्विन के शौक

आप हमेशा इस तरह के अद्भुत खिताब के साथ आते हैं!

— लुइस मेंडो

@ हेलकाहोम्बा-._(._.)_.-

— उपयोगकर्ता ४38५३el

क्या N=3इष्टतम के मामले में संभव उत्पादन शामिल है ?

— आर। कप

पायथ 96 94 बाइट्स

Mt*Q+++bGdHM|%+y_GHQQg1 2++Qd1g2 3g2 1g3 1++Qd2Vr3QgNtN++QdN;g1QVStQVStQI<NHgnNHnNtH)++nN0dnNH

इसे यहाँ आज़माएँ

यह कैसे काम करता है?

यह स्पष्टीकरण N = 5 का उपयोग होगा।

भाग 1: हर स्टैक पर नीचे की परत बनाएं

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

विज़ुअलाइज़ेशन: (कोष्ठक का अर्थ है कि क्या स्थानांतरित किया जाएगा)

     _
11111 |
22222 |_ Can't move 4s here, not monotonically increasing
33333_|
(44444)------------??? Where to put the 4s?
55555 <- Must supply the 5 that will be moved

इसके बजाय, इस पहले एक्सचेंज को करने के लिए, हम पहले सभी 1s को दूसरे स्टैक पर ले जाएँगे, 5 को पहले स्टैक में ले जाएँ (जो अब खाली है), 1s को तीसरे स्टैक में ले जाएँ, 2 एस को पहले स्थानांतरित करें स्टैक, 1s को पहले स्टैक पर वापस ले जाएँ, और अंत में 5 को दूसरे स्टैक पर ले जाएँ।

(11111)-----.
2222211111<-'
===============================
5<---------.
2222211111 : (from stack 5)
===============================
5
22222(11111)-.
3333311111<--'
===============================
522222<-.
(22222)-'
3333311111
===============================
52222211111<-.
             |
33333(11111)-'
===============================
52222211111
5<-----.
33333  |
44444  |
555(5)-'

अब जब हमारे पास स्टैक को स्थानांतरित करने के लिए एक खाली स्थान है (स्टैक 2, जिसमें केवल एक 5 है जिसे सही स्थान पर रखा गया है), हम सभी 3s को स्टैक 2 में स्थानांतरित कर सकते हैं और स्टैक 3 में 5 रख सकते हैं। हम फिर दोहरा सकते हैं स्टैक 4 के लिए एक ही बात है, और अब हम सभी 5 एस को सही जगह पर प्राप्त करते हैं! और बस एक और बात: हम सभी 1s को 5 स्टैक पर ले जाएंगे ताकि हमें अगले स्टैक एक्सचेंज के लिए एक अच्छा सेटअप मिल सके।

522222(11111)-.
533333        |
544444        |
5             |
511111<-------'

भाग 2: बाकी सब कुछ करें :)

अब यह बहुत आसान है, क्योंकि अब हमारे पास हमेशा उन अन्य नंबरों को स्थानांतरित करने के लिए एक फ्री स्टैक होगा, जिन्हें हमें चारों ओर घूमने की आवश्यकता है। तो, पहले हम यह पता लगाते हैं कि 4 कहां है। थोड़ी सी परीक्षा से पता चलेगा कि यह हमेशा 1 से ऊपर होगा जहां से यह शुरू हुआ था, या आखिरी स्टैक के ऊपर 2 था। अब, हम बस स्टैक्स को नीचे रखते हैं, स्टैक में 4 रखते हैं यदि यह मुफ़्त है, या अन्य संख्याओं को 1 स्टैक तक बढ़ा रहा है यदि यह नहीं है। अब हमारे पास सभी 4 जी हैं।

522222<------.
533333<----. |
544444-.-.-'-'
5<-----' |
511111<--'
===============================
5433333
54
54
5411111
5422222

अब, हम महसूस करते हैं कि 3s 2 ढेर ऊपर हैं जहां 4 जी जहां हैं। इसका मतलब है कि हम वही काम कर सकते हैं जो हमने 4s के साथ किया था! और जैसा कि यह पता चला है, हम ऐसा तब तक कर सकते हैं जब तक हम स्टैक इंडेक्स को दूसरी तरफ लपेटते हैं।

5433333-'wrap around 543
54                   543
54                   54311111
5411111 .----------->54322222
5422222 |2 stacks up 543

और इसलिए, हम ऐसा तब तक कर सकते हैं जब तक कि हमने सभी ढेरों का आदान-प्रदान नहीं कर लिया है।

कोड स्पष्टीकरण:

सबसे पहले: (महत्वपूर्ण) पूर्वनिर्धारित चर।

Q: Evaluated input.
b: The newline character, '\n'
d: A space, ' '

2 लंबोदर परिभाषाएँ हैं।

M           | g(G)(H), used for moving Q numbers at a time.
            | We will call these Q numbers a "(number) block"
 t          | Tail, used to remove beginning newline
  *Q        | Repeat the following Q times
    +++bGdH | '\n' + G + ' ' + H. Just a whole bunch of concatenating.
            |
M           | n(G)(H), used for figuring out which stacks to move from
 |       Q  | If the following code is 0 (false), then use Q instead
  %     Q   | Mod Q
   +   H    | Add H
    y       | Multiply by 2
     _G     | Negate (remember in the explanation part 2? Always 2 stacks above?)

स्टैक एक्सचेंजिंग: भाग 1

g1 2                       | Move the 1 block to stack 2
    ++Qd1                  | Move a Q to stack 1
         g2 3              | Move the 1 block to stack 3
             g2 1          | Move the 2 block to stack 1
                 g3 1      | Move the 1 block back to stack 1
                     ++Qd2 | Move a Q to stack 2
 v---Code-continuation---' |I don't have enough room!!!
Vr3Q                       | For N in range(3, Q)
    gNtN                   | Move the number block in stack N up 1
        ++QdN              | Move a Q to stack N
             ;g1Q          | End for loop; move the 1 block to the last stack

स्टैक एक्सचेंजिंग: भाग 2

VStQ                           | For N in [1, 2, ..., Q - 1]
    VStQ                       | For H in [1, 2, ..., Q - 1]
        I<NH                   | If N < H
            g                  | Number block move
             nNH               |  (find number block)
                nNtH           |  (find the previous stack)
                    )          | End "For H"
                     ++nN0dnNH | Find start, move number to next location down

मुझे पहले से पता है कि मुझे ब्राउनी पॉइंट्स नहीं मिल रहे हैं, क्यूज़ मैं कई और अधिक कुशल और अधिक जटिल तरीके देख सकता हूँ :(

— के झांग
स्रोत

ढेर का आदान-प्रदान