एक चिरल पहेली

45

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

इस पहेली के लिए हम एक प्रोग्राम को अक्षरों के आयताकार मैट्रिक्स के रूप में सोचेंगे। जैसे कि इस चुनौती के सभी समाधान आयताकार होने चाहिए (यह सभी पंक्तियाँ समान लंबाई की होनी चाहिए)। हम इन कार्यक्रमों को क्वार्टर टर्न इंक्रीमेंट में घुमा सकते हैं। उदाहरण के लिए कार्यक्रम

The quickish fish
    lept deftly  
  rightwards

जब घुमाया जाता है तो एक चौथाई मोड़ जैसा दिखता है

  T
  h
r e
i  
glq
heu
tpi
wtc
a k
rdi
des
sfh
 t 
 lf
 yi
  s
  h

हम इन कार्यक्रमों को भी दर्शा सकते हैं। यहाँ एक ही प्रोग्राम एक ऊर्ध्वाधर अक्ष पर परिलक्षित होता है:

hsif hsikciuq ehT
  yltfed tpel    
    sdrawthgir

एक चिरल कार्यक्रम एक ऐसा कार्यक्रम है जो किसी भी संख्या में घुमाया जाने पर हमेशा आउटपुट " left" होगा। हालांकि जब परिलक्षित होता है तो एक प्रोग्राम उत्पन्न होता है जो आउटपुट को " right" कितनी बार घुमाया जाता है।

आपका कार्य संभव के रूप में कुछ बाइट्स में एक चिरल कार्यक्रम लिखना है।

अतिरिक्त नियम

  • आउटपुट केस-संवेदी नहीं है, लेकिन सुसंगत होना चाहिए। (उदा। आप " LEFT" और " rIgHt" आउटपुट कर सकते हैं लेकिन यह आवरण घूर्णन के अनुरूप होना चाहिए)

  • लाइनों को या तो एक नई रेखा या एक नई रेखा और एक पंक्ति-पटल पर विभाजित किया जाना है।

  • आपका कार्यक्रम एक आयत होना चाहिए, आप इसे रिक्त स्थान या टिप्पणियों के साथ पैड कर सकते हैं लेकिन प्रत्येक पंक्ति की लंबाई समान होनी चाहिए।

  • यदि आप चाहें तो वैकल्पिक रूप से आपके सभी कार्यक्रमों में एक अनुगामी न्यूलाइन (या न्यूलाइन और लाइनफीड) हो सकती है।

code-golf  restricted-source  source-layout 
— गेहूं का जादूगर
स्रोत
क्या किसी के पास ऐसा कोई प्रोग्राम है जो इसके इनपुट को प्रेरित कर सकता है, जो कम से कम इस सब को बनाने की प्रक्रिया को आसान बना देगा
— KrystosTheOverlord
@KrystosTheOverlord मैंने इसे विम के ब्लॉक कमांड्स और :set virtualedit=allमोड के साथ मिलकर इस्तेमाल किया । प्रारंभिक Boolआउटपुट जांचता है कि क्या इनपुट अपने स्वयं के रोटेशन के बराबर है, जो चीजों को सरल करता है। निकाला जा रहा है {-यह परिलक्षित इनपुट प्रिंट बनाता है।
— अर्जन जोहान्सन
@ ReallyrjanJohansen धन्यवाद, यह वास्तव में मदद करता है, अब तक, मैं अपने लैपटॉप की स्क्रीन को चालू कर रहा हूं, यह सोचकर कि परिणाम क्या होगा और यह पता लगाने की कोशिश करेंगे कि इसे कैसे घुमाएं !!!
— KrystosTheOverlord

जवाबों:

18

पास्कल (एफपीसी) , 2161 755 349 बाइट्स

///////bw(,,),(wb///////
///////er'''e''re///////
begin//girgtnflig//nigeb
write//itih'dteti//etirw
('le'//ne'' .''en//'ir'(
,'ft'//////////////'hg',
)end.////////////// 't',
,'t' //////////////.dne)
,'gh'//////////////'tf',
('ri'//ne''. ''en//'el'(
write//itetd'hiti//etirw
begin//gilfntgrig//nigeb
///////er''e'''re///////
///////bw(,),,(wb///////

कोशिश छोड़िए

सही कोशिश करो

@tsh ने मुझे फिर से प्रयास करने के लिए प्रेरित किया जब मैंने उनका कार्यक्रम (टिप्पणी में) देखा और यहाँ यह है!

पिछला 755 बाइट्स वाला:

 begin write('left')end.// 
/e .dne)'thgir'(etirw nigeb
/g                        e
.i                       .g
dn                       di
n                        nn
ew                       e 
)r                       )w
'i                       'r
tt                       ti
fe                       ht
e(                       ge
l'                       i(
'r                       r'
(i                       'l
eg                       (e
th                       ef
it                       tt
r'                       i'
w)                       r)
 e                       we
nn                        n
id                       nd
g.                       i.
e                        g/
begin write('right')end. e/
 //.dne)'tfel'(etirw nigeb

कोशिश छोड़िए

सही कोशिश करो

अगर आपने मेरा पिछला सबमिशन देखा, तो इसे भूल जाइए :)

