Thách thức của bạn là định dạng một danh sách các từ trên nhiều dòng không dài hơn một số ký tự cho trước, sao cho mỗi dòng chứa càng nhiều từ càng tốt và không có từ nào bị cắt một cách không cần thiết.

Đầu vào

Đầu vào sẽ là một danh sách các từ được phân tách bằng dấu cách và sau đó là một số ít nhất là 4.

Đầu ra

Đầu ra phải là các từ đầu vào được nhóm thành các dòng sao cho không có dòng nào chứa nhiều ký tự hơn số đầu vào. Các từ nên được xuất theo thứ tự chúng là đầu vào. Các từ nên được phân tách bằng dấu phẩy và sau đó là khoảng trắng, ngoại trừ ở cuối mỗi dòng, nơi không gian không cần thiết. Nếu một từ quá dài để khớp với một dòng, thì nó nên bị cắt càng ít càng tốt trong khi tuân theo các quy tắc khác và "..." nên được thêm vào cuối.

Các trường hợp thử nghiệm

Input:
foo bar baz qux 12

Output:
foo, bar,
baz, qux


Input:
foo bar baz qux 5

Output:
foo,
bar,
baz,
qux


Input:
strength dexterity constitution intelligence wisdom charisma 10

Output:
strength,
dexterity,
consti...,
intell...,
wisdom,
charisma


Input:
quas wex exort 4

Output:
...,
wex,
e...

Không thể đọc được , 2559 byte

Thử thách này rất phù hợp với Unreadable.

Phiên bản đầu tiên của nó là 3379 byte, chỉ để cho bạn biết tôi đã chơi golf này bao nhiêu.

Chương trình chấp nhận đầu vào chính xác như được mô tả trong thử thách: danh sách các từ được phân tách bằng dấu cách (cũng có thể chứa các chữ số và dấu chấm câu), theo sau là khoảng trắng và số nguyên ít nhất là 4 (số thấp hơn tạo ra các vòng lặp vô hạn) .

"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" ""

Giải trình

Tôi sẽ hướng dẫn bạn cách chương trình xử lý đầu vào thyme horseradish peppermint 10. Sản lượng dự kiến ​​là thyme,\nhorser...,\npeppermint.

Đầu tiên chúng ta bắt đầu ở ô số 7 và đọc toàn bộ đầu vào, nhưng trừ 32 từ mỗi ký tự để khoảng trắng trở thành số không.

