Sie erhalten eine einzelne druckbare ASCII-Zeichenfolge, die keine Zeilenumbrüche enthält, und eine mehrzeilige "Form", die Leerzeichen ( ) und Hashes ( #) enthält.

Sie müssen Zeichen für Zeichen in der Zeichenfolge eingeben und Hashes durch die Zeichen aus der Zeichenfolge in der Reihenfolge von links nach rechts und von oben nach unten ersetzen . Wenn die Zeichenfolge zu kurz ist, um die Form zu füllen, hören Sie mit der Ausgabe auf. Wenn die Zeichenfolge zu lang ist, kürzen Sie die Zeichenfolge, um die Form genau zu füllen.

Beispiel String / Form (String zu lang, abgeschnitten):

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

Beispielausgabe:

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

Beispiel String / Mold (String zu kurz, Ausgabe gestoppt):

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

Entsprechende Ausgabe:

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

Kürzester Code in Bytes gewinnt.

^{Dank für die Idee zu dieser Website .}

CJam, 16 bis 14 Bytes

Danke an Sp3000 für das Speichern von 2 Bytes.

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

Beendet mit einem Fehler, wenn die Zeichenfolge zu kurz ist, der Fehler jedoch in STDERR ausgegeben wird.

Probieren Sie es online!

Alternativ (gleiche Byteanzahl):

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

Erläuterung

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-Grundelemente

Teilt die Zeichenfolge in Text und Form und wandelt sie dann in ein Array um. Überprüft die Form, ob es ein # gibt, und setzt ein Zeichen aus dem Text, sonst macht es nichts. Wenn entweder der Text oder die Form leer sind, verlassen Sie die Schleife

Haskell, 48 Bytes

heißt wie "(durch String ersetzen) # (Hashmark-String)":

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

Weniger golfen:

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 bis 40 Bytes

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.

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

Der Zeilenvorschub am Ende ist signifikant.

Probieren Sie es online!

Erläuterung

T`#`×`¶.+

Wir ersetzen zuerst # die Teil des Rasters sind, durch das Nicht-ASCII-Zeichen (aber erweitertes ASCII-Zeichen), ×damit wir sie nicht mit denen verwechseln #, die in der ersten Zeile erscheinen könnten.

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

Jetzt füllen wir so viele × wie möglich aus der ersten Zeile, indem ×wir die erste Zeile, die wir finden, wiederholt durch das erste Zeichen in der ersten Zeile ersetzen (das dabei entfernt wird).

^.*¶|×\D*

Schließlich entfernen wir alles, was in der ersten Zeile noch übrig ist, sowie alles, was aus der ersten Zeile stammt × um die Eingabe in beide Richtungen abzuschneiden.

JavaScript (ES6), 57 56 55 Bytes

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

1 Byte gespeichert dank @Neil gespeichert !

Erläuterung

Arbeitet mit Hashes in der Eingabezeichenfolge und behält den nachgestellten Leerraum bei, nachdem die Eingabezeichenfolge beendet wurde.

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 Bytes

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

Ideone

Danke an FryAmTheEggman, Chiel ten Brinke für das Byte off. Alternativ hätte ich Python 2 für ein zusätzliches verwenden können ( printohne ()).

pb , 359 bytes

^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 ist die Eingabe nur eindimensional. Es versteht sich nicht, dass Sie mit Ihrer Eingabe eine Form zeichnen, es wird nur eine lange Zeile mit einigen Bytes mit dem Wert 10 angezeigt. Das erste, was dieses Programm tut, ist, alle Eingaben außer der ersten "Zeile" auf Y = 0, Y = 1 usw. zu kopieren, um die Form der Form zu erzeugen.

Etwas, das mir beim Codegolf sehr aufgefallen ist, aber besonders beim Golfspielen in esoterischen Sprachen, ist, dass Sie häufig nicht zwei Zweige haben möchten, mit denen Sie sich befassen müssen. Sie haben sich einfach so eingestellt, dass Sie in beiden Fällen dasselbe tun. Die naive Art, dieses Problem zu lösen, würde wahrscheinlich die Länge des Strings mit der Anzahl der Hashes im Rest der Eingabe vergleichen und je nach Ergebnis etwas tun, da es sich anders verhalten muss, je nachdem, was abgeschnitten wird. Aber das sind viele Bytes.

Stattdessen wird nach Abschluss der Form eine zusätzliche Linie am Boden hinzugefügt. Es sind einfach nHashes in einer Reihe, wobei ndie Länge der Zeichenkette ist. Jetzt passt die Saite garantiert! Nach dem Einfügen aller Zeichen der Zeichenfolge wird die hinzugefügte zusätzliche Zeile unbedingt gelöscht. Alle verbleibenden Hashes in der eigentlichen Form werden ebenfalls gelöscht, und das ist die erforderliche Ausgabe!

Natürlich würde es die Spezifikation verletzen, einfach alle Hashes zu zerstören. Schließlich könnte es einen Hash in der Eingabezeichenfolge geben! Um damit umzugehen, verweise ich auf einen anderen Teil der Spezifikation:

Sie erhalten eine einzelne druckbare ASCII-Zeichenfolge, die keine Zeilenumbrüche enthält

(Hervorheben von mir.) Bis wir uns mit der Saite befassen, ist es uns eigentlich egal, ob sie Zeilenumbrüche enthält, aber wir wissen, dass es keine gibt. Also werden alle Hashes durch Zeilenumbrüche ersetzt, bevor sie in die Form gegeben werden! Nachdem alle Hashes zerstört wurden, werden alle Zeilenumbrüche wieder durch Hashes ersetzt. Dadurch wird nicht die gesamte Ausgabe in eine einzige durch Hash-Zeichen getrennte Zeile umgewandelt, da aufgrund der Art der 2D-Ausgabe von pb nie eine neue Zeile am Ende jeder Zeile eingefügt wird, sondern lediglich die nächste Zeile.

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 Bytes

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

70 Bytes, wenn der Text Hashes enthalten kann:

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

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

Muss -pausgeführt werden. Erläuterung:

@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 Bytes

¹ƈ<”#$?€

Probieren Sie es hier aus!

Perl 6 , 72 Bytes

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

ES6, 47 Bytes

Wahrscheinlich die einfachste Lösung.

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

Dieser Code erstellt eine anonyme Funktion, die 2 Parameter empfängt und das Endergebnis zurückgibt.

Der erste Parameter Sist die "Map" -Zeichenfolge mit Ihrem "#", während der zweite Parameter Rdie "Ersetzung" für diese ist "#".

Python 3

152 127 Bytes

Ein volles Programm.

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 Bytes

Eine Funktion, die den Stream als Eingabe verwendet.

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