कितना पानी बचा है?

Question

यहाँ कैलिफ़ोर्निया में, हम सूखे में हैं, इसलिए हमें यह जानना होगा कि हमारे पास कितना पानी बचा है इसलिए हम जितना संभव हो उतना पानी का संरक्षण कर सकते हैं।

क्योंकि पानी सीमित आपूर्ति है, आपके कोड को यथासंभव कम होना चाहिए।

उदाहरण

|   |
|   |
|~~~|
|___|

Output: 0.5

|~~~~~|
|     |
|     |
|_____|

Output: 1

|  |
|__|

Output: 0 (or bonus)

विशिष्टता

इनपुट पूरी तरह से शामिल होगा: |_ ~और newlines। सभी ऊपर ~हवा माना जाता है; _नीचे रिक्त स्थान ~, और ~खुद को पानी माना जाता है। बचे हुए जल का प्रतिशत कंप्यूटर है water / (air + water)। आपके आउटपुट को 4 दशमलव स्थानों पर सटीक होना चाहिए (जब तक कि आप प्रतिशत बोनस के लिए नहीं जाते)। इनपुट हमेशा आयताकार होगा। ~केवल एक लाइन पर होगा किसी पर है। यदि आप चाहें तो इनपुट में वैकल्पिक रूप से एक अनुगामी रेखा फ़ीड भी हो सकती है।

बोनस

यदि आप दोनों बोनस के लिए जाते हैं -15% बोनस -35 बोनस से पहले लागू किया जाता है

-35 बाइट बोनस: यदि आपका कोड "यह सूखा बकरी हाथ से बाहर " प्रिंट करता है , तो आउटपुट के 0 होने पर 0 के बजाय

-15% बोनस: यदि आप एक प्रतिशत का उत्पादन करते हैं।

ऐसा करने के लिए, आप दशमलव स्थान को बाईं ओर दो स्थानों पर स्थानांतरित करेंगे, अग्रणी शून्य को ट्रिम करेंगे, और %अंत में एक जोड़ देंगे । जब तक वे मूल्य को प्रभावित नहीं करते हैं, अनुगामी शून्य (अधिकतम 2) की अनुमति है। 0.5-> इनमें से कोई:50.00% 50% 50.0%

Comments

" क्योंकि पानी सीमित आपूर्ति है, आपके कोड को जितना संभव हो उतना छोटा होना होगा। " ठीक है, समझ में आता है ... मुझे लगता है?

— घातक

@ घातक: यह राज्य के बाहर सामान्य ज्ञान नहीं है, लेकिन तरल तर्क- आधारित कंप्यूटर कैलिफोर्निया में बेहद लोकप्रिय हैं। मुझे लगता है कि वे यह देखने की कोशिश कर रहे हैं कि क्या वे इन दिनों बादाम-आधारित विकल्प पर काम कर सकते हैं।

— जॉन 25

@ जॉन जो शायद बताते हैं कि वहां सूखा क्यों है

— hargasinski

आप लोग जानते हैं कि द्रवयुक्त कंप्यूटर पानी का उपयोग नहीं करते हैं, है ना? बिजली के कंप्यूटर की तरह इलेक्ट्रॉन की कमी का कारण नहीं है।

— user253751

यह है: |~~~|(कोई अंडरस्कोर) वैध इनपुट?

— edc65

Answer 1

पायथ - 17 46 45 52 * .85 - 35 = 9.2 बाइट्स

