Die Herausforderung:

Erstellen Sie ein ASCII-Diagramm mit den am häufigsten verwendeten Wörtern in einem bestimmten Text.

Die Regeln:

• Akzeptiere nur a-zund A-Z(alphabetische Zeichen) als Teil eines Wortes.
• Gehäuse ignorieren ( She== shefür unseren Zweck).
• Ignoriere die folgenden Wörter (ziemlich willkürlich, ich weiß): the, and, of, to, a, i, it, in, or, is

• Klarstellung: Überlegung don't: Dies würde als 2 verschiedene "Wörter" in den Bereichen a-zund A-Z: ( donund t) genommen.

• Optional (es ist zu spät formell die Spezifikationen nun sich zu ändern) Sie können Drop wählen , um alle einzelnen Buchstaben ‚Worte‘ (dies möglicherweise für eine Verkürzung der zu ignorieren Liste machen könnte).

Analysieren Sie eine gegebene text(lesen Sie eine Datei, die über Befehlszeilenargumente angegeben oder weitergeleitet wurde; nehmen Sie an us-ascii) und erstellen Sie eine word frequency chartmit den folgenden Eigenschaften:

• Zeigen Sie das Diagramm (siehe auch das folgende Beispiel) mit den 22 häufigsten Wörtern an (geordnet nach absteigender Häufigkeit).
• Die Bar width die Anzahl der Vorkommen (Häufigkeit) des Wortes (proportional) an. Fügen Sie ein Leerzeichen hinzu und drucken Sie das Wort.
• Stellen Sie sicher, dass diese Balken (plus Leerzeichen-Wort-Leerzeichen) immer passen : bar+ [space]+ word+ [space]sollten immer <= 80Zeichen sein (berücksichtigen Sie mögliche unterschiedliche Balken- und Wortlängen: Beispiel: Das zweithäufigste Wort könnte dann viel länger sein die erste, obwohl sie sich nicht so stark in der Frequenz unterscheidet). Maximieren Sie die Balkenbreite innerhalb dieser Einschränkungen und skalieren Sie die Balken entsprechend (entsprechend den Frequenzen, die sie darstellen).

Ein Beispiel:

Den Text für das Beispiel finden Sie hier ( Alice's Adventures in Wonderland, von Lewis Carroll ).

Dieser spezifische Text würde die folgende Tabelle ergeben:

 _________________________________________________________________________
| _________________________________________________________________________ | sie
| _______________________________________________________________ | Sie
| ____________________________________________________________ | sagte
| ____________________________________________________ | Alice
| ______________________________________________ | war
| __________________________________________ | Das
| ___________________________________ | wie
| _______________________________ | ihr
| ____________________________ | mit
| ____________________________ | beim
| ___________________________ | s
| ___________________________ | t
| _________________________ | auf
| _________________________ | alles
| ______________________ | Dies
| ______________________ | zum
| ______________________ | hätten
| _____________________ | aber
| ____________________ | Sein
| ____________________ | nicht
| ___________________ | Sie
| __________________ | so

Zu Ihrer Information: Dies sind die Frequenzen, auf denen die obige Tabelle basiert:

[('sie', 553), ('du', 481), ('sagte', 462), ('alice', 403), ('war', 358), ('das'
', 330), (' as ', 274), (' her ', 248), (' with ', 227), (' at ', 227), (' s ', 219), (' t ')
, 218), ('on', 204), ('all', 200), ('this', 181), ('for', 179), ('had', 178), ('
aber ', 175), (' sei ', 167), (' nicht ', 166), (' sie ', 155), (' so ', 152)]

Ein zweites Beispiel (um zu überprüfen, ob Sie die vollständige Spezifikation implementiert haben): Ersetzen Sie jedes Vorkommen youin der verknüpften Alice im Wunderland- Datei durch superlongstringstring:

 ________________________________________________________________
| ________________________________________________________________ | sie
| _______________________________________________________ | Superlongstringstring
| _____________________________________________________ | sagte
| ______________________________________________ | Alice
| ________________________________________ | war
| _____________________________________ | Das
| ______________________________ | wie
| ___________________________ | ihr
| _________________________ | mit
| _________________________ | beim
| ________________________ | s
| ________________________ | t
| ______________________ | auf
| _____________________ | alles
| ___________________ | Dies
| ___________________ | zum
| ___________________ | hätten
| __________________ | aber
| _________________ | Sein
| _________________ | nicht
| ________________ | Sie
| ________________ | so

Der Gewinner:

Kürzeste Lösung (nach Zeichenanzahl pro Sprache). Habe Spaß!

Bearbeiten : Tabelle mit einer Zusammenfassung der bisherigen Ergebnisse (15.02.2012) (ursprünglich vom Benutzer Nas Banov hinzugefügt):

Sprache entspannt Entspannt
========= ======= ======
GolfScript 130 143
Perl 185
Windows PowerShell 148 199
Mathematica 199
Ruby 185 205
Unix Toolchain 194 228
Python 183 243
Clojure 282
Scala 311
Haskell 333
Awk 336
R 298
Javascript 304 354
Groovy 321
Matlab 404
C # 422
Smalltalk 386
PHP 450
F # 452
TSQL 483 507

Die Zahlen geben die Länge der kürzesten Lösung in einer bestimmten Sprache an. "Streng" bezieht sich auf eine Lösung, die die Spezifikation vollständig implementiert (zeichnet |____|Balken, schließt den ersten Balken oben mit einer ____Linie, berücksichtigt die Möglichkeit langer Wörter mit hoher Frequenz usw.). "Entspannt" bedeutet, dass einige Freiheiten genommen wurden, um die Lösung zu verkürzen.

Es sind nur Lösungen enthalten, die kürzer als 500 Zeichen sind. Die Liste der Sprachen ist nach der Länge der "strengen" Lösung sortiert. 'Unix Toolchain' wird verwendet, um verschiedene Lösungen zu kennzeichnen, die die traditionelle * nix-Shell sowie eine Mischung von Werkzeugen verwenden (wie grep, tr, sort, uniq, head, perl, awk).

LabVIEW 51 Knoten, 5 Strukturen, 10 Diagramme

Dem Elefanten Stepptanz beizubringen ist nie schön. Ich werde die Anzahl der Zeichen überspringen.

Das Programm läuft von links nach rechts:

Ruby 1,9, 185 Zeichen

(stark basierend auf den anderen Ruby-Lösungen)

w=($<.read.downcase.scan(/[a-z]+/)-%w{the and of to a i it in or is}).group_by{|x|x}.map{|x,y|[-y.size,x]}.sort[0,22]
k,l=w[0]
puts [?\s+?_*m=76-l.size,w.map{|f,x|?|+?_*(f*m/k)+"| "+x}]

Anstatt Befehlszeilenoptionen wie die anderen Lösungen zu verwenden, können Sie einfach den Dateinamen als Argument übergeben. (dh ruby1.9 wordfrequency.rb Alice.txt)

Da ich hier Zeichenliterale verwende, funktioniert diese Lösung nur in Ruby 1.9.

Bearbeiten: Semikolons durch Zeilenumbrüche ersetzt, um die Lesbarkeit zu gewährleisten. : P.

Edit 2: Shtééf wies darauf hin, dass ich den nachgestellten Leerzeichen vergessen habe - das wurde behoben.

Edit 3: Das nachfolgende Leerzeichen wieder entfernt;)

GolfScript, 177 175 173 167 164 163 144 131 130 Zeichen

Langsam - 3 Minuten für den Beispieltext (130)

{32|.123%97<n@if}%]''*n%"oftoitinorisa"2/-"theandi"3/-$(1@{.3$>1{;)}if}/]2/{~~\;}$22<.0=~:2;,76\-:1'_':0*' '\@{"
|"\~1*2/0*'| '@}/

Erläuterung:

{           #loop through all characters
 32|.       #convert to uppercase and duplicate
 123%97<    #determine if is a letter
 n@if       #return either the letter or a newline
}%          #return an array (of ints)
]''*        #convert array to a string with magic
n%          #split on newline, removing blanks (stack is an array of words now)
"oftoitinorisa"   #push this string
2/          #split into groups of two, i.e. ["of" "to" "it" "in" "or" "is" "a"]
-           #remove any occurrences from the text
"theandi"3/-#remove "the", "and", and "i"
$           #sort the array of words
(1@         #takes the first word in the array, pushes a 1, reorders stack
            #the 1 is the current number of occurrences of the first word
{           #loop through the array
 .3$>1{;)}if#increment the count or push the next word and a 1
}/
]2/         #gather stack into an array and split into groups of 2
{~~\;}$     #sort by the latter element - the count of occurrences of each word
22<         #take the first 22 elements
.0=~:2;     #store the highest count
,76\-:1     #store the length of the first line
'_':0*' '\@ #make the first line
{           #loop through each word
"
|"\~        #start drawing the bar
1*2/0       #divide by zero
*'| '@      #finish drawing the bar
}/

"Richtig" (hoffentlich). (143)

{32|.123%97<n@if}%]''*n%"oftoitinorisa"2/-"theandi"3/-$(1@{.3$>1{;)}if}/]2/{~~\;}$22<..0=1=:^;{~76@,-^*\/}%$0=:1'_':0*' '\@{"
|"\~1*^/0*'| '@}/

Weniger langsam - eine halbe Minute. (162)

'"'/' ':S*n/S*'"#{%q
'\+"
.downcase.tr('^a-z','
')}\""+~n%"oftoitinorisa"2/-"theandi"3/-$(1@{.3$>1{;)}if}/]2/{~~\;}$22<.0=~:2;,76\-:1'_':0*S\@{"
|"\~1*2/0*'| '@}/

Ausgabe in Revisionsprotokollen sichtbar.

206

Shell, Grep, Tr, Grep, Sortieren, Uniq, Sortieren, Kopf, Perl

~ % wc -c wfg
209 wfg
~ % cat wfg
egrep -oi \\b[a-z]+|tr A-Z a-z|egrep -wv 'the|and|of|to|a|i|it|in|or|is'|sort|uniq -c|sort -nr|head -22|perl -lape'($f,$w)=@F;$.>1or($q,$x)=($f,76-length$w);$b="_"x($f/$q*$x);$_="|$b| $w ";$.>1or$_=" $b\n$_"'
~ % # usage:
~ % sh wfg < 11.txt

hm, gerade oben gesehen: sort -nr-> sort -nund dann head->tail => 208 :)
update2: ähm, natürlich ist das obige albern, da es dann umgekehrt wird. Also, 209.
update3: optimiert den Ausschluss regexp -> 206

egrep -oi \\b[a-z]+|tr A-Z a-z|egrep -wv 'the|and|o[fr]|to|a|i[tns]?'|sort|uniq -c|sort -nr|head -22|perl -lape'($f,$w)=@F;$.>1or($q,$x)=($f,76-length$w);$b="_"x($f/$q*$x);$_="|$b| $w ";$.>1or$_=" $b\n$_"'

Zum Spaß hier eine Nur-Perl-Version (viel schneller):

~ % wc -c pgolf
204 pgolf
~ % cat pgolf
perl -lne'$1=~/^(the|and|o[fr]|to|.|i[tns])$/i||$f{lc$1}++while/\b([a-z]+)/gi}{@w=(sort{$f{$b}<=>$f{$a}}keys%f)[0..21];$Q=$f{$_=$w[0]};$B=76-y///c;print" "."_"x$B;print"|"."_"x($B*$f{$_}/$Q)."| $_"for@w'
~ % # usage:
~ % sh pgolf < 11.txt

Transact SQL Set-basierte Lösung (SQL Server 2005) 1063 892 873 853 827 820 783 683 647 644 630 Zeichen

Vielen Dank an Gabe für einige nützliche Vorschläge zur Reduzierung der Zeichenanzahl.

Hinweis: Zeilenumbrüche wurden hinzugefügt, um Bildlaufleisten zu vermeiden. Es ist nur der letzte Zeilenumbruch erforderlich.

DECLARE @ VARCHAR(MAX),@F REAL SELECT @=BulkColumn FROM OPENROWSET(BULK'A',
SINGLE_BLOB)x;WITH N AS(SELECT 1 i,LEFT(@,1)L UNION ALL SELECT i+1,SUBSTRING
(@,i+1,1)FROM N WHERE i<LEN(@))SELECT i,L,i-RANK()OVER(ORDER BY i)R INTO #D
FROM N WHERE L LIKE'[A-Z]'OPTION(MAXRECURSION 0)SELECT TOP 22 W,-COUNT(*)C
INTO # FROM(SELECT DISTINCT R,(SELECT''+L FROM #D WHERE R=b.R FOR XML PATH
(''))W FROM #D b)t WHERE LEN(W)>1 AND W NOT IN('the','and','of','to','it',
'in','or','is')GROUP BY W ORDER BY C SELECT @F=MIN(($76-LEN(W))/-C),@=' '+
REPLICATE('_',-MIN(C)*@F)+' 'FROM # SELECT @=@+' 
|'+REPLICATE('_',-C*@F)+'| '+W FROM # ORDER BY C PRINT @

