^{ความท้าทายนี้คล้ายกับของเก่าแต่มีบางส่วนที่ไม่ชัดเจนของสเป็คที่ใช้ค้อนทุบและข้อกำหนด I / O ที่เข้มงวดน้อยกว่า}

เมื่อกำหนดอินพุตของสตริงที่ประกอบด้วย ASCII ที่พิมพ์ได้และบรรทัดใหม่เท่านั้นให้เอาต์พุตเมทริกต่างๆ (ไบต์, คำ, การนับบรรทัด)

เมทริกที่คุณต้องแสดงผลมีดังนี้:

• จำนวนไบต์ เนื่องจากสตริงอินพุตยังคงอยู่ภายใน ASCII นี่จึงเป็นจำนวนอักขระ

• การนับจำนวนคำ. นี่คือwcคำจำกัดความของคำว่า "word:" ลำดับใด ๆ ของ non-whitespace ตัวอย่างเช่นabc,def"ghi""word" หนึ่งคำ

• การนับบรรทัด นี่คือการอธิบายตนเอง อินพุตจะมีการขึ้นบรรทัดใหม่ที่ต่อท้ายเสมอซึ่งหมายความว่าการนับบรรทัดนั้นมีความหมายเหมือนกันกับ "การนับบรรทัดใหม่" จะไม่มีบรรทัดขึ้นต่อท้ายมากกว่าหนึ่งบรรทัด

เอาท์พุทจะต้องทำซ้ำwcเอาท์พุทเริ่มต้น(ยกเว้นชื่อไฟล์):

llama@llama:~$ cat /dev/urandom | tr -cd 'A-Za-z \n' | head -90 > example.txt
llama@llama:~$ wc example.txt
  90  165 5501 example.txt

โปรดทราบว่าการนับบรรทัดนั้นมาก่อนจากนั้นนับจำนวนคำและในที่สุดก็นับไบต์ นอกจากนี้การนับแต่ละรายการจะต้องมีเบาะด้านซ้ายด้วยช่องว่างเพื่อให้มีความกว้างเท่ากัน ในตัวอย่างข้างต้น5501คือหมายเลข "ยาวที่สุด" ที่มี 4 หลักดังนั้นจึง165มีเบาะหนึ่งช่องว่างและ90สอง ในที่สุดตัวเลขทั้งหมดต้องรวมเข้าด้วยกันเป็นสตริงเดียวโดยมีช่องว่างระหว่างแต่ละหมายเลข

เนื่องจากนี่คือcode-golfรหัสที่สั้นที่สุดเป็นไบต์จะเป็นผู้ชนะ

(โอ้และโดยวิธี ... คุณไม่สามารถใช้wcคำสั่งในคำตอบของคุณในกรณีที่ยังไม่ชัดเจน)

กรณีทดสอบ ( \nหมายถึงการขึ้นบรรทัดใหม่คุณอาจต้องเลือกการขึ้นบรรทัดใหม่ที่ต่อท้ายเช่นกัน):

"a b c d\n" -> "1 4 8"
"a b c d e f\n" -> " 1  6 12"
"  a b c d e f  \n" -> " 1  6 16"
"a\nb\nc\nd\n" -> "4 4 8"
"a\n\n\nb\nc\nd\n" -> " 6  4 10"
"abc123{}[]()...\n" -> " 1  1 16
"\n" -> "1 0 1"
"   \n" -> "1 0 4"
"\n\n\n\n\n" -> "5 0 5"
"\n\n\na\nb\n" -> "5 2 7"

Perl, 49 ไบต์

เพิ่ม +3 สำหรับ -an0

อินพุตบน STDIN หรือ 1 ชื่อไฟล์ขึ้นไปเป็นอาร์กิวเมนต์ เรียกใช้เป็นperl -an0 wc.pl

wc.pl:

/\z/g;pos=~//;printf"%@+d %@+d $`
",y/
//,~~@F

คำอธิบาย:

-n0      slurps the whole input into $_ and says we will do our own printing
-a       tells perl to split the input on whitespace into array @F
/\z/g    Matches the absolute end of the input. g modifier so the position 
         is remembered in pos which will now contain the input length
