एएससीआईआई डूडलिंग: एक बॉक्स में लेजर

Question

कभी-कभी जब मैं डूडलिंग कर रहा होता हूं, तो मैं एक आयत खींचता हूं, एक कोने से एक विकर्ण के साथ शुरू करता हूं, और फिर जब भी मैं आयत के एक तरफ से टकराता हूं तो इसे "प्रतिबिंबित" करके एक रेखा का पता लगाता हूं। मैं इसे तब तक जारी रखता हूं जब तक कि मैं आयत के दूसरे कोने को नहीं मारता (और आशा करता हूं कि मेरी आयत का पहलू अनुपात तर्कहीन नहीं था;))। यह एक बॉक्स में लेज़र शोन के रास्ते को ट्रेस करने जैसा है। आप ASCII कला के साथ उस का परिणाम तैयार कर रहे हैं।

एक उदाहरण के रूप में, चौड़ाई 5और ऊंचाई के एक बॉक्स पर विचार करें 3। हम हमेशा ऊपरी बाएँ कोने में शुरू करेंगे। #निशान बॉक्स की सीमा। ध्यान दें कि चौड़ाई और ऊंचाई आंतरिक आयामों को संदर्भित करती है।

#######    #######    #######    #######    #######    #######    #######
#\    #    #\    #    #\   \#    #\  /\#    #\  /\#    #\/ /\#    #\/\/\#
# \   #    # \  /#    # \  /#    # \/ /#    # \/ /#    #/\/ /#    #/\/\/#
#  \  #    #  \/ #    #  \/ #    # /\/ #    #\/\/ #    #\/\/ #    #\/\/\#
#######    #######    #######    #######    #######    #######    #######

चुनौती

बॉक्स की सकारात्मक (सकारात्मक) चौड़ाई और ऊंचाई को देखते हुए, आपको लेजर का पता लगाने के अंतिम परिणाम का उत्पादन करना चाहिए। आप STDIN (या निकटतम विकल्प), कमांड-लाइन तर्क, फ़ंक्शन तर्क और इनपुट के माध्यम से परिणाम ले रहे हैं या STDOUT (या निकटतम वैकल्पिक), या फ़ंक्शन रिटर्न मान या तर्क के माध्यम से परिणाम लिख सकते हैं।

आप इनपुट के लिए किसी भी सुविधाजनक सूची, स्ट्रिंग या संख्या प्रारूप का उपयोग कर सकते हैं। आउटपुट एक स्ट्रिंग होना चाहिए (जब तक कि आप इसे STDOUT में प्रिंट नहीं करते हैं, जिसे आप निश्चित रूप से धीरे-धीरे कर सकते हैं)। इसका मतलब यह भी है कि आप ऊँचाई पहले और चौड़ाई दूसरी ले सकते हैं - बस अपने उत्तर में सटीक इनपुट प्रारूप निर्दिष्ट करें।

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

आपको अंतरिक्ष का उपयोग करना चाहिए /, \और #परीक्षण मामलों को बिल्कुल वैसा ही दिखाना चाहिए जैसा कि दिखाया गया है।

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

2 2
####
#\ #
# \#
####

3 2
#####
#\/\#
#/\/#
#####

6 3
########
#\    /#
# \  / #
#  \/  #
########

7 1
#########
#\/\/\/\#
#########

1 3
###
#\#
#/#
#\#
###

7 5
#########
#\/\/\/\#
#/\/\/\/#
#\/\/\/\#
#/\/\/\/#
#\/\/\/\#
#########

22 6
########################
#\  /\  /\  /\  /\  /\ #
# \/  \/  \/  \/  \/  \#
# /\  /\  /\  /\  /\  /#
#/  \/  \/  \/  \/  \/ #
#\  /\  /\  /\  /\  /\ #
# \/  \/  \/  \/  \/  \#
########################

Comments

शायद एक अच्छा अनुवर्ती प्रश्न, एक बार जब यह अपना कोर्स चला लेता है, तो इस चुनौती को मनमाने ढंग से आकार के बक्से और शुरुआती बिंदुओं के साथ करना है।

— Sanchises

@sanchises मैंने वास्तव में माना था कि (और अभी भी इसे पोस्ट कर सकते हैं), लेकिन मैंने इस उम्मीद में आयत के साथ जाने का फैसला किया कि कोई स्पष्ट सूत्र के साथ आ सकता है। मैं कई शुरुआती बिंदुओं पर भी विचार कर रहा था जो Xक्रॉसिंग के लिए आवश्यक होंगे। शायद अगली बार। ;)

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