बाएं और दाएं दोनों कार्यक्रमों के लिए सभी घुमाव समान हैं।

— AlexRacer
स्रोत
1
— tsh
1
मुझे पता है कि उन प्रतिबिंबित कोष्ठक सही हैं, लेकिन वे अभी भी मुझे परेशान करते हैं।
— सेल्यमे
1
यह एक फ़्रेमयुक्त दर्पण की तरह दिखता है!
— फ्रेडरिक ग्रॉफंस
@tsh उत्कृष्ट विचार! आपने मुझे बेहतर लेआउट खोजने के लिए प्रेरित किया।
— एलेक्सरसेर
— अर्जन जोहान्सन
11

क्लेन (000) , 109 87 बाइट्स

."left"@\.
\"right"..
@"thgir">.
..@"tfel"\
\"left"@..
.>"right"@
.."thgir"\
.\@"tfel".

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

इस उत्तर का एक छोटा संस्करण प्राप्त करना संभव होना चाहिए ताकि शुभकामनाएँ!

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

तिमाही मोड़

...\.@\.
\.>"."""
@""l@trl
"tre"hie
thiftggf
fggtfiht
eih"ert"
lrt@l""@
""".">.\
.\@.\...

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

प्रतिबिंबित

.\@.\...
""".">.\
lrt@l""@
eih"ert"
fggtfiht
thiftggf
"tre"hie
@""l@trl
\.>"."""
...\.@\.

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

प्रतिबिंबित और क्वार्टर बारी

.\@"tfel".
.."thgir"\
.>"right"@
\"left"@..
..@"tfel"\
@"thgir">.
\"right"..
."left"@\.

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

— गेहूं का जादूगर
स्रोत
10

क्लेन (000) , 27 25 बाइट्स