pos=~//  An empy regex repeats the last succesful match, so /\z/ again.
         After that $` will contain the the number of input characters and
         the array @+ will contain the length of this number
printf   All preparation is complete, we can go print the result
"%@+d"   will become e.g. %6d if the number of characters is a number of
         length 6, so lines and words will get printed right aligned 
         in a field of length 6.
$`       $` we can directly interpolate since it won't contain a %
y/\n//   Count the number of newlines in $_
~~@F     The array of words @F in scalar context gives the number of words

Python 2, 100 77 ไบต์

วิธีนี้เป็นฟังก์ชั่น Python ที่ยอมรับสตริงแบบหลายบรรทัดและพิมพ์จำนวนที่ต้องการเป็น stdout โปรดทราบว่าฉันใช้สตริงรูปแบบเพื่อสร้างสตริงรูปแบบ (ซึ่งต้องใช้%%เพื่อหลีกเลี่ยงตัวยึดรูปแบบแรก)

แก้ไข: บันทึก 23 ไบต์เนื่องจากการเพิ่มประสิทธิภาพการพิมพ์โดย Dennis

def d(b):c=len(b);a='%%%us'%len(`c`);print a%b.count('\n'),a%len(b.split()),c

ก่อนหน้าตัวย่อดูเหมือนว่า:

def wc(text) :
    size = len(text);
    numfmt = '%%%us' % len(`size`);
    print numfmt % text.count('\n'), numfmt % len(text.split()), size

Pyth, 21 ไบต์

jdm.[;l`lQ`ld[@bQcQ)Q

ชุดทดสอบ

Pyth มี built-in ที่ดีมาก ๆ อยู่ที่นี่ เราเริ่มต้นด้วยการสร้าง list ( [) ของการขึ้นบรรทัดใหม่ใน string ( @bQ), คำใน string ( cQ)) และ string เอง ( Q) จากนั้นเราตัด ( .[) ความยาวของแต่ละสตริง ( ld) ด้วยช่องว่าง ( ;ในบริบทนี้) ออกไปตามความยาวของจำนวนอักขระ ( l`lQ) สุดท้ายเข้าร่วมในช่องว่าง ( jd)

POSIX awk, 79 75 67 65 ไบต์

{w+=NF;c+=length+1}END{d=length(c)"d %";printf"%"d d"d\n",NR,w,c}

แก้ไข: บันทึก 4 ไบต์ตั้งแต่ POSIX ช่วยให้เปลือยlengthบันทึก 7 ไบต์ลดโดยส่วนหนึ่งภาวนาและบันทึกไว้สองไบต์ขอบคุณที่ปลาย Doorknob สำหรับการเพิ่มการd %d

นี่เป็นครั้งแรกสำหรับ GNU awk แต่ที่ดีที่สุดที่ฉันสามารถบอกได้ก็คือใช้ฟังก์ชั่น POSIX awk เท่านั้น

รูปแบบที่ดีขึ้น:

gawk '{
  w += NF
  c += length($0) + 1  # length($0) misses the newline
}
END {
  d = length(c) # GNU awk's length returns the length of string representation of number
  printf "%"d"d %"d"d %d\n", NR, w, c
}'

อย่างจริงจัง 39 ไบต์

"
 "╩╜l;$l╝@╜sl'
╜ck`#╛#"{:>%d}"%f`M' j

ลองออนไลน์!

คำอธิบาย (บรรทัดใหม่ถูกแทนที่ด้วย\n):

