系统会为您提供一个不包含换行符的可打印ASCII字符串，以及一个包含空格（）和哈希（#）的多行“ mold” 。

您必须在字符串中一个接一个地输入字符，并使用字符串中的字符按从左到右，从上到下的顺序替换哈希。如果字符串太短而无法填充模具，则停止输出；如果字符串太长，则截断字符串以准确填充模具。

示例字符串/模具（字符串太长，被截断）：

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

输出示例：

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

示例字符串/模具（字符串太短，输出停止）：

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

对应的输出：

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

以字节为单位的最短代码获胜。

^{将此想法归功于此网站。}

CJam，16个 14字节

感谢Sp3000节省2个字节。

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

如果字符串太短，则以错误终止，但错误会打印到STDERR。

在线尝试！

或者（相同的字节数）：

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

说明

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个LabVIEW原语

将字符串拆分为文本并进行模制，然后将其转换为数组。检查模具是否存在＃，然后从文本中放入一个char，否则不执行任何操作。如果文本或模具为空，则退出循环

Haskell，48个字节

像“（用字符串替换）＃（井号标记字符串）”这样称呼：

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

少打高尔夫球：

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

视网膜，42 40字节

字节数假定为ISO 8859-1编码。

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

尾随换行很重要。

在线尝试！

说明

T`#`×`¶.+

我们首先用#非ASCII（但扩展的ASCII）字符替换网格的一部分，×因此我们不会将它们与#第一行中出现的任何字符混淆。

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

现在，我们×将第一行中的第×一个字符替换为第一行中的第一个字符（在此过程中将其删除），从而尽可能多地填充第一行中的字符。

^.*¶|×\D*

最后，我们摆脱了第一行上剩下的所有内容以及从第一行到第二个×方向截断输入的所有内容。

JavaScript（ES6），57 56 55字节

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

@Neil节省了1个字节！

说明

在输入字符串中使用哈希值，并在输入字符串完成后保留尾随空格。

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字节

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

Ideone

多亏了FryAmTheEggman，Chiel赢得了十个Brinke大奖。或者，我本可以使用Python 2来额外使用一个（print不带()）。

pb，359字节

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

在pb中，输入严格是一维的。它不理解您正在使用输入来绘制形状，它只是看到一条长行，其中包含一些字节，其中包含值10。该程序要做的第一件事是将输入的第一个“行”以外的所有内容复制到Y = 0，Y = 1等上，以创建模具的形状。

我在代码高尔夫中注意到了很多事情，但是特别是在打高尔夫球的奥秘语言时，您经常不想拥有两个分支来处理；您只是将自己设置为在两种情况下都执行相同的操作。解决该问题的幼稚方法可能是将字符串的长度与其余输入中的哈希数进行比较，并根据结果进行操作，因为它的行为取决于截断的内容而有所不同。但这是很多字节。

而是在完成模具后，在底部添加一条额外的线。它只是n连续的散列，n字符串的长度在哪里。现在可以保证字符串适合！插入字符串的所有字符后，添加的该额外行将无条件地销毁。模具中的所有剩余哈希也将被擦除，这就是必要的输出！

当然，仅破坏所有哈希将违反规范。毕竟，输入字符串中可能存在哈希！为了解决这个问题，我参考了规范的另一部分：

系统会为您提供一个不包含换行符的可打印ASCII字符串

（强调一下。）到我们处理字符串时，我们实际上并不关心其中是否包含换行符，但是我们确实知道没有任何换行符。因此，在放入模具之前，所有散列都用换行符替换！销毁所有哈希之后，所有换行符都会再次替换为哈希。这不会将整个输出变成单个用哈希分隔的行，因为pb的2D输出的性质意味着它实际上从未在每行的末尾放置换行符，而是继续到下一行。

取消高尔夫：

# 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个字节

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

如果文本可以包含哈希，则为70个字节：

(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字节

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

需要-p运行。说明：

@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

果冻，10 8个字节

¹ƈ<”#$?€

在这里尝试！

Perl 6，72个字节

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

ES6，47个字节

可能是最直接的解决方案。

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

此代码创建一个匿名函数，该函数接收2个参数并返回最终结果。

第一个参数S是您的“地图”字符串"#"，而第二个参数R是这些人的“替换” 字符串"#"。

Python 3

152个 127字节

完整的程序。

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字节

将流作为输入的函数。

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