Lesbare Version

DECLARE @  VARCHAR(MAX),
        @F REAL
SELECT @=BulkColumn
FROM   OPENROWSET(BULK'A',SINGLE_BLOB)x; /*  Loads text file from path
                                             C:\WINDOWS\system32\A  */

/*Recursive common table expression to
generate a table of numbers from 1 to string length
(and associated characters)*/
WITH N AS
     (SELECT 1 i,
             LEFT(@,1)L

     UNION ALL

     SELECT i+1,
            SUBSTRING(@,i+1,1)
     FROM   N
     WHERE  i<LEN(@)
     )
  SELECT   i,
           L,
           i-RANK()OVER(ORDER BY i)R
           /*Will group characters
           from the same word together*/
  INTO     #D
  FROM     N
  WHERE    L LIKE'[A-Z]'OPTION(MAXRECURSION 0)
             /*Assuming case insensitive accent sensitive collation*/

SELECT   TOP 22 W,
         -COUNT(*)C
INTO     #
FROM     (SELECT DISTINCT R,
                          (SELECT ''+L
                          FROM    #D
                          WHERE   R=b.R FOR XML PATH('')
                          )W
                          /*Reconstitute the word from the characters*/
         FROM             #D b
         )
         T
WHERE    LEN(W)>1
AND      W NOT IN('the',
                  'and',
                  'of' ,
                  'to' ,
                  'it' ,
                  'in' ,
                  'or' ,
                  'is')
GROUP BY W
ORDER BY C

/*Just noticed this looks risky as it relies on the order of evaluation of the 
 variables. I'm not sure that's guaranteed but it works on my machine :-) */
SELECT @F=MIN(($76-LEN(W))/-C),
       @ =' '      +REPLICATE('_',-MIN(C)*@F)+' '
FROM   #

SELECT @=@+' 
|'+REPLICATE('_',-C*@F)+'| '+W
             FROM     #
             ORDER BY C

PRINT @

Ausgabe

 _________________________________________________________________________ 
|_________________________________________________________________________| she
|_______________________________________________________________| You
|____________________________________________________________| said
|_____________________________________________________| Alice
|_______________________________________________| was
|___________________________________________| that
|____________________________________| as
|________________________________| her
|_____________________________| at
|_____________________________| with
|__________________________| on
|__________________________| all
|_______________________| This
|_______________________| for
|_______________________| had
|_______________________| but
|______________________| be
|_____________________| not
|____________________| they
|____________________| So
|___________________| very
|__________________| what

Und mit der langen Schnur

 _______________________________________________________________ 
|_______________________________________________________________| she
|_______________________________________________________| superlongstringstring
|____________________________________________________| said
|______________________________________________| Alice
|________________________________________| was
|_____________________________________| that
|_______________________________| as
|____________________________| her
|_________________________| at
|_________________________| with
|_______________________| on
|______________________| all
|____________________| This
|____________________| for
|____________________| had
|____________________| but
|___________________| be
|__________________| not
|_________________| they
|_________________| So
|________________| very
|________________| what

Ruby 207 213 211 210 207 203 201 200 Zeichen

Eine Verbesserung gegenüber Anurag, die Vorschläge von rfusca enthält. Entfernt auch Argumente zum Sortieren und einige andere kleinere Golfe.

w=(STDIN.read.downcase.scan(/[a-z]+/)-%w{the and of to a i it in or is}).group_by{|x|x}.map{|x,y|[-y.size,x]}.sort.take 22;k,l=w[0];m=76.0-l.size;puts' '+'_'*m;w.map{|f,x|puts"|#{'_'*(m*f/k)}| #{x} "}

Ausführen als:

ruby GolfedWordFrequencies.rb < Alice.txt

Bearbeiten: Setzen Sie 'setzt' wieder ein, muss vorhanden sein, um zu vermeiden, dass Anführungszeichen in der Ausgabe enthalten sind.
Edit2: Geänderte Datei-> IO
Edit3: entfernt / i
Edit4: Entfernte Klammern um (f * 1.0), wiedergegeben
Edit5: Verwenden Sie die Zeichenfolgenaddition für die erste Zeile; erweitert sin-place.
Edit6: M schweben lassen, 1.0 entfernt. EDIT: Funktioniert nicht, ändert die Länge. EDIT: Nicht schlechter als zuvor
Edit7: Verwenden STDIN.read.

Mathematica ( 297 284 248 244 242 199 Zeichen) Pure Functional

und Zipf's Law Testing

Schau Mama ... keine Vars, keine Hände, ... kein Kopf

Bearbeiten Sie 1> einige definierte Abkürzungen (284 Zeichen)

f[x_, y_] := Flatten[Take[x, All, y]]; 

