क्या टावर बैलेंस करेगा?


36

परिचय

एक ASCII टॉवर और हवा के बल को देखते हुए, यह निर्धारित करने के लिए एक कार्यक्रम या फ़ंक्शन लिखें कि क्या टॉवर संतुलन करेगा या किस तरह से गिर जाएगा।

उदाहरण के लिए पहला टॉवर संतुलन लेकिन दूसरा बाईं ओर गिरता है।

  # #            # #
  ###            ### 
 ###            ### 
 # #            # # 
#####          ##### 
 ###            ### 
 ###              #

यह मेरी पहली चुनौती है। मुझे उम्मीद है कि आप इसे पसन्द करेंगें।

दिशा-निर्देश

टॉवर से जुड़े ब्लॉकों का प्रतिनिधित्व करते हैं #और एक कठोर वस्तु बनाते हैं । प्रत्येक ब्लॉक एक वर्ग है जिसकी चौड़ाई और ऊंचाई एक इकाई है और इसमें निरंतर घनत्व है। टावर पर काम करने वाली दो ताकतें हैं, उसका वजन और पवन बल। सभी बल प्रत्येक ब्लॉक पर व्यक्तिगत रूप से कार्य करते हैं और ब्लॉक के केंद्र से गुजरते हैं।

  • अपने वजन के कारण, प्रत्येक ब्लॉक में एक इकाई का एक बल नीचे होता है।
  • इसके अलावा, प्रत्येक ब्लॉक जिसके पास इसकी घुमावदार तरफ एक और ब्लॉक नहीं है, उस पर एक बल है जो हवा की दिशा में क्षैतिज रूप से कार्य करता है। इस बल का परिमाण एक इनपुट के रूप में दिया गया है।
  • हवा की दिशा इनपुट में कहीं ASCII ध्वज द्वारा इंगित की गई है। इनपुट में एक झंडा होगा यदि और केवल अगर हवा शून्य नहीं है। ध्वज किसी भी बल को प्रभावित नहीं करता है।

ध्वज बिल्कुल वैसा ही दिखेगा जैसा नीचे दिखाई देता है।

Flag design and corresponding wind direction:

 o~~        ~~o
 |~~        ~~|

--->        <---

स्पष्ट करने के लिए, टॉवर एक ठोस वस्तु है और अलग नहीं होगा और जमीन से जुड़ा नहीं है। हालांकि, आपके कार्यक्रम को प्रत्येक ब्लॉक के लिए बलों की गणना व्यक्तिगत रूप से यह निर्धारित करने के लिए करनी चाहिए कि क्या टॉवर शेष है।

उदाहरण

  o~~
  |~~
  # #              > > 
  ###              >## 
 ###              >##  
 # #              > >  
#####            >#### 
 ###              >##  
 ###              >##  

Wind force: 1    Wind direction: --->

हवा सही बह रही है और >ऊपर दाईं ओर दिखाए गए ब्लॉकों पर जोर देगी । ध्यान दें कि हवा छेद के अंदर पर कार्य करती है।

मान लें कि टॉवर के निचले बाएं कोने में निर्देशांक हैं (0,0)। टावर के बाएं आधार के चारों ओर का समय (0,0)71 यूनिट है, इसलिए टॉवर बाईं ओर नहीं गिरेगा। (0,3) पर टावर के दाहिने आधार के आसपास का समय 8 यूनिट है, इसलिए टावर दाईं ओर गिरेगा।

यदि हवा बाईं ओर बह रही थी, तो संबंधित क्षण 2 इकाइयां दक्षिणावर्त और 61 इकाइयां एक ही बिंदु पर वामावर्त होंगी, इसलिए टॉवर संतुलन बनाएगा।

