क्लेन टोपोलोलीग्लॉट्स

Question

क्लेन एक 2 डी भाषा है जिसे मैंने डिज़ाइन किया है जिसे 12 विभिन्न सामयिक सतहों पर एम्बेड किया जा सकता है। एक क्लेन प्रोग्राम को विभिन्न सतहों पर कमांड लाइन के तर्कों को बदलकर चलाया जा सकता है।

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

उदाहरण टोपोलॉजी के लिए 000, अधिकांश 2D भाषाओं द्वारा उपयोग की जाने वाली टोपोलॉजी , निर्देश सूचक को दूसरी तरफ लपेटने का कारण बनती है जब वह किसी किनारे से जाती है।

कार्य

यह कार्य बहुत सरल है, एक क्लेन कार्यक्रम लिखिए कि जब रन टोपोलॉजी को आउटपुट करेगा तो यह रन हो जाएगा। अलग-अलग नंबर रिक्त स्थान से अलग हो सकते हैं। (उदाहरण के लिए 000और 0 0 0दोनों अनुमेय आउटपुट हैं)। आप -Aकमांड लाइन के झंडे का उपयोग करने या अनदेखा करने का विकल्प चुन सकते हैं, यदि आप इसका उपयोग करते हैं तो आपको बाइट का खर्च नहीं करना पड़ेगा।

यह कोड-गोल्फ है इसलिए सबसे छोटा उत्तर विजेता होगा।

यहाँ एक ऑनलाइन टेस्ट ड्राइवर है जिसका उपयोग सभी टोपोलॉजी को एक ही बार में करने के लिए किया जा सकता है। पूर्णांक मोड में चलाने के लिए निकालें -A।

Comments

एक अच्छी भाषा-विशिष्ट चुनौती के बेहतरीन उदाहरण के लिए +1। :)

— मार्टिन एंडर

@StephenS No. मैं इसे आपको मुफ्त में दूंगा :)

— गेहूं जादूगर

आईपी ​​आंदोलन मेरे सिर को चोट पहुँचा रहे हैं

— मिकी

कृपया छवि ठीक करें ...

— user202729

@JoKing मैं थोड़ी देर के लिए जाना जाता है, और इसे ठीक करने का अर्थ है। मैंने अब के लिए छवि हटा दी है और उम्मीद है कि मैं अंततः एक नया बनाने के लिए समय लूंगा। धन्यवाद।

— गेहूं जादूगर

Answer 1

52 48 बाइट्स

./@$0<$
21\./01
..>..!\
@
.<..<\
20//\11
@01$00@

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

परीक्षण चालक

व्याख्या

क्लेन में आईपी शीर्ष बाएं कोने में दाईं ओर शुरू होता है। पहला कदम जो मैं चाहता था कि मेरा कार्यक्रम पहला और तीसरा बिट निर्धारित करने के लिए आईपी को कार्यक्रम के शीर्ष पर भेजना था। IP टोपोलॉजी के आधार पर कार्यक्रम को इस प्रकार प्रस्तुत करेगा:

             ^
            I|P
            ./.....
201, 211 -->.......<-- 100, 110
            .......
            .......
            .......
200, 210 -->.......<-- 101, 111
            .......
             ^   ^
             |   |
            000 001
            010 011

मैंने फैसला किया कि मेरा कार्यक्रम दूसरे बिट से पहले टोपोलॉजी के तीसरे बिट को रिकॉर्ड करेगा लेकिन $अंत से पहले उन्हें (उपयोग करके ) स्वैप करेगा । उस अंत तक मैंने ऊपर वर्णित प्रविष्टि के आईपी बिंदुओं पर प्रत्येक टोपोलॉजी के पहले और तीसरे बिट्स को पुश करने के लिए कोड जोड़ा।

./.....
21...01
.......
.......
.......
20...11
.0...0.

आगे मैंने टोपोलॉजी पर 1या 2उनके पहले बिट के रूप में ध्यान केंद्रित किया । मैंने उन्हें फिर से जोड़ने और उत्तर की ओर से जुड़े न होने के कारण उन्हें वापस भेजने का फैसला किया ताकि मैं उनकी दूसरी बिट का निर्धारण कर सकूं।

                      ./.....
                      21\./01
                      ..>....--> 200, 201, 210, 211
                      .......
100, 101, 110, 111 <--....<..
                      20/.\11
                      .0...0.
                        ^ ^
                        | |
                        / \
                      110 100
                      111 101
                      210 200
                      211 201

आसानी से इस टोपोलॉजी को उनके दूसरे बिट द्वारा फिर से संगठित किया गया ताकि मैं उसे ढेर कर सकूं।

./.....
21\./01
..>....
.......
....<..
20/.\11
.01.00.

उसके बाद मुझे बस दूसरे और तीसरे बिट को स्वैप करने की आवश्यकता थी और कार्यक्रम को समाप्त करना होगा।

./.$...
21\./01
..>....
@......
....<..
20//\11
.01$00.

अब जबकि टोपोलॉजी के साथ 1या 2उनके पहले बिट ने काम किया था, मैं 0सही आउटपुट देने के साथ टोपोलॉजी बनाने पर ध्यान केंद्रित कर सकता था । पहला चरण उन्हें पुनर्संयोजित कर रहा था ताकि उन्हें उनके दूसरे बिट के आधार पर दो समूहों में अलग किया जा सके।

                      ./.$...
                      21\./01
                      ..>....<-- 010, 011
                      @......
