텍스트 블록을 완전히 정렬 및 하이픈으로 연결


26
Given  a width  and  a block  of
text containing possible hyphen-
ation points,  format it  fully-
justified (in monospace).

완전 정렬은 왼쪽 오른쪽 에 정렬되며 각 줄에 맞을 때까지 단어 사이의 간격을 늘림으로써 달성됩니다.

관련 :

입력

원하는 형식으로 입력 할 수 있습니다. 당신은 주어질 것입니다 :

  • 5-100 (포함) 범위의 대상 너비 (문자)
  • 하이픈으로 묶인 단어가 포함 된 텍스트 블록입니다. 공백으로 구분 된 문자열, 단어 배열 또는 단어 조각 배열 (또는 원하는 다른 데이터 표현) 일 수 있습니다.

일반적인 입력은 다음과 같습니다.

Width: 25
Text:  There's no bu-si-ne-ss lik-e s-h-o-w busine-ss, n-o bus-iness I know.

하이픈은 가능한 하이픈 포인트를 나타내고 공백은 단어 경계를 나타냅니다. 텍스트의 가능한 대체 표현 :

[["There's"], ["no"], ["bu", "si", "ne", "ss"], ["lik", "e"], (etc.)]

산출

단어 사이에 공백이 추가 된 입력 텍스트, 열 너비의 줄 바꾸기 및 열 너비에 완전히 맞춰 지도록 하이픈 넣기 지점이 선택되었습니다. 함수의 경우, 줄 바꾸기를 사용하지 않고 문자열 배열 (각 줄에 하나씩)을 반환 할 수 있습니다.

위 입력에 대한 가능한 출력은 다음과 같습니다.

There's no  business like
show  business,  no  bus-
iness I know.

마지막 "bus-iness"에있는 하이픈을 제외한 모든 하이픈이 제거되었습니다.이 하이픈은 단어가 다음 줄로 줄 바꿈되어 두 번째 줄에 가능한 한 많은 텍스트가 포함되도록 선택되었습니다.

규칙

  • 각 줄 내에서 단어 사이의 공백 수는 1을 초과 할 수 없지만 추가 공백을 삽입하는 위치는 사용자에게 달려 있습니다.

    hello hi foo     bar    <-- not permitted (1,1,5)
    hello  hi foo    bar    <-- not permitted (2,1,4)
    hello  hi  foo   bar    <-- OK (2,2,3)
    hello  hi   foo  bar    <-- OK (2,3,2)
    hello   hi  foo  bar    <-- OK (3,2,2)
    
  • 어떤 줄도 공백으로 시작하거나 끝날 수 없습니다 (마지막 줄은 공백으로 끝날 수는 없습니다).

  • 마지막 단어는 각 단어 사이에 단일 공백이 포함 된 자리를 유지해야합니다. 원하는 경우 임의의 공백 / 줄 바꿈이 올 수 있지만 필수는 아닙니다.

  • 단어는 AZ, az, 0-9 및 간단한 구두점 ( .,'()&)으로 구성됩니다.

  • 단어 조각이 대상 너비보다 길지 않을 것이라고 가정 할 수 있으며 규칙에 따라 항상 줄을 채울 수 있습니다 (즉, 각 줄에 최소 2 개의 단어 조각이 있거나 줄을 채우는 1 개의 단어 조각이 있음) 아주)

  • 이전 줄의 단어 문자 수를 최대화하는 하이픈 넣기 지점을 선택해야합니다.

    This is an input stri-ng with hyph-en-at-ion poi-nts.
    
    This     is     an     input    stri-      <-- not permitted
    ng with hyphenation points.
    
    This  is an  input string  with hyph-      <-- not permitted
    enation points.
    
    This is an input  string with hyphen-      <-- OK
    ation points.
    
  • 바이트 단위의 최단 코드 승리

Width: 20
Text:  The q-uick brown fox ju-mp-s ove-r t-h-e lazy dog.

The quick  brown fox
jumps over the  lazy
dog.

Width: 32
Text: Given a width and a block of text cont-ain-ing pos-sible hyphen-ation points, for-mat it ful-ly-just-ified (in mono-space).

Given  a width  and  a block  of
text containing possible hyphen-
ation points,  format it  fully-
justified (in monospace).

