^{Diese Herausforderung ähnelt der alten , jedoch mit einigen unklaren Teilen der Spezifikation und weniger strengen E / A-Anforderungen.}

Wenn Sie eine Zeichenfolge eingeben, die nur aus druckbarem ASCII und Zeilenumbrüchen besteht, geben Sie die verschiedenen Metriken (Byte, Wort, Zeilenzahl) aus.

Die Metriken, die Sie ausgeben müssen, lauten wie folgt:

• Byteanzahl. Da die Eingabezeichenfolge innerhalb von ASCII bleibt, ist dies auch die Zeichenanzahl.

• Wortzahl. Dies ist wcdie Definition eines "Wortes": jede Folge von Nicht-Leerzeichen. Zum Beispiel abc,def"ghi"ist ein "Wort".

• Zeilenanzahl. Das ist selbsterklärend. Die Eingabe enthält immer einen nachgestellten Zeilenumbruch, was bedeutet, dass Zeilenanzahl gleichbedeutend mit "Zeilenumbruch" ist. Es wird nie mehr als eine einzige nachgestellte Zeile geben.

Die Ausgabe muss genau der Standardausgabe entsprechen wc(mit Ausnahme des Dateinamens):

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

Beachten Sie, dass die Zeilenanzahl zuerst kommt, dann die Wortanzahl und schließlich die Byteanzahl. Darüber hinaus muss jeder Zählwert mit Leerzeichen aufgefüllt werden, damit sie alle die gleiche Breite haben. Im obigen Beispiel 5501ist die "längste" Zahl 4-stellig, wird also 165mit einem Leerzeichen und 90mit zwei aufgefüllt . Schließlich müssen alle Zahlen zu einer einzigen Zeichenfolge mit einem Leerzeichen zwischen den Zahlen zusammengefügt werden.

Da es sich um Code-Golf , wird der kürzeste Code in Bytes gewinnen.

(Oh, und übrigens ... Sie können den wcBefehl nicht in Ihrer Antwort verwenden. Falls das noch nicht klar war.)

Testfälle ( \nstellt eine neue Zeile dar; optional können Sie auch eine zusätzliche nachgestellte Zeile benötigen):

"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 Bytes

+3 für hinzugefügt -an0

Eingabe in STDIN oder 1 oder mehr Dateinamen als Argumente. Rennen wieperl -an0 wc.pl

wc.pl:

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

Erläuterung:

-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 Bytes

Diese Lösung ist eine Python-Funktion, die eine mehrzeilige Zeichenfolge akzeptiert und die erforderlichen Zählungen an stdout ausgibt. Beachten Sie, dass ich eine Formatzeichenfolge verwende, um eine Formatzeichenfolge zu erstellen (die ein erfordert %%, um den ersten Formatplatzhalter zu maskieren).

Bearbeiten: 23 Byte aufgrund von Druckoptimierungen von Dennis gespeichert.

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

Vor dem Minifier sieht es so aus:

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

Pyth, 21 Bytes

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

Testsuite