प्रासंगिक: i.imgur.com/6tXrIfw.webm

— orlp

यह एक एनीमेशन बिंदु के लिए एकदम सही होगा। "चेतन 1 फट (एक स्लैश) 1 चक्र / अंतहीन)"

— मार्टिज़न

Answer 1

पायथ, 43 41 39 बाइट्स

K*\#+2QKVvzp<*QXX*dyivzQN\\_hN\/Q\#\#)K

इसे ऑनलाइन आज़माएं: पायथ कंपाइलर / एक्ज़ीक्यूटर । निम्नलिखित क्रम में संख्याओं को इनपुट करें: ऊंचाई पहली पंक्ति, चौड़ाई दूसरी पंक्ति।

इसहाक के लिए धन्यवाद, जिन्होंने दो बाइट बचाने में मदद की।

स्पष्टीकरण:

मेरा समाधान लेजर को ट्रेस नहीं करता है, यह एक साधारण पैटर्न का उपयोग करता है जिसमें जीसीडी शामिल है। यदि m, nबॉक्स के आयाम हैं, तो आइए d = gcd(m, n)। पैटर्न का आकार बिल्कुल है 2*d x 2*d।

उदाहरण के लिए दोहराव पैटर्न 7 5

#########
#\/\/\/\#
#/\/\/\/#
#\/\/\/\#
#/\/\/\/#
#\/\/\/\#
#########

है

\/
/\

( gcd(7, 5) = 1, पैटर्न का आकार है 2 x 2)

और के लिए दोहरा पैटर्न 22 6

########################
#\  /\  /\  /\  /\  /\ #
# \/  \/  \/  \/  \/  \#
# /\  /\  /\  /\  /\  /#
#/  \/  \/  \/  \/  \/ #
#\  /\  /\  /\  /\  /\ #
# \/  \/  \/  \/  \/  \#
########################

है

\  /
 \/ 
 /\
/  \

( gcd(22, 6) = 2, पैटर्न का आकार है 4 x 4)

मेरा हल प्रत्येक पंक्तियों के लिए निम्न कार्य करता है: यह बस पैटर्न की एक पंक्ति उत्पन्न करता है, इसे कुछ बार दोहराता है और इसे अंत में काटता है ताकि यह बॉक्स में फिट हो जाए।

K*\#+2QK   implicit: Q is the second input number (=width)
K          K = 
 *\#+2Q        "#" * (2 + Q)
       K   print K (first line)

Vvzp<*QXX*dyivzQN\\_hN\/Q\#\#)K  implicit: vz is the first input number (=height)
VQ                               for N in [0, 1, ..., vz-1]:
           ivzQ                             gcd(vz,Q)
          y                               2*gcd(vz,Q)
        *d                           string with 2*gcd(vz,Q) space chars
       X       N\\                   replace the Nth char with \
      X           _hN\/              replace the -(N+1)th char with /
    *Q                               repeat Q times
   <                   Q           only use the first Q chars
  p                     \#\#       print "#" + ... + "#"
                            )    end for
                             K   print K

Comments

के बाद से Xसमर्थन तार करने के लिए "बताए", आप बदल सकते हैं m\ करने के लिए *dऔर हटाने s।

— इसहाक

@isaacg अच्छा कॉल। मैंने शीघ्र ही उपयोग *\ करने के बारे में सोचा m\ , लेकिन इसे त्याग दिया क्योंकि इसका आकार समान है। चर dऔर अनावश्यक के बारे में नहीं सोचा था s।

— जक्यूब

Answer 2

सी, 256 बाइट्स

f(w,h){int i,j,x=1,y=1,v=1,u=1;char b[h+2][w+3];for(i=0;i<w+3;i++)for(j=0;j<h+2;j++)b[j][i]=!i||!j||i>w||j>h?i>w+1?0:35:32;while((x||y)&&(x<=w||y<=h))v=x&&w+1-x?v:(x-=v,-v),u=y&&h+1-y?u:(y-=u,-u),b[y][x]=v/u<0?47:92,x+=v,y+=u;for(i=0;i<h+2;i++)puts(b[i]);}

मैं शायद इसे 200 से कम कर सकता हूं, और मैं बाद में एक स्पष्टीकरण जोड़ूंगा, लेकिन मेरे पास कुछ घंटों के कारण एक पेपर हो सकता है जो मुझे इसके बजाय करना चाहिए।

