दो दर्पण के बीच दो लेज़र

70

क्या होगा यदि हमारे पास एक कॉरिडोर है जिसमें दो समानांतर दर्पण शामिल हैं?

|          |
|          |
|          |
|          |
|          |
|          |
|          |
|          |
|          |
|          |

अब, हम इसे नीचे एक लेजर चमक ...

|  \       |
|   \      |
|    \     |
|     \    |
|      \   |
|       \  |
|        \ |
|         \|
|         /|
|        / |

अरे देखो। यह उछाल, अंत की ओर, वहाँ।

क्या होगा यदि हम विपरीत दिशा में जाने वाले दो लेज़रों को खींचते हैं?

|  \    /  |
|   \  /   |
|    \/    |
|    /\    |
|   /  \   |
|  /    \  |
| /      \ |
|/        \|
|\        /|
| \      / |

हम्म, वे वहाँ नहीं मिल रहे थे। यह सुविधाजनक है। यदि दोनों लेजर एक ही स्थान को लेते हैं तो क्या होगा?

|  \     / |
|   \   /  |
|    \ /   |
|     X    |
|    / \   |
|   /   \  |
|  /     \ |
| /       \|
|/        /|
|\       / |

मुझे लगता है कि बहुत स्पष्ट था, हुह?

इन आरेखों को हाथ से खींचना काफी श्रमसाध्य है (मुझे इस पर विश्वास करें)। शायद कुछ कोड हमारे लिए यह कर सकता है?

  • कुछ कोड दो समानांतर दर्पण के उत्पादन के लिए लिखें, दो शेख़ी के साथ, पराबैंगनीकिरण को काटना।
  • इनपुट (सभी पूर्णांक):
    • गलियारे की चौड़ाई
    • गलियारे की लंबाई
    • सही जा रही लेजर की स्थिति (शून्य-अनुक्रमित, चौड़ाई से कम होनी चाहिए)
    • बाएं जा रहे लेजर की स्थिति (शून्य-अनुक्रमित, चौड़ाई से कम होनी चाहिए)
  • प्रक्रिया
    • यदि कोई लेज़र सही जा रहा है, तो उसे निम्नलिखित पंक्ति पर दाईं ओर एक स्थान खींचा जाएगा।
    • यदि एक लेजर छोड़ा जा रहा है, तो इसे निम्नलिखित पंक्ति में बाईं ओर एक स्थान खींचा जाएगा।
    • यदि कोई लेज़र इसे बग़ल में कदम नहीं उठा सकता है, तो यह दिशा बदल देगा, लेकिन यह स्थिति नहीं है।
    • यदि दोनों लेज़र एक ही इंडेक्स पर हैं, तो उस इंडेक्स पर एक अपर-केस X प्रिंट करें।
  • उत्पादन
    • कई लाइनों के साथ एक स्ट्रिंग
    • प्रत्येक पंक्ति एक पाइप चरित्र के साथ शुरू और समाप्त होती है (!)
    • दाएं जा रहे लेजर को बैक स्लैश (\) द्वारा निरूपित किया जाता है
    • लेफ्ट-गोइंग लेजर को आगे स्लैश (/) द्वारा दर्शाया जाता है।
    • दो लेज़रों के चौराहे को ऊपरी-मामले X द्वारा दर्शाया जाता है।
  • कोई भी भाषा
  • मैं TIO लिंक देखना चाहूंगा
  • इसे बाइट्स की सबसे छोटी संख्या में ठीक करने का प्रयास करें

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

चौड़ाई: 6 लंबाई: 10 दाएं-बाएं: 1 बाएं-जा रही: 4

| \  / |
|  \/  |
|  /\  |
| /  \ |
|/    \|
|\    /|
| \  / |
|  \/  |
|  /\  |
| /  \ |

चौड़ाई: 6 लंबाई: 10 दाएं-बाएं: 0 बाएं-जा रही: 1

|\/    |
|/\    |
|\ \   |
| \ \  |
|  \ \ |
|   \ \|
|    \/|
|    /\|
|   / /|
|  / / |

