줄 바꿈이없고 공백 ( ) 및 해시 ( #)를 포함하는 여러 줄 "금형"이 포함 된 인쇄 가능한 단일 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 바이트

2 바이트를 절약 한 Sp3000에 감사합니다.

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 프리미티브

문자열을 텍스트와 금형으로 분할 한 다음 배열로 변환합니다. #가 있으면 금형을 확인하고 텍스트에서 문자를 넣습니다. 텍스트 또는 금형이 비어 있으면 루프를 종료하십시오.

하스켈, 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*

마지막으로, 첫 번째 줄에 남은 것을 제거하고 처음 ×부터 입력을 양방향으로 자르는 것을 제거합니다 .

자바 스크립트 (ES6), 57 56 55 바이트

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

@Neil 덕분에 1 바이트가 절약되었습니다 !

설명

입력 문자열의 해시와 함께 작동하며 입력 문자열이 완료된 후 후행 공백을 유지합니다.

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>

파이썬 3, 69 68 67 바이트

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

Ideone

바이트 오프에 대한 Chiel ten Brinke, FryAmTheEggman 덕분에. 또는 파이썬 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에서 입력은 엄격하게 1 차원입니다. 입력으로 모양을 그리는 것을 이해하지 못하고 값이 10 인 바이트가있는 긴 줄 하나만 보입니다. 이 프로그램이하는 첫 번째 일은 입력의 첫 번째 "라인"을 제외한 모든 것을 Y = 0, Y = 1 등으로 복사하여 금형의 모양을 만드는 것입니다.

내가 코드 골프에서 많이 알아 차린 것은 있지만 특히 난해한 언어를 골프로 칠 때 종종 두 가지를 다루고 싶지 않다는 것입니다. 두 경우 모두 동일한 작업을 수행하도록 설정했습니다. 이 문제를 해결하는 순진한 방법은 나머지 입력의 해시 수와 비교하여 문자열의 길이를 확인하고 결과에 따라 무언가를 수행하는 것입니다. 잘리는 부분에 따라 다르게 행동해야하기 때문입니다. 그러나 그것은 많은 바이트입니다.

대신 금형을 완성한 후 바닥에 여분의 선이 추가됩니다. 단순히 n행의 해시이며 n문자열의 길이는 어디입니까 ? 이제 줄이 맞습니다! 문자열의 모든 문자를 삽입 한 후 추가 된 추가 행은 무조건 파괴됩니다. 금형에 남은 해시도 지워 지므로 필요한 출력입니다!

물론, 그것은 모든 해시를 단순히 파괴하는 스펙을 위반할 것입니다. 결국 입력 문자열에 해시가있을 수 있습니다! 이를 처리하기 위해 사양의 다른 부분을 참조합니다.

줄 바꿈이없는 인쇄 가능한 단일 ASCII 문자열이 제공됩니다.

우리는 문자열을 다룰 때 줄 바꿈이 있는지 신경 쓰지 않지만 아무 것도 없다는 것을 알고 있습니다. 따라서 모든 해시는 금형에 넣기 전에 줄 바꿈으로 바뀝니다! 모든 해시가 삭제되면 모든 줄 바꿈이 다시 해시로 바뀝니다. pb의 2D 출력의 특성상 실제로 각 줄의 끝에 새 줄을 넣지 않고 다음 줄로 넘어 갔기 때문에 전체 출력을 단일 해시로 구분 된 줄로 바꾸지 않습니다.

언 골프 드 :

# 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)

펄, 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 바이트

¹ƈ<”#$?€

여기 사용해보십시오!

펄 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

152127 바이트

전체 프로그램.

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