Comments

नकली इंटरनेट बिंदु एक शैक्षिक डिग्री से अधिक मूल्य के हैं, मुझे इसका यकीन है।

— एडम डेविस

230 बाइट्स

— छत

Answer 3

जे, 85 बाइट्स

चलो g = gcd(w,h)। समारोह एक के तत्वों भरता w/g by h/gके साथ मैट्रिक्स g by gटाइल्स, होने /के और \'उनके विकर्ण और विरोधी विकर्ण में रों। परिणामी 4D सरणी को एक 2 डी (बॉक्स के अंदर) में उकेरा जाता है, फिर उसे घेर लिया जाता है #। (इसके 0 1 2 3बजाय संख्याओं का उपयोग किया जाता है [space] / \ #और संख्याओं को अंत में वर्णों में बदल दिया जाता है।)

एक प्रत्यक्ष स्थिति के अंदर समन्वय की गणना के आधार पर शायद थोड़ा सा समाधान निकल सकता है।

' \/#'echo@:{~3,.~3,.3,~3,,$[:,[:,"%.0 2 1 3|:((,:2*|.)@=@i.@+.){~[:(2&|@+/&:i.)/,%+.

उपयोग:

   6 (' \/#'echo@:{~3,.~3,.3,~3,,$[:,[:,"%.0 2 1 3|:((,:2*|.)@=@i.@+.){~[:(2&|@+/&:i.)/,%+.) 22
########################
#\  /\  /\  /\  /\  /\ #
# \/  \/  \/  \/  \/  \#
# /\  /\  /\  /\  /\  /#
#/  \/  \/  \/  \/  \/ #
#\  /\  /\  /\  /\  /\ #
# \/  \/  \/  \/  \/  \#
########################

इसे यहाँ ऑनलाइन आज़माएँ।

Answer 4

डेसमोस कैलकुलेटर - गैर-ज्ञान प्रतिस्पर्धा में मदद करने के लिए

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

इनपुट:

h as height of box, with 0-indexing
w as width of box, with 0-indexing

मध्यवर्ती:

Let b = gcd(h,w),
Let c = |b-h%2b| Or |b-mod(h,2b)|

• gcd (h, w) सबसे बड़े सामान्य भाजक का प्रतिनिधित्व करता है
• एक% बी , जैसा कि जावास्क्रिप्ट में, या मॉड (ए, बी) , जैसा कि फोरट्रान में, मापांक ऑपरेशन का प्रतिनिधित्व करता है , अंतराल [0, बी) पर।

सूत्र, संक्षिप्त:

(|b-(x+y)%2b|-c)(|b-(x-y)%2b|-c)=0

आउटपुट:

x as x position, 0-indexed, where the ball will land when released
y as y position, 0-indexed, where the ball will land when released

यह काम किस प्रकार करता है:

(|b-(x+y)%2b|-c)*(|b-(x-y)%2b|-c)=0
                ^ OR operation - |b-(x+y)%2b|-c=0 or |b-(x-y)%2b|-c=0
|b-(x+/-y)%2b|-c = 0
|b-(x+/-y)%2b| = c
|b-(x+/-y)%2b| = c means (b-(x+/-y))%2b = + or -c 
b-(x+/-y)%2b = +/- c -> b +/- c = (x+/-y)%2b -> (x+/-y) = n*2*b + b +/- c 
Where n is integer.  This will force patterns to repeat every 2b steps in x and y.  
Initial pattern n=0: (x +/- y) = b +/- c -> y = +/- x + b +/- c
In the x positive and y positive plane only, these correspond to lines of positive and 
negative slope, set at intercept b, offset by c on either side.

कार्यक्रम अंतिम मानदंड को पूरा करने में विफल रहता है - बॉक्स और लाइनों की ASCII कला उत्पन्न करना, इसलिए मैं दूसरों को चुनौती पूरी करने में मदद करने के लिए जानकारी के लिए गैर-प्रतिस्पर्धी के रूप में प्रस्तुत कर रहा हूं। ध्यान दें कि जब डेमोस को काम करने के लिए सी = 0 या सी = बी, 0.01 का एक छोटा ऑफसेट कारक पेश किया गया था, जैसा कि डेसमोस को [0, बी के बजाय (0, बी) के मॉड (ए, बी) की सीमा लगती है। )