Ici en Californie, nous sommes dans une sécheresse, nous devons donc savoir combien d'eau il nous reste afin de conserver autant d'eau que possible.

L'eau étant limitée, votre code devra être le plus court possible.

Exemples

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

Output: 0.5

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

Output: 1

|  |
|__|

Output: 0 (or bonus)

spécification

L'entrée se composera uniquement de tous: |_ ~et de nouvelles lignes. Tous les ci-dessus ~sont considérés comme de l'air; _, les espaces en dessous ~et ~lui-même sont considérés comme de l'eau. Le pourcentage d'eau restant est à côté de l'ordinateur water / (air + water). Votre sortie doit être précise à 4 décimales (sauf si vous optez pour le bonus en pourcentage). L'entrée sera toujours rectangulaire. Le ~sera sur une seule ligne, le cas échéant. L'entrée peut également éventuellement avoir un saut de ligne si vous le souhaitez.

Prime

Si vous optez pour les deux bonus, le bonus de -15% est appliqué avant le bonus de -35

Bonus de -35 octets: si votre code affiche "Cette chèvre sèche de la main", au lieu de 0 lorsque la sortie est 0

-15% Bonus: Si vous affichez un pourcentage.

Pour ce faire, vous devez déplacer la décimale de deux places vers la gauche, couper les zéros de tête et ajouter un %à la fin. Les zéros de fin (max 2) sont autorisés tant qu'ils n'affectent pas la valeur. 0.5-> l'un des:50.00% 50% 50.0%

Pyth - 17 46 45 52 * .85 - 35 = 9,2 octets

Filtre l'entrée (avec le nouveau #filtre meta-op!) Pour une ligne avec ~en elle, puis indexe cela à l'entrée, puis divise cela par la longueur de l'entrée. S'il n'y en a pas ~, il génère une erreur et déclenche la clause except de .xet imprime la chaîne.

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

Essayez-le en ligne ici .

Python 3, 37 octets

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

Pas de bonus. Prend une chaîne d'entrée avec des retours à la ligne, y compris un retour à la ligne de fin.

Voyons pourquoi la formule fonctionne. La fraction d'eau est le complément de la fraction d'air que nous allons dériver.

frac_water = 1 - frac_air

Numéroter les lignes 0, 1, 2, ..., nous avons

frac_air = water_row_index / num_rows 

Il en va de même si les deux sont multipliés par la largeur de chaque ligne, en comptant les retours à la ligne, ce qui simplifie les expressions en nombre de caractères.

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

Le début de la ligne d'eau se trouve en recherchant la chaîne d'entrée xpour |~, et le nombre de caractères est juste la longueur.

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

Enfin, afin de faire fonctionner les entrées sans eau, nous ajoutons une ligne d'eau fictive du début |~à la fin avant la recherche, ce qui donne l'impression que le niveau d'eau est de 0.

Les bonus ne valaient pas la peine. Le meilleur que j'ai obtenu sur la chaîne est 73-35 = 38:

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

CJam, 19 17 16 58 * 0,85 - 35 = 14,3 octets

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

Essayez-le en ligne

Cette version obtient les deux bonus. L'entrée doit avoir une nouvelle ligne de fin pour que cette solution fonctionne.

Merci à @Martin Büttner pour avoir économisé 2 octets.

Explication:

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.

JavaScript (ES6), 45 (94-15% -35)

En tant que fonction anonyme. À l'aide de chaînes de modèle, il existe une nouvelle ligne significative et incluse dans le nombre d'octets

Modifier 1 octet enregistré 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'

Moins golfé

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' 
)

Extrait de test

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>

Par , 57 * 85% - 35 = 13,45 octets

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

Explication

`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

Perl, 70 - 15% - 35 = 24,5 octets

comprend +1 pour -p

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

Avec commentaires:

$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%

• Version 26 + 1 octet, pas de bonus: 27

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

• Version 34 + 1 octet, avec 15% de bonus: 29,75

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

• Version 61 + 1 octet, avec un bonus de -35: 27

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

• Version 69 + 1 octet, les deux bonus: 24,50

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

Javascript, 59,3

J'espère que les décimales supplémentaires sont OK. Ne suppose aucune nouvelle ligne de fin.

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>

Haskell, 56 octets

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

Exemple d'utilisation: f "| |\n|~~|\n| |\n|__|"-> 0.75.

lest une fonction de longueur personnalisée, ce qui est nécessaire, car la construction dans lengthrenvoie des valeurs entières, mais nous avons besoin de valeurs à virgule flottante pour la division (il y a genericLengthqui fournit également cette fonctionnalité, mais elle est plus longue, sans parler de la condition requise import Data.List). fdivise l'entrée ien lignes (-> s) puis en une paire où le premier élément est une liste avec toutes les lignes jusqu'au (et à l'exclusion) le premier avec un ~dedans. Le deuxième élément est une liste avec le reste des lignes. Le résultat est la longueur du deuxième élément divisée par la longueur de s.

Les bonus ne sont pas payants.

Python est verbeux!

Python: 98,45 octets

(157 * 0,85) - 35 = 98,45 octets

Cette version lit à partir de stdin et recueille les deux bonus:

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)

Awk, 72 caractères - 15% - 35 = 26,2

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

Exemple d'exécution:

(Initiale 1;uniquement utilisée dans ces échantillons pour afficher le réservoir «lisible par l'homme».)

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%

PHP, 92 caractères - 15% - 35 = 43,2

(88 caractères dans deux blocs de code + 4 options de ligne de commande de caractères.)

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

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

Suppose que la error_reportingvaleur par défaut est définie.

(Pas un gros problème, je voulais juste utiliser le -R et -Eune fois. Maintenant, il ne -Breste plus.)

Exemple d'exécution:

(Initiale echo"$argn\n";uniquement utilisée dans ces échantillons pour afficher le réservoir «lisible par l'homme».)

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%

QBIC - 116 - 15% = 98,6 octets

{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}

J'ai créé QBIC pour rendre QBasic plus compétitif, mais il a encore besoin de plusieurs améliorations. À l'heure actuelle, il n'y a pas de raccourcis pour le piégeage d'erreurs THEN(ce qui est une assez grosse erreur de ma part)input$ . Ils seront ajoutés sous peu.

Je n'ai pas pu toucher le bonus 0, trop cher ... J'ai réussi à imprimer des pourcentages.

Échantillon entrée / sortie:

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

Le programme lit l'entrée de manière interactive. Lorsqu'il détecte le fond du lac ( _), il imprime le pourcentage et quitte. Testé pour les conteneurs pleins et les vides également.

Edit: Pour montrer comment QBIC a été développé au cours de la dernière année, voici le même programme écrit pour l'interpréteur actuel:

{_?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 octets, des pourcentages d'impression, soit un score de 74.