당신은 책을 만들었습니다!

15

당신은 가상의 구식 인쇄기에서 일합니다. 모노 스페이스 문자를 더 빨리 정렬 할 수 있도록 가장 짧은 프로그램을 사용하도록 도와주십시오. 문자열과 페이지 크기가 주어지면 텍스트의 각 페이지를 생성하고 출력하십시오.

예

예를 들어, 페이지 너비 14, 높이 7 및 일부 텍스트를 가진 책은 다음과 같습니다.

14, 7, "Fruits make an extremely good snack due to their utterly scrumptious sweetness. They are also very healthy for you."
+------------+
| Fruits     |
| make an    |
| extremely  |
| good snack |
| due to     |
+------------+

+------------+
| their      |
| utterly    |
| scrumptio- |
| -us        |
| sweetness. |
+------------+

+------------+
| They are   |
| also very  |
| healthy    |
| for you.   |
|            |
+------------+

기본 페이지 설정은 다음과 같습니다.

|---i.e.14---|
+------------+ - 
| Xxxxxxxxxx | |
| Xxxxxxxxxx | i.  
| Xxxxxxxxxx | e. 
| Xxxxxxxxxx | 7
| Xxxxxxxxxx | | 
+------------+ -

몇 가지

  1. 페이지 가장자리와 텍스트 사이에 한 칸의 여백이 있습니다.
  2. 너비와 높이에는 명확하지 않은 경우 상자 가장자리가 포함됩니다.
  3. 줄 바꿈은 한 줄에 단어를 넣을 수없는 경우에만 발생합니다.
  4. 프로그램은 필요한만큼 많은 페이지를 출력 할 수 있어야합니다.
  5. 프로그램은 14 x 7이 아닌 모든 페이지 크기를 지원해야합니다.
  6. 이것은 코드 골프이므로 바이트 (모든 언어)의 가장 작은 솔루션이 이깁니다.
  7. 재미를 망치지 마십시오. 표준 허점은 분명히 허용되지 않습니다.

아, 그리고 :

+------------+
| May the    |
| best book  |
| publisher  | 
| win. Good  |
| Luck!      |
+------------+

+------------+
| Best       |
| program    |
| so far:    | 
| Charcoal   |
|            |
+------------+
code-golf  string  ascii-art 
— 나는..
소스
@rod 죄송합니다.
— i ..
7
for example 14그 말 은e.g.
— FrownyFrog
— Martin Ender
4
한 단어에서 '멀티 컷'을 처리해야합니까? (같은 scru-/-mpt-/-ious)
— Arnauld
1
@Arnauld 단어가 충분히 길면 그렇습니다.
— i ..

답변:

5

파이썬 2 , 306 304 283 279 바이트

def f(w,h,s):
 b=[];w-=4;h-=2;H='+-'+'-'*w+'-+';x=l='';s=s.split()
 while s:
	W=s.pop(0)
	if W[w:]:W,s=W[:w-1]+'-',['-'+W[w-1:]]+s
	if len(l+W)<=w-(l>x):l+=' '*(l>x)+W
	else:b+=[l];l=W
 b+=[l]+[x]*h
 while any(b):print'\n'.join([H]+['| %-*s |'%(w,b.pop(0))for _ in' '*h]+[H,x,x])

온라인으로 사용해보십시오!

— TFeld
소스
L=len총 2 바이트를 절약 할 수 있다고 생각합니다 .
— Chas Brown
참고로 (주소 지정이 필요한지 확실하지 않음) 제안한 테스트 사례 ( 7, 3, "Three Is The Magic Number!")는 빈 페이지를 생성합니다.
— Jonathan Allan
1
— @JonathanAllan
3

숯 , 105 83 바이트

ＮθＮηＭ⁺η²↑Ｆ⪪Ｓ «Ｗ›Ｌι⁻θ⁴«⊞υ⁺…ι⁻θ⁵-≔⁺-✂ι⁻θ⁵Ｌι¹ι»⊞υι»Ｆυ«¿‹Ｌι±ⅈ «Ｍ⁻⁻⁴ⅈθ¹¿¬﹪ⅉ⊕η«↙↙Ｂθη↘→»»ι