Width: 80
Text:  Pro-gram-ming Puz-zles & Code Golf is a ques-tion and ans-wer site for pro-gram-ming puz-zle enth-usi-asts and code golf-ers. It's built and run by you as part of the St-ack Exch-ange net-work of Q&A sites. With your help, we're work-ing to-g-et-her to build a lib-rary of pro-gram-ming puz-zles and their sol-ut-ions.

Programming Puzzles &  Code Golf  is a question and answer  site for programming
puzzle enthusiasts  and code golfers.  It's built and run  by you as part of the
Stack Exchange network  of Q&A sites. With your help,  we're working together to
build a library of programming puzzles and their solutions.

Width: 20
Text:  Pro-gram-ming Puz-zles & Code Golf is a ques-tion and ans-wer site for pro-gram-ming puz-zle enth-usi-asts and code golf-ers. It's built and run by you as part of the St-ack Exch-ange net-work of Q&A sites. With your help, we're work-ing to-g-et-her to build a lib-rary of pro-gram-ming puz-zles and their sol-ut-ions.

Programming  Puzzles
&  Code  Golf  is  a
question and  answer
site for programming
puzzle   enthusiasts
and  code   golfers.
It's  built  and run
by  you  as  part of
the  Stack  Exchange
network    of    Q&A
sites.   With   your
help,  we're working
together to  build a
library of  program-
ming   puzzles   and
their solutions.

Width: 5
Text:  a b c d e f g h i j k l mm nn oo p-p qq rr ss t u vv ww x yy z

a b c
d e f
g h i
j k l
mm nn
oo pp
qq rr
ss  t
u  vv
ww  x
yy z

Width: 10
Text:  It's the bl-ack be-ast of Araghhhhh-hhh-h-hhh-h-h-h-hh!

It's   the
black  be-
ast     of
Araghhhhh-
hhhhhhhhh-
hhh!

예, 마지막으로 또 다른 텍스트 기반의 타이포그래피 과제 :-)
ETHproductions

1
@ Adám yes to builtins : 코드 제한이 없으며 코드가 가장 짧습니다. 물론 지루한 답변이 될 수도 있습니다! 라이브러리의 경우 라이브러리를 자유롭게 사용할 수 있고 답변을 "language + library"로 표시 할 수 있습니다. 또한 라이브러리 버전은이 문제를 해결해야합니다.
Dave

1
행이 하이픈이나 단일 문자 (예 : anybod-y너비 7)로 끝날 수있는 경우 anybody또는 anybod-\ny?
darrylyeo

1
@JonathanAllan 예; 죄송합니다, 수정하겠습니다
Dave

3
@darrylyeo이 경우 전체 단어를 출력 할 필요가 없습니다. 각 행에 가능한 한 많은 단어 문자를 탐욕스럽게 가져야하기 때문입니다.
Dave

답변:


7

자바 스크립트 (ES6), 218 바이트

w=>s=>s.map((c,i)=>c.map((p,j)=>(k+p)[l="length"]-w-(b=!i|j>0)+(j<c[l]-1)<0?k+=b?p:" "+p:(Array(w-k[l]-b).fill(h=k.split` `).map((_,i)=>h[i%(h[l]-1)]+=" "),o.push(h.join` `+(b?"-":"")),k=p)),o=[],k="")&&o.join`
`+`
`+k

카레 구문 ( f(width)(text))으로 인수를 취하고 텍스트 입력은 챌린지에 설명 된 이중 배열 형식입니다. 문자열은을 통해 해당 형식으로 변환됩니다 .split` `.map(a=>a.split`-`)). 또한 개행은 템플릿 문자열 내의 리터럴 개행입니다.

언 골프 및 재배치

width=>string=> {
    out=[];
    line="";
    string.map((word,i)=> {
        word.map((part,j)=> {

            noSpaceBefore = i==0 || j>0;
            if ((line+part).length - width - noSpaceBefore + (j<word.length-1) < 0) {
                line += noSpaceBefore ? part : " "+part;
            }
            else {
                words=line.split` `;
                Array(width - line.length - noSpaceBefore).fill()
                    .map((_,i) => words[i % (words.length-1)] += " ");
                out.push(words.join(" ") + (noSpaceBefore? "-" : ""));
                line=part;
            }
        });
    });
    return out.join("\n") + "\n"+line
}

여기서 아이디어는 전체 문자열의 각 부분을 단계별로 실행하여 한 번에 한 줄씩 한 줄씩 작성하는 것입니다. 줄이 완성되면 여분의 공백이 모두 배치 될 때까지 단어 간격이 왼쪽에서 오른쪽으로 증가합니다.

