Vous obtenez une seule chaîne ASCII imprimable ne contenant aucune nouvelle ligne, et un "moule" multiligne, contenant des espaces ( ) et des hachages ( #).

Vous devez parcourir caractère par caractère dans la chaîne et remplacer les hachages en utilisant les caractères de la chaîne dans l'ordre gauche-droite, haut-bas. Si la chaîne est trop courte pour remplir le moule, vous arrêtez la sortie, si la chaîne est trop longue, vous tronquez la chaîne pour remplir exactement le moule.

Exemple de chaîne / moule (chaîne trop longue, tronquée):

Loremipsumdolorsitamet,consecteturadipiscingelit.Namsuscipitmagnanoneratgravidacondimentum.Vestibulumnecnisllorem.Fuscemolestieviverranibh,eueleifendnislplaceratnon.Namblanditturpislacus,vitaemolestielacusimperdietquis.Nullapulvinar,exquissollicitudinfacilisis,eratnullavolutpatlectus,etluctusenimvelitegetex.Inhachabitasseplateadictumst.Donecinterdumnullalacinia,sodalesloremin,eleifendturpis.Pellentesqueanisimi.Aeneannonlobortisdiam,quisaliquetquam.Aeneanaugueipsum,imperdietsedaliquetnon,volutpategetsapien.Nullampharetranullaquispretiumornare.Aliquamfermentumvestibulummassavitaevehicula.
###########################################################
##### ##############   ###### ###### ######################
#####  ##   ######   #  ##### ###### ########        ######
###### #  #  ####  #### ##### ###### #######  ######  #####
######   ###  ###       ##### ###### ####### #######  #####
######  ##### ### ########### ###### #######   ###   ######
###### ###### ###  ########## ######      #####   #########
##################       ####    ##########################
###########################################################

Exemple de sortie:

Loremipsumdolorsitamet,consecteturadipiscingelit.Namsuscipi
tmagn anoneratgravid   acondi mentum .Vestibulumnecnisllore
m.Fus  ce   molest   i  evive rranib h,euelei        fendni
slplac e  r  atno  n.Na mblan dittur pislacu  s,vita  emole
stiela   cus  imp       erdie tquis. Nullapu lvinar,  exqui
ssolli  citud inf acilisis,er atnull avolutp   atl   ectus,
etluct usenim vel  itegetex.I nhacha      bitas   seplatead
ictumst.Donecinter       dumn    ullalacinia,sodalesloremin
,eleifendturpis.Pellentesqueanisimi.Aeneannonlobortisdiam,q

Exemple de chaîne / moule (chaîne trop courte, sortie arrêtée):

This probably won't look good.
### ### ### ###
# # # # #   #
### ### #   # #
#   #   #   # #
#   #   ### ###

Sortie correspondante:

Thi s p rob abl
y   w o n   '
t l ook     g o
o   d   .   

Le code le plus court en octets gagne.

^{Crédit pour l'idée de ce site Web .}

CJam, 16 14 octets

Merci à Sp3000 pour avoir économisé 2 octets.

lq{s'#-\+(\}/;

Se termine avec une erreur si la chaîne est trop courte, mais l'erreur est imprimée dans STDERR.

Essayez-le en ligne!

Alternativement (même nombre d'octets):

lq{SN+&\+(\}/;

Explication

l       e# Read the input line.
q       e# Read the grid.
{       e# For each character in the grid...
  s     e#   Convert to string.
  '#-   e#   Remove "#" from it.
  \+    e#   Prepend it to the input line (this is a no-op for "#"s in the grid).
  (     e#   Pull off the first character from the input line. This will terminate the
        e#   program with an error once the input line is empty.
  \     e#   Swap the character with the input line.
}/
;       e# Discard the remainder of the input line if there is any.

LabVIEW, 37 primitives LabVIEW

divise la chaîne en texte et moule puis les transforme en tableau. Vérifie le moule s'il y a un # et met un caractère à partir du texte sinon il ne fait rien. Si le texte ou le moule sont vides, quittez la boucle

Haskell, 48 octets

appelé comme "(remplacer par une chaîne) # (chaîne de hachage)":

[]#_=[]
(r:t)#('#':s)=r:t#s
r#(c:s)=c:r#s
_#_=[]

Moins golfé:

combine replacements slots | null replacements = []
                           | null slots        = []
                           | head slots == '#' = head replacements : combine (tail replacements) (tail slots)
                           | otherwise         = head slots        : combine       replacements  (tail slots)

Rétine , 42 40 octets

Le nombre d'octets suppose un codage ISO 8859-1.

T`#`×`¶.+
+`^(.)([^×]+)×
$2$1
^.*¶|×\D*

Le saut de ligne arrière est important.

Essayez-le en ligne!

Explication

T`#`×`¶.+

Nous remplaçons d'abord ceux #qui font partie de la grille par le caractère non ASCII (mais ASCII étendu) ×afin de ne pas les confondre avec ceux #qui pourraient apparaître sur la première ligne.

+`^(.)([^×]+)×
$2$1

Maintenant, nous remplissons autant ×que possible de la première ligne en remplaçant à plusieurs reprises le premier que ×nous pouvons trouver par le premier caractère sur la première ligne (qui est supprimé dans le processus).

^.*¶|×\D*

Enfin, nous nous débarrassons de tout ce qui reste sur la première ligne ainsi que de la première ×pour tronquer l'entrée dans les deux directions.

JavaScript (ES6), 57 56 55 octets

(s,m)=>m.replace(x=/[^]/g,c=>c-1?x&&c:x=s[i++]||"",i=0)

1 octet enregistré grâce à @Neil !

Explication

Fonctionne avec des hachages dans la chaîne d'entrée et conserve un espace blanc à la fin une fois la chaîne d'entrée terminée.

var solution =

(s,m)=>
  m.replace(x=/[^]/g,c=> // for each character c of the mold, initialise x to true
    c-1?                 // if c is a space or newline:
      x&&c               // if x is truthy, return c
                         // else if the string has ended, x will equal "" (false), return x
    :                    // else if c is a hash:
      x=                 // set x to the character of the input string
        s[i++]||"",      // return the input string character (or "" if finished)
    i=0                  // initialise i to 0
  )

<input type="text" id="input" value="This probably won't look good." /><br>
<textarea id="mold" rows="6" cols="40">### ### ### ###
# # # # #   #
### ### #   # #
#   #   #   # #
#   #   ### ###</textarea><br>
<button onclick="result.textContent=solution(input.value,mold.value)">Go</button>
<pre id="result"></pre>

Python 3, 69 68 67 octets

def f(s,m):s=iter(s);return''.join(n<'#'and n or next(s)for n in m)

Ideone

Merci à FryAmTheEggman, Chiel ten Brinke pour l'octet désactivé. Alternativement, j'aurais pu utiliser Python 2 pour un supplémentaire ( printsans ()).

pb , 359 octets

^w[B!0]{w[B=10]{t[T+1]b[0]}>}<w[T!0]{w[B!0]{<}>^b[T]vw[B!0]{t[B]b[0]^v[B]v<[X]w[B!0]{>}b[T]<[X]^[Y+2]w[B=0]{>}t[B]b[0]>b[T]v}^t[B-1]vw[B=0]{<}}>b[10]t[X]w[X!-2]{w[B!0]{v}<}w[X!T]{b[35]>}^[Y]^<[X]w[B!10]{t[B]b[0]w[T=35]{t[10]}v<[X]w[B!35]{w[B=0]{v<[X]<b[1]}>}b[T]^[Y]^<[X]w[B=0]{>}}<[X+2]w[B=0]{v}w[B!0]{b[0]>}w[Y!-1]{<[X]^w[B!0]{w[B=35]{b[0]}w[B=10]{b[35]}>}}

En pb, l'entrée est strictement unidimensionnelle. Il ne comprend pas que vous dessinez une forme avec votre entrée, il ne voit qu'une longue ligne avec quelques octets d'une valeur de 10. La première chose que ce programme fait est de copier tout sauf la première "ligne" d'entrée sur Y = 0, Y = 1, etc., pour créer la forme du moule.

Quelque chose que j'ai beaucoup remarqué dans le golf de code, mais surtout lorsque vous jouez aux langages ésotériques, c'est que vous ne voulez souvent pas avoir deux branches à gérer; vous vous préparez simplement à faire la même chose dans les deux cas. La manière naïve de résoudre ce problème serait probablement de vérifier la longueur de la chaîne par rapport au nombre de hachages dans le reste de l'entrée et de faire quelque chose en fonction du résultat, car elle doit se comporter différemment selon ce qui est coupé. Mais cela fait beaucoup d'octets.

Au lieu de cela, après avoir terminé le moule, une ligne supplémentaire est ajoutée au bas. Il s'agit simplement de nhachages consécutifs, où nest la longueur de la chaîne. Maintenant, la chaîne est garantie pour s'adapter! Après avoir inséré tous les caractères de la chaîne, cette ligne supplémentaire qui a été ajoutée est détruite inconditionnellement. Tous les hachages restants dans le moule proprement dit sont également effacés, et c'est la sortie nécessaire!

Bien sûr, cela violerait la spécification pour simplement détruire tous les hachages. Après tout, il pourrait y avoir un hachage dans la chaîne d'entrée! Pour gérer cela, je me réfère à une autre partie de la spécification:

Vous obtenez une seule chaîne ASCII imprimable ne contenant aucune nouvelle ligne

(Je souligne.) Au moment où nous traitons la chaîne, nous ne nous soucions pas vraiment de la présence de nouvelles lignes, mais nous savons qu'il n'y en a pas. Ainsi, tous les hachages sont remplacés par des nouvelles lignes avant d'être mis dans le moule! Une fois tous les hachages détruits, toutes les nouvelles lignes sont à nouveau remplacées par des hachages. Cela ne transforme pas la sortie entière en une seule ligne délimitée par des hachages car la nature de la sortie 2D de pb signifie qu'il n'a jamais réellement mis de nouvelle ligne à la fin de chaque ligne, il est simplement passé à la ligne suivante.

Non golfé:

# Start by copying down the mold
^
# (B means "the character under the cursor")
w[B!0]{       # While B isn't a null byte:
    w[B=10]{    # While B IS a newline:
            t[T+1]    # Increase T by 1
                      # (`T` is the only variable that can be modified directly)
            b[0]      # Overwrite with 0 to break out of inner loop
    }
    >           # Move to the right
                # (dodge the 0 we wrote and progress towards the end of input)
}

# Brush is now at the end of the input, T contains number of lines

<             # Make sure the brush is actually /on/ the input
w[T!0]{       # While T isn't 0:
    w[B!0]{<}>  # Go to the first character of the last line
    ^b[T]       # Place a flag above current character
                # Also a convenient way to get the value of T back later
    vw[B!0]{    # While the character under the flag isn't 0:
            t[B]b[0]  # Put it in T, overwrite with 0
            ^v[B]v    # Go down by the amount written in the space above
            <[X]      # Go left by the amount right the brush is (i.e. go to X=0)
            w[B!0]{>} # Find first empty space
            b[T]      # Write the value of T
            <[X]      # Go left by the amount right the brush is
            ^[Y+2]    # Go up by the amount down the brush is plus 2 (above input)
            w[B=0]{>} # Find flag
            t[B]b[0]  # Pick it up, overwrite with 0
            >b[T]     # Place it to the right
    v}
    ^t[B-1]v    # Collect flag - 1
    w[B=0]{<}   # Go to end of previous line
}

# Mold is placed, all that's left is placing the string
>b[10]        # Put a newline at the end, guaranteed to not be in the string
t[X]          # Save current X value in T

# Add more hashes, guaranteed to fit the input and findable later
w[X!-2]{       # While X!=-2:
    w[B!0]{v}    # Move down until hitting a null byte
    <            # Move left
}
w[X!T]{        # While not at the X value we saved earlier:
    b[35]>       # Travel right, leaving hashes
}

^[Y]^<[X]     # Go to (0, -1)

w[B!10]{      # Until hitting the newline at the end:
    t[B]b[0]    # Pick up character, overwrite with 0
    w[T=35]{    # If it's a hash...
            t[10]     # Make it a newline so we remember, deal with it later
    }
    v<[X]       # Go to (0, 0)
    w[B!35]{    # While B is not a hash:
            w[B=0]{   # While B IS null:
                    v       # Go down
                    <[X]<   # Go to X=-1
                    b[1]    # Print a 1 to break loop (it won't be rendered anyway)
            }
            >           # Go right, either ignore a non hash or go to X=0
    }
    b[T]        # Overwrite hash with picked up character
    ^[Y]^<[X]   # Go to (0, -1)
    w[B=0]{>}   # Go to first character of it to restart loop
}

<[X+2]        # Go to (-2, -1)
w[B=0]{v}     # Go down until finding the row of added hashes
w[B!0]{b[0]>} # Wipe it out unconditionally
w[Y!-1]{      # For every remaining line on the screen:
    <[X]^       # Go to the beginning
    w[B!0]{     # For each character in it:
            w[B=35]{  # If it's a hash:
                    b[0]    # Destroy it
            }
            w[B=10]{  # If it's a newline:
                    b[35]   # Write a hash (after the check to destroy hashes!)
            }
    >}
}

ES6, 59 octets

(t,m)=>m.replace(/#/g,h=>t[i++]||h,i=0).replace(/#[^]*/,'')

70 octets si le texte peut contenir des hachages:

(t,m)=>m.replace(/#/g,(_,n)=>t[i]&&(j=++n)&&t[i++],i=0,j=0).slice(0,j)

Perl, 53 51 42 + 2 = 44 octets

@a=/./g;$/="";$_=<>;s/#/shift@a/ge;s/\s+$//

Nécessite -pde fonctionner. Explication:

@a=/./g; # Split first line into an array of characters
$/=""; # Enable slurp mode (read the rest of lines in one go)
$_=<>;
s/#/shift@a/ge;
s/\s+$//
# With '-p' auto print is enabled

Gelée, 10 8 octets

¹ƈ<”#$?€

Essayez-le ici!

Perl 6 , 72 octets

my@a=get.comb;say(S:g/\#/{@a.shift//''}/~~{S/\s+$//}),@a||last for lines

ES6, 47 octets

Probablement la solution la plus simple.

(S,R)=>(i=-1,S.replace(/#/g,_=>R[++i]||R[i=0]))

Ce code crée une fonction anonyme qui reçoit 2 paramètres et renvoie le résultat final.

Le premier paramètre Sest la chaîne "map" avec votre "#", tandis que le second paramètre Rest le "remplacement" de ceux-ci "#".

Python 3

152 127 octets

Un programme complet.

from sys import stdin as S
s=list(S.readline())
print(''.join([''if not s else(s.pop(0)if m=='#'else m)for m in S.read()]))

106 octets

Une fonction qui prend le flux en entrée.

def f(S):s=list(S.readline());return''.join([''if not s else(s.pop(0)if m=='#'else m)for m in S.read()])