BarChart[f[{##}, -1], 
         BarOrigin -> Left, 
         ChartLabels -> Placed[f[{##}, 1], After], 
         Axes -> None
] 
& @@
Take[
  SortBy[
     Tally[
       Select[
        StringSplit[ToLowerCase[Import[i]], RegularExpression["\\W+"]], 
       !MemberQ[{"the", "and", "of", "to", "a", "i", "it", "in", "or","is"}, #]&]
     ], 
  Last], 
-22]

Einige Erklärungen

Import[] 
   # Get The File

ToLowerCase []
   # To Lower Case :)

StringSplit[ STRING , RegularExpression["\\W+"]]
   # Split By Words, getting a LIST

Select[ LIST, !MemberQ[{LIST_TO_AVOID}, #]&]
   #  Select from LIST except those words in LIST_TO_AVOID
   #  Note that !MemberQ[{LIST_TO_AVOID}, #]& is a FUNCTION for the test

Tally[LIST]
   # Get the LIST {word,word,..} 
     and produce another  {{word,counter},{word,counter}...}

SortBy[ LIST ,Last]
   # Get the list produced bt tally and sort by counters
     Note that counters are the LAST element of {word,counter}

Take[ LIST ,-22]
   # Once sorted, get the biggest 22 counters

BarChart[f[{##}, -1], ChartLabels -> Placed[f[{##}, 1], After]] &@@ LIST
   # Get the list produced by Take as input and produce a bar chart

f[x_, y_] := Flatten[Take[x, All, y]]
   # Auxiliary to get the list of the first or second element of lists of lists x_
     dependending upon y
   # So f[{##}, -1] is the list of counters
   # and f[{##}, 1] is the list of words (labels for the chart)

Ausgabe

Alternativtext http://i49.tinypic.com/2n8mrer.jpg

Mathematica ist nicht gut zum Golfen geeignet, und das liegt nur an den langen, beschreibenden Funktionsnamen. Funktionen wie "RegularExpression []" oder "StringSplit []" lassen mich nur schluchzen :(.

Zipf's Law Testing

Das Zipf-Gesetz sagt voraus, dass für einen Text in natürlicher Sprache das Diagramm Log (Rang) vs Log (Vorkommen) einer linearen Beziehung folgt .

Das Gesetz wird bei der Entwicklung von Algorithmen für die Kriptographie und Datenkomprimierung verwendet. (Aber es ist NICHT das "Z" im LZW-Algorithmus).

In unserem Text können wir es mit folgendem testen

 f[x_, y_] := Flatten[Take[x, All, y]]; 
 ListLogLogPlot[
     Reverse[f[{##}, -1]], 
     AxesLabel -> {"Log (Rank)", "Log Counter"}, 
     PlotLabel -> "Testing Zipf's Law"]
 & @@
 Take[
  SortBy[
    Tally[
       StringSplit[ToLowerCase[b], RegularExpression["\\W+"]]
    ], 
   Last],
 -1000]

Das Ergebnis ist (ziemlich gut linear)

Alternativtext http://i46.tinypic.com/33fcmdk.jpg

Bearbeiten Sie 6> (242 Zeichen)

Umgestaltung des Regex (keine Auswahlfunktion mehr)
Löschen von 1 Zeichenwörtern
Effizientere Definition für Funktion "f"

f = Flatten[Take[#1, All, #2]]&; 
BarChart[
     f[{##}, -1], 
     BarOrigin -> Left, 
     ChartLabels -> Placed[f[{##}, 1], After], 
     Axes -> None] 
& @@
  Take[
    SortBy[
       Tally[
         StringSplit[ToLowerCase[Import[i]], 
          RegularExpression["(\\W|\\b(.|the|and|of|to|i[tns]|or)\\b)+"]]
       ],
    Last],
  -22]

Bearbeiten Sie 7 → 199 Zeichen

BarChart[#2, BarOrigin->Left, ChartLabels->Placed[#1, After], Axes->None]&@@ 
  Transpose@Take[SortBy[Tally@StringSplit[ToLowerCase@Import@i, 
    RegularExpression@"(\\W|\\b(.|the|and|of|to|i[tns]|or)\\b)+"],Last], -22]

• Ersetzt fdurch Transposeund Slot( #1/ #2) Argumente.
• Wir brauchen keine stinkenden Klammern (verwenden f@xstatt f[x]wo möglich)

C # - 510 451 436 446 434 426 422 Zeichen (minimiert)

Nicht so kurz, aber jetzt wahrscheinlich richtig! Beachten Sie, dass in der vorherigen Version die erste Zeile der Balken nicht angezeigt wurde, die Balken nicht richtig skaliert wurden, die Datei heruntergeladen wurde, anstatt sie von stdin abzurufen, und nicht alle erforderlichen C # -Verbosität enthalten waren. Sie könnten leicht viele Striche rasieren, wenn C # nicht so viel zusätzlichen Mist brauchte. Vielleicht könnte Powershell es besser machen.

using C=System.Console;   // alias for Console
using System.Linq;  // for Split, GroupBy, Select, OrderBy, etc.

class Class // must define a class
{
    static void Main()  // must define a Main
    {
        // split into words
        var allwords = System.Text.RegularExpressions.Regex.Split(
                // convert stdin to lowercase
                C.In.ReadToEnd().ToLower(),
                // eliminate stopwords and non-letters
                @"(?:\b(?:the|and|of|to|a|i[tns]?|or)\b|\W)+")
            .GroupBy(x => x)    // group by words
            .OrderBy(x => -x.Count()) // sort descending by count
            .Take(22);   // take first 22 words

        // compute length of longest bar + word
        var lendivisor = allwords.Max(y => y.Count() / (76.0 - y.Key.Length));

        // prepare text to print
        var toPrint = allwords.Select(x=> 
            new { 
                // remember bar pseudographics (will be used in two places)
                Bar = new string('_',(int)(x.Count()/lendivisor)), 
                Word=x.Key 
            })
            .ToList();  // convert to list so we can index into it

        // print top of first bar
        C.WriteLine(" " + toPrint[0].Bar);
        toPrint.ForEach(x =>  // for each word, print its bar and the word
            C.WriteLine("|" + x.Bar + "| " + x.Word));
    }
}

422 Zeichen mit Lendivisor inline (was es 22-mal langsamer macht) in der folgenden Form (Zeilenumbrüche für ausgewählte Leerzeichen):

using System.Linq;using C=System.Console;class M{static void Main(){var
a=System.Text.RegularExpressions.Regex.Split(C.In.ReadToEnd().ToLower(),@"(?:\b(?:the|and|of|to|a|i[tns]?|or)\b|\W)+").GroupBy(x=>x).OrderBy(x=>-x.Count()).Take(22);var
b=a.Select(x=>new{p=new string('_',(int)(x.Count()/a.Max(y=>y.Count()/(76d-y.Key.Length)))),t=x.Key}).ToList();C.WriteLine(" "+b[0].p);b.ForEach(x=>C.WriteLine("|"+x.p+"| "+x.t));}}

Perl, 237 229 209 Zeichen

(Wieder aktualisiert die Ruby - Version mit mehr schmutzig Golf Tricks zu schlagen, ersetzen split/[^a-z/,lcmitlc=~/[a-z]+/g , und einen Scheck für leere Zeichenkette an einem anderen Ort zu beseitigen. Diese inspiriert wurden durch die Ruby - Version, so Kredit , wem Ehre gebührt.)

Update: jetzt mit Perl 5.10! Ersetzen printdurch sayund verwenden Sie ~~, um a zu vermeiden map. Dies muss in der Kommandozeile als aufgerufen werden perl -E '<one-liner>' alice.txt. Da sich das gesamte Skript in einer Zeile befindet, sollte das Schreiben als Einzeiler keine Schwierigkeit darstellen :).

 @s=qw/the and of to a i it in or is/;$c{$_}++foreach grep{!($_~~@s)}map{lc=~/[a-z]+/g}<>;@s=sort{$c{$b}<=>$c{$a}}keys%c;$f=76-length$s[0];say" "."_"x$f;say"|"."_"x($c{$_}/$c{$s[0]}*$f)."| $_ "foreach@s[0..21];

Beachten Sie, dass diese Version für den Fall normalisiert wird. Dies verkürzt die Lösung nicht, da Sie zum Entfernen ,lc(für das untere Gehäuse) A-Zden geteilten regulären Ausdruck hinzufügen müssen, sodass es sich um eine Wäsche handelt.

Wenn Sie sich in einem System befinden, in dem eine neue Zeile aus einem Zeichen und nicht aus zwei besteht, können Sie diese um zwei weitere Zeichen verkürzen, indem Sie anstelle von eine wörtliche neue Zeile verwenden \n. Allerdings habe ich das obige Beispiel nicht so geschrieben, da es so "klarer" (ha!) Ist.

Hier ist eine meist korrekte, aber nicht annähernd kurze Perl-Lösung:

use strict;
use warnings;

my %short = map { $_ => 1 } qw/the and of to a i it in or is/;
my %count = ();

$count{$_}++ foreach grep { $_ && !$short{$_} } map { split /[^a-zA-Z]/ } (<>);
my @sorted = (sort { $count{$b} <=> $count{$a} } keys %count)[0..21];
my $widest = 76 - (length $sorted[0]);

print " " . ("_" x $widest) . "\n";
foreach (@sorted)
{
    my $width = int(($count{$_} / $count{$sorted[0]}) * $widest);
    print "|" . ("_" x $width) . "| $_ \n";
}

Das Folgende ist ungefähr so ​​kurz wie es nur geht, während es relativ lesbar bleibt. (392 Zeichen).

%short = map { $_ => 1 } qw/the and of to a i it in or is/;
%count;

$count{$_}++ foreach grep { $_ && !$short{$_} } map { split /[^a-z]/, lc } (<>);
@sorted = (sort { $count{$b} <=> $count{$a} } keys %count)[0..21];
$widest = 76 - (length $sorted[0]);

print " " . "_" x $widest . "\n";
print"|" . "_" x int(($count{$_} / $count{$sorted[0]}) * $widest) . "| $_ \n" foreach @sorted;

Windows PowerShell, 199 Zeichen

$x=$input-split'\P{L}'-notmatch'^(the|and|of|to|.?|i[tns]|or)$'|group|sort *
filter f($w){' '+'_'*$w
$x[-1..-22]|%{"|$('_'*($w*$_.Count/$x[-1].Count))| "+$_.Name}}
f(76..1|?{!((f $_)-match'.'*80)})[0]

(Der letzte Zeilenumbruch ist nicht erforderlich, wird hier jedoch zur besseren Lesbarkeit angegeben.)

(Aktueller Code und meine Testdateien sind in meinem SVN-Repository verfügbar . Ich hoffe, dass meine Testfälle die häufigsten Fehler erkennen (Balkenlänge, Probleme mit dem Regex-Abgleich und einige andere).)

Annahmen:

• US ASCII als Eingabe. Mit Unicode wird es wahrscheinlich komisch.
• Mindestens zwei ununterbrochene Wörter im Text

Geschichte

Entspannte Version (137), da dies anscheinend inzwischen separat gezählt wird:

($x=$input-split'\P{L}'-notmatch'^(the|and|of|to|.?|i[tns]|or)$'|group|sort *)[-1..-22]|%{"|$('_'*(76*$_.Count/$x[-1].Count))| "+$_.Name}

• schließt den ersten Balken nicht
• berücksichtigt nicht die Wortlänge des nicht ersten Wortes

Variationen der Balkenlängen eines Zeichens im Vergleich zu anderen Lösungen sind darauf zurückzuführen, dass PowerShell beim Konvertieren von Gleitkommazahlen in Ganzzahlen Rundungen anstelle von Kürzungen verwendet. Da die Aufgabe nur eine proportionale Stablänge erforderte, sollte dies jedoch in Ordnung sein.

Im Vergleich zu anderen Lösungen habe ich bei der Bestimmung der längsten Taktlänge einen etwas anderen Ansatz gewählt, indem ich einfach die höchste Länge ausprobiert und genommen habe, bei der keine Zeile länger als 80 Zeichen ist.

Eine erklärte ältere Version finden Sie hier .

Ruby, 215, 216 , 218 , 221 , 224 , 236 , 237 Zeichen

Update 1: Hurra ! Es ist ein Gleichstand mit der Lösung von JS Bangs . Ich kann mir keinen Weg mehr vorstellen, um zu reduzieren :)

Update 2: Spielte einen schmutzigen Golftrick. Geändert each, mapum 1 Zeichen zu speichern :)

Update 3: Geändert File.readzu IO.read+2. Array.group_bywar nicht sehr fruchtbar, geändert auf reduce+6. Nach dem unteren Gehäuse mit ist keine Prüfung ohne Berücksichtigung der Groß- und Kleinschreibung erforderlichdowncase in Regex +1 Berücksichtigung der Groß- und . Das Sortieren in absteigender Reihenfolge erfolgt einfach durch Negieren des Werts +6. Gesamteinsparungen +15

Update 4: [0]anstatt .first+3. (@ Shtééf)

Update 5: Variable lan Ort und Stelle erweitern, +1. Erweitern Sie die Variable san Ort und Stelle, +2. (@ Shtééf)

Update 6: Verwenden Sie für die erste Zeile +2 die Zeichenfolgenaddition anstelle der Interpolation. (@ Shtééf)

w=(IO.read($_).downcase.scan(/[a-z]+/)-%w{the and of to a i it in or is}).reduce(Hash.new 0){|m,o|m[o]+=1;m}.sort_by{|k,v|-v}.take 22;m=76-w[0][0].size;puts' '+'_'*m;w.map{|x,f|puts"|#{'_'*(f*1.0/w[0][1]*m)}| #{x} "}

Update 7: Ich habe eine ganze Menge Hoopla durchlaufen, um die erste Iteration innerhalb der Schleife mithilfe von Instanzvariablen zu erkennen . Alles was ich habe ist +1, obwohl es vielleicht Potenzial gibt. Beibehaltung der vorherigen Version, da ich glaube, dass dies schwarze Magie ist. (@ Shtééf)

(IO.read($_).downcase.scan(/[a-z]+/)-%w{the and of to a i it in or is}).reduce(Hash.new 0){|m,o|m[o]+=1;m}.sort_by{|k,v|-v}.take(22).map{|x,f|@f||(@f=f;puts' '+'_'*(@m=76-x.size));puts"|#{'_'*(f*1.0/@f*@m)}| #{x} "}

Lesbare Version

string = File.read($_).downcase

words = string.scan(/[a-z]+/i)
allowed_words = words - %w{the and of to a i it in or is}
sorted_words = allowed_words.group_by{ |x| x }.map{ |x,y| [x, y.size] }.sort{ |a,b| b[1] <=> a[1] }.take(22)
highest_frequency = sorted_words.first
highest_frequency_count = highest_frequency[1]
highest_frequency_word = highest_frequency[0]

word_length = highest_frequency_word.size
widest = 76 - word_length

puts " #{'_' * widest}"    
sorted_words.each do |word, freq|
  width = (freq * 1.0 / highest_frequency_count) * widest
  puts "|#{'_' * width}| #{word} "
end

Benutzen:

echo "Alice.txt" | ruby -ln GolfedWordFrequencies.rb

Ausgabe:

 _________________________________________________________________________
|_________________________________________________________________________| she 
|_______________________________________________________________| you 
|____________________________________________________________| said 
|_____________________________________________________| alice 
|_______________________________________________| was 
|___________________________________________| that 
|____________________________________| as 
|________________________________| her 
|_____________________________| with 
|_____________________________| at 
|____________________________| s 
|____________________________| t 
|__________________________| on 
|__________________________| all 
|_______________________| this 
|_______________________| for 
|_______________________| had 
|_______________________| but 
|______________________| be 
|_____________________| not 
|____________________| they 
|____________________| so 

Python 2.x, latitudinarianer Ansatz = 227 183 Zeichen

import sys,re
t=re.split('\W+',sys.stdin.read().lower())
r=sorted((-t.count(w),w)for w in set(t)if w not in'andithetoforinis')[:22]
for l,w in r:print(78-len(r[0][1]))*l/r[0][0]*'=',w

Unter Berücksichtigung der Freiheit bei der Implementierung habe ich eine Zeichenfolgenverkettung erstellt, die alle zum Ausschluss angeforderten Wörter enthält ( the, and, of, to, a, i, it, in, or, is) - und außerdem die beiden berüchtigten "Wörter" sund taus dem Beispiel ausschließt - und den Ausschluss für an, for, he. Ich habe alle Verkettungen dieser Wörter gegen das Korpus der Wörter aus Alice, King James 'Bibel und der Jargon-Datei versucht, um festzustellen, ob es Wörter gibt, die von der Zeichenfolge falsch ausgeschlossen werden. Und so endete ich mit zwei Ausschlusszeichenfolgen: itheandtoforinisund andithetoforinis.

PS. von anderen Lösungen ausgeliehen, um den Code zu verkürzen.

=========================================================================== she 
================================================================= you
============================================================== said
====================================================== alice
================================================ was
============================================ that
===================================== as
================================= her
============================== at
============================== with
=========================== on
=========================== all
======================== this
======================== had
======================= but
====================== be
====================== not
===================== they
==================== so
=================== very
=================== what
================= little

Schimpfen

In Bezug auf zu ignorierende Wörter würde man denken, dass diese aus der Liste der am häufigsten verwendeten Wörter auf Englisch entnommen werden. Diese Liste hängt vom verwendeten Textkorpus ab . Gemäß einer der beliebtesten Listen ( http://en.wikipedia.org/wiki/Most_common_words_in_English , http://www.english-for-students.com/Frequently-Used-Words.html , http: // www. sporcle.com/games/common_english_words.php ), Top 10 Wörter sind:the be(am/are/is/was/were) to of and a in that have I

Die 10 besten Wörter aus dem Alice im Wunderland-Text sind the and to a of it she i you said
Die 10 besten Wörter aus der Jargon-Datei (v4.4.7)the a of to and in is that or for

Die Frage ist also, warum orin die Ignorierliste des Problems aufgenommen wurde, wo es ~ 30 in der Popularität ist, wenn das Wort that(8. am häufigsten verwendet) nicht ist. usw. usw. Daher glaube ich, dass die Ignorierliste dynamisch bereitgestellt werden sollte (oder weggelassen werden könnte).

Eine alternative Idee wäre einfach, die Top-10-Wörter aus dem Ergebnis zu überspringen - was die Lösung tatsächlich verkürzen würde (elementar - muss nur den 11. bis 32. Eintrag anzeigen).

Python 2.x, pünktlicher Ansatz = 277 243 Zeichen

Das im obigen Code gezeichnete Diagramm wird vereinfacht (wobei nur ein Zeichen für die Balken verwendet wird). Wenn man das Diagramm aus der Problembeschreibung (die nicht erforderlich war) genau reproduzieren möchte, wird dieser Code dies tun:

import sys,re
t=re.split('\W+',sys.stdin.read().lower())
r=sorted((-t.count(w),w)for w in set(t)-set(sys.argv))[:22]
h=min(9*l/(77-len(w))for l,w in r)
print'',9*r[0][0]/h*'_'
for l,w in r:print'|'+9*l/h*'_'+'|',w

Ich habe ein Problem mit der etwas zufälligen Auswahl der 10 Wörter, die ausgeschlossen the, and, of, to, a, i, it, in, or, iswerden sollen, damit diese als Befehlszeilenparameter übergeben werden, wie folgt:
python WordFrequencyChart.py the and of to a i it in or is <"Alice's Adventures in Wonderland.txt"

Dies sind 213 Zeichen + 30, wenn wir die "ursprüngliche" Ignorierliste berücksichtigen, die über die Befehlszeile übergeben wurde = 243

PS. Der zweite Code "passt" auch die Länge aller oberen Wörter an, sodass keines von ihnen im entarteten Fall überläuft.

 _______________________________________________________________
|_______________________________________________________________| she
|_______________________________________________________| superlongstringstring
|_____________________________________________________| said
|______________________________________________| alice
|_________________________________________| was
|______________________________________| that
|_______________________________| as
|____________________________| her
|__________________________| at
|__________________________| with
|_________________________| s
|_________________________| t
|_______________________| on
|_______________________| all
|____________________| this
|____________________| for
|____________________| had
|____________________| but
|___________________| be
|___________________| not
|_________________| they
|_________________| so

Haskell - 366 351 344 337 333 Zeichen

(Ein Zeilenumbruch wurde mainzur besseren Lesbarkeit hinzugefügt, und am Ende der letzten Zeile ist kein Zeilenumbruch erforderlich.)

import Data.List
import Data.Char
l=length
t=filter
m=map
f c|isAlpha c=toLower c|0<1=' '
h w=(-l w,head w)
x!(q,w)='|':replicate(minimum$m(q?)x)'_'++"| "++w
q?(g,w)=q*(77-l w)`div`g
b x=m(x!)x
a(l:r)=(' ':t(=='_')l):l:r
main=interact$unlines.a.b.take 22.sort.m h.group.sort
  .t(`notElem`words"the and of to a i it in or is").words.m f

Wie es funktioniert, lässt sich am besten anhand des Arguments interactrückwärts lesen :

• map f Kleinbuchstaben, ersetzt alles andere durch Leerzeichen.
• words Erzeugt eine Liste von Wörtern, wobei das trennende Leerzeichen gelöscht wird.
• filter (notElem words "the and of to a i it in or is")verwirft alle Einträge mit verbotenen Wörtern.
• group . sort sortiert die Wörter und gruppiert identische in Listen.
• map h ordnet jede Liste identischer Wörter einem Tupel des Formulars zu (-frequency, word) .
• take 22 . sort sortiert die Tupel nach absteigender Häufigkeit (der erste Tupeleintrag) und behält nur die ersten 22 Tupel bei.
• b ordnet Tupel Balken zu (siehe unten).
• a stellt die erste Zeile der Unterstriche voran, um den obersten Balken zu vervollständigen.
• unlines verbindet alle diese Zeilen mit Zeilenumbrüchen.

Das Knifflige ist, die richtige Stablänge zu finden. Ich nahm an, dass nur Unterstriche zur Länge des Balkens zählen, also ||ein Balken mit der Länge Null. Die Funktion bordnet c xüber x, wo xdie Liste der Histogramme ist. Die gesamte Liste wird an übergeben c, so dass jeder Aufruf vonc den Skalierungsfaktor durch Aufrufen für sich selbst berechnen kann u. Auf diese Weise vermeide ich die Verwendung von Gleitkomma-Mathematik oder Rationalen, deren Konvertierungsfunktionen und -importe viele Zeichen verbrauchen würden.

Beachten Sie den Trick der Verwendung -frequency. Dadurch entfällt die Notwendigkeit, reversedie sortseit Sortierung (aufsteigend) -frequencywerden Orte der Worte mit der größten Frequenz zuerst. Später in der Funktion uwerden zwei -frequencyWerte multipliziert, wodurch die Negation aufgehoben wird.

JavaScript 1.8 (SpiderMonkey) - 354

x={};p='|';e=' ';z=[];c=77
while(l=readline())l.toLowerCase().replace(/\b(?!(the|and|of|to|a|i[tns]?|or)\b)\w+/g,function(y)x[y]?x[y].c++:z.push(x[y]={w:y,c:1}))
z=z.sort(function(a,b)b.c-a.c).slice(0,22)
for each(v in z){v.r=v.c/z[0].c
c=c>(l=(77-v.w.length)/v.r)?l:c}for(k in z){v=z[k]
s=Array(v.r*c|0).join('_')
if(!+k)print(e+s+e)
print(p+s+p+e+v.w)}

Leider for([k,v]in z)scheint die Version aus der Rhino-Version nicht in SpiderMonkey funktionieren zu wollen und readFile()ist ein wenig einfacher als die Verwendung, readline()aber wenn wir auf 1.8 aufsteigen, können wir Funktionsabschlüsse verwenden, um ein paar weitere Zeilen zu schneiden.

Hinzufügen von Leerzeichen zur besseren Lesbarkeit:

x={};p='|';e=' ';z=[];c=77
while(l=readline())
  l.toLowerCase().replace(/\b(?!(the|and|of|to|a|i[tns]?|or)\b)\w+/g,
   function(y) x[y] ? x[y].c++ : z.push( x[y] = {w: y, c: 1} )
  )
z=z.sort(function(a,b) b.c - a.c).slice(0,22)
for each(v in z){
  v.r=v.c/z[0].c
  c=c>(l=(77-v.w.length)/v.r)?l:c
}
for(k in z){
  v=z[k]
  s=Array(v.r*c|0).join('_')
  if(!+k)print(e+s+e)
  print(p+s+p+e+v.w)
}

Verwendung: js golf.js < input.txt

Ausgabe:

 _________________________________________________________________________ 
| _________________________________________________________________________ | sie
| _______________________________________________________________ | Sie
| ____________________________________________________________ | sagte
| ____________________________________________________ | Alice
| ______________________________________________ | war
| ___________________________________________ | Das
| ___________________________________ | wie
| ________________________________ | ihr
| _____________________________ | beim
| _____________________________ | mit
| ____________________________ | s
| ____________________________ | t
| __________________________ | auf
| _________________________ | alles
| _______________________ | Dies
| ______________________ | zum
| ______________________ | hätten
| ______________________ | aber
| _____________________ | Sein
| _____________________ | nicht
| ___________________ | Sie
| ___________________ | so

(Basisversion - behandelt Balkenbreiten nicht richtig)

JavaScript (Rhino) - 405 395 387 377 368 343 304 Zeichen

Ich denke, meine Sortierlogik ist aus, aber ... ich weiß nicht. Brainfart behoben.

Minimiert (Missbrauch wird manchmal \nals interpretiert ;):

x={};p='|';e=' ';z=[]
readFile(arguments[0]).toLowerCase().replace(/\b(?!(the|and|of|to|a|i[tns]?|or)\b)\w+/g,function(y){x[y]?x[y].c++:z.push(x[y]={w:y,c:1})})
z=z.sort(function(a,b){return b.c-a.c}).slice(0,22)
for([k,v]in z){s=Array((v.c/z[0].c)*70|0).join('_')
if(!+k)print(e+s+e)
print(p+s+p+e+v.w)}

PHP CLI-Version (450 Zeichen)

Diese Lösung berücksichtigt die letzte Anforderung, die die meisten Puristen bewusst ignoriert haben. Das hat 170 Zeichen gekostet!

Verwendung: php.exe <this.php> <file.txt>

Minimiert:

<?php $a=array_count_values(array_filter(preg_split('/[^a-z]/',strtolower(file_get_contents($argv[1])),-1,1),function($x){return !preg_match("/^(.|the|and|of|to|it|in|or|is)$/",$x);}));arsort($a);$a=array_slice($a,0,22);function R($a,$F,$B){$r=array();foreach($a as$x=>$f){$l=strlen($x);$r[$x]=$b=$f*$B/$F;if($l+$b>76)return R($a,$f,76-$l);}return$r;}$c=R($a,max($a),76-strlen(key($a)));foreach($a as$x=>$f)echo '|',str_repeat('-',$c[$x]),"| $x\n";?>

Für Menschen lesbar:

<?php

// Read:
$s = strtolower(file_get_contents($argv[1]));

// Split:
$a = preg_split('/[^a-z]/', $s, -1, PREG_SPLIT_NO_EMPTY);

// Remove unwanted words:
$a = array_filter($a, function($x){
       return !preg_match("/^(.|the|and|of|to|it|in|or|is)$/",$x);
     });

// Count:
$a = array_count_values($a);

// Sort:
arsort($a);

// Pick top 22:
$a=array_slice($a,0,22);


// Recursive function to adjust bar widths
// according to the last requirement:
function R($a,$F,$B){
    $r = array();
    foreach($a as $x=>$f){
        $l = strlen($x);
        $r[$x] = $b = $f * $B / $F;
        if ( $l + $b > 76 )
            return R($a,$f,76-$l);
    }
    return $r;
}

// Apply the function:
$c = R($a,max($a),76-strlen(key($a)));


// Output:
foreach ($a as $x => $f)
    echo '|',str_repeat('-',$c[$x]),"| $x\n";

?>

Ausgabe:

|-------------------------------------------------------------------------| she
|---------------------------------------------------------------| you
|------------------------------------------------------------| said
|-----------------------------------------------------| alice
|-----------------------------------------------| was
|-------------------------------------------| that
|------------------------------------| as
|--------------------------------| her
|-----------------------------| at
|-----------------------------| with
|--------------------------| on
|--------------------------| all
|-----------------------| this
|-----------------------| for
|-----------------------| had
|-----------------------| but
|----------------------| be
|---------------------| not
|--------------------| they
|--------------------| so
|-------------------| very
|------------------| what

Wenn es ein langes Wort gibt, werden die Balken richtig eingestellt:

|--------------------------------------------------------| she
|---------------------------------------------------| thisisareallylongwordhere
|-------------------------------------------------| you
|-----------------------------------------------| said
|-----------------------------------------| alice
|------------------------------------| was
|---------------------------------| that
|---------------------------| as
|-------------------------| her
|-----------------------| with
|-----------------------| at
|--------------------| on
|--------------------| all
|------------------| this
|------------------| for
|------------------| had
|-----------------| but
|-----------------| be
|----------------| not
|---------------| they
|---------------| so
|--------------| very

Python 3.1 - 245 229 Zeichen

Ich denke, Counter zu benutzen ist eine Art Betrug :) Ich habe gerade vor einer Woche darüber gelesen, also war dies die perfekte Gelegenheit, um zu sehen, wie es funktioniert.

import re,collections
o=collections.Counter([w for w in re.findall("[a-z]+",open("!").read().lower())if w not in"a and i in is it of or the to".split()]).most_common(22)
print('\n'.join('|'+76*v//o[0][1]*'_'+'| '+k for k,v in o))

Druckt aus:

|____________________________________________________________________________| she
|__________________________________________________________________| you
|_______________________________________________________________| said
|_______________________________________________________| alice
|_________________________________________________| was
|_____________________________________________| that
|_____________________________________| as
|__________________________________| her
|_______________________________| with
|_______________________________| at
|______________________________| s
|_____________________________| t
|____________________________| on
|___________________________| all
|________________________| this
|________________________| for
|________________________| had
|________________________| but
|______________________| be
|______________________| not
|_____________________| they
|____________________| so

Ein Teil des Codes wurde aus der AKX-Lösung "entlehnt".

Perl, 205 191 189 Zeichen / 205 Zeichen (vollständig implementiert)

Einige Teile wurden von den früheren Perl / Ruby-Einsendungen inspiriert, einige ähnliche Ideen wurden unabhängig voneinander gefunden, die anderen sind originell. Die kürzere Version enthält auch einige Dinge, die ich aus anderen Einsendungen gesehen / gelernt habe.

Original:

$k{$_}++for grep{$_!~/^(the|and|of|to|a|i|it|in|or|is)$/}map{lc=~/[a-z]+/g}<>;@t=sort{$k{$b}<=>$k{$a}}keys%k;$l=76-length$t[0];printf" %s
",'_'x$l;printf"|%s| $_
",'_'x int$k{$_}/$k{$t[0]}*$l for@t[0..21];

Neueste Version mit bis zu 191 Zeichen:

/^(the|and|of|to|.|i[tns]|or)$/||$k{$_}++for map{lc=~/[a-z]+/g}<>;@e=sort{$k{$b}<=>$k{$a}}keys%k;$n=" %s
";$r=(76-y///c)/$k{$_=$e[0]};map{printf$n,'_'x($k{$_}*$r),$_;$n="|%s| %s
"}@e[0,0..21]

Neueste Version mit bis zu 189 Zeichen:

/^(the|and|of|to|.|i[tns]|or)$/||$k{$_}++for map{lc=~/[a-z]+/g}<>;@_=sort{$k{$b}<=>$k{$a}}keys%k;$n=" %s
";$r=(76-m//)/$k{$_=$_[0]};map{printf$n,'_'x($k{$_}*$r),$_;$n="|%s| %s
"}@_[0,0..21]

Diese Version (205 Zeichen) berücksichtigt die Zeilen mit Wörtern, die länger sind als die später gefundenen.

/^(the|and|of|to|.|i[tns]|or)$/||$k{$_}++for map{lc=~/[a-z]+/g}<>;($r)=sort{$a<=>$b}map{(76-y///c)/$k{$_}}@e=sort{$k{$b}<=>$k{$a}}keys%k;$n=" %s
";map{printf$n,'_'x($k{$_}*$r),$_;$n="|%s| %s
";}@e[0,0..21]

Perl: 203 202 201 198 195 208 203/231 Zeichen

$/=\0;/^(the|and|of|to|.|i[tns]|or)$/i||$x{lc$_}++for<>=~/[a-z]+/gi;map{$z=$x{$_};$y||{$y=(76-y///c)/$z}&&warn" "."_"x($z*$y)."\n";printf"|%.78s\n","_"x($z*$y)."| $_"}(sort{$x{$b}<=>$x{$a}}keys%x)[0..21]

Alternative, vollständige Implementierung einschließlich angegebenem Verhalten (globales Balkenquetschen) für den pathologischen Fall, in dem das Sekundärwort sowohl beliebt als auch lang genug ist, um mit über 80 Zeichen kombiniert zu werden ( diese Implementierung umfasst 231 Zeichen ):

$/=\0;/^(the|and|of|to|.|i[tns]|or)$/i||$x{lc$_}++for<>=~/[a-z]+/gi;@e=(sort{$x{$b}<=>$x{$a}}keys%x)[0..21];for(@e){$p=(76-y///c)/$x{$_};($y&&$p>$y)||($y=$p)}warn" "."_"x($x{$e[0]}*$y)."\n";for(@e){warn"|"."_"x($x{$_}*$y)."| $_\n"}

In der Spezifikation wurde nirgends angegeben, dass dies an STDOUT gehen musste, daher habe ich perl's warn () anstelle von print verwendet - vier Zeichen wurden dort gespeichert. Verwendete Karte anstelle von foreach, aber ich habe das Gefühl, dass der Split (join ()) noch weitere Einsparungen bringen könnte. Trotzdem habe ich es auf 203 gebracht - könnte darauf schlafen. Zumindest ist Perl jetzt unter der Zeichenanzahl "shell, grep, tr, grep, sort, uniq, sort, head, perl";)

PS: Reddit sagt "Hallo";)

Update: join () wurde zugunsten der Zuweisung und des impliziten skalaren Konvertierungs-Joins entfernt. Bitte beachten Sie auch, dass ich die optionale Regel "1-Buchstaben-Wörter ignorieren" genutzt habe, um 2 Zeichen zu entfernen. Denken Sie also daran, dass die Häufigkeit dies widerspiegelt.

Update 2: Zuweisung und impliziter Join ausgetauscht, um $ / zu töten und die Datei mit <> in einem Zug zu erhalten. Gleiche Größe, aber böser. Ausgetauscht, wenn (! $ Y) {} gegen $ y || {} &&, 1 weiteres Zeichen gespeichert => 201.

Update 3: Übernahm die Kontrolle über die frühzeitige Kleinschreibung (lc <>), indem lc aus dem Kartenblock verschoben wurde. - Beide regulären Ausdrücke wurden ausgetauscht, um die Option / i nicht mehr zu verwenden, da sie nicht mehr benötigt wird. Vertauschtes explizites bedingtes x? Y: z-Konstrukt für traditionelles Perlgolf || implizites bedingtes Konstrukt - /^...$/i?1:$x{$ } ++ für /^...$/||$x{$ } ++ Drei Zeichen gespeichert! => 198, durchbrach die 200er Barriere. Könnte bald schlafen ... vielleicht.

Update 4: Schlafentzug hat mich verrückt gemacht. Gut. Wahnsinniger. Als ich herausfand, dass dies nur normale Happy-Text-Dateien analysieren muss, gab ich es auf, wenn es eine Null erreicht. Zwei Zeichen gespeichert. Ersetzt "Länge" durch das 1-Zeichen kürzere (und viel mehr Golf) y /// c - Sie hören mich, GolfScript? Ich komme für Sie!!! Schluchzen

Update 5: Sleep Dep hat mich das 22row-Limit und das Limit für nachfolgende Zeilen vergessen lassen. Sichern Sie bis zu 208 mit den behandelten. Nicht schlecht, 13 Zeichen sind nicht das Ende der Welt. Spielte mit Perls Regex-Inline-Bewertung herum, hatte aber Probleme, sie zum Laufen zu bringen und Zeichen zu sparen ... lol. Das Beispiel wurde aktualisiert, um der aktuellen Ausgabe zu entsprechen.

Update 6: Nicht benötigte Klammern wurden entfernt, um (...) zu schützen, da die syntaktische Süßigkeit ++ es ermöglicht, sie glücklich gegen die zu schieben. Dank der Eingabe von Chas. Owens (erinnert mein müdes Gehirn) hat dort die Lösung für die Charakterklasse i [tns] gefunden. Zurück zu 203.

Update 7: Zweite Arbeit hinzugefügt, vollständige Implementierung der Spezifikationen (einschließlich des vollständigen Quetschverhaltens der Balken für sekundäre Langwörter anstelle der Kürzung, die die meisten Leute ausführen, basierend auf der ursprünglichen Spezifikation ohne den pathologischen Beispielfall).

Beispiele:

 _________________________________________________________________________
|_________________________________________________________________________| she
|_______________________________________________________________| you
|____________________________________________________________| said
|_____________________________________________________| alice
|_______________________________________________| was
|___________________________________________| that
|____________________________________| as
|________________________________| her
|_____________________________| with
|_____________________________| at
|__________________________| on
|__________________________| all
|_______________________| this
|_______________________| for
|_______________________| had
|_______________________| but
|______________________| be
|_____________________| not
|____________________| they
|____________________| so
|___________________| very
|__________________| what

Alternative Implementierung im pathologischen Fallbeispiel:

 _______________________________________________________________
|_______________________________________________________________| she
|_______________________________________________________| superlongstringstring
|____________________________________________________| said
|______________________________________________| alice
|________________________________________| was
|_____________________________________| that
|_______________________________| as
|____________________________| her
|_________________________| with
|_________________________| at
|_______________________| on
|______________________| all
|____________________| this
|____________________| for
|____________________| had
|____________________| but
|___________________| be
|__________________| not
|_________________| they
|_________________| so
|________________| very
|________________| what

F #, 452 Zeichen

Unkompliziert: Holen Sie sich eine Folge avon Wortzahlpaaren , finden Sie den besten Multiplikator für die Wortzahl pro Spalte kund drucken Sie die Ergebnisse.

let a=
 stdin.ReadToEnd().Split(" .?!,\":;'\r\n".ToCharArray(),enum 1)
 |>Seq.map(fun s->s.ToLower())|>Seq.countBy id
 |>Seq.filter(fun(w,n)->not(set["the";"and";"of";"to";"a";"i";"it";"in";"or";"is"].Contains w))
 |>Seq.sortBy(fun(w,n)-> -n)|>Seq.take 22
let k=a|>Seq.map(fun(w,n)->float(78-w.Length)/float n)|>Seq.min
let u n=String.replicate(int(float(n)*k)-2)"_"
printfn" %s "(u(snd(Seq.nth 0 a)))
for(w,n)in a do printfn"|%s| %s "(u n)w

Beispiel (Ich habe andere Freq-Zählungen als Sie, unsicher warum):

% app.exe < Alice.txt

 _________________________________________________________________________
|_________________________________________________________________________| she
|_______________________________________________________________| you
|_____________________________________________________________| said
|_____________________________________________________| alice
|_______________________________________________| was
|___________________________________________| that
|___________________________________| as
|________________________________| her
|_____________________________| with
|_____________________________| at
|____________________________| t
|____________________________| s
|__________________________| on
|_________________________| all
|_______________________| this
|______________________| had
|______________________| for
|_____________________| but
|_____________________| be
|____________________| not
|___________________| they
|__________________| so

Python 2.6, 347 Zeichen

import re
W,x={},"a and i in is it of or the to".split()
[W.__setitem__(w,W.get(w,0)-1)for w in re.findall("[a-z]+",file("11.txt").read().lower())if w not in x]
W=sorted(W.items(),key=lambda p:p[1])[:22]
bm=(76.-len(W[0][0]))/W[0][1]
U=lambda n:"_"*int(n*bm)
print "".join(("%s\n|%s| %s "%((""if i else" "+U(n)),U(n),w))for i,(w,n)in enumerate(W))

Ausgabe:

 _________________________________________________________________________
|_________________________________________________________________________| she 
|_______________________________________________________________| you 
|____________________________________________________________| said 
|_____________________________________________________| alice 
|_______________________________________________| was 
|___________________________________________| that 
|____________________________________| as 
|________________________________| her 
|_____________________________| with 
|_____________________________| at 
|____________________________| s 
|____________________________| t 
|__________________________| on 
|__________________________| all 
|_______________________| this 
|_______________________| for 
|_______________________| had 
|_______________________| but 
|______________________| be 
|_____________________| not 
|____________________| they 
|____________________| so 

* SH (+ Wellung), partielle Lösung

Dies ist unvollständig, aber zum Teufel, hier ist die Worthäufigkeit, die die Hälfte des Problems in 192 Bytes zählt:

curl -s http://www.gutenberg.org/files/11/11.txt|sed -e 's@[^a-z]@\n@gi'|tr '[:upper:]' '[:lower:]'|egrep -v '(^[^a-z]*$|\b(the|and|of|to|a|i|it|in|or|is)\b)' |sort|uniq -c|sort -n|tail -n 22

Gawk - 336 (ursprünglich 507) Zeichen

(nach dem Korrigieren der Ausgabeformatierung; Korrigieren der Kontraktionssache; Optimieren; erneutes Optimieren; Entfernen eines völlig unnötigen Sortierschritts; erneutes Optimieren; und noch einmal (hoppla, dieser hat die Formatierung gebrochen); noch mehr optimieren; Matts Herausforderung annehmen, die ich verzweifelt optimiere so mehr; fand einen anderen Ort, um ein paar zu retten, gab aber zwei zurück, um den Fehler in der Balkenlänge zu beheben)

Heh heh! Ich bin momentan der ^{Herausforderung} des [Matt] JavaScript] [1] -Lösungszählers voraus ^{! ;)} und [AKXs Python] [2].

Das Problem scheint nach einer Sprache zu verlangen, die native assoziative Arrays implementiert, daher habe ich natürlich eine mit einer schrecklich mangelhaften Anzahl von Operatoren ausgewählt. Insbesondere können Sie die Reihenfolge, in der awk die Elemente einer Hash-Map anbietet, nicht steuern. Daher scanne ich wiederholt die gesamte Map, um das aktuell zahlreichste Element zu finden, es auszudrucken und aus dem Array zu löschen.

Es ist alles furchtbar ineffizient, mit all den Golfspielen, die ich gemacht habe, ist es auch ziemlich schrecklich geworden.

Minimiert:

{gsub("[^a-zA-Z]"," ");for(;NF;NF--)a[tolower($NF)]++}
END{split("the and of to a i it in or is",b," ");
for(w in b)delete a[b[w]];d=1;for(w in a){e=a[w]/(78-length(w));if(e>d)d=e}
for(i=22;i;--i){e=0;for(w in a)if(a[w]>e)e=a[x=w];l=a[x]/d-2;
t=sprintf(sprintf("%%%dc",l)," ");gsub(" ","_",t);if(i==22)print" "t;
print"|"t"| "x;delete a[x]}}

Zeilenumbrüche dienen nur der Übersichtlichkeit: Sie sind nicht erforderlich und sollten nicht gezählt werden.

Ausgabe:

$ gawk -f wordfreq.awk.min < 11.txt 
 _________________________________________________________________________
|_________________________________________________________________________| she
|_______________________________________________________________| you
|____________________________________________________________| said
|____________________________________________________| alice
|______________________________________________| was
|__________________________________________| that
|___________________________________| as
|_______________________________| her
|____________________________| with
|____________________________| at
|___________________________| s
|___________________________| t
|_________________________| on
|_________________________| all
|______________________| this
|______________________| for
|______________________| had
|_____________________| but
|____________________| be
|____________________| not
|___________________| they
|__________________| so
$ sed 's/you/superlongstring/gI' 11.txt | gawk -f wordfreq.awk.min
 ______________________________________________________________________
|______________________________________________________________________| she
|_____________________________________________________________| superlongstring
|__________________________________________________________| said
|__________________________________________________| alice
|____________________________________________| was
|_________________________________________| that
|_________________________________| as
|______________________________| her
|___________________________| with
|___________________________| at
|__________________________| s
|__________________________| t
|________________________| on
|________________________| all
|_____________________| this
|_____________________| for
|_____________________| had
|____________________| but
|___________________| be
|___________________| not
|__________________| they
|_________________| so

Lesbar; 633 Zeichen (ursprünglich 949):

{
    gsub("[^a-zA-Z]"," ");
    for(;NF;NF--)
    a[tolower($NF)]++
}
END{
    # remove "short" words
    split("the and of to a i it in or is",b," ");
    for (w in b) 
    delete a[b[w]];
    # Find the bar ratio
    d=1;
    for (w in a) {
    e=a[w]/(78-length(w));
    if (e>d)
        d=e
    }
    # Print the entries highest count first
    for (i=22; i; --i){               
    # find the highest count
    e=0;
    for (w in a) 
        if (a[w]>e)
        e=a[x=w];
        # Print the bar
    l=a[x]/d-2;
    # make a string of "_" the right length
    t=sprintf(sprintf("%%%dc",l)," ");
    gsub(" ","_",t);
    if (i==22) print" "t;
    print"|"t"| "x;
    delete a[x]
    }
}

Common LISP, 670 Zeichen

Ich bin ein LISP-Neuling, und dies ist ein Versuch, eine Hash-Tabelle zum Zählen zu verwenden (also wahrscheinlich nicht die kompakteste Methode).

(flet((r()(let((x(read-char t nil)))(and x(char-downcase x)))))(do((c(
make-hash-table :test 'equal))(w NIL)(x(r)(r))y)((not x)(maphash(lambda
(k v)(if(not(find k '("""the""and""of""to""a""i""it""in""or""is"):test
'equal))(push(cons k v)y)))c)(setf y(sort y #'> :key #'cdr))(setf y
(subseq y 0(min(length y)22)))(let((f(apply #'min(mapcar(lambda(x)(/(-
76.0(length(car x)))(cdr x)))y))))(flet((o(n)(dotimes(i(floor(* n f)))
(write-char #\_))))(write-char #\Space)(o(cdar y))(write-char #\Newline)
(dolist(x y)(write-char #\|)(o(cdr x))(format t "| ~a~%"(car x))))))
(cond((char<= #\a x #\z)(push x w))(t(incf(gethash(concatenate 'string(
reverse w))c 0))(setf w nil)))))

kann zum Beispiel mit ausgeführt werden cat alice.txt | clisp -C golf.lisp.

In lesbarer Form ist

(flet ((r () (let ((x (read-char t nil)))
               (and x (char-downcase x)))))
  (do ((c (make-hash-table :test 'equal))  ; the word count map
       w y                                 ; current word and final word list
       (x (r) (r)))  ; iteration over all chars
       ((not x)

        ; make a list with (word . count) pairs removing stopwords
        (maphash (lambda (k v)
                   (if (not (find k '("" "the" "and" "of" "to"
                                      "a" "i" "it" "in" "or" "is")
                                  :test 'equal))
                       (push (cons k v) y)))
                 c)

        ; sort and truncate the list
        (setf y (sort y #'> :key #'cdr))
        (setf y (subseq y 0 (min (length y) 22)))

        ; find the scaling factor
        (let ((f (apply #'min
                        (mapcar (lambda (x) (/ (- 76.0 (length (car x)))
                                               (cdr x)))
                                y))))
          ; output
          (flet ((outx (n) (dotimes (i (floor (* n f))) (write-char #\_))))
             (write-char #\Space)
             (outx (cdar y))
             (write-char #\Newline)
             (dolist (x y)
               (write-char #\|)
               (outx (cdr x))
               (format t "| ~a~%" (car x))))))

       ; add alphabetic to current word, and bump word counter
       ; on non-alphabetic
       (cond
        ((char<= #\a x #\z)
         (push x w))
        (t
         (incf (gethash (concatenate 'string (reverse w)) c 0))
         (setf w nil)))))

C (828)

Es sieht sehr nach verschleiertem Code aus und verwendet glib für Zeichenfolge, Liste und Hash. Char count mit wc -msagt 828 . Einzelzeichen werden nicht berücksichtigt. Um die maximale Länge des Balkens zu berechnen, wird das längste mögliche Wort unter allen berücksichtigt, nicht nur die ersten 22. Ist dies eine Abweichung von der Spezifikation?

Es behandelt keine Fehler und gibt keinen verwendeten Speicher frei.

#include <glib.h>
#define S(X)g_string_##X
#define H(X)g_hash_table_##X
GHashTable*h;int m,w=0,z=0;y(const void*a,const void*b){int*A,*B;A=H(lookup)(h,a);B=H(lookup)(h,b);return*B-*A;}void p(void*d,void*u){int *v=H(lookup)(h,d);if(w<22){g_printf("|");*v=*v*(77-z)/m;while(--*v>=0)g_printf("=");g_printf("| %s\n",d);w++;}}main(c){int*v;GList*l;GString*s=S(new)(NULL);h=H(new)(g_str_hash,g_str_equal);char*n[]={"the","and","of","to","it","in","or","is"};while((c=getchar())!=-1){if(isalpha(c))S(append_c)(s,tolower(c));else{if(s->len>1){for(c=0;c<8;c++)if(!strcmp(s->str,n[c]))goto x;if((v=H(lookup)(h,s->str))!=NULL)++*v;else{z=MAX(z,s->len);v=g_malloc(sizeof(int));*v=1;H(insert)(h,g_strdup(s->str),v);}}x:S(truncate)(s,0);}}l=g_list_sort(H(get_keys)(h),y);m=*(int*)H(lookup)(h,g_list_first(l)->data);g_list_foreach(l,p,NULL);}

Perl, 185 char

200 (leicht gebrochen) 199 197 195 193 187 185 Zeichen. Die letzten beiden Zeilenumbrüche sind von Bedeutung. Entspricht der Spezifikation.

map$X{+lc}+=!/^(.|the|and|to|i[nst]|o[rf])$/i,/[a-z]+/gfor<>;
$n=$n>($:=$X{$_}/(76-y+++c))?$n:$:for@w=(sort{$X{$b}-$X{$a}}%X)[0..21];
die map{$U='_'x($X{$_}/$n);" $U
"x!$z++,"|$U| $_
"}@w

In der ersten Zeile werden die Anzahl der gültigen Wörter geladen %X.

Die zweite Zeile berechnet den minimalen Skalierungsfaktor, sodass alle Ausgabezeilen <= 80 Zeichen sind.

Die dritte Zeile (enthält zwei Zeilenumbruchzeichen) erzeugt die Ausgabe.

Java - 886 865 756 744 742 744 752 742 714 680 Zeichen

• Aktualisierungen vor dem ersten 742 : Verbesserter Regex, Entfernen überflüssiger parametrisierter Typen, Entfernen überflüssiger Leerzeichen.

• Update 742> 744 Zeichen : Der Hack mit fester Länge wurde behoben. Es hängt nur vom 1. Wort ab, (noch) nicht von anderen Wörtern. Es wurden mehrere Stellen gefunden, an denen der Code \\sgekürzt werden konnte ( in Regex ersetzt durch und ArrayListersetzt durch Vector). Ich suche jetzt nach einem kurzen Weg, um die Commons IO-Abhängigkeit und das Lesen von stdin zu entfernen.

• Update 744> 752 Zeichen : Ich habe die Commons-Abhängigkeit entfernt. Es liest jetzt von stdin. Fügen Sie den Text in stdin ein und drücken Sie Ctrl+Z, um das Ergebnis zu erhalten.

• Update 752> 742 Zeichen : Ich habe publicein Leerzeichen entfernt und den Klassennamen 1 anstelle von 2 Zeichen gesetzt. Jetzt werden Wörter mit einem Buchstaben ignoriert.

• Update 742> 714 Zeichen : Aktualisiert gemäß den Kommentaren von Carl: Redundante Zuweisung entfernt (742> 730), ersetzt m.containsKey(k)durch m.get(k)!=null(730> 728), Teilstring der Zeile (728> 714) eingeführt.

• Update 714> 680 Zeichen : Aktualisiert gemäß den Kommentaren von Rotsor: Verbesserte Berechnung der Balkengröße, um unnötiges Casting zu entfernen, und verbessert split(), um unnötiges zu entfernen replaceAll().

import java.util.*;class F{public static void main(String[]a)throws Exception{StringBuffer b=new StringBuffer();for(int c;(c=System.in.read())>0;b.append((char)c));final Map<String,Integer>m=new HashMap();for(String w:b.toString().toLowerCase().split("(\\b(.|the|and|of|to|i[tns]|or)\\b|\\W)+"))m.put(w,m.get(w)!=null?m.get(w)+1:1);List<String>l=new Vector(m.keySet());Collections.sort(l,new Comparator(){public int compare(Object l,Object r){return m.get(r)-m.get(l);}});int c=76-l.get(0).length();String s=new String(new char[c]).replace('\0','_');System.out.println(" "+s);for(String w:l.subList(0,22))System.out.println("|"+s.substring(0,m.get(w)*c/m.get(l.get(0)))+"| "+w);}}

Lesbarere Version:

import java.util.*;
class F{
 public static void main(String[]a)throws Exception{
  StringBuffer b=new StringBuffer();for(int c;(c=System.in.read())>0;b.append((char)c));
  final Map<String,Integer>m=new HashMap();for(String w:b.toString().toLowerCase().split("(\\b(.|the|and|of|to|i[tns]|or)\\b|\\W)+"))m.put(w,m.get(w)!=null?m.get(w)+1:1);
  List<String>l=new Vector(m.keySet());Collections.sort(l,new Comparator(){public int compare(Object l,Object r){return m.get(r)-m.get(l);}});
  int c=76-l.get(0).length();String s=new String(new char[c]).replace('\0','_');System.out.println(" "+s);
  for(String w:l.subList(0,22))System.out.println("|"+s.substring(0,m.get(w)*c/m.get(l.get(0)))+"| "+w);
 }
}

Ausgabe:

 _________________________________________________________________________
| _________________________________________________________________________ | sie
| _______________________________________________________________ | Sie
| ____________________________________________________________ | sagte
| _____________________________________________________ | Alice
| _______________________________________________ | war
| ___________________________________________ | Das
| ____________________________________ | wie
| ________________________________ | ihr
| _____________________________ | mit
| _____________________________ | beim
| __________________________ | auf
| __________________________ | alles
| _______________________ | Dies
| _______________________ | zum
| _______________________ | hätten
| _______________________ | aber
| ______________________ | Sein
| _____________________ | nicht
| ____________________ | Sie
| ____________________ | so
| ___________________ | sehr
| __________________ | Was

Es saugt ziemlich , dass Java nicht hat String#join()und Verschlüsse (noch) nicht .

Bearbeiten von Rotsor:

Ich habe einige Änderungen an Ihrer Lösung vorgenommen:

• Liste durch einen String ersetzt []
• Das Argument 'args' wurde wiederverwendet, anstatt mein eigenes String-Array zu deklarieren. Verwendet es auch als Argument für .ToArray ()
• Ersetzte StringBuffer durch einen String (ja, ja, schreckliche Leistung)
• Ersetzte die Java-Sortierung durch eine Auswahlsortierung mit frühem Anhalten (nur die ersten 22 Elemente müssen gefunden werden)
• Aggregierte eine int-Deklaration zu einer einzigen Anweisung
• Implementiert den Algorithmus ohne Betrug, der die einschränkendste Ausgabezeile findet. Implementiert ohne FP.
• Das Problem, dass das Programm abstürzte, wenn der Text weniger als 22 verschiedene Wörter enthielt, wurde behoben
• Implementierung eines neuen Algorithmus zum Lesen von Eingaben, der schnell und nur 9 Zeichen länger als der langsame ist.

Der komprimierte Code ist 688 711 684 Zeichen lang:

import java.util.*;class F{public static void main(String[]l)throws Exception{Map<String,Integer>m=new HashMap();String w="";int i=0,k=0,j=8,x,y,g=22;for(;(j=System.in.read())>0;w+=(char)j);for(String W:w.toLowerCase().split("(\\b(.|the|and|of|to|i[tns]|or)\\b|\\W)+"))m.put(W,m.get(W)!=null?m.get(W)+1:1);l=m.keySet().toArray(l);x=l.length;if(x<g)g=x;for(;i<g;++i)for(j=i;++j<x;)if(m.get(l[i])<m.get(l[j])){w=l[i];l[i]=l[j];l[j]=w;}for(;k<g;k++){x=76-l[k].length();y=m.get(l[k]);if(k<1||y*i>x*j){i=x;j=y;}}String s=new String(new char[m.get(l[0])*i/j]).replace('\0','_');System.out.println(" "+s);for(k=0;k<g;k++){w=l[k];System.out.println("|"+s.substring(0,m.get(w)*i/j)+"| "+w);}}}

Die schnelle Version ( 720 693 Zeichen)

import java.util.*;class F{public static void main(String[]l)throws Exception{Map<String,Integer>m=new HashMap();String w="";int i=0,k=0,j=8,x,y,g=22;for(;j>0;){j=System.in.read();if(j>90)j-=32;if(j>64&j<91)w+=(char)j;else{if(!w.matches("^(|.|THE|AND|OF|TO|I[TNS]|OR)$"))m.put(w,m.get(w)!=null?m.get(w)+1:1);w="";}}l=m.keySet().toArray(l);x=l.length;if(x<g)g=x;for(;i<g;++i)for(j=i;++j<x;)if(m.get(l[i])<m.get(l[j])){w=l[i];l[i]=l[j];l[j]=w;}for(;k<g;k++){x=76-l[k].length();y=m.get(l[k]);if(k<1||y*i>x*j){i=x;j=y;}}String s=new String(new char[m.get(l[0])*i/j]).replace('\0','_');System.out.println(" "+s);for(k=0;k<g;k++){w=l[k];System.out.println("|"+s.substring(0,m.get(w)*i/j)+"| "+w);}}}

Lesbarere Version:

import java.util.*;class F{public static void main(String[]l)throws Exception{
    Map<String,Integer>m=new HashMap();String w="";
    int i=0,k=0,j=8,x,y,g=22;
    for(;j>0;){j=System.in.read();if(j>90)j-=32;if(j>64&j<91)w+=(char)j;else{
        if(!w.matches("^(|.|THE|AND|OF|TO|I[TNS]|OR)$"))m.put(w,m.get(w)!=null?m.get(w)+1:1);w="";
    }}
    l=m.keySet().toArray(l);x=l.length;if(x<g)g=x;
    for(;i<g;++i)for(j=i;++j<x;)if(m.get(l[i])<m.get(l[j])){w=l[i];l[i]=l[j];l[j]=w;}
    for(;k<g;k++){x=76-l[k].length();y=m.get(l[k]);if(k<1||y*i>x*j){i=x;j=y;}}
    String s=new String(new char[m.get(l[0])*i/j]).replace('\0','_');
    System.out.println(" "+s);
    for(k=0;k<g;k++){w=l[k];System.out.println("|"+s.substring(0,m.get(w)*i/j)+"| "+w);}}
}

Die Version ohne Verhaltensverbesserungen besteht aus 615 Zeichen:

import java.util.*;class F{public static void main(String[]l)throws Exception{Map<String,Integer>m=new HashMap();String w="";int i=0,k=0,j=8,g=22;for(;j>0;){j=System.in.read();if(j>90)j-=32;if(j>64&j<91)w+=(char)j;else{if(!w.matches("^(|.|THE|AND|OF|TO|I[TNS]|OR)$"))m.put(w,m.get(w)!=null?m.get(w)+1:1);w="";}}l=m.keySet().toArray(l);for(;i<g;++i)for(j=i;++j<l.length;)if(m.get(l[i])<m.get(l[j])){w=l[i];l[i]=l[j];l[j]=w;}i=76-l[0].length();String s=new String(new char[i]).replace('\0','_');System.out.println(" "+s);for(k=0;k<g;k++){w=l[k];System.out.println("|"+s.substring(0,m.get(w)*i/m.get(l[0]))+"| "+w);}}}

Scala 2.8, 311 314 320 330 332 336 341 375 Zeichen

einschließlich Langworteinstellung. Ideen aus den anderen Lösungen entlehnt.

Jetzt als Skript ( a.scala):

val t="\\w+\\b(?<!\\bthe|and|of|to|a|i[tns]?|or)".r.findAllIn(io.Source.fromFile(argv(0)).mkString.toLowerCase).toSeq.groupBy(w=>w).mapValues(_.size).toSeq.sortBy(-_._2)take 22
def b(p:Int)="_"*(p*(for((w,c)<-t)yield(76.0-w.size)/c).min).toInt
println(" "+b(t(0)._2))
for(p<-t)printf("|%s| %s \n",b(p._2),p._1)

Laufen Sie mit

scala -howtorun:script a.scala alice.txt

Übrigens entfernt die Bearbeitung von 314 auf 311 Zeichen tatsächlich nur 1 Zeichen. Jemand hat die Zählung vorher falsch verstanden (Windows CRs?).

Clojure 282 streng

(let[[[_ m]:as s](->>(slurp *in*).toLowerCase(re-seq #"\w+\b(?<!\bthe|and|of|to|a|i[tns]?|or)")frequencies(sort-by val >)(take 22))[b](sort(map #(/(- 76(count(key %)))(val %))s))p #(do(print %1)(dotimes[_(* b %2)](print \_))(apply println %&))](p " " m)(doseq[[k v]s](p \| v \| k)))

Etwas leserlicher:

(let[[[_ m]:as s](->> (slurp *in*)
                   .toLowerCase
                   (re-seq #"\w+\b(?<!\bthe|and|of|to|a|i[tns]?|or)")
                   frequencies
                   (sort-by val >)
                   (take 22))
     [b] (sort (map #(/ (- 76 (count (key %)))(val %)) s))
     p #(do
          (print %1)
          (dotimes[_(* b %2)] (print \_))
          (apply println %&))]
  (p " " m)
  (doseq[[k v] s] (p \| v \| k)))

Scala, 368 Zeichen

Zunächst eine lesbare Version mit 592 Zeichen:

object Alice {
  def main(args:Array[String]) {
    val s = io.Source.fromFile(args(0))
    val words = s.getLines.flatMap("(?i)\\w+\\b(?<!\\bthe|and|of|to|a|i|it|in|or|is)".r.findAllIn(_)).map(_.toLowerCase)
    val freqs = words.foldLeft(Map[String, Int]())((countmap, word)  => countmap + (word -> (countmap.getOrElse(word, 0)+1)))
    val sortedFreqs = freqs.toList.sort((a, b)  => a._2 > b._2)
    val top22 = sortedFreqs.take(22)
    val highestWord = top22.head._1
    val highestCount = top22.head._2
    val widest = 76 - highestWord.length
    println(" " + "_" * widest)
    top22.foreach(t => {
      val width = Math.round((t._2 * 1.0 / highestCount) * widest).toInt
      println("|" + "_" * width + "| " + t._1)
    })
  }
}

Die Konsolenausgabe sieht folgendermaßen aus:

$ scalac alice.scala 
$ scala Alice aliceinwonderland.txt
 _________________________________________________________________________
|_________________________________________________________________________| she
|_______________________________________________________________| you
|_____________________________________________________________| said
|_____________________________________________________| alice
|_______________________________________________| was
|____________________________________________| that
|____________________________________| as
|_________________________________| her
|______________________________| at
|______________________________| with
|_____________________________| s
|_____________________________| t
|___________________________| on
|__________________________| all
|_______________________| had
|_______________________| but
|______________________| be
|______________________| not
|____________________| they
|____________________| so
|___________________| very
|___________________| what

Wir können aggressiv minimieren und es auf 415 Zeichen reduzieren:

object A{def main(args:Array[String]){val l=io.Source.fromFile(args(0)).getLines.flatMap("(?i)\\w+\\b(?<!\\bthe|and|of|to|a|i|it|in|or|is)".r.findAllIn(_)).map(_.toLowerCase).foldLeft(Map[String, Int]())((c,w)=>c+(w->(c.getOrElse(w,0)+1))).toList.sort((a,b)=>a._2>b._2).take(22);println(" "+"_"*(76-l.head._1.length));l.foreach(t=>println("|"+"_"*Math.round((t._2*1.0/l.head._2)*(76-l.head._1.length)).toInt+"| "+t._1))}}

Die Konsolensitzung sieht folgendermaßen aus:

$ scalac a.scala 
$ scala A aliceinwonderland.txt
 _________________________________________________________________________
|_________________________________________________________________________| she
|_______________________________________________________________| you
|_____________________________________________________________| said
|_____________________________________________________| alice
|_______________________________________________| was
|____________________________________________| that
|____________________________________| as
|_________________________________| her
|______________________________| at
|______________________________| with
|_____________________________| s
|_____________________________| t
|___________________________| on
|__________________________| all
|_______________________| had
|_______________________| but
|______________________| be
|______________________| not
|____________________| they
|____________________| so
|___________________| very
|___________________| what

Ich bin sicher, ein Scala-Experte könnte es noch besser machen.

Update: In den Kommentaren gab Thomas eine noch kürzere Version mit 368 Zeichen an:

object A{def main(a:Array[String]){val t=(Map[String, Int]()/:(for(x<-io.Source.fromFile(a(0)).getLines;y<-"(?i)\\w+\\b(?<!\\bthe|and|of|to|a|i|it|in|or|is)".r findAllIn x) yield y.toLowerCase).toList)((c,x)=>c+(x->(c.getOrElse(x,0)+1))).toList.sortBy(_._2).reverse.take(22);val w=76-t.head._1.length;print(" "+"_"*w);t map (s=>"\n|"+"_"*(s._2*w/t.head._2)+"| "+s._1) foreach print}}

Lesbar mit 375 Zeichen:

object Alice {
  def main(a:Array[String]) {
    val t = (Map[String, Int]() /: (
      for (
        x <- io.Source.fromFile(a(0)).getLines
        y <- "(?i)\\w+\\b(?<!\\bthe|and|of|to|a|i|it|in|or|is)".r.findAllIn(x)
      ) yield y.toLowerCase
    ).toList)((c, x) => c + (x -> (c.getOrElse(x, 0) + 1))).toList.sortBy(_._2).reverse.take(22)
    val w = 76 - t.head._1.length
    print (" "+"_"*w)
    t.map(s => "\n|" + "_" * (s._2 * w / t.head._2) + "| " + s._1).foreach(print)
  }
}

Java - 896 Zeichen

931 Zeichen

1233 Zeichen unlesbar gemacht

1977 Zeichen "unkomprimiert"

Update: Ich habe die Anzahl der Zeichen aggressiv reduziert. Lässt Wörter mit einem Buchstaben pro aktualisierter Spezifikation weg.

Ich beneide C # und LINQ so sehr.

import java.util.*;import java.io.*;import static java.util.regex.Pattern.*;class g{public static void main(String[] a)throws Exception{PrintStream o=System.out;Map<String,Integer> w=new HashMap();Scanner s=new Scanner(new File(a[0])).useDelimiter(compile("[^a-z]+|\\b(the|and|of|to|.|it|in|or|is)\\b",2));while(s.hasNext()){String z=s.next().trim().toLowerCase();if(z.equals(""))continue;w.put(z,(w.get(z)==null?0:w.get(z))+1);}List<Integer> v=new Vector(w.values());Collections.sort(v);List<String> q=new Vector();int i,m;i=m=v.size()-1;while(q.size()<22){for(String t:w.keySet())if(!q.contains(t)&&w.get(t).equals(v.get(i)))q.add(t);i--;}int r=80-q.get(0).length()-4;String l=String.format("%1$0"+r+"d",0).replace("0","_");o.println(" "+l);o.println("|"+l+"| "+q.get(0)+" ");for(i=m-1;i>m-22;i--){o.println("|"+l.substring(0,(int)Math.round(r*(v.get(i)*1.0)/v.get(m)))+"| "+q.get(m-i)+" ");}}}

"Lesbar":

import java.util.*;
import java.io.*;
import static java.util.regex.Pattern.*;
class g
{
   public static void main(String[] a)throws Exception
      {
      PrintStream o = System.out;
      Map<String,Integer> w = new HashMap();
      Scanner s = new Scanner(new File(a[0]))
         .useDelimiter(compile("[^a-z]+|\\b(the|and|of|to|.|it|in|or|is)\\b",2));
      while(s.hasNext())
      {
         String z = s.next().trim().toLowerCase();
         if(z.equals(""))
            continue;
         w.put(z,(w.get(z) == null?0:w.get(z))+1);
      }
      List<Integer> v = new Vector(w.values());
      Collections.sort(v);
      List<String> q = new Vector();
      int i,m;
      i = m = v.size()-1;
      while(q.size()<22)
      {
         for(String t:w.keySet())
            if(!q.contains(t)&&w.get(t).equals(v.get(i)))
               q.add(t);
         i--;
      }
      int r = 80-q.get(0).length()-4;
      String l = String.format("%1$0"+r+"d",0).replace("0","_");
      o.println(" "+l);
      o.println("|"+l+"| "+q.get(0)+" ");
      for(i = m-1; i > m-22; i--)
      {
         o.println("|"+l.substring(0,(int)Math.round(r*(v.get(i)*1.0)/v.get(m)))+"| "+q.get(m-i)+" ");
      }
   }
}

Ausgabe von Alice:

 _________________________________________________________________________
|_________________________________________________________________________| she
|_______________________________________________________________| you
|_____________________________________________________________| said
|_____________________________________________________| alice
|_______________________________________________| was
|____________________________________________| that
|____________________________________| as
|_________________________________| her
|______________________________| with
|______________________________| at
|___________________________| on
|__________________________| all
|________________________| this
|________________________| for
|_______________________| had
|_______________________| but
|______________________| be
|______________________| not
|____________________| they
|____________________| so
|___________________| very
|___________________| what

Ausgabe von Don Quijote (ebenfalls aus Gutenberg):

 ________________________________________________________________________
|________________________________________________________________________| that
|________________________________________________________| he
|______________________________________________| for
|__________________________________________| his
|________________________________________| as
|__________________________________| with
|_________________________________| not
|_________________________________| was
|________________________________| him
|______________________________| be
|___________________________| don
|_________________________| my
|_________________________| this
|_________________________| all
|_________________________| they
|________________________| said
|_______________________| have
|_______________________| me
|______________________| on
|______________________| so
|_____________________| you
|_____________________| quixote