테스트 스 니펫

f=
w=>s=>s.map((c,i)=>c.map((p,j)=>(k+p)[l="length"]-w-(b=!i|j>0)+(j<c[l]-1)<0?k+=b?p:" "+p:(Array(w-k[l]-b).fill(h=k.split` `).map((_,i)=>h[i%(h[l]-1)]+=" "),o.push(h.join` `+(b?"-":"")),k=p)),o=[],k="")&&o.join`
`+`
`+k
<style>*{font-family:Consolas,monospace;}</style>
<div oninput="O.innerHTML=f(+W.value)(S.value.split` `.map(a=>a.split`-`))">
Width: <input type="number" size="3" min="5" max="100" id="W">
Tests: <select id="T" style="width:20em" oninput="let x=T.value.indexOf(','),s=T.value;W.value=s.slice(0,x);S.value=s.slice(x+2)"><option></option><option>20, The q-uick brown fox ju-mp-s ove-r t-h-e lazy dog.</option><option>32, Given a width and a block of text cont-ain-ing pos-sible hyphen-ation points, for-mat it ful-ly-just-ified (in mono-space).</option><option>80, Pro-gram-ming Puz-zles & Code Golf is a ques-tion and ans-wer site for pro-gram-ming puz-zle enth-usi-asts and code golf-ers. It's built and run by you as part of the St-ack Exch-ange net-work of Q&A sites. With your help, we're work-ing to-g-et-her to build a lib-rary of pro-gram-ming puz-zles and their sol-ut-ions.</option><option>20, Pro-gram-ming Puz-zles & Code Golf is a ques-tion and ans-wer site for pro-gram-ming puz-zle enth-usi-asts and code golf-ers. It's built and run by you as part of the St-ack Exch-ange net-work of Q&A sites. With your help, we're work-ing to-g-et-her to build a lib-rary of pro-gram-ming puz-zles and their sol-ut-ions.</option><option>5, a b c d e f g h i j k l mm nn oo p-p qq rr ss t u vv ww x yy z</option><option>10, It's the bl-ack be-ast of Araghhhhh-hhh-h-hhh-h-h-h-hh</option></select><br>
Text: &nbsp;<textarea id="S" cols="55" rows="4"></textarea>
</div>
<pre id="O" style="border: 1px solid black;display:inline-block;"></pre>


8

GNU sed -r, 621 바이트

입력을 두 줄로 가져옵니다. 너비는 단항 수로, 문자열은 초로 표시합니다.

나는 이것이 훨씬 더 골프를 칠 수 있다고 확신하지만 이미 너무 많은 시간을 버렸습니다.

x;N
G
s/\n/!@/
:
/@\n/bZ
s/-!(.*)@ /\1 !@/
s/!(.*[- ])(@.*1)$/\1!\2/
s/@(.)(.*)1$/\1@\2/
s/-!(.*-)(@.*)\n$/\1!\2\n1/
s/(\n!@) /\1/
s/-!(.* )(@.*)\n$/\1!\2\n1/
s/-!(.*-)(@.*1)$/\1!\21/
s/!(.*)-@([^ ]) /\1\2!@ /
t
s/ !@(.*)\n$/\n!@\1#/
s/!(.*-)@(.*)\n$/\1\n!@\2#/
s/!(.*)(@ | @)(.*)\n$/\1\n!@\3#/
s/-!(.*[^-])@([^ ]) (.*)\n$/\1\2\n!@\3#/
s/!(.+)@([^ ].*)\n$/\n!@\1\2#/
/#|!@.*\n$/{s/#|\n$//;G;b}
:Z
s/-?!|@.*//g
s/ \n/\n/g
s/^/%/
:B
G
/%.*\n.+\n/!bQ
:C
s/%([^\n])(.*)1$/\1%\2/
tC
s/([^\n]+)%\n/%\1\n/
:D
s/%([^ \n]* )(.*)1$/\1 %\2/
tD
s/(^|\n)([^\n]+)%(.*1)$/\1%\2\3/
tD
s/%([^\n]*)\n(.*)\n$/\1\n%\2/
tB
:Q
s/%(.*)\n1*$/\1/

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

설명

이 프로그램은 두 단계로 진행됩니다 : 1. 분할 및 2. 정당화. 아래의 경우 입력이 다음과 같다고 가정하십시오.