온라인으로 사용해보십시오! 링크는 디버 보시 파이가 ⅈ및 ⅉnilary 연산자를 처리 할 수없는 자세한 버전의 코드 입니다. 선행 빈 줄이 허용되는 경우 76 바이트로 줄일 수 있습니다.

≔⁻Ｎ⁴θＭθ→ＮηＦ⪪Ｓ «Ｗ›Ｌιθ«⊞υ⁺…ι⊖θ-≔⁺-✂ι⊖θＬι¹ι»⊞υι»Ｆυ«¿‹⁺ⅈＬιθ «Ｆ¬﹪ⅉ⊕η«⸿↙↙Ｂ⁺θ⁴η»⸿»ι

설명:

ＮθＮη

에 너비 q와 높이를 입력하십시오 h.

Ｍ⁺η²↑

첫 번째 상자가 그려 지지만 상단 여백이 생성되지 않는 위치로 이동하십시오.

Ｆ⪪Ｓ «

입력 문자열의 모든 단어를 반복합니다.

Ｗ›Ｌι⁻θ⁴«

단어가 너무 넓어 상자에 맞지 않을 때 반복하십시오.

⊞υ⁺…ι⁻θ⁵-

맞는 하이픈을 더한 단어를 추가하십시오.

≔⁺-✂ι⁻θ⁵Ｌι¹ι»

나머지 단어 앞에 하이픈을 붙입니다.

⊞υι»

나머지 단어를 밀어 넣으십시오.

Ｆυ«

하이픈으로 연결된 모든 단어를 반복합니다.

¿‹Ｌι±ⅈ

단어가 현재 줄에 맞는지 확인하십시오.

 «

그렇다면 공백을 인쇄하십시오.

Ｍ⁻⁻⁴ⅈθ¹

그렇지 않으면 다음 줄의 시작으로 이동하십시오.

¿¬﹪ⅉ⊕η

새 상자가 필요한지 확인하십시오.

«↙↙Ｂθη↘→»»

그렇다면 상자를 그립니다.

ι

마지막으로 단어를 인쇄하십시오.

— 닐
소스
2

펄 5 , 203 182 + 1 ( -a) = 183 바이트