Pyth hat hier einige sehr schöne eingebaute. [Zunächst erstellen wir eine Liste ( ) der Zeilenumbrüche in der Zeichenfolge ( @bQ), der Wörter in der Zeichenfolge ( cQ)) und der Zeichenfolge selbst ( Q). Dann füllen wir ( .[) die Länge jedes Strings ( ld) mit Leerzeichen ( ;in diesem Kontext) auf, die der Länge der Anzahl der Zeichen ( l`lQ) entsprechen. Zum Schluss setzen Sie Leerzeichen ( jd).

POSIX awk, 79 75 67 65 Bytes

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

Bearbeiten: 4 Bytes gespart, da POSIX ein Bare zulässt length, 7 Bytes durch Abzinsung des Aufrufteils gespart und zwei Bytes dank Doorknobs Tipp für das Hinzufügen d %zu gespart d.

Dies war ursprünglich für GNU awk, aber soweit ich das beurteilen kann, werden nur POSIX awk-Funktionen verwendet.

Besser formatiert:

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
}'

Im Ernst , 39 Bytes

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

Probieren Sie es online!

Erklärung (Zeilenumbrüche werden durch ersetzt \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 Byte

Dies setzt voraus, dass die Trennzeichen für AppleScript-Textelemente auf Leerzeichen gesetzt sind (wenn ich das Zeug zählen muss, um diese Annahme zu erzwingen, füge ich es hinzu).

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 Bytes

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

Probieren Sie es online!

Wie es funktioniert

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 Bytes

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

Dies ist eine Funktion, die eine Zeichenfolge akzeptiert und eine Zeichenfolge zurückgibt.

Wir speichern als Funktionsargumente:

• n = endof Funktion, die den letzten Index einer indexierbaren Sammlung abruft (in diesem Fall die Länge des Strings)
• l = "$(n(s))Die Länge der Eingabe, die mithilfe von Interpolation in eine Zeichenfolge konvertiert wurde
• Eine Lambda-Funktion g, die einen regulären Ausdruck akzeptiert und die Länge - 1 der auf diese Regex aufgeteilten Eingabe zurückgibt, wobei die Länge mit Leerzeichen aufgefüllt bleibt l.

Wir ermitteln die Anzahl der verwendeten Zeilen g(r"\n")und die Anzahl der verwendeten Wörter g(r"\S+")und fügen diese mit ldurch Leerzeichen begrenzten zusammen.

31 Bytes gespart dank Dennis!

MATL, 38 Bytes

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

Sie können es online ausprobieren! Das sollte aber nicht so lange dauern ...

Erklärung zur Berechnung

'\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

Der letzte Teil übernimmt die Ausgabeformatierung

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 Byte

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

Benötigt keine Eingabe. Das Formatieren war schmerzhaft. Wenn es eine Obergrenze für die Polstermenge gäbe, könnte ich sie (' '.repeat(99)+n)auf etwas kürzeres reduzieren , z ` ${n}`.

PowerShell, 140 Byte

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

_{(Zeilenumbruch aus Gründen der Übersichtlichkeit: D)}

Die erste Zeile nimmt Eingaben entgegen $a, und der nächste Teil besteht aus einer einzigen Anweisung. Wir setzen $cgleich einige Zeichenfolgen .length . Dies wird unsere erforderliche Polsterung bilden. In der Zeichenfolge befindet sich ein sofortiger Codeblock $(...), sodass der Code ausgeführt wird, bevor er in der Zeichenfolge ausgewertet wird.

Im Codeblock senden wir drei Elemente über den |sortBefehl und nehmen dann das größte (...)[-1]. Hier stellen wir sicher, dass die Spalten die richtige Breite haben. Die drei Elemente sind $ldie Zeilenanzahl, bei der wir uns -splitin Zeilenumbrüchen befinden, die Wortanzahl, bei der $wwir uns -splitin Leerzeichen befinden und $bdie Länge.

Die zweite Zeile ist unsere Ausgabe mit dem -fOperator (eine Pseudokurzform fürString.Format() ). Es ist eine andere Möglichkeit, erweiterte Variablen in Zeichenfolgen einzufügen. Hier möchten wir, dass die gesamte Ausgabe nach links aufgefüllt wird, damit jede Spalte $cbreit ist. Das Auffüllen erfolgt über Leerzeichen. Das 0,, 1und 2entsprechen dem $l, $wund $bdas sind Argumente für den Formatoperator, sodass die Zeilenanzahl, die Wortanzahl und die Byteanzahl entsprechend aufgefüllt und ausgegeben werden.

Beachten Sie, dass hierfür entweder die Zeichenfolge bereits erweiterte Zeilenumbrüche aufweisen muss (z. B. Get-Contenteine Textdatei oder etwas anderes bearbeiten und diese dann entweder weiterleiten oder in einer Variablen speichern und dann diesen Code für diese Eingabe aufrufen), oder die PowerShell verwenden. gestaltete Escape-Zeichen mit Backticks (Bedeutung `nstatt \n).

Beispiel

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

Gelee , 14 Bytes

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

Probieren Sie es online!

-1 danke an Dennis .

Rubin, 108 Bytes

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 Bytes

beinhaltet +1 für -n

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

Kommentiert:

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

• Speichern Sie ein weiteres Byte, noch einmal dank @TonHospel.
• Sparen Sie 9 Bytes dank @TonHospel, das mir einige Tricks des Handels zeigt!

Lua, 74 66 Bytes

Golf gespielt:

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

Erhält Eingaben über Befehlszeilenargumente.

Wir benennen das erste Argument ( arg[1]) um, um Bytes zu sparen.string.gsubgibt die Anzahl der Ersetzungen sowie die geänderte Zeichenfolge zurück, sodass wir diese zuerst '\n'(Zeilenumbrüche) und dann '%S+'(Instanzen eines oder mehrerer Nicht-Leerzeichen, so viele wie möglich, dh Wörter) zählen. Wir können für die Ersetzungszeichenfolge alles verwenden, was wir wollen, also verwenden wir die leere Zeichenfolge ( ''), um Bytes zu speichern. Dann ermitteln wir einfach string.lendie Länge des Strings, dh die Anzahl der Bytes. Dann drucken wir endlich alles.

Netzhaut, 65

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

Probieren Sie es online!

Die erste Stufe ist das eigentliche WC-Programm, der Rest ist zum Auffüllen. Das aPlatzhalter-Ding ist wahrscheinlich unnötig und einige der Gruppen können wahrscheinlich ein bisschen vereinfacht werden.

Haskell, 140 Bytes

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

Es folgt die ungolfed Version mit erweiterten Variablen- und Funktionsnamen:

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

Dies ist eine Funktion, die eine Zeichenfolge akzeptiert und eine Zeichenfolge zurückgibt. Es werden nur die PreludeFunktionen words(bzw. lines) verwendet, um die Anzahl der Wörter (bzw. Zeilen) zu erhalten, vorausgesetzt, sie scheinen dieselbe Definition zu verwenden wie wc, und dann wird der längste Wert (als Zeichenfolge) unter den Zählwerten abgerufen und das printf-Format verwendet die Breite unter den Argumenten für die Formatierung.

C 180 178 Bytes

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

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

j ist derzeit fehlerhaft, könnte also 21 Bytes ohne die sein § und sein könnenJ .

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

¨          # 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 Bytes

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

Nimmt die mehrzeilige Zeichenfolge als Befehlszeilenargument. Probieren Sie es online!

Danke an Dennis's CJam Antwort mir klar, dass die längste Zahl immer die Anzahl der Zeichen ist.

Erläuterung

                           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)

Hier ist eine 29-Byte-Lösung mit Flags -rs, die Eingaben von stdin akzeptieren:

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

Probieren Sie es online!

Powershell, 123 115 Bytes

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

Testskript:

$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"
}

Ausgabe:

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

Erläuterung:

• $args|% t*y Teilt Zeichenketten in Zeichen auf
• switch -r($args|% t*y)bewerte alle übereinstimmenden Fälle
  • '\s' case for any whitespace
  • '\S' case for any non-whitespace
  • '(?s).' case for any char (newline enthalten)
  • '\n' case for newline char (newline repräsentiert sich selbst)
• $c="$b".LengthBerechnen Sie eine Länge von Bytes Anzahl. $ b ist standardmäßig immer maximal ($ l, $ w, $ b)
• "{0,$c} {1,$c} $b"-f$l,+$wZahlen mit gleicher Länge formatieren. Die Variable $ w wird in int konvertiert. Es braucht Zeichenfolgen ohne Worte. Andere Variablenformate 'wie sie sind', da 'die Eingabe immer einen abschließenden Zeilenumbruch enthält' und $ l und $ b nicht 0 sein können.