\(("right"@/
\(("left"@!\

इसे ऑनलाइन आज़माएं! एक बार घुमाया! दो बार घुमाया! तीन बार घुमाया!

और फ़्लिप किया: इसे ऑनलाइन आज़माएं! एक बार घुमाया! दो बार घुमाया! तीन बार घुमाया!

केवल एक चीज जिसने मुझे थोड़ी परेशानी दी, वह फ़्लिप और एक बार घुमाया गया, जो इस तरह दिखता है:

\/
!@
@"
"t
th
fg
ei
lr
""
((
((
\\

यह दो सेटों का एकमात्र कारण है ((।

— मजाक कर रहा है
स्रोत
9

क्लेन (211) , 37 बाइट्स

!\"left"@"thgir"\!
!/............../!

यह प्रत्येक रोटेशन के लिए एक अलग कार्यक्रम है।

व्याख्या

ध्यान दें कि इन कार्यक्रमों में से प्रत्येक को निष्पादन से पहले बिना ऑप्स वाले एक वर्ग में रखा जाता है

कोई परिवर्तन नहीं होता है

!\"left"@"thgir"\!
!/............../!

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

!निष्पादन को कूदता है \और "left"@स्ट्रिंग "left"को स्टैक में लोड करता है और स्टैक को प्रिंट करने वाले प्रोग्राम को समाप्त करता है

तिमाही मोड़

!!...IP->
\/
".
r.
i.
g.
h.
t.
".
@.
".
t.
f.
e.
l.
".
\/
!!
^
|
P
I

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

निष्पादन वर्ग के शीर्ष दाएं कोने से चलता है, नीचे बाएँ कोने में जारी है और एक बार फिर !\"left"@प्रिंट करता है "left।

आधा मोड़

                ^
                |
                P
                I
!/............../!
!\"right"@"tfel"\!
..................
..................
..................
..................
..................
..................
..................
..................
..................
..................
..................
..................
................^.
................|.
IP->............P.
................I.

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

यहां, निष्पादन पथ उत्तर की ओर से बाहर निकलता है, पश्चिम की ओर से फिर से प्रवेश करता है, दक्षिण में प्रवेश करने से पहले पूर्व से फिर से बाहर निकलता है। इसे मुद्रित करने के \लिए पथ को बाउंस करता "left"@है।

तीन-चौथाई मोड़

!!..IP->
/\
."
.l
.e
.f
.t
."
.@
."
.t
.h
.g
.i
.r
."
/\
!!
^
|
I
P

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

निष्पादन शीर्ष दाएं कोने से बाहर निकलता है फिर नीचे बाईं ओर फिर से प्रवेश करता है। एक बार फिर दर्पण इसे मुद्रित करने के /\लिए पथ को पुनर्निर्देशित करते हैं "left"@।

प्रतिबिंब

!\"right"@"tfel"\!
!/............../!

यह आवश्यक है कि सभी घुमावों में बाएं के लिए समान है।

— jslip
स्रोत
9

जावास्क्रिप्ट (Node.js) , 1481 599 505 461 341 305 271 बाइट्स

/g+///g/g"c.c"g/
g=//////=rolol=g
"left"///inone/+
console//gsgsf//
.log(g)//ho(ot//
console//tlgl"//
"right"//"e)e//g
g=//////////////
//////////////=g
g//e)e"//"thgir"
//"lglt//elosnoc
//to(oh//)g(gol.
//fsgsg//elosnoc
+/enoni///"tfel"
g=lolor=//////=g
/g"c.c"g/g///+g/

प्रतिबिंबित

/g"c.c"g/g///+g/
g=lolor=//////=g
+/enoni///"tfel"
//fsgsg//elosnoc
//to(oh//)g(gol.
//"lglt//elosnoc
g//e)e"//"thgir"
//////////////=g
g=//////////////
"right"//"e)e//g
console//tlgl"//
.log(g)//ho(ot//
console//gsgsf//
"left"///inone/+
g=//////=rolol=g
/g+///g/g"c.c"g/

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

(सभी परीक्षण मामलों के लिए TIO लिंक देखें, जिसमें मिरर किया गया संस्करण भी शामिल है)

हालांकि आगे गोल्फ, @JoKing के 22x22 -> 21x21क्रेडिट पर आकार !

आकार 38x38 24x24 22x22 21x21 18x18 17x17 16x16, 4 गुना समरूपता।

यहाँ एक प्रश्न आता है - क्या JS के लिए 15x15 या इससे छोटा होना संभव है? ऐसा लगता है कि मुझे कम से कम दो उप-ब्लॉक और किनारे के बीच टिप्पणी विभाजक की आवश्यकता है, इसलिए कम से कम 7 + 2 + 2 + 5 = 16 लाइनें?

— शायरु असकोतो
स्रोत
@JoKing ओह, जो व्यावहारिक लगता है। मेरे पास एक कोशिश होगी;)
— शायरु असाकोटो
@ जोकिंग 21x21 से नीचे पहुंच गया, धन्यवाद;)
— शायरु असाकोतो
8

कैनवस , 109 89 71 बाइट्स

（tfel⁸（（
（h（right
⁸g   q（f
li    re
er    il
f（    g⁸
thgir（h（
（（⁸left（

यहाँ यह कोशिश करो | उलट कोशिश करो! वे केवल दो संभावित कार्यक्रम हैं, क्योंकि कार्यक्रम घूर्णी रूप से सममित है।

में निर्मित इस ।

— dzaima
स्रोत
4
वहाँ पर एक खाली कैनवस ...: /
— आउटगॉल्फ
8

गोल> <> , 23 बाइट्स

\"thgir"H /
\"tfel"H.9\

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

यह मेरे क्लेन उत्तर के समान प्रारूप है , लेकिन 2 बाइट्स कम हैं। हो सकता है कि वहाँ एक और 2 डी भाषा है जो उन आखिरी 2 बाइट को बंद कर सकती है ... लेकिन अभी के लिए, यह उतना ही छोटा है जितना इसे मिलता है।

— मजाक कर रहा है
स्रोत
oof, मैंने अभी पिछले घंटे को gol> <> में बिताया है, फिर मैं इसे खोजने के लिए नीचे स्क्रॉल करता हूं। हालांकि अच्छी नौकरी!
— KrystosTheOverlord
7

ऐलिस , 25 बाइट्स

}/"regttoo {
{/"lifh""@@{

वाम: सामान्य , 1/4 बारी दक्षिणावर्त , 1/2 मोड़ , 1/4 बारी वामावर्त

दाएँ: क्षैतिज अक्ष , नीचे-दाएँ विकर्ण , ऊर्ध्वाधर अक्ष , ऊपर-दाएँ विकर्ण को प्रतिबिंबित करते हैं

व्याख्या

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

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

कार्यक्रम का बाकी हिस्सा सीधा है। क्रमसूचक मोड बाउंस में आईपी तिरछे, तो या तो "left"o@या "right"o@कैसे इस खंड में प्रवेश किया था उसके आधार पर चलाया जाएगा।

— Nitrodon
स्रोत
7

हेक्सागोनी , 98 बाइट्स

\.@.t;./r.
.)@.;...;.
ll..)gt.;$
;.i<;;;i);
e;@.)@e;.l
.;e;d.g|.|
rt/;t.;)g\
@f.#l.;..r
\.;\.;i\.i

इसे ऑनलाइन आज़माएं! | 90 ° घुमाया | घुमाया 180 ° | घुमाया 270 °
उल्टा | 90 ° घुमाया और उलट | घुमाया 180 ° और उलट | 270 ° घुमाया और उलट दिया

हेक्सागोनी इस चुनौती के लिए मज़ेदार था, क्योंकि एक रोटेशन या उत्क्रमण वास्तविक कार्यक्रम को काफी बदल सकता है। प्रत्येक रोटेशन / रिवर्सल अपने स्वयं के अनूठे कार्यक्रम है। कार्यक्रम निष्पादन के कुछ मार्ग दूसरों की तुलना में बहुत अधिक दिलचस्प हैं।

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

— Jo।
स्रोत
6

एपीएल (डीज़िमा / एपीएल) , 181 बाइट्स

कार्यक्रम में घूर्णी समरूपता है इसलिए केवल दो मामलों की जांच करने की आवश्यकता है

बाएं

⍝⍝⍝⍝⍝⍝⍝  t⎕t⍝
t←'lef'⍝ ←←←⍝
⎕←t,     't'⍝
t←'righ'⍝r,l⍝
   ⍝     i e⍝
 ⍝ '     g f⍝
⍝' h     h '⍝
⍝f g     t ⍝ 
⍝e i     ⍝   
⍝l,r⍝'hgir'←t
⍝'t'     ,t←⎕
⍝←←← ⍝'fel'←t
⍝t⎕t  ⍝⍝⍝⍝⍝⍝⍝

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

सही

⍝t⎕t  ⍝⍝⍝⍝⍝⍝⍝
⍝←←← ⍝'fel'←t
⍝'t'     ,t←⎕
⍝l,r⍝'hgir'←t
⍝e i     ⍝   
⍝f g     t ⍝ 
⍝' h     h '⍝
 ⍝ '     g f⍝
   ⍝     i e⍝
t←'righ'⍝r,l⍝
⎕←t,     't'⍝
t←'lef'⍝ ←←←⍝
⍝⍝⍝⍝⍝⍝⍝  t⎕t⍝

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

व्याख्या

यह मेरा पहला एपीएल कार्यक्रम है इसलिए यह बहुत सरल है। यह केवल एक चाल का उपयोग करता है जो मुझे लगता है कि दिलचस्प है।

यदि हम निम्नलिखित प्रोग्रामों को प्राप्त करने वाले सभी टिप्पणियों को अलग करना शुरू करते हैं

बाएं

t←'lef'
⎕←t,     't'
t←'righ'

सही

t←'righ'
⎕←t,     't'
t←'lef'

बाएं कार्यक्रम से शुरू हम तीन चीजें करते हैं।

  1. 'lef'चर को असाइन करेंt

  2. चर tऔर अक्षर को प्रिंट करें't'

  3. 'righ'चर को असाइन करेंt

अब क्योंकि यह दर्पण है सही कार्यक्रम इन तीन चरणों को करता है लेकिन विपरीत क्रम में। इसका मतलब है कि हम 'left'बाएं प्रोग्राम के 'right'लिए और राइट प्रोग्राम के लिए प्रिंट करते हैं ।

यहाँ एक चाल यह है कि 't'वास्तव में कोड की घुमाई गई प्रतिलिपि से आता है। यदि आप हमारे कोड के तीसरे कोलम को देखेंगे तो आप देखेंगे कि यह है 't'। हम 't'इसे घुमाए गए संस्करणों में पुन: उपयोग करने tकी आवश्यकता है।

— गेहूं का जादूगर
स्रोत
5

हास्केल , 461 379 बाइट्स

82 बाइट्स को अर्जन जोहानसन ने बचाया

--_----------mppr--
-- ----------a  l--
rl=p  p--   niam= _
p m="left"-- n==p--
p a="right"++ "" --
main  =putStr rl --
--n +r       =iep--
-- -+t       pgf---
-- -"S       uht---
-- "tt       tt" --
---thu       S"- --
---fgp       t+- --
--pei=       r+ n--
-- lr rtStup=  niam
-- "" ++"thgir"=a p
--p==n --"tfel"=m p
_ =main   --p  p=lr
--l  a---------- --
--rppm----------_--

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

चूँकि इसमें 4-सिम समरूपता है जो आपको केवल दर्पण का परीक्षण करने की आवश्यकता है:

--rppm----------_--
--l  a---------- --
_ =main   --p  p=lr
--p==n --"tfel"=m p
-- "" ++"thgir"=a p
-- lr rtStup=  niam
--pei=       r+ n--
---fgp       t+- --
---thu       S"- --
-- "tt       tt" --
-- -"S       uht---
-- -+t       pgf---
--n +r       =iep--
main  =putStr rl --
p a="right"++ "" --
p m="left"-- n==p--
rl=p  p--   niam= _
-- ----------a  l--
--_----------mppr--

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

यह एक शुरुआत है। यह आदर्श से बहुत दूर है, लेकिन यहां कुछ दिलचस्प चीजें चल रही हैं। हास्केल इस चुनौती के लिए एक निश्चित रूप से एक दिलचस्प भाषा है। मैं एक जवाब की प्रतीक्षा करता हूं जो यह धड़कता है कि यह मेरा है या किसी और का है।

— गेहूं का जादूगर
स्रोत
1
इसे कम करके 379 बाइट्स (19x19)
— अर्जन जोहान्सन
4

प्रोलोग (एसडब्ल्यूआई) , 649 188 बाइट्स

अनफिल्टर्ड, अनरेटेड

:-%    l :%r     %-:
write(%e%-(i %(etirw
left).%f.weg%.)right
%      t)rth.      %
%      )tiit)      %
%      .htr)t      %
right).%gew.f%.)left
write(% i(-%e%(etirw
:-%     r%: l    %-:

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

अनफ़िल्टर्ड, घुमाया हुआ

:wr%%%lw:
-ri   er-
%ig   fi%
 th   tt 
 et   )e 
 ()   .( 
 %.   %% 
  %.)tfel
right).% 
%(etirw-:
:-write(%
 %.)thgir
left).%  
 %%   .% 
 (.   )( 
 e)   re 
 tl   it 
%ie   gi%
-rf   hr-
:wt%%%tw:

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

फ़्लिप, अनरेटेड

:-%     r%: l    %-:
write(% i(-%e%(etirw
right).%gew.f%.)left
%      .htr)t      %
%      )tiit)      %
%      t)rth.      %
left).%f.weg%.)right
write(%e%-(i %(etirw
:-%    l :%r     %-:

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

फ़्लिप, घुमाया गया

:wl%%%rw:
-re   ir-
%if   gi%
 tt   ht 
 e)   te 
 (.   )( 
 %%   .% 
left).%  
 %.)thgir
:-write(%
%(etirw-:
right).% 
  %.)tfel
 %.   %% 
 ()   .( 
 er   )e 
 ti   lt 
%ig   ei%
-rh   fr-
:wt%%%tw:

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

— 0 '
स्रोत
4

प्रोलोग (एसडब्ल्यूआई) , 239 223 209 181 बाइट्स

%%%%%%%  l:r%
right).% e-i%
:-write(%fwg%
left).%  trh%
  %      )it%
 %(      .t)%