Vì các lý do rõ ràng, điều này để lại con trỏ đang chạy (được đặt tên p ở đây, được lưu trữ trong ô # 0) ở cuối. Chúng tôi sử dụng một vòng lặp while để tìm khoảng trống cuối cùng, đó là điểm bắt đầu của số xác định độ rộng của đầu ra (ô số 36 trong ví dụ này).

Bây giờ chúng tôi muốn giải mã số (tức là chuyển đổi từ số thập phân). Kết quả cuối cùng sẽ ở cả hai ô t và r . Chúng tôi dựa vào thực tế là họ bắt đầu từ con số không.

Đối với mỗi chữ số trong số, hãy làm như sau:

• Đặt t thành −15.
• Trong một vòng lặp while, giảm r (chứa kết quả cho đến nay) đến −1 (vì chúng ta cần lặp lại chính xác r , nhưng vì sự giảm giảm xảy ra trước khi nó được kiểm tra như điều kiện của vòng lặp while, việc giảm xuống 0 sẽ cho một lần lặp ít hơn) và với mỗi lần lặp, thêm 10 đến t . Bây giờ t chứa 10 lần kết quả trước đó trừ 15.
• Một lần nữa trong một vòng lặp while, giảm * p thành 0 và với mỗi lần lặp, thêm 1 vào t . Sau này t chứa các kết quả trung gian đúng cho đến nay: các nhân vật '0'để '9'có mã ASCII 48-57, vì vậy sau khi trừ trước của 32 họ là 16-25, vì vậy chúng tôi thực sự thêm 15-24 để t , mà hủy bỏ với -15 chúng tôi đặt nó sớm hơn. Điều quan trọng nữa là điều này thay đổi các ô được sử dụng để chứa các ký tự chữ số để mã tiếp theo có thể nhận ra phần cuối của danh sách các từ.
• Đặt r thành kết quả trung gian mới để lần lặp tiếp theo tìm thấy nó trong r . (Lưu ý rằng chúng ta không cần phải đọc lại từ t , chúng ta chỉ có thể sử dụng giá trị cuối cùng từ vòng lặp while trước đó vì chúng ta biết rằng * p không thể bằng 0, vì vậy nó đã chạy ít nhất một lần.)

Cuối cùng, chúng tôi sử dụng một vòng lặp while đơn giản khác (giảm t làm bộ đếm) để chuyển đổi số chúng tôi vừa tính thành đơn vị. Chúng tôi lưu trữ một chuỗi 1 giây đi từ trái sang ô số 0. Điều này phụ thuộc vào thực tế là ô số 1, con trỏ đang chạy của chúng tôi ( q ), bắt đầu từ 0. Chúng tôi nhận được ít hơn 1 giây vì trong khi các vòng lặp trong Unreadable giống như vậy:

Sau này, chúng ta không còn cần giá trị trong r nữa , vì vậy chúng ta sử dụng lại ô đó cho mục đích khác. Chúng tôi đặt lại các con trỏ p và q và khởi tạo một số ô có mã ký tự ASCII mà chúng tôi cần sau này. Tôi cũng đã dán nhãn c và s mà chúng tôi sẽ sử dụng sau này và chúng tôi sẽ dựa vào thực tế là bắt đầu từ 0:

Này, đợi một chút. Tại sao ô số 0 có màu đỏ? ... Chà, đây là để làm nổi bật một mánh khóe lén lút. Hãy nhớ rằng chúng tôi đầu ra 1 quá ít? Thủ thuật là chúng tôi sử dụng ô số 0 làm phần mở rộng của Google để sửa lỗi đó. Điều này hoạt động vì chúng ta biết rằng p sẽ không bao giờ bằng 0. Bằng cách này, khối màu đỏ hiện rộng 10 ô, chính xác là số chúng ta muốn. Nó cũng lưu 9 ký tự để có thể khởi tạo q thành 1 thay vì 0.

Bây giờ chúng ta nhập vòng lặp while đi qua các từ và xuất ra tất cả.

Bước 1: Tìm hiểu xem từ tiếp theo có phù hợp với dòng hiện tại không. Chúng tôi thực hiện điều này bằng cách di chuyển p sang phải và q trái với một vòng lặp while cho đến khi p chạm vào khoảng trống tiếp theo:

Bây giờ p ở bên phải của từ, chúng ta có thể kiểm tra xem đây có phải là từ cuối cùng trong danh sách hay không bằng cách kiểm tra xem * (p + 1) có bằng không. Chúng tôi cũng lưu trữ giá trị đó (mà trong ví dụ của chúng tôi là 72 vì đó là giá trị từ horseradish Lần trừ 32) trong c vì chúng tôi sẽ cần lại sau. Trong trường hợp này, nó không bằng 0, vì vậy chúng ta sẽ cần xuất một dấu phẩy cùng với từ đó, vì vậy từ này dài hơn một ký tự. Hãy tính đến điều này bằng cách giảm q thêm một lần nữa. Cuối cùng, sử dụng một vòng lặp while khác để di chuyển p trở lại đầu từ.

Bây giờ chúng ta biết rằng từ này sẽ phù hợp với dòng hiện tại vì q đang trỏ đến một giá trị khác không, vì vậy tất cả những gì chúng ta phải làm là:

• Di chuyển p về phía trước thông qua từ một lần nữa, in từng ký tự (cộng với 32, vì tất cả các mã ASCII bị tắt bởi 32).
• Nếu c khác không, hãy in dấu phẩy (sử dụng giá trị trong ô số 5).
• Đặt s thành giá trị khác không để chỉ ra lần lặp tiếp theo rằng chúng ta không còn ở đầu dòng và do đó cần xuất ký tự khoảng trắng trước từ tiếp theo. (Chúng tôi sử dụng lại giá trị trả về của câu lệnh in ở trên cho giá trị này là 44 cho dấu phẩy.)

Đầu ra cho đến nay: thyme,

Sau đó, lần lặp tiếp theo của vòng lặp lớn bắt đầu. Như trước đây, chúng tôi kiểm tra xem từ tiếp theo có khớp với phần còn lại của dòng hay không bằng cách giảm q khi chúng tôi đi qua từ từ trái sang phải. Lưu ý rằng q vẫn là −5 so với lần lặp trước, theo dõi số lượng ký tự chúng tôi đã in trong dòng hiện tại. Sau khi đếm các ký tự trong bộ cải ngựa, cộng với một ký tự cho dấu phẩy, cộng với một vì s khác không chỉ ra rằng chúng ta cũng cần xuất ra một khoảng trắng , q sẽ vượt quá phần cuối của khối 1s:

Bây giờ q chỉ vào một ô số 0, điều đó có nghĩa là cải ngựa không phù hợp với dòng hiện tại. Những gì chúng ta làm bây giờ phụ thuộc vào việc s có khác không. Trong trường hợp của chúng tôi, điều đó có nghĩa là chúng tôi cần phải bọc đến dòng tiếp theo. Tất cả chúng ta phải làm cho điều đó là:

• In một dòng mới (sử dụng ô số 3)
• Đặt q trở lại 1
• Đặt s thành 0

Đầu ra cho đến nay: thyme,\n

Đối với lần lặp tiếp theo, p ở cùng một vị trí như trước, vì vậy chúng ta sẽ xem xét lại cùng một từ. Như trước đây, chúng tôi đếm các nhân vật trong “cải ngựa”, bộ c đến 80 lần nữa khi chúng tôi nhận thấy có một từ khác sau này, sụt lần q cho dấu phẩy, và tua p lại phần đầu của từ này:

Như trong lần lặp lại trước, chúng ta thấy rằng cải ngựa vẫn không phù hợp vì q kết thúc trên một ô bằng không. Tuy nhiên, lần này s là số không, có nghĩa là chúng ta làm điều gì đó khác biệt so với thời gian qua. Chúng ta cần xuất một số từ, ba dấu chấm và dấu phẩy. Chiều rộng của chúng tôi là 10, vì vậy chúng tôi cần xuất 6 ký tự của từ. Chúng ta hãy xem nơi chúng ta kết thúc nếu chúng ta:

• Tìm điểm bắt đầu của khối màu đỏ 1s. Chúng ta có thể làm điều này bằng cách đi bên phải bởi vì chúng ta biết rằng q phải nằm bên trái của nó.
• Tăng q một lần nữa nếu chúng ta cũng cần xuất một dấu phẩy ( c ≠ 0).

Các băng bây giờ trông như thế này:

Tôi đã đánh dấu một khoảng 6 ô ở đây. Như bạn có thể thấy, chúng ta cần xuất các ký tự cho đến khi q = 1. Điều này rất hiệu quả để kiểm tra (về cơ bản, while ((++q)+1) { ... }). Vì thế:

• In các ký tự đó (cộng với 32, vì tất cả các mã ASCII bị tắt 32) cho đến khi q đạt −1. p sau đó sẽ ở ô 19, ở giữa chữ horseradish.
• In ba chấm. Vì lệnh in trả về đối số của chính nó, chúng ta có thể lồng mã một cách hiệu quả (về cơ bản, print(print(print('.')))). Chúng tôi lấy giá trị ASCII từ ô số 5 và thêm 2 vào nó để lấy mã ASCII của dấu chấm.
• Di chuyển p đến cuối từ. Vì chúng tôi biết rằng chúng tôi không thể đi đến cuối từ (vì từ này quá dài và chúng tôi phải xóa ít nhất 3 ký tự khỏi nó để khớp với các dấu chấm), nên vòng lặp này chắc chắn có ít nhất một lần lặp, vì vậy mã ngắn hơn để có phần thân của vòng lặp while tính giá trị ASCII cho dấu chấm và sau đó chuyển giá trị trả về của vòng lặp while cho các hàm in.
• In dấu phẩy nếu c khác không.

Sau tất cả những điều này, chúng tôi cũng in một dòng mới (sử dụng ô số 3) và đặt q trở lại 1. Chúng tôi cũng có thể đặt s thành 0 ngay cả khi nó đã là 0, điều này giống với những gì chúng tôi đã làm trước đây khi chúng tôi bọc dòng tiếp theo (khi s là khác không), vì vậy để tránh lặp lại mã, chúng tôi thực hiện sau khi có điều kiện kiểm tra s .

Đầu ra cho đến nay: thyme,\nhorser...,\n

Chỉ có một lần lặp lại. Lần này, sau khi đếm các chữ cái của từ, chúng ta nhận được điều này:

Lần này, không có gì sau p , vì vậy chúng tôi đặt c thành 0 để chỉ ra không có dấu phẩy, và theo đó chúng tôi không giảm q thêm một lần nữa. Vì q bây giờ trỏ vào một ô khác không, chúng tôi biết từ này sẽ phù hợp, do đó, mã tương tự được thực thi như trong lần lặp đầu tiên, ngoại trừ lần này c bằng 0, vì vậy đơn giản là nó sẽ không in dấu phẩy.

Đầu ra: thyme,\nhorser...,\npeppermint

Trong phần hướng dẫn này, tôi đã không bao gồm một trường hợp mã thực sự sẽ in một khoảng trắng, nhưng tôi nghĩ rằng nó sẽ khá rõ ràng ngay bây giờ. Nếu mã thấy rằng từ phù hợp ( * q 0) và s khác không, nó sẽ chỉ xuất ra một khoảng trắng trước từ.

JavaScript (ES6), 171

Là một hàm ẩn danh trả về đầu ra dưới dạng một mảng

(vì điều này thường được cho phép trừ khi bị cấm rõ ràng: meta meta )

s=>(s=s.split` `,n=s.pop()-1,t='',o=[],s.map((w,i)=>(w=w[n+=!s[i+1]]?w.slice(0,n-3)+'...':w,(t+w)[n-2]&&(t&&o.push(t.slice(1)),t=''),t+=` ${w},`)),o.push(t.slice(1,-1)),o)

f=s=>(s=s.split` `,n=s.pop()-1,t='',o=[],s.map((w,i)=>(w=w[n+=!s[i+1]]?w.slice(0,n-3)+'...':w,(t+w)[n-2]&&(t&&o.push(t.slice(1)),t=''),t+=` ${w},`)),o.push(t.slice(1,-1)),o)

// Less golfed
U=s=>(
  s=s.split` `,
  n=s.pop()-1,
  t='', // current line
  o=[], // output
  s.map( (w,i)=>(
    w=w[
      n+=!s[i+1] // space for 1 more char on the last line
    ]?w.slice(0,n-3)+'...':w, // change w if it is too long
    (t+w)[n-2]&& ( // if current line + w is too long, ouput t and reset current line
      t&&o.push(t.slice(1)),t=''
    ),
    t+=` ${w},`
  )),
  o.push(t.slice(1,-1)), // remove tailing comma on last line
  o
)

console.log=x=>O.textContent+=x+'\n\n';
  
console.log(f("foo bar baz qux 12").join`\n`)
console.log(f("foo bar baz qux 5").join`\n`)
console.log(f("strength dexterity constitution intelligence wisdom charisma 10").join`\n`)
console.log(f("quas wex exort 4").join`\n`)

<pre id=O></pre>

Python 2, 206 byte

i=input().split()
l=int(i.pop())
i=[[w[:l-4]+'...',w][len(w)<l]+','for w in i][:-1]+[[w,w[:l-3]+'...'][len(w)>l]]
r=[i.pop(0)]
for w in i:
 if len(r[-1])+len(w)<l:r[-1]+=' '+w
 else:r+=[w]
print'\n'.join(r)