Anda diberi satu string ASCII yang dapat dicetak yang tidak mengandung baris baru, dan "cetakan" multiline, yang mengandung spasi ( ), dan hash ( #).

Anda harus menggunakan karakter demi karakter dalam string, dan mengganti hash menggunakan karakter dari string dalam urutan kiri-kanan, atas-bawah. Jika string terlalu pendek untuk mengisi cetakan, Anda berhenti mengeluarkan, jika string terlalu panjang Anda memotong string untuk secara tepat mengisi cetakan.

Contoh string / cetakan (string terlalu panjang, terpotong):

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

Contoh output:

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

Contoh string / cetakan (string terlalu pendek, output berhenti):

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

Output yang sesuai:

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

Kode terpendek dalam byte menang.

^{Penghargaan untuk ide ke situs web ini .}

CJam, 16 14 byte

Terima kasih kepada Sp3000 untuk menghemat 2 byte.

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

Berakhir dengan kesalahan jika string terlalu pendek, tetapi kesalahan dicetak ke STDERR.

Cobalah online!

Atau (jumlah byte yang sama):

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

Penjelasan

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 Primitif

membelah string menjadi teks dan cetakan kemudian mengubahnya menjadi sebuah array. Periksa cetakan jika ada # dan menempatkan char dari teks yang lain itu tidak melakukan apa-apa. Jika teks atau cetakan kosong, keluar dari loop

Haskell, 48 byte

disebut seperti "(ganti dengan string) # (string hashmark)":

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

Kurang bermain golf:

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 byte

Hitungan byte mengasumsikan penyandian ISO 8859-1.

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

Linefeed tambahan sangat penting.

Cobalah online!

Penjelasan

T`#`×`¶.+

Kami pertama-tama mengganti #yang merupakan bagian dari kisi dengan karakter non-ASCII (tetapi diperluas ASCII) ×sehingga kami tidak membingungkan mereka dengan karakter #yang mungkin muncul di baris pertama.

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

Sekarang kita mengisi sebanyak ×mungkin dari baris pertama dengan berulang kali mengganti karakter pertama yang ×dapat kita temukan dengan karakter pertama pada baris pertama (yang dihapus dalam proses).

^.*¶|×\D*

Akhirnya, kami menyingkirkan semua yang tertinggal di baris pertama dan juga apapun dari yang pertama ×untuk memotong input di kedua arah.

JavaScript (ES6), 57 56 55 byte

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

Disimpan 1 byte berkat @Neil !

Penjelasan

Bekerja dengan hash dalam string input dan mempertahankan spasi putih setelah string input selesai.

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 byte

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

Ideone

Terima kasih kepada FryAmTheEggman, Chiel ten Brinke untuk byte off. Atau, saya bisa menggunakan Python 2 untuk yang ekstra ( printtanpa ()).

pb , 359 byte

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

Dalam pb, input benar-benar satu dimensi. Tidak mengerti bahwa Anda menggambar bentuk dengan input Anda, hanya melihat satu garis panjang dengan beberapa byte dengan nilai 10 dilemparkan ke sana. Hal pertama yang dilakukan program ini adalah menyalin semua kecuali "baris" pertama input ke Y = 0, Y = 1, dll, untuk membuat bentuk cetakan.

Sesuatu yang saya perhatikan banyak di golf kode, tetapi terutama ketika bermain golf bahasa esoteris, adalah bahwa Anda sering tidak ingin memiliki dua cabang untuk berurusan dengan; Anda hanya mengatur diri sendiri bahwa Anda melakukan hal yang sama dalam kedua kasus tersebut. Cara naif untuk menyelesaikan masalah ini mungkin akan memeriksa panjang string terhadap jumlah hash di sisa input dan melakukan sesuatu tergantung pada hasilnya, karena itu harus berperilaku berbeda tergantung pada apa yang terputus. Tapi itu banyak byte.

Sebagai gantinya, setelah menyelesaikan cetakan, garis tambahan ditambahkan ke bagian bawah. Ini hanya nhash berturut-turut, di mana npanjang string. Sekarang talinya dijamin pas! Setelah memasukkan semua karakter string, baris tambahan yang ditambahkan akan dihancurkan tanpa syarat. Setiap hash sisa dalam cetakan yang tepat dihapus juga, dan itulah output yang diperlukan!

Tentu saja, itu akan melanggar spesifikasi untuk hanya menghancurkan semua hash. Bagaimanapun, mungkin ada hash dalam string input! Untuk menangani ini, saya merujuk ke bagian lain dari spesifikasi:

Anda diberi string ASCII yang dapat dicetak dan tidak mengandung baris baru

(Tekankan milikku.) Pada saat kita berurusan dengan string, kita tidak benar-benar peduli jika ada baris baru di dalamnya, tetapi kita tahu bahwa tidak ada. Jadi, semua hash diganti dengan baris baru sebelum dimasukkan ke dalam cetakan! Setelah semua hash dihancurkan, semua baris baru diganti dengan hash lagi. Ini tidak mengubah seluruh output menjadi garis hash-delimited tunggal karena sifat output 2D pb berarti bahwa itu tidak pernah benar-benar menempatkan baris baru di akhir setiap baris, itu hanya melanjutkan ke baris berikutnya.

Tidak Disatukan:

# 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 byte

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

70 byte jika teks dapat berisi hash:

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

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

Harus -pdijalankan. Penjelasan:

@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

Jelly, 10 8 byte

¹ƈ<”#$?€

Coba di sini!

Perl 6 , 72 byte

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

ES6, 47 byte

Mungkin solusi yang paling mudah.

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

Kode ini menciptakan fungsi anonim yang menerima 2 parameter dan mengembalikan hasil akhir.

Parameter pertama Sadalah string "map" dengan Anda "#", sedangkan parameter kedua Radalah "pengganti" untuk itu "#".

Python 3

152 127 byte

Program lengkap.

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 byte

Fungsi yang mengambil aliran sebagai input.

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