%.e%     %e.%
%)t.      (%
%ti)      %
%hrt  %.)tfel
%gwf%(etirw-:
%i-e %.)thgir
%r:l  %%%%%%%

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

चूंकि कार्यक्रम में 4 गुना समरूपता है, आपको केवल दर्पण की जांच करने की आवश्यकता है:

%r:l  %%%%%%%
%i-e %.)thgir
%gwf%(etirw-:
%hrt  %.)tfel
%ti)      %  
%)t.      (% 
%.e%     %e.%
 %(      .t)%
  %      )it%
left).%  trh%
:-write(%fwg%
right).% e-i%
%%%%%%%  l:r%

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

— गेहूं का जादूगर
स्रोत
4

अजगर 2 , 209 बाइट्स (14 x 14)

सामान्य (बाएं): 

##########sps#
s="left"##=r=#
print s###"i"#
s="right"#rnl#
####      ite#
###"      g f#
#"#t      hst#
#tsh      t#"#
#f g      "###
#eti      ####
#lnr#"thgir"=s
#"i"###s tnirp
#=r=##"tfel"=s
#sps##########

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

प्रतिबिंबित (दाएं): 

#sps##########
#=r=##"tfel"=s
#"i"###s tnirp
#lnr#"thgir"=s
#eti      ####
#f g      "###
#tsh      t#"#
#"#t      hst#
###"      g f#
####      ite#
s="right"#rnl#
print s###"i"#
s="left"##=r=#
##########sps#

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