111111111111
I re-mem-ber a time of cha-os, ru-ined dreams, this was-ted land.

설정

먼저 입력을 읽고 첫 번째 줄 (단항 숫자)을 보류 공간 ( x)으로 이동 한 후 다음 행 ( N) 을 추가 한 다음 보류 공간 ( G)에서 패턴 공간으로 너비의 사본 을 추가합니다 . N우리를 선행으로 남겨 두었 으므로 \n그것을로 대체합니다 !@. 1 단계에서 커서로 사용합니다.

x;N
G
s/\n/!@/

이제 보류 공간의 내용은 1111111111111(그리고 이후 변경되지 않음) 패턴 공간은 (sed의 "명확하게 인쇄" l명령 형식으로 ) :

!@I re-mem-ber a time of cha-os, ru-ined dreams, this was-ted land.\n111111111111$

1 단계

1 단계에서 기본 @커서는 한 번에 한 문자 씩 전진하며 각 문자마다 a 1가 패턴 공간의 끝에서 "카운터"에서 제거됩니다. 즉, @foo\n111$, f@oo\n11$, fo@o\n1$, 등

!뒤에서 커서 산책로 @카운터가 라인의 중간에 0에 도달하면 장소를 표시 커서, 우리는 깨질 수 있습니다. 몇 라운드는 다음과 같습니다.

!@I re-mem-ber a time of cha-os, ru-ined dreams, this was-ted land.\n111111111111$
!I@ re-mem-ber a time of cha-os, ru-ined dreams, this was-ted land.\n11111111111$
!I @re-mem-ber a time of cha-os, ru-ined dreams, this was-ted land.\n1111111111$

여기에 우리가 인식하는 패턴이 @있습니다. 바로 뒤에 공백이 있습니다. 카운터가 0보다 크므로 중단 마커를 진행 한 다음 기본 커서를 계속 진행합니다.

I !@re-mem-ber a time of cha-os, ru-ined dreams, this was-ted land.\n1111111111$
I !r@e-mem-ber a time of cha-os, ru-ined dreams, this was-ted land.\n111111111$
I !re@-mem-ber a time of cha-os, ru-ined dreams, this was-ted land.\n11111111$
I !re-@mem-ber a time of cha-os, ru-ined dreams, this was-ted land.\n1111111$

또 다른 패턴이 있습니다 :. -@카운터에 여전히 7이 있으므로 중단 커서를 다시 진행시키고 계속 진행합니다.

I re-!mem-@ber a time of cha-os, ru-ined dreams, this was-ted land.\n111$

다른 패턴이 있습니다 : 브레이크 커서 바로 앞의 하이픈과 메인 커서 앞의 하이픈. 첫 번째 하이픈을 제거하고 나누기 커서를 진행 한 다음 문자를 제거 했으므로 카운터에 1을 추가합니다.

I remem-!@ber a time of cha-os, ru-ined dreams, this was-ted land.\n1111$

메인 커서를 계속 진행합니다 :

I remem-!ber@ a time of cha-os, ru-ined dreams, this was-ted land.\n1$

이전과 유사하지만 이번에는 기본 커서가 하이픈 뒤에 오는 것이 아니라 공백보다 우선합니다. 하이픈을 제거하지만 주 커서도 진행하므로 카운터를 줄이지 않습니다.

I remember !@a time of cha-os, ru-ined dreams, this was-ted land.\n1$
I remember !a@ time of cha-os, ru-ined dreams, this was-ted land.\n$

마지막으로 카운터가 0에 도달했습니다. 기본 커서 다음의 문자는 공백이므로 개행을 삽입하고 두 커서를 바로 뒤에 놓습니다. 그런 다음 카운터를 보충하고 ( G) 다시 시작하십시오.

I remember a\n!@ time of cha-os, ru-ined dreams, this was-ted land.\n111111111111$

1 단계는 @커서가 문자열의 끝에 도달 할 때까지 커서를 전진시키고 다양한 패턴과 일치 시킵니다.