इनपुट

  • आपके प्रोग्राम या फ़ंक्शन को दो इनपुट, एक दशमलव संख्या और एक नई लाइन-अलग स्ट्रिंग लेनी होगी।
  • दशमलव संख्या शून्य से अधिक होगी और उदाहरण के रूप में प्रत्येक उजागर ब्लॉक पर हवा द्वारा लगाए गए बल का प्रतिनिधित्व करती है।
  • स्ट्रिंग ऊपर से नीचे तक टॉवर का प्रतिनिधित्व करेगी और इसमें रिक्त स्थान, #|o~वर्ण और नई लाइनें हो सकती हैं । आप वैकल्पिक रूप से एक अनुगामी न्यूलाइन मान सकते हैं और / या एक आयत बनाने के लिए अनुगामी स्थानों के साथ टॉवर को पैड कर सकते हैं।
  • टॉवर #में नीचे की पंक्ति में कम से कम एक होगा ।
  • आप या तो क्रम में संख्या और स्ट्रिंग इनपुट कर सकते हैं।
  • यदि पवन सेना का परिमाण गैर-शून्य है, तो इनपुट में कहीं एक झंडा होगा, या तो जमीन पर या टॉवर से जुड़ा होगा। ध्वज में ऊपर दिखाया गया सटीक रूप होगा।
  • #ब्लॉक एक जुड़ा आकार कि छेद हो सकती है बनेगी। दूसरे शब्दों में, सभी ब्लॉक एक दूसरे ब्लॉक से तब तक सटे रहेंगे जब तक कि एक ब्लॉक न हो।

उत्पादन

  • पात्रों में से एक B, Lया R, चाहे टॉवर संतुलन जाएगा पर निर्भर करता है, बाएं (वामावर्त) की ओर गिर जाते हैं, या सही (दक्षिणावर्त) की ओर गिर जाते हैं।
  • आउटपुट में एक वैकल्पिक अनुगामी न्यूलाइन हो सकती है।

यह ; मानक नियम और कमियां लागू होती हैं।

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

Wind: 1
    ~~o
    ~~|
      # #
      ###
     ###
     # #
    #####
     ###
     ###

Wind: 0
##
# ##
###

Wind: 1.7
o~~
|~~
#
##

Wind: 0.768
      o~~
      |~~
      # #
      ###
     ###
     # #
    #####
     ###
     ###

Wind: 0.1
#
#
#
#
#
# o~~
# |~~

Wind: 0
#

Wind: 0
############

Wind: 144
               o~~
############   |~~

Wind: 0
#######
 ##
 #
 ##

Wind: 0
                ############
           ############
       ############
    ############
   ############
 ############
############

Wind: 41
                 ############
            ############
        ############
     ############
    ############
  ############     ~~o
 ############      ~~|

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

Wind: 0
#####
   #


Wind: 42
                 ############
            ############
        ############
     ############
    ############
  ############     ~~o
 ############      ~~|

Wind: 4
########
    ###
 ~~o# ##
 ~~|#  #

Wind: 3
########
    ###
 o~~# ##
 |~~   #

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

Wind: 1
      o~~
      |~~
      # #
      ###
     ###
     # #
    #####
     ###
     ###

Wind: 2
o~~
|~~
#

Wind: 0.001
                 ############
            ############
        ############
     ############
    ############
  ############     o~~
 ############      |~~

Wind: 145
               o~~
############   |~~

Wind: 1
#
#
#
#
#
# o~~
# |~~

Wind: 0.26
#######
 ##
 #   o~~
 ##  |~~

संदर्भ समाधान (जावास्क्रिप्ट)

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

function balanced(tower, wind) {
    var rows = tower.split('\n').reverse(); // Reverse so row index matches height of row.
    var height = rows.length;
    var leftEdge = rows[0].indexOf('#'); // Find bottom left corner of tower.
    var rightEdge = rows[0].lastIndexOf('#') + 1; // Find bottom right corner of tower.
    var leftMoment = 0, rightMoment = 0; // Moments around the bottoms corners of tower.
    wind *= tower.indexOf('~o')>-1 ? -1 : 1; // Find direction of the wind.

    // Sum the moments for each block in the tower.
    for (var i = height - 1; i >= 0; i--) {
        rows[i].split('').map(function(ch, index, arr) {
            if (ch=='#') {
                // If there's not a block toward the windward side of the current one.
                if ((wind < 0 && arr[index-1] != '#') || (wind > 0 && arr[index+1]!='#')) {
                    // Add moments from wind.
                    leftMoment += (i+0.5)*-wind;
                    rightMoment += (i+0.5)*-wind; 
                }

                leftMoment += leftEdge - (index + 0.5);
                rightMoment += rightEdge - (index + 0.5);
            }
        }, 0);
    }
    if (leftMoment > 0) return 'L';
    else if (rightMoment < 0) return 'R';
    else return 'B';
}