— कर्टिस Bechtel
स्रोत
3

स्वच्छ , 1331 1055 बाइट्स

-276 बाइट्स थैंक्स टू अर्जन जोहान्सन

// ////////////;/;/////////// //
// ////////////S/S/////////// //
  module m////mtmt////m eludom  
//o///////////=a=a///////////o//
//d///////////"r"r///////////d//
//u///////////tttt///////////u//
//l///////////f#h#///////////l//
//e///////////emgm///////////e//
// ///////////loio/////////// //
//m///////////"drd///////////m//
//////////////=u"u//////////////
//////////////ml=l//////////////
//////////////#eme//////////////
////////////// =#=//////////////
;Start#module= 0   #m="left"=m//
//m="thgir"=m#   0=eludom#tratS;
;Start#module=0   #m="right"=m//
//m="tfel"=m#   0 =eludom#tratS;
//////////////=#= //////////////
//////////////eme#//////////////
//////////////l=lm//////////////
//////////////u"u=//////////////
//m///////////drd"///////////m//
// ///////////oiol/////////// //
//e///////////mgme///////////e//
//l///////////#h#f///////////l//
//u///////////tttt///////////u//
//d///////////r"r"///////////d//
//o///////////a=a=///////////o//
  module m////tmtm////m eludom  