# Phase 1
:
  # End of string; branch to :Z (end of phase 1)
  /@\n/bZ

  # Match -!.*@_
  s/-!(.*)@ /\1 !@/

  # Match [-_]@ and >0
  s/!(.*[- ])(@.*1)$/\1!\2/

  # Advance cursor
  s/@(.)(.*)1$/\1@\2/

  # Match -!.*-@ and 0; add 1
  s/-!(.*-)(@.*)\n$/\1!\2\n1/

  # Match \n!@_
  s/(\n!@) /\1/

  # Match -!.*_@ and 0; add 1
  s/-!(.* )(@.*)\n$/\1!\2\n1/

  # Match -!.*-@ and >0; add 1
  s/-!(.*-)(@.*1)$/\1!\21/

  # Match -@[^_]_
  s/!(.*)-@([^ ]) /\1\2!@ /

  # If there were any matches, branch to `:`
  t

  # Match _!@ and 0
  s/ !@(.*)\n$/\n!@\1#/

  # Match -@ and 0
  s/!(.*-)@(.*)\n$/\1\n!@\2#/

  # Match @_|_@ and 0
  s/!(.*)(@ | @)(.*)\n$/\1\n!@\3#/

  # Match -!.*[^-]@[^_]_ and 0
  s/-!(.*[^-])@([^ ]) (.*)\n$/\1\2\n!@\3#/

  # Match !.+@[^_] and 0
  s/!(.+)@([^ ].*)\n$/\n!@\1\2#/

  # Match marked line (#) or !@ and 0
  /#|!@.*\n$/{
    # Remove mark; append width and branch to `:`
    s/#|\n$//
    G
    b
  }

:Z

# Cleanup
s/-?!|@.*//g
s/ \n/\n/g

1 단계가 끝나면 패턴 공간은 다음과 같습니다.

I remember a\ntime of cha-\nos, ruined\ndreams, this\nwasted land.

또는:

I remember a
time of cha-
os, ruined
dreams, this
wasted land.

2 단계

2 단계 %에서 커서로 사용하고 다음과 같이 카운터를 비슷한 방식으로 사용합니다.

%I remember a\ntime of cha-\nos, ruined\ndreams, this\nwasted land.\n111111111111$

먼저, 커서를 진행시키고 카운터에서 1을 제거하여 첫 번째 줄의 문자 수를 계산합니다.

I remember a%\ntime of cha-\nos, ruined\ndreams, this\nwasted land.\n$

카운터가 0이므로이 줄에서 다른 작업을 수행하지 않습니다. 두 번째 줄에는 카운터와 동일한 문자 수가 있으므로 세 번째 줄로 건너 뛰겠습니다.

I remember a\ntime of cha-\nos, ruined%\ndreams, this\nwasted land.\n11$

카운터가 0보다 크므로 커서를 줄의 처음으로 다시 이동합니다. 그런 다음 첫 번째 공백을 찾아서 공백을 추가하여 카운터를 줄입니다.

I remember a\ntime of cha-\nos, % ruined\ndreams, this\nwasted land.\n1$

카운터가 0보다 큽니다. 커서가 이미 줄의 마지막 (유일한) 공간에 있으므로 커서를 줄의 처음으로 이동 한 후 다시 수행하십시오.

I remember a\ntime of cha-\nos,  % ruined\ndreams, this\nwasted land.\n$

이제 카운터는 0이므로 커서를 다음 줄의 시작 부분으로 이동합니다. 우리는 마지막을 제외한 모든 줄에 대해 이것을 반복합니다. 이것이 2 단계의 끝과 프로그램의 끝입니다! 최종 결과는 다음과 같습니다.

I remember a
time of cha-
os,   ruined
dreams, this
wasted land.
# Phase 2
# Insert cursor
s/^/%/
:B
  # Append counter from hold space
  G
  # This is the last line; branch to :Q (end of phase 1)
  /%.*\n.+\n/!bQ

  :C
    # Count characters
    s/%([^\n])(.*)1$/\1%\2/
    tC

  # Move cursor to beginning of line
  s/([^\n]+)%\n/%\1\n/

  :D
    # Add one to each space on the line as long as counter is >0
    s/%([^ \n]* )(.*)1$/\1 %\2/
    tD

    # Counter is still >0; go back to beginning of line
    s/(^|\n)([^\n]+)%(.*1)$/\1%\2\3/
    tD

    # Counter is 0; move cursor to next line and branch to :B
    s/%([^\n]*)\n(.*)\n$/\1\n%\2/
    tB

:Q

# Remove cursor, any remaining 1s
s/%(.*)\n1*$/\1/

이것은 믿어지지 않지만 사용하여 실행할 때 gsed (GNU sed) 4.4얻을 수 gsed: -e expression #1, char 16: ":" lacks a label있습니다. 정확히 어떻게 호출하는지 메모를 추가 할 수 있습니까? (사용하고 있습니다 printf "%s\n%s" "$1" "$2" | gsed -r '<code here>';)
Dave