लीडरबोर्ड

यहां एक नियमित लीडरबोर्ड और भाषा के अनुसार विजेताओं का अवलोकन करने के लिए एक स्टैक स्निपेट है।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिख रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

# Language Name, N bytes

Nआपके प्रस्तुत करने का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

# Ruby, <s>104</s> <s>101</s> 96 bytes

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फ़ाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक अंक अंतिम संख्या है:

# Perl, 43 + 2 (-p flag) = 45 bytes

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो लीडरबोर्ड स्निपेट में दिखाई देगा:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes


17
PPCG में आपका स्वागत है; यह एक उत्कृष्ट लिखित पहली चुनौती है! :)
दरवाज़े

जवाबों:


2

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

मैंने अपना संदर्भ कार्यान्वयन लागू किया। यदि स्टेटमेंट्स, और फंक्शन में एक स्पष्ट वापसी से बचने के लिए, ताकि एक बयान पर सब कुछ फिट करने के लिए ऑपरेटर का उपयोग mapकरके &&और ||शॉर्ट-सर्किट के लिए लूप के लिए बदलकर मैं बाइट्स को बचाने में सक्षम था ,

(a,b)=>((c=a.split`
`.reverse(),d=c[f=g=0].indexOf`#`,e=c[0].lastIndexOf`#`+1),a.match`o~`&&(b*=-1),c.map((h,i)=>h.replace(/#/g,(j,k,l)=>(b>0&l[k-1]!='#'|b<0&l[k+1]!='#'&&(f+=(i+=0.5)*b,g+=i*b),f+=d-k-0.5,g+=e-k-0.5))),f>0?'L':g<0?'R':'B')

यह अभी भी इसे और अधिक गोल्फ के लिए संभव हो सकता है। सुझावों का स्वागत है।


मेरे भोले समाधान की तुलना में +1 बेहतर
कॉनर ओ'ब्रायन

1

जावास्क्रिप्ट ईएस 6, 297 293 बाइट्स

मूल रूप से दिए गए कार्यान्वयन का एक संकुचित संस्करण।

b=(n,e)=>{r=n.split`
`.reverse(),t=r.length,a=r[0].indexOf`#`,f=r[i=l=0].lastIndexOf`#`+1;e*=n.indexOf`~o`>-1?-1:1;for(d=t-1;d>=0;d--)r[d].split``.map((n,r,t)=>{(j="#")==n&&((0>e&&j!=t[r-1]||e>0&&j!=t[r+1])&&(i+=(d+.5)*-e,l+=(d+.5)*-e),i+=a-(r+.5),l+=f-(r+.5))},0);return i>0?"L":0>l?"R":"B"}

अर्द्ध विस्तार:

b = (n, e) => {
    r = n.split `
`.reverse(), t = r.length, a = r[0].indexOf `#`, f = r[i = l = 0].lastIndexOf `#` + 1;
    e *= n.indexOf `~o` > -1 ? -1 : 1;
    for (d = t - 1; d >= 0; d--) r[d].split ``.map((n, r, t) => {
        (j = "#") == n && ((0 > e && j != t[r - 1] || e > 0 && j != t[r + 1]) && (i += (d + .5) * -e, l += (d + .5) * -e), i += a - (r + .5), l += f - (r + .5))
    }, 0);
    return i > 0 ? "L" : 0 > l ? "R" : "B"
}
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.