// ///////////S/S//////////// //
// ///////////;/;//////////// //

ऑनलाइन "बाएं" का प्रयास करें!

ऑनलाइन "सही" की कोशिश करो!

यह कई कारणों से मुश्किल था:

  • क्लीन के लिए एक फाइल हैडर module <filename>शुरू में मौजूद होना चाहिए, और केवल फाइल की शुरुआत । दुर्भाग्य से, इसका मतलब यह है कि मिरर किए गए प्रोग्राम के रोटेशन के लिए वैध होने के लिए इसे फ़ाइल के निचले भाग में भी दिखाना होगा। इस बदतर बनाने के लिए, module ..वैश्विक लिए अमान्य है, let .. in, where ..औरwith .. परिभाषाओं; और moduleअगर यह परिभाषित नहीं किया गया है तो टोकन एक त्रुटि का कारण बनता है।
  • दोनों टिप्पणी और लाइन टिप्पणी घोंसला: /* /* */टिप्पणी के एक स्तर खुला छोड़ देता है, और ऐसा करता है/* // */ (साथ ही साथ शेष पंक्ति को टिप्पणी करता है)।
  • एक ही फ़ंक्शन को कई बार परिभाषित किया जा सकता है, लेकिन केवल सीधे बाद में।

सौभाग्य से, हम कुछ को एक (लेट-बिफोर) अभिव्यक्ति के रूप में परिभाषित कर सकते हैं , जिसकी हमें आवश्यकता है। क्योंकि क्लीन टाइप-चेक विकल्प नहीं है जो कभी उपयोग नहीं किया जाता है (और अन्य समान रूप से अप्रयुक्त चीजों की एक किस्म), आवश्यक दूसरी परिभाषा का पूरा कचरा हो सकता है। यह हमें दूसरे का उपयोग करने की अनुमति देता है क्योंकि स्वच्छ व्यवहार करता है फ़ाइल के तल पर मॉड्यूल शीर्ष लेख का उपभोग करने के प्रकार्य को बुलाने पर और (जो बाद से हमने परिभाषित किया है और , एक त्रुटि का कारण नहीं है)। इससे कोई फर्क नहीं पड़ता कि यह एक स्ट्रिंग है और फ़ंक्शन नहीं है, क्योंकि विकल्प कभी भी टाइप-चेक नहीं किया जाता है।module#..StartStartm module mmmodulemmodulemmStart

यह देखना आसान है कि क्या आप इसे संकलक की आंखों से देखते हैं:

module m;
Start#module=0#m="left"=m;
Start#module=0#m="right"=m module m
— Οurous
स्रोत
1
1055 विलय mऔर s।
— अर्जन जोहानसन
@ CatchrjanJohansen ऊओह अच्छी पकड़!
— Οurous
3

ब्रेकीलॉग , 341 बाइट्स

Ẹw"thgir"∧"left"wẸ
w"              "w
"                "
t                t
f                h
e                g
l                i
"                r
∧                "
"                ∧
r                "
i                l
g                e
h                f
t                t
"                "
w"              "w
Ẹw"tfel"∧"right"wẸ

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

! इल्न्नो टीआई yrT