"\n "╩╜l;$l╝@╜sl'\n╜ck`#╛#"{:>%d}"%f`M' j
"\n "                                      push a string containing a newline and a space
     ╩                                     push input to register 0 (we'll call it s)
      ╜l;                                  push two copies of len(s) (byte count)
         $l╝                               push len(str(len(s))) to register 1
                                            (this will serve as the field width in the output)
            @╜sl                           push word count by getting the length of the list formed by
                                            splitting s on spaces and newlines
                '\n╜c                      count newlines in input
                     k                     push stack to list
                      `#╛#"{:>%d}"%f`M     map:
                       #                     listify
                        ╛#                   push reg 1 (field width), listify
                          "{:>%d}"           push that string
                                  %          do old-style string formatting for field width
                                   f         do new-style string formatting to pad the field appropriately
                                      ' j  join on spaces

AppleScript 253 ไบต์

นี่ถือว่าสมมติว่าตัวคั่นรายการข้อความของ AppleScript ถูกกำหนดเป็นที่ว่าง (ถ้าฉันต้องการนับสิ่งของที่จะบังคับให้มีการสันนิษฐานฉันจะเพิ่มมัน)

set w to(display dialog""default answer"")'s text returned
set x to b(w)
set y to w's text item's number
set z to w's paragraph's number
a(x,z)&z&a(x,y)&y&" "&x
on a(x,n)
set o to" "
repeat b(x)-b(n)
set o to o&" "
end
o
end
on b(n)
count(n as text)
end

CJam, 31 26 ไบต์

q_)/_S*S%@_]:,:s),f{Se[}S*

ลองออนไลน์!

มันทำงานอย่างไร

q_                         e# Read all input from STDIN and push two copies.
  )                        e# Pop the last character (linefeed) of the second copy.
   /                       e# Split the remaining string at linefeeds.
    _                      e# Push a copy.
     S*                    e# Join the copy, separating by spaces.
       S%                  e# Split at runs of spaces.
         @_                e# Rotate the original input on top and push a copy.
           ]               e# Wrap all four items in an array.
            :,             e# Get the length of each item.
              :s           e# Cast the lengths (integers) to strings.
                )          e# Pop the last length (byte count).
                 ,         e# Get the number of digits.
                  f{Se[}   e# Left-pad all three length with spaces to that length.
                        S* e# Join, separating by spaces.

Julia, 112 81 ไบต์

f(s,n=endof,l="$(n(s))",g=r->lpad(n(split(s,r))-1,n(l)))=g(r"\n")" "g(r"\S+")" "l

นี่คือฟังก์ชั่นที่ยอมรับสตริงและส่งคืนสตริง

เราบันทึกสิ่งต่อไปนี้เป็นฟังก์ชันอาร์กิวเมนต์:

• n = endof ฟังก์ชั่นซึ่งได้รับดัชนีล่าสุดของคอลเลกชันที่จัดทำดัชนีได้ (ในกรณีนี้คือความยาวของสตริง)
• l = "$(n(s))ความยาวของอินพุตที่แปลงเป็นสตริงโดยใช้การแก้ไข
• ฟังก์ชั่นแลมบ์ดาgที่ยอมรับการแสดงออกปกติและส่งกลับความยาว - 1 จากแยกข้อมูลเกี่ยวกับ regex lที่เหลือเบาะที่มีช่องว่างเพื่อให้ตรงกับความยาวของ

เราได้รับจำนวนบรรทัดที่ใช้g(r"\n")และจำนวนคำที่ใช้g(r"\S+")แล้วเราจะเข้าร่วมกับเหล่านั้นด้วยการlคั่นด้วยช่องว่าง

บันทึกแล้ว 31 ไบต์ขอบคุณ Dennis!

MATL, 38 ไบต์

'\n'32cZtttnGnw-wPZvPYbnqbnvvV!3Z"vX:!

คุณสามารถลองออนไลน์ได้! ไม่ควรนานขนาดนี้ ...

คำอธิบายสำหรับการคำนวณ

'\n'32cZt  %// Takes implicit input and replaces any \n with a space
tt         %// Duplicate that string twice
nGnw-w     %// Length of the string with \n's minus length with spaces to give number of \n's
PZvPYbnq   %// Take string with spaces, flip it, remove leading spaces, flip it again,
           %// split on spaces, find length and decrement for number of words
bn         %// get length of string with spaces, the number of characters

ส่วนสุดท้ายทำการฟอร์แมตเอาต์พุต

vvV!       %// concatenate the 3 numbers to a column vector, convert to string and transpose
3Z"v       %// make string '   ' and concatenate on the bottom of previous string
X:!        %// linearise and transpose to get correct output (impicitly printed)

JavaScript (ES6), 115 ไบต์

s=>[/\n\/g,/\S+/g,/[^]/g].map(r=>l=(s.match(r)||[]).length).map(n=>(' '.repeat(99)+n).slice(-`${l}`.length)).join` `

ไม่ต้องการอินพุตใด ๆ การจัดรูปแบบนั้นเจ็บปวด ถ้ามีขีด จำกัด บนอยู่กับปริมาณของการขยายที่ฉันสามารถลดบางสิ่งบางอย่างที่สั้นกว่าเช่น(' '.repeat(99)+n)` ${n}`

PowerShell 140 ไบต์

param($a)$c="$((($l=($a-split"`n").Count-1),($w=($a-split"\S+").Count-1),($b=$a.length)|sort)[-1])".Length;
"{0,$c} {1,$c} {2,$c}"-f$l,$w,$b

_{(ขึ้นบรรทัดใหม่เพื่อความชัดเจน: D)}

บรรทัดแรกรับอินพุต$aจากนั้นส่วนถัดไปคือคำสั่งเดียวทั้งหมด เรากำลังตั้ง$cเท่ากับบางสายของ .lengthสิ่งนี้จะทำให้เกิดช่องว่างภายในข้อกำหนดของเรา ข้างในสตริงนั้นเป็นบล็อคโค้ดทันที$(...)ดังนั้นโค้ดนั้นจะถูกประมวลผลก่อนที่จะถูกประเมินเข้าไปในสตริง

ในการป้องกันรหัสเราจะส่งสามรายการผ่านคำสั่งและการหนึ่งที่ใหญ่ที่สุด|sort (...)[-1]นี่คือที่เรามั่นใจได้ว่าจะได้คอลัมน์ที่มีความกว้างที่ถูกต้อง รายการทั้งสามคือ$lการนับบรรทัดที่เรา-splitขึ้นบรรทัดใหม่$wจำนวนคำที่เรา-splitอยู่ในช่องว่างและ$bความยาว

บรรทัดที่สองคือเอาต์พุตของเราโดยใช้-fโอเปอเรเตอร์ (ซึ่งเป็นแบบ pseudo-shorthand for String.Format()) มันเป็นอีกวิธีในการแทรกตัวแปรที่ขยายเข้าไปในสตริง ที่นี่เรากำลังบอกว่าเราต้องการให้เอาท์พุททั้งหมดเป็นเบาะไปทางซ้ายเพื่อให้แต่ละคอลัมน์$cกว้าง การเติมจะกระทำผ่านช่องว่าง 0, 1และ2สอดคล้องกับ$l, $wและ$bที่มีข้อโต้แย้งไปยังผู้ประกอบรูปแบบเพื่อให้การนับสายการนับจำนวนคำและนับไบต์มีเบาะและผลผลิตอย่างเหมาะสม

โปรดทราบว่าสิ่งนี้ต้องการสตริงที่มีการขยายบรรทัดใหม่แล้ว (เช่นการทำGet-Contentไฟล์ข้อความหรือบางอย่างจากนั้นทำการไพพ์หรือบันทึกลงในตัวแปรจากนั้นเรียกรหัสนี้ในอินพุตนั้น) หรือใช้ PowerShell- สไตล์อักขระการหลบหนีพร้อม backticks (หมายถึง`nแทน\n)

