अपने अध्यक्ष का विश्लेषण करें


11

यह चुनौती डाउनगेट की अपनी कुर्सी को समायोजित करने पर आधारित है ।

चुनौती

आपने अभी अपनी नई कुर्सी को समायोजित किया है! यह आपको पूरी तरह से फिट बैठता है। हालाँकि, पहिया बहुत कमज़ोर है और आप जानते हैं कि मरम्मत करने वाले लोग समायोजन को बदल देंगे। समस्या यह है कि आपके पास शासक नहीं है, इसलिए आपको इसे मापने के लिए एक कार्यक्रम लिखना होगा। मरम्मत करने वाले लोग केवल इतने लंबे समय तक इंतजार कर सकते हैं। इसलिए आपका कोड यथासंभव छोटा होना चाहिए।
एक समायोज्य कुर्सी का उदाहरण

उदाहरण

O
|
|
| _
| |
|_|_
  |
  |
  O

5,3,2,2,1

O
|  _
|  |
|__|__
   |
   |
 __|__
 OOOOO

3,5,2,3,5

O
|      _
|______|______
 ______|______
 OOOOOOOOOOOOO

2,13,1,1,13

कुर्सी भागों

कुर्सी के विभिन्न घटक हैं:

O  <- Headrest
|
|  <- Backrest
|  _  <- Armrest
|  |
|__|__ <- Seat
   |  
   |   <- Leg
  _|_
  OOO  <- Wheels

विस्तृत चेयर विवरण

कुर्सी के हिस्से हैं:


Headrest: वहाँ हमेशा बाक़ी ऊपर एक headrest हो जाएगा

O
|

बाक़ी: की संख्या |है बाक़ी ऊंचाई

O
|
|

सीट: सीट चौड़ाई की संख्या _है , आर्मरेस्ट के लिए बीच में एक है।|

__|__

आर्मरेस्ट: की संख्या |है आर्मरेस्ट ऊंचाई । इसे सीट के बीच में डाला जाएगा।

_
|
|

लेग: की संख्या |है लेग ऊंचाई

|
|

पहिए: पहिए पैरों के नीचे केंद्रित हैं। यदि वे एक से अधिक हैं, तो केंद्र पहिया _उनके ऊपर की रेखा में होगा ।

_ _
OOO

उत्पादन

एक कुर्सी को देखते हुए, आप विभिन्न चर का उत्पादन करेंगे।

आउटपुट निम्न क्रम में होना चाहिए:

  1. बाक़ी ऊंचाई
  2. सीट चौड़ाई हमेशा विषम
  3. आर्मरेस्ट हाइट हमेशा बैकरेस्ट ऊंचाई से कम होती है
  4. पैर की ऊँचाई
  5. व्हील की गिनती हमेशा सीट की चौड़ाई से कम या बराबर होती है और हमेशा विषम होती है

यदि यह एक फ़ंक्शन है, तो आउटपुट में एक अनुगामी न्यूलाइन हो सकती है, या एक सरणी / सूची रूप में हो सकती है।

लीडरबोर्ड

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

# 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

आर्मरेस्ट को मापा जाता है?
J Atkin

जवाबों:


3

लुआ, 187 बाइट्स

मुझे लगता है कि मैं इसे कुछ और करने में सक्षम हो सकता हूं, लेकिन मुझे लगता है कि यह इस समय अच्छा है। इसके अलावा, अगर आउटपुट को अल्पविराम से अलग करने की आवश्यकता होती है, तो मैं इसे ठीक कर सकता हूं, लेकिन यह अभी भी आवश्यकताओं को पूरा करता है।

इसके अलावा, इनपुट को एक बार में एक पंक्ति में फीड किया जाता है। पहियों के इनपुट होने के बाद, इनपुट को अंतिम रूप देने के लिए एक खाली लाइन के साथ एंटर दबाएं।