चौड़ाई: 4 लंबाई: 10 दाएं-बाएं: 2 बाएं-जा रही: 0

|/ \ |
|\  \|
| \ /|
|  X |
| / \|
|/  /|
|\ / |
| X  |
|/ \ |
|\  \|

चौड़ाई: 20 लंबाई: 5 दाएं-बाएं: 5 बाएं-जा रही: 15

|     \         /    |
|      \       /     |
|       \     /      |
|        \   /       |
|         \ /        |

चौड़ाई: 5 लंबाई: 6 दाएं-बाएं: 2 बाएं-जा रही: 2

|  X  |
| / \ |
|/   \|
|\   /|
| \ / |
|  X  |

चौड़ाई: 1 लंबाई: 2 दाएं-बाएं: 0 बाएं-जा रही: 0

|X|
|X|
code-golf  ascii-art 
— AJFaraday
स्रोत
6
सुझाए गए किनारे का मामला: चौड़ाई: 1, लंबाई: जो भी हो, दाएं: 0, बाएं: 0
— अरनौलड
2
@ अरनल्ड | एक्स | ;)
— एजेराडाय

जवाबों:

12

स्टैक्स , 40 बाइट्स

àù@○⌡┼PY¼îαφu^·A☺°É⌠■╟¡Åt^◘v(µ╩Ñ♣t{╓○xß╦

इसे चलाएं और डीबग करें

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

बहुत यकीन है कि यह आगे गोल्फ हो सकता है।

इनपुट width [right-going left-going] length(@EngineerToast द्वारा प्रति टिप्पणी) के रूप में दिया गया है ।

ASCII समकक्ष:

xHXdmzx);hi+x%Y92&;Hi-x%cy=41*47+&2ME:R\{|+m'||S
— वीजुन झोउ
स्रोत
1
इनपुट प्रारूप को नोट करना चाहते हैंwidth [right-going left-going] length
— इंजीनियर टोस्ट
18

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

करी सिंटैक्स में इनपुट लेता है (w)(h)([a,b])।

w=>h=>g=(p,d=[1,-1],s=Array(w).fill` `)=>h--?`|${p=p.map((x,i)=>~(k=d[i],s[x]='/X\\'[x-p[i^1]?k+1:1],x+=k)&&x<w?x:x+(d[i]=-k)),s.join``}|
`+g(p,d):''

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

टिप्पणी की गई

w => h =>                  // w = width, h = height
  g = (                    // g = recursive function taking:
    p,                     //   p[] = array holding the point coordinates
    d = [1, -1],           //   d[] = directions
    s = Array(w).fill` `   //   s = array of w spaces (we can't use a string because it's
  ) =>                     //       immutable in JS)
    h-- ?                  // if we haven't reached the last row yet:
      `|${                 //   append the left pipe
      p = p.map((x, i) =>  //   for each x at position i in p[]:
        ~(k = d[i],        //     k = direction for this point
          s[x] = '/X\\'[   //     insert either '/', 'X' or '\' at position x in s
            x - p[i ^ 1] ? //     if p[0] != p[1]:
              k + 1        //       use the direction
            :              //     else:
              1            //       force 'X'
          ], x += k        //     add k to x
        ) &&               //     if the result is not equal to -1
        x < w ?            //     and is less than w:
          x                //       use the current value of x
        :                  //     else:
          x + (d[i] = -k)  //       change the direction and restore the initial value of x
      ),                   //   end of map()
      s.join``}|\n` +      //   join and append s; append the right bar and a linefeed
      g(p, d)              //   followed by the result of a recursive call
    :                      // else:
      ''                   //   stop recursion
— Arnauld
स्रोत
11

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

w,l,a,b=input()
exec"print'|%s|'%''.join(' \/X'[sum(i==k%(2*w)for k in[a,~b]+[~a,b]*2)]for i in range(w));a+=1;b-=1;"*l

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

— XNOR
स्रोत
आप गोल्फ नहीं कर सकते \\/करने के लिए \/? भले ही बैकस्लैश की दो बार व्याख्या की गई हो, फिर भी यह स्लैश से बच नहीं पाएगा।
— जोनाथन फ्रीच
@JonathanFrech आप सही कह रहे हैं, मैंने सोचा था कि एक स्ट्रिंग-इन-स्ट्रिंग में विफल हो जाएगा, लेकिन यह वास्तव में या तो समय से नहीं बचता है।
— xnor
ओह जीजा, मेरा समाधान इस विचार के करीब पहुंच गया - काम करने का मोडुलो 2w रेट्रोस्पेक्ट में बहुत मायने रखता है। बहुत चालाक!
— लिन
9

पायथन 2 , 168 बाइट्स

w,n,r,l=input()
R=L=1
exec"""
d=[~r*R,-~l*L].count
print'|%s|'%''.join(' /\X'[2*d(~x)|d(x+1)]for x in range(w))
if-1<r+R<w:r+=R
else:R=-R
if-1<l-L<w:l-=L
else:L=-L"""*n

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

— लिन
स्रोत
— आउटगोल्फर
9

पायथन 2 , 187 181 179 177 174 172 171 बाइट्स

def f(w,l,a,b,A=1,B=-1):
 while l:l-=1;print'|%s|'%''.join(' \X/'[[0,A,B,2][(i==a)+2*(i==b)]]for i in range(w));a,A=[a,a+A,-A,A][-1<a+A<w::2];b,B=[b,b+B,-B,B][-1<b+B<w::2]

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

पुनरावर्ती:

पायथन 2 , 172 बाइट्स

def f(w,l,a,b,A=1,B=-1):
 if not-1<a<w:A=-A;a+=A
 if not-1<b<w:B=-B;b+=B
 if l:print'|%s|'%''.join(' \X/'[[0,A,B,2][(i==a)+2*(i==b)]]for i in range(w));f(w,l-1,a+A,b+B,A,B)

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

पुनरावर्ती, वैकल्पिक प्रिंट:

पायथन 2 , 172 बाइट्स

def f(w,l,a,b,A=1,B=-1):
 if not-1<a<w:A=-A;a+=A
 if not-1<b<w:B=-B;b+=B
 if l:L=[' ']*w;L[a]=' \/'[A];L[b]=[' \/'[B],'X'][a==b];print'|%s|'%''.join(L);f(w,l-1,a+A,b+B,A,B)

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

— TFeld
स्रोत
मैं एक बार फिर से कोड गोल्फ चुनौतियों पर पहले उत्तरों की गति से चकित हूं। अच्छा है! :)
— AJFaraday
8

सी (क्लैंग) , 240 236 208 बाइट्स

#define g(a,b) b?a++,a==x&&(a=x-1,b=0):a--,a==-1&&(a=0,b=1)
i,m,n,o,p,t[]={47,92};f(x,y,r,l){for(m=1,n=0;y--;puts("|"),g(r,m),g(l,n))for(printf("|"),i=0;i<x;o=i==r,p=i++==l,putchar(o*p?88:o?t[m]:p?t[n]:32));}

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

f () निम्नानुसार पैरामीटर लेता है:

x= चौड़ाई,
y= लंबाई,
r= प्रारंभ में दाईं ओर जाने वाली रेखा आरंभिक स्थिति
l= प्रारंभ में बाईं ओर जाने वाली रेखा आरंभिक स्थिति

-4 निवाले। क्रेडिट केविन क्रूज़सेन। धन्यवाद

— GPS
स्रोत
1
आप सेमी-कॉलनों में whileसे एक forको हटाने के लिए ए को बदलकर 3 बाइट्स को गोल्फ कर सकते हैं {}। और बदलकर 1 अधिक बाइट c&&dके लिए c&d। इसे ऑनलाइन 236 बाइट्स आज़माएं ।
— केविन क्रूज़सेन
ऐसा लगता है कि आप दो अतिरिक्त इनपुट ले रहे हैं, जो कि एफैक की अनुमति नहीं है।
— OOBalance
1
आप चुनौती के सामान्यीकरण को हल करने वाले नहीं हैं, लेकिन यह चुनौती निर्दिष्ट है। अतिरिक्त इनपुट के बारे में, मैं मेटा के चारों ओर थोड़ा खोदा और यह पाया: codegolf.meta.stackexchange.com/a/12696/79343 मैं सोच रहा हूं कि इसे कहीं और लिखा जाना चाहिए, लेकिन मुझे यह नहीं मिल रहा है। हालांकि यह आदर्श है।
— OOBalance
1
अपने जी मैक्रो में, आप एक == - 1 को <0 में बदलकर 2 बाइट्स गोल्फ कर सकते हैं।
— जॉनवेल्स
1
वास्तव में मैक्रो में अधिक मिला, एक ++, एक और एक, एक कर सकते हैं गोल्फ 2 बाइट्स प्रत्येक के लिए ++ और
— --a
5

चारकोल , 56 50 बाइट्स

↷ＰＩθＭ⊕η→ＩθＦ²«Ｊ⊕⎇ιεζ⁰ＦＩθ«✳§⟦↘↙⟧ι∨⁼ＫＫψX¿⁼ＫＫ|«¿ι→←≦¬ι

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। संपादित करें: धुरी पर निर्भरता को कम करके 6 बाइट्स सहेजे गए। स्पष्टीकरण:

↷ＰＩθＭ⊕η→Ｉθ

पक्षों को प्रिंट करें।

Ｆ²«

दो लेज़रों पर लूप।

Ｊ⊕⎇ιεζ⁰

लेजर की शुरुआत करने के लिए ले जाएँ।

ＦＩθ«

ऊंचाई पर लूप।

✳§⟦↘↙⟧ι∨⁼ＫＫψX

एक \या /उचित दिशा में ड्रा करें, जब तक कि चौकोर खाली न हो, जिस स्थिति में ड्रॉ ए X।

¿⁼ＫＫ|«

क्या हमने एक पक्ष मारा है?

¿ι→←≦¬ι

यदि ऐसा है तो एक कदम आगे बढ़ाएं और यात्रा की दिशा को उल्टा करें।

— नील
स्रोत
इनपुट "10 2 4 2" होने पर यह सीमा से बाहर हो जाता है
— मार्टीजन विर्स
1
@MartijnVissers ठीक है, यदि आपकी चौड़ाई 2 है, तो आपकी स्थिति केवल 0 या 1 हो सकती है ...
— नील
3

PHP, 177 169 166 बाइट्स

[,$w,$h,$a,$b]=$argv;for($e=-$d=1;$h--;$s[$a+=$d]^L?:$a+=$d=-$d,$s[$b+=$e]^L?:$b+=$e=-$e){$s=str_pad("",$w)."|";$s[$b]="X\/"[$e];$s[$a]="X\/"[$a-$b?$d:0];echo"|$s
";}

नकारात्मक स्ट्रिंग अनुक्रमित के लिए PHP 7.1 , PHP 5.5 या बाद में स्ट्रिंग शाब्दिक अनुक्रमण के लिए PHP की आवश्यकता होती है।
के लिए PHP <7.1 , हटाने ^L, की जगह "X\/"के साथ "/X\\", :0के साथ +1:1, [$e]के साथ [$e+1], हटाने ."|"और डालने |न्यू लाइन से पहले। PHP <5.5 के
लिए (+3 बाइट्स) , शुरुआत के साथ बदलें और डालें । (+2 बाइट्स)"/X\\"$p$p="/X\\";

कमांड लाइन तर्कों से इनपुट लेता है। ऑनलाइन चलाएं -nrया उन्हें आज़माएं ।

— टाइटस
स्रोत
यह दुर्भाग्यपूर्ण है कि onlinephpfunctions.com साझा लिंक में सही PHP संस्करण को नहीं बचाता है ...
— Arnauld
3

पायथन 3 , 162 बाइट्स

from numpy import*
def f(w,h,u,v):
 v=w+w-v-1;T=eye(w);M=vstack([T,2*T[::-1]]*2*h)
 for r in M[u:u+h,:]+M[v:v+h,:]:print('|%s|'%''.join(' \/X'[int(i)]for i in r))

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

— RootTwo
स्रोत
मुझे आपके टेस्ट सूट में फ़ॉर्मेटिंग पसंद है, मज़बूती से आउटपुट के खिलाफ इनपुट दिखाने ... अच्छा लगा?)
— AJFaraday
3

रूबी , 117 बाइट्स

->w,h,a{a[1]-=w;(1..h).map{s=' '*w;a.map!{|x|d=x<0?-1:1;s[x]='X\\/'[s[x][/ /]?d:0];x+=d;x==w ?-1:x<-w ?0:x};?|+s+?|}}

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

अनाम लंबोतरा चौड़ाई w, ऊंचाई hऔर प्रारंभिक बिंदुओं की एक सरणी के रूप में इनपुट ले रहा है a।

— किरिल एल।
स्रोत
आपने केवल 2 शुरुआती बिंदुओं को नहीं, बल्कि इसे एक विस्तार योग्य सरणी बनाकर मेरा दिन बनाया।
— AJFaraday
2

पॉवरशेल , 243 233 222 205 बाइट्स

param($w,$h,$a,$b)$l,$r,$s=1,-1,' \/'
1..$h|%{$p,$p[$b],$p[$a]=[char[]](' '*$w),$s[$r],($s[$l],"x")[!($a-$b)]
if($a+$l-in($z=0..($w-1))){$a+=$l}else{$l*=-1}if($b+$r-in$z){$b+=$r}else{$r*=-1}"|$(-join$p)|"}

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

Oooof। उन लॉजिक ब्लॉक बड़े और गंदे हैं और ज्यादातर नकली हैं। अगला कदम उन्हें फिर से लिखना होगा ताकि उन्हें अन्य विवरण की आवश्यकता न हो।

— Veskah
स्रोत
1

पायथन 2, 165 164 बाइट्स

w,h,x,y=input()
a,b,s=1,-1,' \/'
exec"""l=[' ']*w
l[x],l[y]=s[a],s[b]if x-y else'X'
if-1<x+a<w:x+=a
else:a=-a
if-1<y+b<w:y+=b
else:b=-b
print'|%s|'%''.join(l)
"""*h

जोनाथन फ्रेच को एक बाइट धन्यवाद दिया।
इसे ऑनलाइन आज़माएं!

— स्मृति सहायक
स्रोत
1
\\/के बराबर है \/।
— जोनाथन फ्रीच
1

के (ngn / k) , 58 बाइट्स

{" \\/X|"4,'(+/3!1 2*(x#'e+2*|e:=2*x)(2*x)!z+(!y;-!y)),'4}

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

अनाम फ़ंक्शन जो तीन तर्कों को स्वीकार करता है: xचौड़ाई, yलंबाई, zलेज़रों के लिए शुरुआती पदों की एक जोड़ी

— NGN
स्रोत
1

कोटलिन , 322 311 302 बाइट्स

बदल दिया है कि मैं 11 बाइट्स के लिए स्ट्रिंग में लेजर दिशा कैसे डालता हूं। 9 बाइट्स के लिए जब से बाहर असाइनमेंट ले जाया गया।

{w:Int,h:Int,r:Int,l:Int->{var a=""
var f=r
var d=1>0
var s=l
var t=!d
for(o in 1..h){a+="|"
for(c in 0..w-1)a+=when{c==f&&c==s->"X"
c==f&&d||c==s&&t->"\\"
c==f||c==s->"/"
else->" "}
a+="|\n"
if(d){if(++f==w){--f
d=!d}}else if(--f<0){f=0
d=!d}
if(t){if(++s==w){--s
t=!t}}else if(--s<0){s=0
t=!t}}
a}()}

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

— JohnWells
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.