ตัวอย่าง

PS C:\Tools\Scripts\golfing> .\reimplement-wc.ps1 "This line`nis broken`ninto three lines.`n"
 3  7 38

เยลลี่ขนาด 14 ไบต์

»⁶Ḳ¹ƇLṭċ⁷$;LWG

ลองออนไลน์!

-1 ขอบคุณที่เดนนิส

Ruby, 108 ไบต์

f=->s{a=[s.count($/),s.split(/\S+/).size-1,s.size].map(&:to_s)
a.map{|b|" "*(a.map(&:size).max-b.size)+b}*" "}

Perl, 71 62 61 ไบต์

รวม +1 สำหรับ -n

$;=length($b+=y///c);$w+=split$"}{printf"%$;d %$;d $b",$.,$w

แสดงความคิดเห็น:

while (<>) {                         # implicit because of -n
    $; = length(                     # printf formatting: width
       $b += y///c                   # count characters
    );
    $w += split $"                   # count words
}{                                   # explicit: end while, begin END block
    printf "%$;d %$;d $b", $., $w    #  $. = $INPUT_LINE_NUMBER
}                                    # implicit because of -n

• บันทึกไบต์อื่นขอบคุณ @TonHospel อีกครั้ง
• บันทึก 9 ไบต์ด้วย @TonHospel แสดงให้ฉันเห็นเทคนิคการซื้อขาย!

Lua, 74 66 ไบต์

แข็งแรงเล่นกอล์ฟ:

t=arg[1]_,l=t:gsub('\n','')_,w=t:gsub('%S+','')print(l,w,t:len())

Ungolfed:

text = arg[1]
_,lines = text:gsub('\n','')
_,words = text:gsub('%S+','')
print(lines, words, text:len())

รับอินพุตผ่านอาร์กิวเมนต์บรรทัดคำสั่ง

เราเปลี่ยนชื่ออาร์กิวเมนต์แรก ( arg[1]) เพื่อบันทึกไบต์ string.gsubส่งคืนจำนวนการแทนที่รวมถึงสตริงที่มีการแก้ไขดังนั้นเราจึงใช้มันเพื่อนับเป็นครั้งแรก'\n'(ขึ้นบรรทัดใหม่) จากนั้น'%S+'(อินสแตนซ์ของอักขระที่ไม่ใช่ whitespace หนึ่งอักขระขึ้นไปให้มากที่สุดเท่าที่จะเป็นไปได้เช่นคำ) เราสามารถใช้ทุกอย่างที่เราต้องการสำหรับสตริงแทนที่ดังนั้นเราจึงใช้สตริงว่าง ( '') เพื่อบันทึกไบต์ จากนั้นเราก็ใช้string.lenเพื่อค้นหาความยาวของสตริงเช่นจำนวนไบต์ จากนั้นในที่สุดเราพิมพ์ทั้งหมด

เรติน่า 65

^((\S+)|(¶)|.)*
$#3 $#2 $.0
+`(\b(.)+ )(?!.*\b(?<-2>.)+$)
a$1
a
<space>

ลองออนไลน์!

ขั้นตอนแรกคือโปรแกรม wc จริงส่วนที่เหลือของมันคือการขยาย aสิ่งที่ตัวยึดคืออาจจะไม่จำเป็นและบางส่วนของกลุ่มอาจได้ง่ายนิด

Haskell, 140 ไบต์

import Text.Printf
w h=let{l=length;s=show.l;c=s h;m=s.words$h;n=s.lines$h;f=maximum$map l[c, m, n];p=printf"%*s"f}in p n++' ':p m++' ':p c

รุ่น ungolfed อยู่ที่นี่พร้อมกับตัวแปรที่ขยายและชื่อฟังก์ชั่น:

import Text.Printf

wc str =
  let charcount = show.length $ str
      wordcount = show.length.words $ str
      linecount = show.length.lines $ str
      fieldwidth = maximum $ map length [charcount, wordcount, linecount]
      printer = printf "%*s" fieldwidth
  in printer linecount ++ (' ' : printer wordcount ++ (' ' : printer charcount))

นี่คือฟังก์ชั่นที่ยอมรับสตริงและส่งคืนสตริง มันแค่ใช้Preludeฟังก์ชั่นwords(resp. lines) เพื่อรับจำนวนคำ (resp. lines) เนื่องจากดูเหมือนว่าพวกเขาจะใช้คำจำกัดความเดียวกันwcแล้วได้รับค่าที่ยาวที่สุด (เป็นสตริง) ระหว่างจำนวนและใช้รูปแบบ printf ความกว้างระหว่างอาร์กิวเมนต์สำหรับการจัดรูปแบบ

C, 180 178 ไบต์

#include <stdio.h>
#include <ctype.h>
main(b,w,l,c,d){d=' ';b=w=l=0;while((c=fgetc(stdin))!=EOF){if(!isspace(c)&&isspace(d))w++;b++;d=c;if(c==10)l++;}printf("%d %d %d\n",l,w,b);}

05AB1E , 24 23 ไบต์

¨¶¡¹… 
    S¡õK¹)€g§Zg>jJ¦

jขณะนี้ถูกบั๊กดังนั้นอาจมีขนาด 21 ไบต์หากไม่มี§และJ..

ลองมันออนไลน์หรือตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย:

¨          # Remove the trailing newline of the (implicit) input
 ¶¡        # And split it on newlines
¹… 
    S¡     # Take the first input again, and split it on [" \n\t"]
      õK   # Then remove all empty string items
¹          # And take the first input again as is
)          # Wrap all three value of the stack to a single list
 €g        # Take the length of each of the items
   §       # Cast the integers to strings (should have been implicit, but `j` is bugged)
    Z      # Take the max (always the last / amount of bytes) (without popping the list)
     g>    # Take the length + 1 of this max
       j   # Append leading spaces so all items or of this length
        J  # Join them together (should have been done by the `j` already, but it's bugged)
         ¦ # Remove the leading space (and output implicitly to STDOUT)

Pip -s , 25 ไบต์

sX##a-#_._M[nNa`\S+`Na#a]

รับสตริงหลายบรรทัดเป็นอาร์กิวเมนต์บรรทัดคำสั่ง ลองออนไลน์!

ขอบคุณคำตอบ CJam ของเดนนิสทำให้ฉันรู้ว่าจำนวนที่ยาวที่สุดนั้นจะนับจำนวนตัวละครเสมอ

คำอธิบาย

                           s is space; n is newline; a is 1st cmdline arg (implicit)
           [            ]  Construct a list of three elements:
            nNa             Number of newlines in a
               `\S+`Na      Regex search: number of runs of non-whitespace characters in a
                      #a    Length of a (i.e. number of characters in a)
          M                To each element of that list, map this function:
   #a                       Number of characters in a
  #                         Length of that number
     -#_                    Subtract length of each element
sX                          Construct a string of that many spaces
        ._                  Prepend it to the element
                           The resulting list is autoprinted, space-separated (-s flag)

ต่อไปนี้เป็นโซลูชันขนาด 29 ไบต์พร้อมธง-rsที่รับอินพุตจาก stdin:

[#g`\S+`NST:gY#g+1]MsX#y-#_._

ลองออนไลน์!

Powershell, 123 115 ไบต์

switch -r($args|% t*y){'\s'{$a=0}'\S'{$w+=!$a;$a=1}'(?s).'{$b++}'
'{$l++}}$c="$b".Length
"{0,$c} {1,$c} $b"-f$l,+$w

สคริปต์ทดสอบ:

$f = {

switch -r($args|% t*y){    # evaluate all matched cases
    '\s'   {$a=0}          # any whitespace (newline not included)
    '\S'   {$w+=!$a;$a=1}  # any not-whitespace (newline not included)
    '(?s).'{$b++}          # any char (newline included!)
    '`n'   {$l++}          # new line char
}
$c="$b".Length
"{0,$c} {1,$c} $b"-f$l,+$w


}