$t=($\=-3+shift@F)-2;$h=shift@F}{say$_='+'.'-'x$\.'-+';map{$_="";{$_.=shift@F;s/.{$t}\K..+/-/&&unshift@F,-$&;$_.=$";y///c+length$F[0]<$\&&redo}printf"| %-$\s|
",$_}3..$h;say;@F&&redo

온라인으로 사용해보십시오!

— Xcali
소스
2

자바 스크립트 (ES8), 242 바이트

버그를보고 해 주신 @ Tvde1에게 감사합니다

(s,w,h)=>s.split` `.map(g=s=>l=(l+s)[W=w-5]?s[l&&A(l),l='',w-4]?g('-'+s.slice(W),A(s.slice(0,W)+'-')):s:l?l+' '+s:s,n=o=l='',h-=2,b=`+${'-'.repeat(w-2)}+
`,A=s=>o+=(!n|n++%h?'':b+`
`+b)+`| ${s.padEnd(w-3)}|
`)&&(g=s=>A(s)&&n%h?g(''):b+o+b)(l)

온라인으로 사용해보십시오!

댓글

(s, w, h) =>                        // given s = string, w = width, h = height
  s.split` `                        // get all words by splitting the string on spaces
  .map(g = s =>                     // for each word s:
    l = (l + s)[W = w - 5] ?        //   if the word is too long for the current line:
      s[ l && A(l),                 //     append the line (if not empty)
         l = '',                    //     clear the line
         w - 4 ] ?                  //     if the word itself doesn't fit:
        g(                          //       do a recursive call with:
          '-' + s.slice(W),         //         a hyphen + the next part
          A(s.slice(0, W) + '-')    //         and append the current part + a hyphen
        )                           //       end of recursive call
      :                             //     else:
        s                           //       initialize a new line with this word
    :                               //   else:
      l ?                           //     if the current line is not empty:
        l + ' ' + s                 //       append a space + the word
      :                             //     else:
        s,                          //       initialize a new line with this word
    n = o = l = '',                 //   n = line counter, o = output, l = line
    h -= 2,                         //   adjust h
    b = `+${'-'.repeat(w - 2)}+\n`, //   b = border + linefeed
    A = s =>                        //   A = function that updates the output o:
      o += (                        //     append to o:
        !n | n++ % h ?              //       if we haven't reached an end of page:
          ''                        //         an empty string
        :                           //       else:
          b + `\n` + b              //         bottom border + linefeed + top border
      ) +                           //       followed by
      `| ${s.padEnd(w - 3)}|\n`     //       left border + padded text + right border
  ) &&                              // end of map()
  (g = s =>                         // g = recursive function taking s:
    A(s) &&                         //   append s
    n % h ?                         //   if we haven't reached an end of page:
      g('')                         //     go on with an empty line
    :                               //   else:
      b + o + b                     //     return top border + output + bottom border
  )(l)                              // initial call to g() with the last pending line
— 아르나 울드
소스
귀하의 예를 들어 텍스트를 시도 12하고 7, 일부 라인 / 단어가 반전된다.
— Tvde1
1
@ Tvde1 감사합니다. 이제 수정되었습니다 .
— Arnauld
1

젤리 , 93 바이트

1,⁴Ṭị⁾+-W,`
ṣ⁶µḊṖs⁴_6¤j⁾--;@Ḣ;Ṫḟ0s⁴_©4¤µ€ẎŒṖK€€µL€>®ẸµÐḟṪ;€⁶x®¤ḣ€®s⁵_2¤Zz⁶x®¤j@€€⁾| ,U¤j@€¢ẎY

세 개의 인수를 복용 전체 프로그램은 ( text, width, height) 페이지를 인쇄한다.

온라인으로 사용해보십시오! NB 60 초 내에 OP에서 예제를 실행하는 데 너무 비효율적입니다.

( 페이지 사이의 빈 줄이 실제로 필요한 경우 97 바이트 )

어떻게?

1,⁴Ṭị⁾+-W,` - Link 1, make header & footer: no arguments
  ⁴         - program's 2nd argument, width
1           - literal one
 ,          - pair = [1,width]
   Ṭ        - untruth = [1,0,0,...,0,0,1] (a 1 at index 1 and index width; 0 elsewhere)
     ⁾+-    - literal list of characters = "+-"
    ị       - index into (1-based & modular) = "+--...--+"
        W   - wrap = ["+---...--+']
          ` - use as both arguments of the dyad:
         ,  - pair = [["+---...--+'],["+---...--+']]

ṣ⁶µḊṖs⁴_6¤j⁾--;@Ḣ;Ṫḟ0s⁴_©4¤µ€ẎŒṖK€€µL€>®ẸµÐḟṪ;€⁶x®¤ḣ€®s⁵_2¤Zz⁶x®¤j@€€⁾| ,U¤j@€¢ẎY

 - Main link. This is long so splitting it up into parts like so:
ṣ⁶µ "A" µ€ "B" µ "C" µÐḟ "D"
ṣ⁶                           - split 1st argument (text) at spaces
  µ "A" µ€                   - for €ach resulting word do "A" (get hyphenated parts)
           "B"               - do "B" (all ways to partition those joining with spaces)
                     µÐḟ     - filter discard if:
               µ "C"         -   do "C" (any parts are too long)
                         "D" - do "D" (format the resulting list into the page-format)

"A" = ḊṖs⁴_6¤j⁾--;@Ḣ;Ṫḟ0s⁴_©4¤ - Hyphenate: list, word     e.g. "Something"
      Ḋ                        - dequeue                        "omething"
       Ṗ                       - pop                            "omethin"
            ¤                  - nilad followed by link(s) as a nilad
         ⁴                     -   program's 2nd argument  e.g. 9  (width)
           6                   -   literal six                  6
          _                    -   subtract                     3
        s                      - split into chunks             ["ome","thi","n"]
              ⁾--              - literal list of characters     "--"
             j                 - join                           "ome--thi--n"
                   Ḣ           - head (word)                    "S"
                 ;@            - concatenate (sw@p arguments)   "Some--thi--n"
                     Ṫ         - tail (word)                    "g"
                    ;          - concatenate                    "Some--thi--ng"
                      ḟ0       - filter out zeros (tail yields 0 for words of length 1)
                             ¤  - nilad followed by link(s) as a nilad:
                         ⁴      -   program's 2nd argument      9
                            4   -   literal four                4
                          _     -   subtract                    5
                           ©    -   copy to register & yield    5
                        s       - split into chunks             ["Some-","-thi-","-ng"]

"B" = ẎŒṖK€€ - Line arrangements: list of lists of hyphen-parts / single words
      Ẏ      - flatten by one (make a list of words and hyphen-parts
             - e.g. [["Not"],["hyph-","-ena-","-ted"]] -> ["Not","hyph-","-ena-","-ted"]
       ŒṖ    - partition e.g. [1,2,3]->[[[1],[2],[3]],[[1],[2,3]],[[1,2],[3]],[[1,2,3]]]
         K€€ - join with spaces for €ach for €ach e.g. ["one","two"]->"one two"

"C" = L€>®Ẹ - Any part too long?: one of the list of lines from "B"
      L€    - length of €ach
         ®  - recall from the register (width minus 4)
        >   - greater than (vectorises) - 1 if so 0 if not
          Ẹ - any truthy? (1 if any too long)

"D" = Ṫ;€⁶x®¤ḣ€®s⁵_2¤Zz⁶x®¤j@€€⁾| ,U¤j@€¢ẎY - Format as pages: list of valid arrangements
      Ṫ                                     - tail (last valid partition is greediest)
            ¤                               - nilad followed by links as a nilad:
         ⁶                                  -   literal space character
           ®                                -   recall from register (width minus 4)
          x                                 -   repeat elements
       ;€                                   - concatenate to €ach
               ®                            - recall from register (width minus 4)
             ḣ€                             - head €ach to index
                    ¤                       - nilad followed by links as a nilad:
                 ⁵                          -   program's 3rd argument, height
                   2                        -   literal two
                  _                         -   subtract
                     Z                      - transpose
                          ¤                 - nilad followed by link(s) as a nilad:

                       ⁶                    -   literal space character
                         ®                  -   recall from register (width minus 4)
                        x                   -   repeat elements

                      z                     - transpose with filler (repeated spaces)
                                    ¤       - nilad followed by link(s) as a nilad:
                               ⁾|<space>    -   literal list of characters = "| "
                                   U        -   upend = " |"
                                  ,         -   pair = ["| "," |"]
                           j@€€             - join for €ach for €ach (sw@p arguments)
                                        ¢   - call last link (1) as a nilad
                                     j@€    - join for €ach (sw@p arguments)
                                         Ẏ  - flatten by one
                                          Y - join with line feeds
                                            - implicit print
— 조나단 앨런
소스
0

PHP, 299 바이트

for($a=explode(" ",$argv[3]);$y|$e=strlen($d=$a[+$i++]);$x||print"|",$x|$e<$w?$e<$w-$x?$x+=$e+print" $d":$i-=!$x=!$y+=print str_pad("",$w-$x)." |
":$y+=print" ".substr($d,0,$w-2)."- |
".!$a[--$i]="-".substr($d,$w-2),$y>$argv[2]-2&&$y=!print"$t
")$y||$y=print$t=str_pad("+",2+$w=$argv[1]-3,"-")."+
";

온라인으로 실행 php -nr '<code>' <width> <height> '<text>'하거나 온라인으로 사용해보십시오 .

— 디도서
소스
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.