คุณจะได้รับสตริง 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   .   

รหัสที่สั้นที่สุดในหน่วยไบต์ชนะ

^{เครดิตสำหรับแนวคิดในเว็บไซต์นี้}

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 Primitives

แยกสตริงออกเป็นข้อความและโมลด์จากนั้นแปลงเป็นอาเรย์ ตรวจสอบราถ้ามี # และทำให้ถ่านจากข้อความอื่นมันไม่ทำอะไรเลย หากข้อความหรือแบบแม่พิมพ์ว่างเปล่าให้ออกจากลูป

Haskell, 48 ไบต์

เรียกว่า "(แทนที่ด้วยสตริง) # (สตริง hashmark)":

[]#_=[]
(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 42ไบต์

จำนวนไบต์ถือว่าการเข้ารหัส 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)

บันทึกแล้ว 1 ไบต์ขอบคุณ@Neil !

คำอธิบาย

ทำงานกับแฮชในสตริงอินพุตและคงพื้นที่สีขาวต่อท้ายหลังจากอินพุตสตริงเสร็จสิ้นแล้ว

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 อินพุตเป็นหนึ่งมิติอย่างเคร่งครัด ไม่เข้าใจว่าคุณกำลังวาดรูปร่างด้วยอินพุตของคุณมันเพิ่งเห็นหนึ่งบรรทัดยาวที่มีบางไบต์ที่มีค่า 10 ขว้างในนั้น สิ่งแรกที่โปรแกรมนี้ทำคือคัดลอกทั้งหมดยกเว้น "บรรทัด" แรกของอินพุตไปยัง Y = 0, Y = 1, ฯลฯ เพื่อสร้างรูปร่างของแม่พิมพ์

สิ่งที่ฉันได้สังเกตเห็นจำนวนมากในสนามกอล์ฟรหัส แต่โดยเฉพาะอย่างยิ่งเมื่อเล่นภาษาที่ลึกลับนั่นคือคุณมักไม่ต้องการให้มีสองสาขาที่จะจัดการ คุณเพิ่งตั้งค่าตัวเองว่าคุณทำสิ่งเดียวกันไม่ว่าในกรณีใด วิธีที่ไร้เดียงสาในการแก้ปัญหานี้อาจตรวจสอบความยาวของสตริงกับจำนวนของแฮชในอินพุตที่เหลือและทำบางสิ่งตามผลลัพธ์เนื่องจากต้องทำงานแตกต่างกันขึ้นอยู่กับสิ่งที่ถูกตัดออก แต่นั่นเป็นจำนวนมากไบต์

แต่หลังจากปั้นเสร็จแล้วจะมีการเพิ่มบรรทัดพิเศษที่ด้านล่าง มันเป็นเพียงการnแฮชในแถวที่nมีความยาวของสตริง ตอนนี้สตริงรับประกันว่าจะพอดี! หลังจากแทรกอักขระทั้งหมดของสตริงแล้วบรรทัดพิเศษที่ถูกเพิ่มจะถูกทำลายโดยไม่มีเงื่อนไข แฮชที่เหลือในแม่พิมพ์ที่เหมาะสมจะถูกลบเช่นกันและนั่นเป็นผลลัพธ์ที่จำเป็น!

แน่นอนว่ามันจะเป็นการละเมิดสเป็คเพื่อทำลายแฮ็คทั้งหมด ท้ายที่สุดอาจมีแฮชในอินพุตสตริง! เพื่อจัดการนี้ฉันหมายถึงส่วนอื่นของ spec:

คุณจะได้รับสตริง ASCII ที่พิมพ์ได้เดียวที่ไม่มีการขึ้นบรรทัดใหม่

(เน้นของฉัน.) ตามเวลาที่เราจัดการกับสตริงเราไม่สนใจจริงๆถ้ามีการขึ้นบรรทัดใหม่ในนั้น แต่เรารู้ว่าไม่มี ดังนั้นแฮชทั้งหมดจะถูกแทนที่ด้วยบรรทัดใหม่ก่อนที่จะใส่ลงในแม่พิมพ์! หลังจากแฮชทั้งหมดถูกทำลายบรรทัดใหม่ทั้งหมดจะถูกแทนที่ด้วยแฮชอีกครั้ง สิ่งนี้ไม่เปลี่ยนเอาต์พุตทั้งหมดเป็นบรรทัดที่มีการคั่นด้วยแฮชเดียวเนื่องจากลักษณะของเอาต์พุต 2D ของ pb หมายความว่ามันไม่เคยใส่บรรทัดใหม่ที่ตอนท้ายของแต่ละบรรทัด แต่เพิ่งไปยังบรรทัดถัดไป

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 ไบต์

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