इनपुट को फ़िल्टर करता है (इसके साथ #एक लाइन के लिए नए फिल्टर मेटा-ओपी के साथ) ~, फिर उस इनपुट को अनुक्रमित करता है, और फिर इनपुट की लंबाई से विभाजित करता है। यदि कोई नहीं है ~, तो यह त्रुटि है, और .xस्ट्रिंग को छोड़कर और ट्रिगर को ट्रिगर करता है ।

.x+*100-1cxK.zh@#\~KlK\%." u(C$éáPãbÉãç*îÂe[W

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

Answer 2

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

lambda x:1-(x+'|~').find('|~')/len(x)

कोई बोनस नहीं। एक अनुगामी newline सहित newlines के साथ एक इनपुट स्ट्रिंग लेता है।

आइए देखें कि सूत्र क्यों काम करता है। पानी का अंश हवा के अंश का पूरक है, जिसे हम प्राप्त करेंगे।

frac_water = 1 - frac_air

पंक्तियों की संख्या 0, 1, 2, ..., हमारे पास है

frac_air = water_row_index / num_rows 

यदि दोनों को प्रत्येक पंक्ति की चौड़ाई से गुणा किया जाता है, तो नई संख्याओं को गिनते हुए एक ही सही है, जो वर्णों की संख्या में अभिव्यक्ति को सरल बनाता है।

frac_air = (width * water_row_index) / (width * num_rows)
         = water_row_start_char_index / num_chars

के लिए इनपुट स्ट्रिंग xको खोजकर पानी की पंक्ति शुरू होती है |~, और चर की संख्या सिर्फ लंबाई होती है।

frac_air = x.find('|~') / len(x)

अंत में, बिना पानी के इनपुट काम करने के लिए, हम एक काल्पनिक पानी की पंक्ति शुरू करते हैं |~ खोज करने से पहले करने के लिए , जिससे ऐसा लगता है कि पानी का स्तर 0 है।

बोनस के लायक नहीं लग रहा था। सबसे अच्छा मुझे स्ट्रिंग पर मिला 73-35 = 38:

lambda x:['This drought goat out of hand',1-x.find('|~')/len(x)]['~'in x]

Answer 3

CJam, 19 17 16 58 * 0.85 - 35 = 14.3 बाइट्स

q'|-_'~#_)\@,d/1\m100*s'%+"This drought goat out of hand"?

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

इस संस्करण में दोनों बोनस मिलते हैं। इनपुट चाहिएइस समाधान के काम करने के लिए में एक अनुगामी न्यूलाइन ।

2 बाइट बचाने के लिए @Martin Büttner को धन्यवाद।

स्पष्टीकरण:

q       Get input.
'|-     Remove left/right wall, so that position of first ~ in remaining string
        corresponds to the water level.
_       Make a copy.
'~#     Find ~ character.
_)      Make copy of find result, and increment it. This is 0 if the ~
        was not found, and will be used for the bonus condition.
\       Swap original find result to top.
@,      Rotate copy of remaining input to top, and get its length.
d       Convert to double to get float division.
/       Divide the two values. Since the position of the ~ was indexed from
        the top, this is 1 minus the desired result.
1\m     Subtract value from 1, to get the actual result.
100*    Multiply by 100 to get percent.
s       Convert to string.
'%+     Append % sign.
"This drought goat out of hand"
        Push bonus zero string.
?       Ternary operator to pick calculated result or zero string.

Answer 4

जावास्क्रिप्ट (ईएस 6), 45 (94 -15% -35)

एक अनाम फ़ंक्शन के रूप में। टेम्प्लेट स्ट्रिंग्स का उपयोग करना, एक नई रेखा है जो महत्वपूर्ण है और बाइट काउंट में शामिल है

1 बाइट बचाया thx @ user81655 संपादित करें

p=>p.split`
`.map((r,i)=>r>'|~'?p=i:q=~i)&&q-p?(1+p/q)*100+'%':'This drought goat out of hand'

कम गोल्फ वाला

p=>(
  p.split('\n') // split in rows
  .map((r,i)=> // execute for each row
    r>'|~'   // look for the water top
      ? p=i  // position of water top in p
      : q=~i // if not water top, set current position (-i-1) in q
  ),
  // at the end,if water top not found, p still contains the input string
  q-p // subtracting the input string I get NaN (that is a falsy value)
  ? (1+p/q)*100+'%' // calc % taking into account the negative sign of q
  : 'This drought goat out of hand' 
)

टेस्ट स्निपेट

F=p=>p.split`\n`.map((r,i)=>r>'|~'?p=i:q=~i)&&q-p?(1+p/q)*100+'%':'This drought goat out of hand'

function Update() {
  var w=+W.value, h=+H.value, t=+T.value,
      b=Array(h).fill().map((r,i)=>'|'+(i==h-1?'_':i==t?'~':' ').repeat(w)+'|').join`\n`  
  O.textContent = b+'\n\n'+F(b)
  
}

Update()

<table>
  <tr><td>Width</td><td><input id=W type=number value=4 oninput='Update()'></td></tr>
  <tr><td>Height</td><td><input id=H type=number value=4 oninput='Update()'></td></tr>
  <tr><td>~~~ at row</td><td><input id=T type=number value=2 oninput='Update()'></td></tr>
</table>  
<pre id=O></pre>

Comments

सुंदर परीक्षण स्निपेट और हमेशा की तरह बढ़िया कोड! एक सुझाव यह है: आप बदल सकते p=~iके साथ p=i, &&-pके साथ &&p-qऔर 1+~pकरने के लिए 1+p1 बाइट को बचाने के लिए।

— user81655

@ user81655 अच्छा सुझाव, धन्यवाद

— edc65

Answer 5

बराबर , 57 * 85% - 35 = 13.45 बाइट्स

`This drought goat out of hand`r√″T┐↑⌐'~˦↑↔~÷Zx²*'%↔╡\z_g

व्याख्या