ब्रैकीग्लॉग का लाभ लेता है, जो मुख्य रूप से पहली पंक्ति में एक होने का अनुमान लगाता है और अन्य लाइनों के बारे में ज्यादा परवाह नहीं करता है कि वे संकलित कर सकें। अपरिष्कृत, यह एक ही लाइन पर "बाएं" द्वारा खाली स्ट्रिंग प्रिंट करता है, और यह प्रतिबिंबित करता है कि एक ही लाइन पर "सही" के बाद एक खाली स्ट्रिंग प्रिंट करता है। मुझे लगता है कि वहाँ एक (उपयोगी) गैर-वर्ग संस्करण का उपयोग करने का एक तरीका हो सकता है सोचने के लिए परीक्षा है ṇ, लेकिन यह प्रतिबिंब के तहत अलग तरह से काम करने की कोशिश किए बिना बहुत मुश्किल हो सकता है।

— असंबंधित स्ट्रिंग
स्रोत
2

माणिक , 181 बाइट्स

#########tpt#
t=:left##=u=#
puts t###:t:#
t=:right#rsl#
####     i e#
###t     gtf#
#t#h     h#t#
#ftg     t###
#e i     ####
#lsr#thgir:=t
#:t:###t stup
#=u=##tfel:=t
#tpt#########

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

यह रूबी को कर्टिस बेचटेल के पायथन जवाब का एक बंदरगाह है, थोड़ा और गोल किया गया है।

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

अपना खुद का बनाओ

— जीबी
स्रोत
2

बैच, 438 321 बाइट्स

:::::::::::::@@@:
@echo left&: eee:
@exit/b&:    cxc:
@echo right&:hih:
:  :         oto:
:: &          / :
:& t         rbl:
:t h         i&e:
:f:g         g:f:
:e&i         h t:
:lbr         t &:
: /          & ::
:oto         :  :
:hih:&thgir ohce@
:cxc    :&b/tixe@
:eee :&tfel ohce@
:@@@:::::::::::::

स्पष्टीकरण: ए :का उपयोग एक लेबल को इंगित करने के लिए किया जाता है, जो एक टिप्पणी के रूप में अच्छा है, इसलिए जैसे ही प्रोग्राम में घूर्णी समरूपता होती है, केवल दो संस्करणों के बीच अंतर होता है कि कौन सी रेखा @पहले है, किस मामले में leftयाright स्क्रिप्ट से पहले आउटपुट है बाहर निकलता है।

मैंने रचनात्मक रूप से एक दूसरे के साथ घुमाए गए लाइनों को ओवरलैप करने की कोशिश की, लेकिन मेरा प्रयास वास्तव में एक बड़ी ग्रिड के साथ समाप्त हुआ।

संपादित करें: 117 बाइट्स @ orjanJohansen के लिए धन्यवाद।

— नील
स्रोत
मुझे लगता है कि आप की जगह ले सकता &rem से &:।
— अर्जन जोहान्सन
@ TryingrjanJohansen मुझे लगता है कि एक समान चुनौती से पहले कोशिश करना याद है, लेकिन मुझे नहीं लगता कि यह अच्छी तरह से काम किया है।
— नील
यह (हास्केल बुरा मत मानना, TIO बैच नहीं लगता है) मेरे test.batलिए Win10 कमांड प्रॉम्प्ट में काम किया ।
— अर्जन जोहान्सन
@ MightrjanJohansen मेला काफी, यह पिछले संस्करण में एक बग हो सकता है CMD.EXEया कुछ और।
— नील
2

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

'…¸q©ƒ'
ƒ     …
©     ¸
q     q
¸     ©
…     ƒ
'ƒ©q¸…'

बहुत बुनियादी दृष्टिकोण। पूर्ण लोअरकेस में आउटपुट।

इसे ऑनलाइन आज़माएं या इसे ऑनलाइन प्रतिबिंबित करने का प्रयास करें (प्रत्येक घुमाव समान है)।

स्पष्टीकरण:

'…¸   '# Push the dictionary string "left" to the stack
   q   # Stop the program (and output the top of the stack implicitly)
       # Everything else after it is ignored

उलट:

'ĩ   '# Push the dictionary string "right" to the stack
   q   # Stop the program (and output the top of the stack implicitly)
       # Everything else after it is ignored

मेरा यह 05AB1E टिप देखें (अनुभाग कैसे शब्दकोश उपयोग कैसे करें? ) को समझने के लिए क्यों '…¸है "left"और 'ƒ©है "right"।

