Étant donné la topographie des terres au format ASCII, déterminez où les lacs iraient et remplissez-les. Supposez une quantité infinie de pluie.

exemple

contribution

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

production

         #               
         ##              
      #@####             
#@@@@#########           
##@@###########          
##@#############@@@####  
##@##############@@##### 
#################@#######
#########################
#########################

L'entrée ne contiendra que des espaces et des #marques. Chaque ligne aura la même longueur. La sortie devrait être le #modèle identique avec des espaces où l'eau s'accumulerait remplie de @marques.

La ligne d'entrée inférieure sera toujours composée de tous les signes #. Il n'y aura pas de trous ou de surplombs dans la terre. Le code le plus court gagne.

sed -r, 27 24 (27 avec -r)

24 (27):

:;s/(#|@) ( *#)/\1@\2/;t

27 (30):

:e;s/([#@]) ( *#)/\1@\2/;te

Concourt avec le meilleur des deux solutions Perl

Perl, 25

s/# +#/$_=$&;y| |@|;$_/ge

Perl (> = v5.9.5), 24 caractères

Courir avec perl -p:

1while s/#.*\K (?=\S)/@/

Cela nécessite Perl 5.9.5 ou une version ultérieure pour utiliser l'échappement spécial \K.

Windows PowerShell, 36 74 138

$input-replace'(?<!^ *) (?! *$)','@'

Rétine , 10 octets

La rétine est (beaucoup) plus récente que ce défi. Mais cette solution est trop soignée pour ne pas la poster:

T` `@`#.*#

Essayez-le en ligne.

Il s'agit simplement d'une étape de translittération qui remplace les espaces par @, mais l'opération est limitée aux correspondances de #.*#, c'est-à-dire aux personnages qui sont entourés de terres des deux côtés.

Ruby 1.8, 30 caractères

#!ruby -p
gsub(/# +#/){$&.tr" ","@"}

Si quelqu'un a une idée pourquoi cela ne fonctionne pas dans Ruby 1.9 (testé avec 1.9.2p0 et 1.9.2p204), même si la documentation dit que cela devrait fonctionner , faites le moi savoir!

Python, 95 92 octets

for s in S.split('\n'):b=s.find('#');e=s.rfind('#');print s[:b]+s[b:e].replace(' ','@')+s[e:]

05AB1E , 17 16 octets

|εγć?D¨ð'@:sθJJ,

Essayez-le en ligne.

Explication:

|            # Take all input-lines as list
 ε           # For each line:
  γ          #  Split the line into chunks of consecutive equal characters
             #   i.e. " ##   # " → [' ','##','   ','#',' ']
   ć         #  Split into head and the rest of the list
             #   i.e. [' ','##','   ','#',' '] → ['##','   ','#',' '] and ' '
    ?        #  Print this head
   D         #  Duplicate the rest of the list
    ¨        #  Remove the last element
             #   i.e. ['##','   ','#',' '] → ['##','   ','#']
     ð'@:    #  Replace every space with a "@"
             #   i.e. ['##','   ','#'] → ['##','@@@','#']
     sθ      #  Swap so the duplicated list is at the top, and take the last item as is
             #   i.e. ['##','   ','#',' '] → ' '
         JJ  #  Join the lists and individual items in the list together to a single string
             #   i.e. ['##','@@@','#'] and ' ' → "##@@@# "
           , #  Print with trailing new-line

Javascript, 107 octets

var f=function(x){return x.replace(/# +#/g, function(x){return "#"+new Array(x.length-1).join("@")+"#";})};

Non golfé:

var f = function(x) {
    return x.replace(/# +#/g, function(x){
        return "#" + new Array(x.length - 1).join("@") + "#";
    })
};

Python, 108 106 92 bytes

import re
n=1
while n: S,n=re.subn('# +#',lambda m:'#'+'@'*len(m.group(0)[2:])+'#',S)
print S

Gelée , 15 octets

Ỵ”@ẹ”#ṂrṀḟƲ$¦€Y

Essayez-le en ligne!

Pip , 15 octets

aR:`#.*#`_TRs'@

Prend l'entrée sous forme de chaîne multiligne via un argument de ligne de commande: Essayez-le en ligne! (Alternativement, spécifiez les -rnindicateurs et changez le premier aen g, et vous pouvez donner votre entrée via stdin: essayez-le en ligne! )

Même idée que la réponse Retina: remplacer chaque correspondance de l'expression régulière #.*#par le résultat de la translittération de l'espace @dans la correspondance. Pip ne peut pas égaler la gravité de Retina pour un problème de regex pur - mais ce n'est pas tous les jours que vous pouvez nouer avec Jelly, après tout.