Ti viene data una singola stringa ASCII stampabile che non contiene newline e uno "stampo" multilinea, contenente spazi ( ) e hash ( #).

È necessario passare carattere per carattere nella stringa e sostituire gli hash utilizzando i caratteri della stringa nell'ordine da sinistra a destra, dall'alto verso il basso. Se la stringa è troppo corta per riempire lo stampo, si interrompe l'output, se la stringa è troppo lunga, si tronca la stringa per riempire esattamente lo stampo.

Esempio di stringa / stampo (stringa troppo lunga, troncata):

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

Esempio di 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

Esempio stringa / stampo (stringa troppo corta, uscita interrotta):

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

Uscita corrispondente:

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

Vince il codice più breve in byte.

^{Ringraziamo l'idea per questo sito Web .}

CJam, 16 14 byte

Grazie a Sp3000 per aver salvato 2 byte.

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

Termina con un errore se la stringa è troppo corta, ma l'errore viene stampato su STDERR.

Provalo online!

In alternativa (stesso conteggio byte):

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

Spiegazione

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

divide la stringa in testo e stampo quindi li trasforma in un array. Controlla lo stampo se c'è un # e inserisce un carattere dal testo altrimenti non fa nulla. Se il testo o lo stampo sono vuoti, uscire dal ciclo

Haskell, 48 byte

chiamato come "(sostituisci con stringa) # (stringa hashmark)":

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

Meno 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

Il conteggio dei byte presuppone la codifica ISO 8859-1.

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

L'alimentazione di linea finale è significativa.

Provalo online!

Spiegazione

T`#`×`¶.+

Sostituiamo innanzitutto quelli #che fanno parte della griglia con il carattere non ASCII (ma esteso ASCII) in ×modo da non confonderli con alcun# che potrebbero apparire sulla prima riga.

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

Ora riempiamo il maggior numero ×possibile dalla prima riga sostituendo ripetutamente il primo ×che possiamo trovare con il primo carattere sulla prima riga (che viene rimosso nel processo).

^.*¶|×\D*

Infine, ci sbarazziamo di tutto ciò che è rimasto sulla prima riga, nonché di qualsiasi cosa dalla prima ×per troncare l'input in entrambe le direzioni.

JavaScript (ES6), 57 56 55 byte

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

Salvato 1 byte grazie a @Neil !

Spiegazione

Funziona con gli hash nella stringa di input e mantiene gli spazi vuoti finali al termine della stringa di input.

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

Grazie a FryAmTheEggman, Chiel dieci Brinke per il byte off. In alternativa, avrei potuto usare Python 2 per uno extra ( printsenza ()).

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

In pb, l'input è strettamente monodimensionale. Non capisce che stai disegnando una forma con il tuo input, vede solo una lunga linea con alcuni byte con un valore di 10 gettato lì dentro. La prima cosa che fa questo programma è copiare tutto tranne la prima "linea" di input su Y = 0, Y = 1, ecc., Per creare la forma dello stampo.

Qualcosa che ho notato molto nel golf del codice, ma soprattutto quando si gioca a golf nelle lingue esoteriche, è che spesso non si desidera avere due rami da affrontare; ti sei appena impegnato a fare la stessa cosa in entrambi i casi. Il modo ingenuo di risolvere questo problema probabilmente verificherebbe la lunghezza della stringa rispetto al numero di hash nel resto dell'input e farebbe qualcosa in base al risultato, perché deve comportarsi in modo diverso a seconda di cosa viene tagliato. Ma sono molti byte.

Invece, dopo aver completato lo stampo, viene aggiunta una riga aggiuntiva sul fondo. Si tratta semplicemente di nhash di fila, dove si ntrova la lunghezza della stringa. Ora la corda è garantita per adattarsi! Dopo aver inserito tutti i caratteri della stringa, quella riga aggiuntiva aggiunta viene distrutta incondizionatamente. Anche tutti gli hash rimanenti nello stampo vengono cancellati e questo è il risultato necessario!

Naturalmente, violerebbe le specifiche per distruggere semplicemente tutti gli hash. Dopotutto, potrebbe esserci un hash nella stringa di input! Per gestire questo, mi riferisco a un'altra parte delle specifiche:

Ti viene data una singola stringa ASCII stampabile che non contiene nuove righe

(Enfasi mia.) Quando abbiamo a che fare con la corda, non ci interessa davvero se ci sono nuove linee, ma sappiamo che non ce ne sono. Quindi, tutti gli hash vengono sostituiti con nuove righe prima di essere inseriti nello stampo! Dopo la distruzione di tutti gli hash, tutte le nuove righe vengono nuovamente sostituite con hash. Questo non trasforma l'intero output in una singola linea delimitata da hash perché la natura dell'output 2D di pb significa che non ha mai effettivamente inserito una nuova riga alla fine di ogni riga, ma è passata alla riga successiva.

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 byte

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

70 byte se il testo può contenere 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+$//

Richiede -pdi correre. Spiegazione:

@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

Gelatina, 10 8 byte

¹ƈ<”#$?€

Provalo qui!

Perl 6 , 72 byte

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

ES6, 47 byte

Probabilmente la soluzione più semplice.

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

Questo codice crea una funzione anonima che riceve 2 parametri e restituisce il risultato finale.

Il primo parametro Sè la stringa "map" con il tuo "#", mentre il secondo parametro Rè la "sostituzione" per quelli "#".

Python 3

152 127 byte

Un programma completo.

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

Una funzione che accetta lo stream come 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()])