Se le proporciona una única cadena ASCII imprimible que no contiene líneas nuevas y un "molde" multilínea, que contiene espacios ( ) y hashes ( #).

Debe ir carácter por carácter en la cadena y reemplazar los hashes utilizando los caracteres de la cadena en orden de izquierda a derecha, de arriba a abajo. Si la cadena es demasiado corta para llenar el molde, deja de salir, si la cadena es demasiado larga, trunca la cadena para llenar exactamente el molde.

Ejemplo de cadena / molde (cadena demasiado larga, truncada):

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

Salida de ejemplo:

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

Ejemplo de cadena / molde (cadena demasiado corta, salida detenida):

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

Salida correspondiente:

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

El código más corto en bytes gana.

^{Crédito por la idea de este sitio web .}

CJam, 16 14 bytes

Gracias a Sp3000 por guardar 2 bytes.

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

Termina con un error si la cadena es demasiado corta, pero el error se imprime en STDERR.

Pruébalo en línea!

Alternativamente (mismo recuento de bytes):

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

Explicación

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 primitivas de LabVIEW

divide la cadena en texto y molde y luego los transforma en una matriz. Comprueba el molde si hay un # y pone un carácter del texto; de lo contrario, no hace nada. Si el texto o el molde están vacíos, salga del bucle

Haskell, 48 bytes

llamado como "(reemplazar con una cadena) # (cadena de hashmark)":

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

Menos golfizado:

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

Retina , 42 40 bytes

El recuento de bytes asume la codificación ISO 8859-1.

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

El avance de línea final es significativo.

Pruébalo en línea!

Explicación

T`#`×`¶.+

Primero reemplazamos los #que son parte de la cuadrícula con el carácter no ASCII (pero ASCII extendido) ×para no confundirlos con ninguno #que pueda aparecer en la primera línea.

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

Ahora llenamos tantos ×como sea posible desde la primera línea reemplazando repetidamente el primero ×que podemos encontrar con el primer carácter en la primera línea (que se elimina en el proceso).

^.*¶|×\D*

Finalmente, nos deshacemos de todo lo que queda en la primera línea, así como de cualquier cosa desde el primero ×para truncar la entrada en ambas direcciones.

JavaScript (ES6), 57 56 55 bytes

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

¡Guardado 1 byte gracias a @Neil !

Explicación

Funciona con hashes en la cadena de entrada y conserva los espacios en blanco al final de la cadena de entrada.

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 bytes

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

Ideone

Gracias a FryAmTheEggman, Chiel ten Brinke por el byte apagado. Alternativamente, podría haber usado Python 2 para uno adicional ( printsin ()).

pb , 359 bytes

^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, la entrada es estrictamente unidimensional. No entiende que está dibujando una forma con su entrada, solo ve una línea larga con algunos bytes con un valor de 10. Lo primero que hace este programa es copiar todo menos la primera "línea" de entrada en Y = 0, Y = 1, etc., para crear la forma del molde.

Algo que he notado mucho en el golf de código, pero especialmente cuando se practica golf en idiomas esotéricos, es que a menudo no quieres tener dos ramas con las que lidiar; simplemente configuras que haces lo mismo en cualquier caso. La forma ingenua de resolver este problema probablemente verificaría la longitud de la cadena contra el número de hashes en el resto de la entrada y haría algo dependiendo del resultado, porque tiene que comportarse de manera diferente dependiendo de lo que se corta. Pero eso es muchos bytes.

En cambio, después de completar el molde, se agrega una línea adicional al fondo. Es simplemente nhash en una fila, donde nestá la longitud de la cadena. ¡Ahora la cuerda está garantizada! Después de insertar todos los caracteres de la cadena, esa línea adicional que se agregó se destruye incondicionalmente. Los restos de hash en el molde también se borran, ¡y esa es la salida necesaria!

Por supuesto, violaría la especificación simplemente destruir todos los hashes. Después de todo, ¡podría haber un hash en la cadena de entrada! Para manejar esto, me refiero a otra parte de la especificación:

Se le proporciona una única cadena ASCII imprimible que no contiene líneas nuevas

(El énfasis es mío). Para cuando tratamos con la cadena, realmente no nos importa si hay nuevas líneas en ella, pero sabemos que no hay ninguna. Por lo tanto, ¡todos los hashes se reemplazan por saltos de línea antes de colocarlos en el molde! Después de que se destruyen todos los hashes, todas las líneas nuevas se reemplazan con hashes nuevamente. Esto no convierte toda la salida en una sola línea delimitada por hash porque la naturaleza de la salida 2D de pb significa que nunca puso una nueva línea al final de cada línea, simplemente pasó a la siguiente línea.

Sin 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 bytes

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

70 bytes si el texto puede contener hashes:

(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 bytes

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

Requiere -pcorrer. Explicación:

@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

Jalea, 10 8 bytes

¹ƈ<”#$?€

Pruébalo aquí!

Perl 6 , 72 bytes

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

ES6, 47 bytes

Probablemente la solución más sencilla.

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

Este código crea una función anónima que recibe 2 parámetros y devuelve el resultado final.

El primer parámetro Ses la cadena de "mapa" con su "#", mientras que el segundo parámetro Res el "reemplazo" de esos "#".

Python 3

152 127 bytes

Un programa completo

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 bytes

Una función que toma la secuencia como entrada.

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()])