c={}i=1t=""while c[i-1]~=""do c[i]=io.read():gsub("%s+","")t=t..c[i]a=(not a and c[i]:find("_")and i or a)s=(not s and c[i]:find("_|_")and i or s)i=i+1 end print(s-1,c[s]:len()-1,s-a,#c-s-2,c[#c-1]:len())

Ungolfed

c={}
i=1
while c[i-1]~=""do 
    c[i]=io.read():gsub("%s+","")          --remove spaces
    a=(not a and c[i]:find"_"and i or a)   --armrest position
    s=(not s and c[i]:find"_|_"and i or s) --seat position
    i=i+1
end
print(s-1, c[s]:len()-1, s-a, #c-s-2, c[#c-1]:len())

(पदों को शीर्ष-से-नीचे मापा जाता है, इसलिए शीर्ष 'O' स्थिति 1 है, और पहिए सबसे बड़ी स्थिति हैं।

  • बैकरेस्ट की ऊंचाई सीट माइनस एक की स्थिति है, जो शीर्ष पर 'ओ' के लिए क्षतिपूर्ति करता है।
  • सीट का आकार सीट की स्थिति शून्य से एक पर वें स्ट्रिंग की लंबाई है, जो बैकरेस्ट के लिए क्षतिपूर्ति करता है।
  • आर्मरेस्ट की ऊँचाई सीट की स्थिति से कम से कम आर्मरेस्ट की स्थिति है।
  • पैर की ऊंचाई कुर्सी की ऊंचाई है (#c ) माइनस 2 की स्थिति माइनस 2, पहियों और सीट के लिए क्षतिपूर्ति करने के लिए।
  • व्हील काउंट अंतिम स्ट्रिंग की लंबाई है।

3

ग्रूवी, 161 बाइट्स !!!

वाह!! आखिरी में नहीं !!

f={s->a=s.split(/\n/)
b=a.findIndexOf{it.contains('|_')}
d=b-a.findIndexOf{it.contains('_')}
print"$b,${a[b].count('_')+1},$d,${a.size()-b-2},${s.count('O')-1}"}

Ungolfed:

f={String s ->
    split = s.split(/\n/)
    bottomOfChairBack = split.findIndexOf {it.contains('|_')}
    armHeight = bottomOfChairBack-split.findIndexOf {it.contains('_')}
    width = split[bottomOfChairBack].count('_')+1
    height = split.size() - bottomOfChairBack - 2

    wheelCount = s.count('O')-1
    return [bottomOfChairBack, width, armHeight, height, wheelCount]
}

अपुष्ट कार्यक्रम के परीक्षण:

assert f('''O
|
|
| _
| |
|_|_
  |
  |
  O''') == [5, 3, 2, 2, 1]

assert f('''O
|  _
|  |
|__|__
   |
   |
 __|__
 OOOOO''') == [3,5,2,3,5]

assert f('''O
|  _
|  |
|__|__
   |
   |
 __|__
 OOOOO''') == [3,5,2,3,5]

assert f('''O
|      _
|______|______
 ______|______
 OOOOOOOOOOOOO''') == [2,13,1,1,13]

2

Pyth, 57 54 53 50 बाइट्स

संभवतः आगे गोल्फ हो सकता है। -3 बाइट्स एकल वर्ण स्ट्रिंग चाल के लिए issacg के लिए धन्यवाद ।

=kjb.z
=H/k+b\|
-/k\_=G-/k\O2
--/k\|H=Nt/k+bd
N
hG

स्पष्टीकरण:

=kjb.z
=k              Assign k
     z          Input
  jb.           Join list by newlines

=H/k+b\|
=H              Assign H
  / +b\|        Count occurrences of "\n|"
   k            In input
                (Implicit: print backrest height)

-/k\_=G-/k\O2
     =G         Assign G
       -/k\O2   The number of wheels minus 1
-/k\_           Count the number of "_"
                (Implicit: print seat width)

--/k\|H=Nt/k+bd
       =N       Assign N
          /k+bd Count the number of lines starting with " "
         t      Subtract 1 (N is now the leg height)
  /k\|          Count the number of "|"
 -    H         Subtract the "|" for the backrest
-               Subtract leg height
                (Implicit: print armrest height)

N               Print leg height

hG              Print the number of wheels

1
एक-वर्ण स्ट्रिंग बनाने के लिए, का उपयोग करें \। तो "_"=\_
isaacg

आउच, कोई रास्ता नहीं मैं इसे हरा करने जा रहा हूँ;)
जे एटकिन

2

पर्ल, 93 + 2 = 95 90 + 1 = 91 83 + 1 = 84 बाइट्स

जाहिर तौर पर आउटपुट को अल्पविराम-पृथक्करण की आवश्यकता नहीं है

perl -n chair.pl chairInput(ध्वज के लिए 1B दंड) के साथ चालान करें ।

END{print$b,2+$u-$o,$a,$.-$b-2,$o-1}$u+=s/_//g;$o+=s/O//g;s/^\|//&&$b++&&/\|/&&$a++

Ungolfed:

END{         # Put the END block first to save 1 ;
    print
        $b,   
    2+$u-$o,
    $a,
    $.-$b-2, # $. is the number of lines total
    $o-1
}
$u+=s/_//g; # count _s incrementally
$o+=s/O//g; # count Os incrementally
s/^\|// && $b++ # it's backrest if it starts with |
    && /\|/ && $a++ # and it's armrest if it has another one

पुराना वर्जन:

के साथ आह्वान किया perl -0n chair.pl < chairInput

s/^\|//&&$b++?/\|/&&$a++:$h++for split"
",$_;$,=",";print$b,2+s/_//g-($o=s/O//g),$a,$h-3,$o-1

स्पष्टीकरण:

s/^\|// && $back++   # the backrest is all lines starting with |
    ? /\|/ && $arm++ # the armrest is all of those lines with another |
    : $height++      # otherwise it counts for the seat height
    for split"
",$_;       # literal newline for 1 byte saved
$,=",";     # output separator
print
    $back,
    2+s/_//g-($o_count=s/O//g),  # you can find the seat size
                                 # from the different between the number
                                 # of Os and _s
    $arm,
    $height-3,
    $o_count-1

1

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

यह कोड काम करता है लेकिन केवल निम्न स्थितियों पर: 1) armrest height > 0अन्यथा _गिनती टूट जाती है और 2) seat width > 1अन्यथा आर्मरेस्ट चौड़ाई-एक सीट को ब्लॉक कर देता है और _गिनती टूट जाती है।

def f(s):
 a=s.split("\n");x=[];y=[];l=len(a)
 for i in range(l):
  m=a[i].count("_")
  if m:x+=i,;y+=m,
 return x[1],y[1]+1,x[1]-x[0],l-x[1]-2,s.count("O")-1
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.