@Dave GNU sed 4.2에서 작동합니다. 요점은 다음과 같습니다. gist.github.com/jrunning/91a7584d95fe10ef6b036d1c82bd385c TiO의 sed 페이지는 -r플래그 를 존중하지 않는 것 같습니다. 따라서 TiO 링크가 bash 페이지로 이동합니다.
Jordan

아, 나는 TiO 링크를 눈치 채지 못했다. 그것은 나를 위해 할 것입니다; +1하세요! 마지막 예제에는 2 개의 작은 실수가 있습니다 ( "검은 짐승") : 두 번째 줄부터 마지막 ​​줄까지 한 문자를 인쇄하고 마지막 문자를 !놓칩니다 ( !가능한 특수 문자 목록에서 누락되었으므로 그것을 반대하지 않습니다).
Dave

5

자바 스크립트 (ES6), 147 바이트

로 입력을 (width)(text)받습니다.

w=>F=(s,p=S=' ')=>(g=([c,...b],o='',h=c=='-')=>c?o[w-1]?c==S&&o+`
`+F(b):o[w+~h]?o+c+`
`+F(b):c>S?g(b,h?o:o+c):g(b,o+p)||g(b,o+p+c):o)(s)||F(s,p+S)

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

댓글

w =>                              // w = requested width
  F = (                           // F is a recursive function taking:
    s,                            //   s = either the input string (first iteration) or an
                                  //       array of remaining characters (next iterations)
    p =                           //   p = current space padding
    S = ' '                       //   S = space character
  ) => (                          //
    g = (                         // g is a recursive function taking:
      [c,                         //   c   = next character
          ...b],                  //   b[] = array of remaining characters
      o = '',                     //   o   = output for the current line
      h = c == '-'                //   h   = flag set if c is a hyphen
    ) =>                          //
      c ?                         // if c is defined:
        o[w - 1] ?                //   if the line is full:
          c == S &&               //     fail if c is not a space
          o + `\n` + F(b)         //     otherwise, append o + a linefeed and process the
                                  //     next line
        :                         //   else:
          o[w + ~h] ?             //     if this is the last character and c is a hyphen:
            o + c + `\n` + F(b)   //       append o + c + a linefeed and process the next
                                  //       line
          :                       //     else, we process the next character:
            c > S ?               //       if c is not a space:
              g(b, h ? o : o + c) //         append c if it's not a hyphen
            :                     //       else:
              g(b, o + p) ||      //         append either the current space padding
              g(b, o + p + c)     //         or the current padding and one extra space
      :                           // else:
        o                         //   success: return o
  )(s)                            // initial call to g() with s
  || F(s, p + S)                  // in case of failure, try again with a larger padding



1

파이썬 2 , 343 바이트

W,T=input()
T+=' '
L,l=[],len
while T:
 p,r=0,''
 for i in range(l(T)):
  s=T[:i].replace('-','')
  if'-'==T[i]:s+='-'
  if T[i]in' -'and W-l(s)>=0:p,r=i,s
 R=r.split()
 if R:
  d,k=W-l(''.join(R)),0
  for j in range(d):
   R[k]+=' '
   k+=1
   if k==l(R)-1:k=0
  L+=[''.join(R)]
  T=T[p+1:]
print'\n'.join(L[:-1])
print' '.join(L[-1].split())

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

The  input  is a block of text
containing possibly hyphenated
words.  For  each space/hyphen
position  p  the code computes
l(p)  the  length  of the line
induced  by  slipping the text
to this space/hyphen. Then the
code choses the position p for
which  the  length l(p) is the
closest  to  the given width W
(and  l(p)<=W).  If l(p)<W the
code  adds spaces  fairly  in-
between  the  words to achieve
the length W.

입력은 원하는 형식이더라도 STDIN 또는 매개 변수에서 가져와야합니다. I / O의 기본값을 참조하십시오 . 우리는 일반적으로 "입력"이 사전 할당 된 변수로부터 오는 것을 허용하지 않습니다.
mbomb007

print'\n'.join(L[:-1])대신 다음을 수행하여 바이트를 절약 할 수 있습니다.for e in L[:-1]:print e
mbomb007

@ mbomb007 ok yes I / O를 존중하기 위해 필요한 변경을 할 것입니다
mdahmoune
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.