Você recebe uma única string ASCII imprimível que não contém novas linhas e um "molde" de várias linhas, contendo espaços ( ) e hashes ( #).

Você deve inserir caractere por caractere na sequência e substituir os hashes usando os caracteres da sequência na ordem superior esquerda, esquerda e direita. Se a sequência for muito curta para preencher o molde, você para de produzir; se a sequência for muito longa, você truncará a sequência para preencher exatamente o molde.

Exemplo de string / molde (string muito longa, 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.
###########################################################
##### ##############   ###### ###### ######################
#####  ##   ######   #  ##### ###### ########        ######
###### #  #  ####  #### ##### ###### #######  ######  #####
######   ###  ###       ##### ###### ####### #######  #####
######  ##### ### ########### ###### #######   ###   ######
###### ###### ###  ########## ######      #####   #########
##################       ####    ##########################
###########################################################

Exemplo de saída:

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

Exemplo de string / molde (string muito curta, saída interrompida):

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

Saída correspondente:

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

O menor código em bytes vence.

^{Crédito para a idéia neste site .}

CJam, 16 14 bytes

Agradecimentos ao Sp3000 por salvar 2 bytes.

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

Termina com um erro se a sequência for muito curta, mas o erro é impresso em STDERR.

Experimente online!

Como alternativa (mesma contagem de bytes):

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

Explicação

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 do LabVIEW

divide a string em texto e molde e depois as transforma em uma matriz. Verifica o molde se houver um # e coloca um caractere de texto, caso contrário ele não faz nada. Se o texto ou o molde estiverem vazios, saia do loop

Haskell, 48 bytes

chamado como "(substitua por string) # (string de marca de hash)":

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

Menos golfe:

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

A contagem de bytes assume a codificação ISO 8859-1.

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

O avanço de linha à direita é significativo.

Experimente online!

Explicação

T`#`×`¶.+

Primeiro, substituímos #as partes da grade pelo caractere não ASCII (mas ASCII estendido) ×para não confundi-los com nenhum #que possa aparecer na primeira linha.

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

Agora, preenchemos o maior número ×possível da primeira linha, substituindo repetidamente a primeira ×que podemos encontrar pelo primeiro caractere na primeira linha (que é removida no processo).

^.*¶|×\D*

Finalmente, nos livramos de tudo o que resta na primeira linha e também do primeiro ×para truncar a entrada nas duas direções.

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 graças a @Neil !

Explicação

Funciona com hashes na cadeia de entrada e mantém o espaço em branco à direita após a conclusão da cadeia 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

Graças a FryAmTheEggman, Chiel ten Brinke pelo byte off. Como alternativa, eu poderia ter usado o Python 2 por um extra ( printsem ()).

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

Em pb, a entrada é estritamente unidimensional. Ele não entende que você está desenhando uma forma com sua entrada, apenas vê uma linha longa com alguns bytes com um valor de 10 jogados lá. A primeira coisa que este programa faz é copiar todos, exceto a primeira "linha" de entrada, em Y = 0, Y = 1, etc., para criar a forma do molde.

Algo que eu notei muito no código de golfe, mas especialmente ao jogar idiomas esotéricos, é que muitas vezes você não quer ter dois ramos para lidar; você apenas decide que faz a mesma coisa nos dois casos. A maneira ingênua de resolver esse problema provavelmente verificaria o comprimento da string em relação ao número de hashes no restante da entrada e faria algo dependendo do resultado, porque ele deveria se comportar de maneira diferente, dependendo do que for cortado. Mas isso é muitos bytes.

Em vez disso, após a conclusão do molde, uma linha extra é adicionada ao fundo. É simplesmente nhashes seguidos, onde nestá o comprimento da string. Agora a corda está garantida para caber! Depois de inserir todos os caracteres da sequência, essa linha extra que foi adicionada é destruída incondicionalmente. Quaisquer hashes restantes no molde apropriado também são apagados, e essa é a saída necessária!

Obviamente, violaria as especificações para simplesmente destruir todos os hashes. Afinal, pode haver um hash na string de entrada! Para lidar com isso, refiro-me a outra parte da especificação:

Você recebe uma única string ASCII imprimível que não contém novas linhas

(Ênfase minha.) No momento em que lidamos com a string, não nos importamos se há novas linhas nela, mas sabemos que não há nenhuma. Portanto, todos os hashes são substituídos por novas linhas antes de serem inseridos no molde! Depois que todos os hashes são destruídos, todas as novas linhas são substituídas por hashes novamente. Isso não transforma toda a saída em uma única linha delimitada por hash, porque a natureza da saída 2D do pb significa que ele nunca coloca uma nova linha no final de cada linha, apenas passa para a próxima linha.

Ungolfed:

# 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 se o texto puder conter 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+$//

Requer -ppara executar. Explicação:

@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éia, 10 8 bytes

¹ƈ<”#$?€

Experimente aqui!

Perl 6 , 72 bytes

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

ES6, 47 bytes

Provavelmente a solução mais direta.

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

Este código cria uma função anônima que recebe 2 parâmetros e retorna o resultado final.

O primeiro parâmetro Sé a string "map" com o seu "#", enquanto o segundo parâmetro Ré a "substituição" deles "#".

Python 3

152 127 bytes

Um 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

Uma função que recebe o fluxo 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()])