— केविन क्रूज़सेन
स्रोत
क्या अनदेखा कमांड वास्तव में नो-ऑप्स हैं, या सिर्फ इस वजह से कभी नहीं पहुंचे हैं q?
— अर्जन जोहानसन
@ ArerjanJohansen दूसरा वास्तव में, वे कभी नहीं पहुंचते हैं। इसलिए तकनीकी रूप से वास्तव में नो-ऑप्स (जो कि वह शब्द है जो मैं आमतौर पर उन सभी कोड के लिए उपयोग करता हूं जिन्हें मेरे उत्तरों में अनदेखा किया गया है)। यह भी 05AB1E के नए संस्करण में काम नहीं करता है, क्योंकि ऐसा लगता है कि कोड पहले (संकलन के प्रकार) को देखता है, और उसके बाद ही निष्पादित होता है। जबकि लिगेसी संस्करण बस मुझे लगता है कि निष्पादित करना शुरू कर देता है। यही कारण है कि मैंने निर्दिष्ट किया है कि मैंने (legacy)05AB1E के संस्करण का उपयोग किया है ।
— केविन क्रूज़सेन
1

रूनिक एनचेंमेंट्स , 116 बाइट्स

> \ !U\L
 ...@.. 
 \.R""" 
 @""trl 
 "lrhie 
 teiggf 
 ffgiht 
 ethrt" 
 l"t""@ 
 " "R.\ 
 .\@.@. 
DR\!!/R 
     !!

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

और पलट गया

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

"left"सभी 4 रोटेशन में प्रिंट और"right" जब मिरर किया जाता है (और उसके बाद के सभी चार घुमावों में)। मेरे संशोधनों के बाद दो मध्य स्तंभ पूरी तरह से अप्रयुक्त थे, इसलिए मैं उन्हें हटाने में सक्षम था।

सिद्धांत रूप में, बहुत सारे अनुगामी व्हॉट्सएप के साथ एक रोटेशन कम बाइट गिनती (जैसे। यह संस्करण ) के लिए इस्तेमाल किया जा सकता है , हालांकि बाहरी उपकरणों का उपयोग करके संरचना को सही ढंग से घुमाने के लिए रिक्त स्थान की आवश्यकता होती है और इसलिए मैंने उन्हें शामिल किया।

नीचे के वेरिएंट में अप्रयुक्त विखंडू हैं जिन्हें हटा दिया गया था, लेकिन अन्यथा समान हैं:

सभी चार लेफ्ट । आउटपुट leftleftleftleft(तथ्य यह है कि चारों को इस तरह चलाया जा सकता है) संयोग है।

राइट 1 , राइट 2 , राइट 3 , राइट 4

— Draco18s
स्रोत
1

गोल> <> , 342 बाइट्स

 8A_          _A8 
9       ""       9
A       LR       A
_       EI       _
        FG        
        TH        
        "T        
         "        
 "TFEL" HH"RIGHT" 
 "THGIR"HH "LEFT" 
        "         
        T"        
        HT        
        GF        
_       IE       _
A       RL       A
9       ""       9
 8A_          _A8

वाह! मुझे उम्मीद की तुलना में अधिक समय लग गया, आधे रास्ते में मुझे एहसास हुआ कि प्रतिबिंब लंबवत था , क्षैतिज रूप से नहीं जैसे मैं के लिए कोडिंग कर रहा था! मुझे पूरा यकीन है कि यह काम करता है, लेकिन अगर मैंने कोई गलती की है तो कृपया मुझे बताएं। यह सबसे अधिक संभावना है कि यह एक हास्यास्पद राशि अधिक हो सकती है, मैंने बस ऐसा करने के लिए एक अत्यधिक क्रूर बल विधि ली। आकार वास्तव में एक वर्ग है, यह एक्स-अक्ष पर छोड़कर, तकनीकी रूप से सममित है, इसलिए जब यह फ़्लिप होता है, तो इसके बजाय "राइट" लौटाता है !!!

इस कार्यक्रम को संभव बनाने वाला चरित्र 'ए' है, जो एक निश्चित लाइन की शुरुआत में टेलीपोर्टेशन की अनुमति देता है!

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

— KrystosTheOverlord
स्रोत
1
कार्यक्षेत्र और क्षैतिज प्रतिबिंब में अंतर नहीं होना चाहिए क्योंकि वे रोटेशन के बाद समान होते हैं।
— गेहूं जादूगर
@TRITICIMAGVS हुह, उस के बारे में नहीं सोचा था, कि बाहर इशारा करने के लिए धन्यवाद, मैं भी महसूस किया कि यह पूरी बात व्यर्थ है, जोकिंग ने 27 बाइट्स आकार में बनाया
— KrystosTheOverlord
1
एह, मुझे लगता है कि यदि आप इस प्रक्रिया का आनंद लेते हैं तो यह हमेशा इसके लायक है।
— गेहूं जादूगर
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.