000, 001, 010, 011 <--.<..<<.<-- 000, 001
                      20//\11
                      .01$00.

मैंने पहली बार उन टोपोलॉजीज़ पर ध्यान केंद्रित किया जो 1उनके दूसरे बिट के रूप में हैं। इन लोगों ने एक चुनौती पेश की क्योंकि उनके लिए आईपी पहले से ही सबसे 2पहले के रूप में टोपोलॉजी द्वारा उपयोग की जाने वाली एक लाइन पर थी । चूंकि यह उस लाइन पर एक से अधिक निर्देशों को फिट करने के लिए मुश्किल होगा (अनुदेश का उपयोग करके एक एकल निर्देश को छलांग लगाया जा सकता है !) और मैं संपूर्ण रूप से अंतरिक्ष पर कम चल रहा था, मैंने उस लाइन से आईपी को पुनर्निर्देशित करने और एक मौजूदा 1निर्देश का पुन: उपयोग करने का निर्णय लिया दूसरा सा धक्का देने के लिए।

./.$...
21\./01
..>..!\
@......
.<..<<.
20//\11
.01$00.

अब उन सभी के लिए टोपोलॉजी के लिए छोड़ दिया गया था 1क्योंकि उनके दूसरे बिट को दूसरे और तीसरे बिट के आदेश को ठीक करना और समाप्त करना था।

       ^
       |
 ./.$..$
 21\./01
 ..>..!\
 @......
 .<..<<.
 20//\11
 @01$00@
 ^     ^
 |     |
011   010

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

./.$.<$
21\./01
..>..!\
@......
.<..<\.
20//\11
@01$00@

मुझे अभी भी 0दूसरे बिट के लिए धक्का देने और दूसरे और तीसरे बिट के क्रम को ठीक करने के साथ-साथ कार्यक्रम को समाप्त करने की आवश्यकता थी। सौभाग्य से, मैं एक मौजूदा $निर्देश का पुन: उपयोग करने में सक्षम था ताकि शेष स्थानों में निर्देश 0और @निर्देश फिट हो सकें।

./@$0<$
21\./01
..>..!\
@......
.<..<\.
20//\11
@01$00@

अंत में अंतिम कार्यक्रम प्राप्त करने के लिए लाइनों के सिरों से नोड्स छीन लिए जा सकते हैं।

Answer 2

116 88 86 77 69 61 60 59 58 54 53 50 बाइट्स

\2..@2
/1\<$00
/>!..>!
0//
@0$10@1
011\.<0
\.<@>1@

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

Comments

@WheatWizard आपने इसे कैसे बनाया है फिर 0.o और हो सकता है कि आपको क्यूबिक्स के लिए बनाए गए ईटीएच

— स्टीफन

@StephenS यदि आप क्लेन को -dध्वज के साथ चलाते हैं तो यह ठीक यही करेगा। दुर्भाग्य से यह TIO में काम नहीं करता है।

— गेहूं जादूगर

Answer 3

44 41 40 38 37 बाइट्स

\\1.>2
/0./
@./$(\
$>0!>
11$/10
$.@.1

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

परीक्षण चालक।

6 बाय 6 वर्ग का उपयोग करता है। अगर मैं इसे सुधारने की कोशिश करना चाहता हूं तो सबसे कम मैं 8 से 8 वर्ग के साथ 38 बाइट्स प्राप्त कर सकता हूं ।

स्पष्टीकरण:

पहला पास-थ्रू कोड कोड उपसर्गों के लिए पहले दो संख्याओं को कूटबद्ध करता है 0और 1। के लिए 2, यह तीसरे नंबर को फिर पहले को एनकोड करता है।

     201  200
     211  210
       |  |
       v  v
   -> \\1.>2
 IP<- /../..  <- 000, 001
      ...$..
      .>0...
      .1..10  <- 010, 011
      ....1.
       ^  ^
       |  |
     100  110
     101  111

फिर हम अंतिम संख्या तय करने के लिए तीसरे किनारे से आईपी पास करते हैं। हम समान उपसर्ग के साथ आईपी को जोड़ते हैं।

     201  200
     211  210
       |  |
       v  v
   -> \\1.>2  -> 0,2 or 1,2
 IP<- /../..  <- 000, 001
      ...$..
      .>0!>.  -> 1
      .1./10  <- 010, 011
      ....1.
       ^ |^
       | v|
       | 0|
     100  110
     101  111

के लिए 0और 1उपसर्गों, वे दोनों तीसरे नंबर तय करने के लिए ऊपरी किनारे बाहर आते हैं।

     201  200
     211  210
       |  |
       |10|
       vvvv
   -> \\1.>2  -> 2
 IP<- /0./..  <- 000, 001
      @./$..
      .>0!>.  -> 1
      .1./10  <- 010, 011
      ....1.
       ^ |^
       | v|
       | 0|
     100  110
     101  111

के लिए 2उपसर्ग, आईपी निचले किनारे से कोनों बाहर आते हैं।

     201  200
     211  210
       |  |
       |10|
       vvvv
   -> \\1.>2  -> 2
 IP<- /0./..  <- 000, 001
      @./$(\
      $>0!>.  -> 1
      11$/10  <- 010, 011
      $.@.1.
      ^^ |^^
      || v||
      1| 0|0
     100  110
     101  111

दोनों किनारों ने पहले और तीसरे नंबर को स्वैप किया, दूसरे नंबर को धक्का दिया और सही ऑर्डर प्राप्त करने के लिए तीसरे के साथ स्वैप किया।