改行を含まない単一の印刷可能なASCII文字列と、スペース（）およびハッシュ（#）を含む複数行の「型」が与えられます。

文字列内の文字ごとに移動し、左から右、上から下の順に文字列の文字を使用してハッシュを置き換える必要があります。文字列が短すぎて金型を満たすことができない場合は出力を停止し、文字列が長すぎる場合は文字列を切り捨てて金型を正確に埋めます。

文字列/型の例（文字列が長すぎる、切り捨てられた）：

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   .   

バイト単位の最短コードが優先されます。

^{このWebサイトのアイデアの功績です。}

CJam、16 14バイト

2バイトを節約してくれたSp3000に感謝します。

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プリミティブ

文字列をテキストと金型に分割してから、配列に変換します。＃がある場合は金型をチェックし、テキスト以外の文字を入力する場合は何もしません。テキストまたは型のいずれかが空の場合、ループを終了します

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 ten 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では、入力は厳密に1次元です。入力でシェイプを描画していることを理解していません。10の値がスローされたいくつかのバイトを持つ1つの長い行が表示されます。このプログラムが最初に行うことは、入力の最初の「行」を除くすべてをY = 0、Y = 1などにコピーして、金型の形状を作成することです。

コードゴルフで私が気づいたことは、特に難解な言語でゴルフをする場合、2つのブランチを扱いたくない場合が多いということです。どちらの場合でも同じことを行うように設定するだけです。この問題を解決する素朴な方法は、おそらく入力の残りのハッシュ数に対して文字列の長さをチェックし、結果に応じて何かをするでしょう。しかし、それは大量のバイトです。

代わりに、金型の完成後、下部に余分な線が追加されます。これは単にn行のハッシュnです。ここで、文字列の長さです。これで、文字列が収まることが保証されます！文字列のすべての文字を挿入した後、追加された余分な行は無条件に破棄されます。適切な金型に残っているハッシュもすべて消去され、それが必要な出力です！

もちろん、すべてのハッシュを破棄するだけでは仕様に違反します。結局のところ、入力文字列にハッシュがある可能性があります！これを処理するために、仕様の別の部分を参照します。

改行を含まない単一の印刷可能なASCII文字列が与えられます

（Emphasis mine。）文字列を処理するときまでに、改行が含まれているかどうかはあまり気にしませんが、文字列がないことはわかっています。したがって、すべてのハッシュは、型に入れる前に改行に置き換えられます！すべてのハッシュが破棄された後、すべての改行が再びハッシュに置き換えられます。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はの「マップ」文字列で"#"、2番目のパラメーター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()])