Yeni satır içermeyen tek bir yazdırılabilir ASCII dizesi ve boşluk ( ) ve karma ( #) içeren çok satırlı bir "kalıp" verilir .

Dizede karakter karakter gitmeli ve dizeden karakterleri sol-sağ, üst-alt sırayla kullanarak karmaları değiştirmelisiniz . Dize kalıbı doldurmak için çok kısaysa, çıktıyı durdurursunuz, dize çok uzunsa, kalıbı tam olarak doldurmak için ipi kesersiniz.

Örnek dize / kalıp (dize çok uzun, kesik):

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

Örnek çıktı:

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

Örnek dize / kalıp (dize çok kısa, çıkış durdu):

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

Karşılık gelen çıktı:

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

Bayt cinsinden en kısa kod kazanır.

^{Fikir için bu web sitesine teşekkür ederiz .}

CJam, 16 14 bayt

2 bayt tasarruf için Sp3000'e teşekkürler.

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

Dize çok kısaysa hatayla sonlanır, ancak hata STDERR'a yazdırılır.

Çevrimiçi deneyin!

Alternatif olarak (aynı bayt sayısı):

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

açıklama

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 Temel Öğeleri

dizgiyi metne ve kalıba ayırır, sonra diziye dönüştürür. # Varsa kalıp kontrol eder ve başka bir şey yapmaz metinden bir karakter koyar. Metin veya kalıp boşsa döngüden çıkın

Haskell, 48 bayt

"(string ile değiştir) # (hashmark string)" olarak adlandırılır:

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

Daha az 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 bayt

Bayt sayımı ISO 8859-1 kodlamasını varsayar.

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

Sondaki satır besleme önemlidir.

Çevrimiçi deneyin!

açıklama

T`#`×`¶.+

İlk #olarak kılavuzun bir parçası olan ASCII olmayan (ancak genişletilmiş ASCII) karakteriyle değiştiririz, ×böylece onları #ilk satırda görünebilecek olanlarla karıştırmayız .

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

Şimdi , bulabildiğimiz ilk satırı, ilk satırdaki ilk karakterle (işlemde kaldırılır) ×tekrar tekrar değiştirerek, ilk satırdan mümkün olduğunca çok dolduruyoruz ×.

^.*¶|×\D*

Son olarak, ilk satırda kalan her şeyden ×ve her iki yönde girişi kesecek her şeyden kurtuluyoruz .

JavaScript (ES6), 57 56 55 bayt

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

Sayesinde 1 bayt kaydedildi @Neil kaydedildi !

açıklama

Giriş dizesindeki karmalarla çalışır ve giriş dizesi bittikten sonra arka boşluğu korur.

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 bayt

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

Ideone

FryAmTheEggman sayesinde bayt için Chiel ten Brinke. Alternatif olarak, Python 2'yi ekstra bir tane için ( printolmadan ()) kullanabilirdim.

pb , 359 bayt

^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'de, girdi kesinlikle bir boyutludur. Girişinizle bir şekil çizdiğinizi anlamıyor, sadece 10 baytlık bir bayt ile uzun bir çizgi görüyor. Bu programın yaptığı ilk şey, kalıbın şeklini oluşturmak için girdinin ilk "satırı" hariç tüm Y = 0, Y = 1, vb.

Bir şey kod golf çok fark ettim, ama özellikle ezoterik diller golf yaparken, genellikle başa çıkmak için iki şube olmasını istemiyorum; her iki durumda da aynı şeyi yaptığınıza karar verdiniz. Bu sorunu çözmenin naif yolu, muhtemelen dizenin uzunluğunu girdinin geri kalanındaki karma sayısına göre kontrol edecek ve sonuca bağlı olarak bir şeyler yapacaktır, çünkü neyin kesildiğine bağlı olarak farklı davranması gerekir. Ama bu çok fazla bayt.

Bunun yerine, kalıbı tamamladıktan sonra, tabana ekstra bir çizgi eklenir. Bu, dizenin uzunluğu olan nbir satırdaki hash'lerdir n. Şimdi ipin sığacağı garanti! Dizenin tüm karakterlerini ekledikten sonra, eklenen ekstra satır koşulsuz olarak yok edilir. Kalıptaki herhangi bir artık karması da silinir ve bu gerekli çıktıdır!

Tabii ki, tüm karmaları yok etmek spesifikasyonu ihlal eder. Sonuçta, girdi dizesinde bir karma olabilir! Bunu ele almak için, spesifikasyonun başka bir bölümüne başvuruyorum:

Yeni satır içermeyen tek bir yazdırılabilir ASCII dizesi verilir

(Vurgu benim.) Dize ile uğraşırken, içinde yeni satırlar olup olmadığını gerçekten umursamıyoruz, ancak olmadığını biliyoruz. Böylece, tüm karmalar kalıba konulmadan önce yeni satırlarla değiştirilir! Tüm karmalar yok edildikten sonra, tüm yeni satırlar tekrar karmalarla değiştirilir. Bu, tüm çıktıyı tek bir karma sınırlandırılmış çizgiye dönüştürmez, çünkü pb'nin 2D çıktısının doğası, her satırın sonuna asla yeni bir satır koymadığı anlamına gelir, sadece bir sonraki satıra geçti.

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 bayt

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

Metin karma içerebiliyorsa 70 bayt:

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

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

Gerektirir -pçalıştırmak için. Açıklama:

@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

Jöle, 10 8 bayt

¹ƈ<”#$?€

Burada deneyin!

Perl 6 , 72 bayt

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

ES6, 47 bayt

Muhtemelen en basit çözüm.

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

Bu kod, 2 parametre alan ve nihai sonucu döndüren anonim bir işlev oluşturur.

İlk parametre S"map" dizgisi ile birlikte "#", ikinci parametre Rise "değiştir" dir "#".

Python 3

152126 bayt

Tam bir program.

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 bayt

Akışı giriş olarak alan bir işlev.

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