Вам надається єдиний рядок для друку 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 примітивів

розбиває рядок на текст і форму, а потім перетворює їх у масив. Перевіряє форму, якщо є номер # та ставить знак із тексту, він нічого не робить. Якщо текст або форма порожні, вийдіть з циклу

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)

Збережено 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довжина струни. Тепер рядок гарантовано підходить! Після вставки всіх символів рядка той додатковий рядок, який був доданий, безумовно знищується. Будь-які залишки хешів у власній формі також стираються, і це необхідний вихід!

Звичайно, було б порушено специфікацію просто знищити всі хеши. Зрештою, у вхідному рядку може бути хеш! Щоб вирішити це, я посилаюся на іншу частину специфікації:

Вам надається одна друкована рядок ASCII, що не містить нових рядків

(Наголос мій.) На той час, коли ми маємо справу зі струною, нас насправді не хвилює, чи є в ній нові рядки, але ми знаємо, що таких немає. Отже, всі хеші замінюються новими рядками перед тим, як поставити у форму! Після того, як всі хеші будуть знищені, всі нові рядки знову замінюються хешами. Це не перетворює весь вихід у єдиний відмічений хеш-рядок, оскільки природа 2D-виводу pb означає, що він ніколи фактично не ставив новий рядок в кінці кожного рядка, він просто перейшов до наступного рядка.

Безголівки:

# 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- це рядок "map" з вашим "#", а другий параметр R- "заміною" для них "#".

Пітон 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()])