Вам предоставляется одна печатаемая строка 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без ()).

пб , 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 означает, что он фактически никогда не ставит новую строку в конце каждой строки, он просто переходит на следующую строку.

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- это строка «map» с вашим "#", а второй параметр 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()])