`This dr...d`  ## 'This drought goat out of hand'
r              ## Read entire input
√              ## Split by newlines
″              ## Duplicate
T              ## Transpose
┐↑             ## Second element of each line
⌐              ## Reverse
'~˦            ## First index of '~'
↑              ## Plus one
↔              ## Swap
~÷             ## Divide by size
Z              ## Assign to z
x²*            ## Multiply by 100
'%↔╡           ## Append '%'
\              ## Array of string and number
z_g            ## If z=0, then string; else, number

Answer 6

पर्ल, 70 - 15% - 35 = 24.5 बाइट्स

के लिए +1 शामिल है -p

 $S[$w|=/~/]++}{$_=$w?100*$S[1]/$..'%':'This drought goat out of hand'

टिप्पणियों के साथ:

$S[ $w |= /~/ ]++                   # $w=0 for air, 1 for having seen water; count element
}{                                  # -n/-p: end the `while(<>){` and begin END block
$_ = $w                             # assign output for -p
  ? 100 * $S[1] / $. . '%'          # $. is $INPUT_LINE_NUMBER
  :'This drought goat out of hand'  # costs 35 aswell, but is effectively more after -15%

---

• 26 + 1 बाइट संस्करण, कोई बोनस नहीं: 27

  $S[$w|=/~/]++}{$_=$S[1]/$.
  

• 34 + 1 बाइट संस्करण, 15% बोनस के साथ: 29.75

  $S[$w|=/~/]++}{$_=100*$S[1]/$..'%'
  

• 61 + 1 बाइट संस्करण, -35 बोनस के साथ: 27

  $S[$w|=/~/]++}{$_=$w?$S[1]/$.:'This drought goat out of hand'
  

• 69 + 1 बाइट संस्करण, दोनों बोनस: 24.50

  $S[$w|=/~/]++}{$_=$w?100*$S[1]/$..'%':'This drought goat out of hand'
  

Answer 7

जावास्क्रिप्ट, 59.3

मुझे उम्मीद है कि अतिरिक्त दशमलव स्थान ठीक हैं। कोई अनुगामी न्यूलाइन मानता है।

drought=
// code
a=>(b=-1,e=a.split`
`.map((c,d)=>b=c[1]=='~'?d:b).length,++b?(e-b+1)*100/e+"%":"This drought goat out of hand")

// I/O
var i = document.getElementById("i");
var o = document.getElementById("o");
i.onchange = i.onkeyup = function(){
  o.textContent = drought(i.value);
};

// explanation
inputStr=>(
  tildePosition = -1, // default: not found
  containerDepth =    // if the current line has a tilde, set tildePosition, otherwise
                      // keep current tildePosition
      inputStr.split`\n`.map((line, pos)=> tildePosition = line[1]=='~' ? pos : tildePosition)
    .length,          // assign number of lines (container depth) to containerDepth
  ++tildePosition     // if it's still -1, print the message, otherwise print percent
    ?(containerDepth-tildePosition+1)*100/containerDepth+"%"
    :"This drought goat out of hand")

<textarea id="i"></textarea>
<p id="o"></p>

Answer 8

हास्केल, 56 बाइट्स

l=sum.(>>[1])
f i|s<-lines i=l(snd$break(elem '~')s)/l s

उपयोग उदाहरण: f "| |\n|~~|\n| |\n|__|"->0.75।

lएक कस्टम लंबाई फ़ंक्शन है, जो आवश्यक है, क्योंकि lengthरिटर्न में पूर्णांक मानों का निर्माण होता है, लेकिन हमें विभाजन के लिए फ्लोटिंग पॉइंट वैल्यू की आवश्यकता होती है (इसमें वह genericLengthभी है जो यह सुविधा प्रदान करता है, लेकिन यह अधिक लंबा है, अकेले ही आवश्यक है import Data.List)। fइनपुट iको लाइनों में विभाजित करता है (-> s) और फिर एक जोड़ी में जहां पहला तत्व एक सूची है जिसमें सभी लाइनें हैं (और बाहर करने वाली) इसमें एक के साथ पहला ~। दूसरा तत्व बाकी पंक्तियों के साथ एक सूची है। परिणाम की लंबाई से विभाजित दूसरे तत्व की लंबाई हैs ।

बोनस का भुगतान नहीं करते हैं।

Answer 9

पायथन क्रिया है!

पायथन: 98.45 बाइट्स

(157 * 0.85) - 35 = 98.45 बाइट्स

यह संस्करण स्टड से पढ़ता है, और दोनों बोनस जमा करता है:

import sys
r=[x[1]for x in sys.stdin.read().split('\n|')]
o="This drought goat out of hand"if'~'not in r else"%g%%"%(100-100.0*r.index('~')/len(r))
print(o)

Comments

66 बिना किसी बोनस के:import sys;r=[x[1]for x in sys.stdin];print(1-r.index('~')/len(r))

— ब्लेंडर

अच्छा! हालांकि, वैकल्पिक अनुगामी न्यूलाइन द्वारा इसे ट्रिप किया जाता है, है ना? इसके अलावा, क्या यह पायथन 3 है-केवल डिवीजन ऑपरेटर के कारण?

— निकोलस क्लार्क

वैकल्पिक अनुगामी newline शामिल करने के लिए आप पर निर्भर है। विभाजन के लिए, हाँ, लेकिन आप पहले से ही printएक समारोह की तरह व्यवहार कर रहे हैं इसलिए मैंने मान लिया कि आप पायथन 3 का उपयोग कर रहे थे

— ब्लेंडर

Answer 10

अक्क, 72 वर्ण - 15% - 35 = 26.2

/~/{w=NR}END{print w?(NR-w+1)/NR*100"%":"This drought goat out of hand"}

नमूना रन:

(शुरुआत में 1;केवल इन नमूनों का उपयोग "मानव पठनीय" टैंक प्रदर्शित करने के लिए किया गया था।)

bash-4.3$ awk '1;/~/{w=NR}END{print w?(NR-w+1)/NR*100"%":"This drought goat out of hand"}' <<< $'| |\n| |\n| |\n|_|'
| |
| |
| |
|_|
This drought goat out of hand

bash-4.3$ awk '1;/~/{w=NR}END{print w?(NR-w+1)/NR*100"%":"This drought goat out of hand"}' <<< $'| |\n| |\n|~|\n|_|'
| |
| |
|~|
|_|
50%

Answer 11

PHP, 92 अक्षर - 15% - 35 = 43.2

(कोड के दो ब्लॉक में 88 वर्ण + 4 वर्ण कमांड लाइन विकल्प।)

$argn[1]>z&&$w=+$argi;

echo$w?100*($argi-$w+1)/$argi."%":"This drought goat out of hand";

मानों error_reportingको डिफ़ॉल्ट पर सेट किया गया है।

(कोई बड़ी बात नहीं, बस -Rऔर -Eएक बार उपयोग करने की इच्छा थी । अब केवल -Bबचा है।)

नमूना रन:

(शुरुआत में echo"$argn\n";केवल इन नमूनों का उपयोग "मानव पठनीय" टैंक प्रदर्शित करने के लिए किया गया था।)

bash-4.3$ php -R 'echo"$argn\n";$argn[1]>z&&$w=+$argi;' -E 'echo$w?100*($argi-$w+1)/$argi."%":"This drought goat out of hand";' <<< $'| |\n| |\n| |\n|_|'
| |
| |
| |
|_|
This drought goat out of hand

bash-4.3$ php -R 'echo"$argn\n";$argn[1]>z&&$w=+$argi;' -E 'echo$w?100*($argi-$w+1)/$argi."%":"This drought goat out of hand";' <<< $'| |\n| |\n|~|\n|_|'
| |
| |
|~|
|_|
50%

Answer 12

QBIC - 116 - 15% = 98.6 बाइट्स

{input S$:S$=MID$(S$,2,1):I=I+1:IF y<1 then x=I
y=y+instr(S$,"~"):IF instr(S$,"_")>0 THEN ?(1-(x-y)/I)*100;"%":END}

मैंने QBasic को अधिक प्रतिस्पर्धी बनाने के लिए QBIC बनाया है, लेकिन इसमें अभी भी कई सुधारों की आवश्यकता है। अभी तक, फँसाने के लिए कोई शॉर्टकट नहीं हैं, THEN(जो कि मेरी ओर से एक बहुत बड़ा निरीक्षण है) और input$। जल्द ही उन्हें जोड़ दिया जाएगा।

मैं 0 बोनस नहीं मार सकता, बहुत महंगा ... मैंने प्रतिशत प्रिंट करने का प्रबंधन किया।

नमूना में / आउटपुट:

? |  |
? |  |
? |~~|
? |__|
 50 %

कार्यक्रम इनपुट को अंतःक्रियात्मक रूप से पढ़ता है। जब यह झील के नीचे का पता लगाता है (_ ) यह प्रतिशत को प्रिंट करता है और क्विट करता है। पूर्ण कंटेनर और खाली लोगों के लिए भी परीक्षण किया गया।

संपादित करें: यह दिखाने के लिए कि पिछले वर्ष के दौरान QBIC का विस्तार कैसे किया गया है, यहां वर्तमान दुभाषिया के लिए लिखित एक ही कार्यक्रम है:

{_?A=$MID$|(A,2,1)#~|#_| i=i+1~j<1|k=i]j=j+instr(A,B)~instr(A,C)|?(1-(k-j)/i)*100,@%|_X

87 बाइट, मुद्रण प्रतिशत, 74 का स्कोर है।