@(
    , ("a b c d`n", "1 4 8")
    , ("a b c d e f`n", " 1  6 12")
    , ("  a b c d e f  `n", " 1  6 16")
    , ("a`nb`nc`nd`n", "4 4 8")
    , ("a`n`n`nb`nc`nd`n", " 6  4 10")
    , ("abc123{}[]()...`n", " 1  1 16")
    , ("`n", "1 0 1")
    , ("   `n", "1 0 4")
    , ("`n`n`n`n`n", "5 0 5")
    , ("`n`n`na`nb`n", "5 2 7")
) | % {
    $s,$e = $_
    $r = &$f $s
    "$($e-eq$r): $r"
}

เอาท์พุท:

True: 1 4 8
True:  1  6 12
True:  1  6 16
True: 4 4 8
True:  6  4 10
True:  1  1 16
True: 1 0 1
True: 1 0 4
True: 5 0 5
True: 5 2 7

คำอธิบาย:

• $args|% t*y แยกสตริง arument ออกเป็น chars
• switch -r($args|% t*y)ประเมินทุกกรณีที่ตรงกัน
  • '\s' กรณีสำหรับช่องว่างใด ๆ
  • '\S' กรณีสำหรับช่องว่างที่ไม่ใช่
  • '(?s).' กรณีสำหรับ char ใด ๆ (ขึ้นบรรทัดใหม่)
  • '\n' กรณีสำหรับ newline char (ขึ้นบรรทัดใหม่แทนตัวเอง)
• $c="$b".Lengthคำนวณความยาวของจำนวนไบต์ $ b เป็นค่าสูงสุดเสมอ ($ l, $ w, $ b) โดยการออกแบบ
• "{0,$c} {1,$c} $b"-f$l,+$wหมายเลขรูปแบบที่มีความยาวเท่ากัน ตัวแปร $ w แปลงเป็น int มันต้องการสตริงที่ไม่มีคำพูด รูปแบบตัวแปรอื่น ๆ 'ตามสภาพ' เนื่องจาก 'อินพุตจะมีบรรทัดขึ้นบรรทัดใหม่เสมอ' และ $ l และ $ b ไม่สามารถเป็น 0