Die Herausforderung:
Erstellen Sie ein ASCII-Diagramm mit den am häufigsten verwendeten Wörtern in einem bestimmten Text.
Die Regeln:
- Akzeptiere nur
a-z
undA-Z
(alphabetische Zeichen) als Teil eines Wortes. - Gehäuse ignorieren (
She
==she
fü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 Bereichena-z
undA-Z
: (don
undt
) 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 chart
mit 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 <=80
Zeichen 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 you
in 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).
quelle
s
und vertretent
sind.Antworten:
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:
quelle
Ruby 1,9, 185 Zeichen
(stark basierend auf den anderen Ruby-Lösungen)
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;)
quelle
GolfScript,
177175173167164163144131130 ZeichenLangsam - 3 Minuten für den Beispieltext (130)
Erläuterung:
"Richtig" (hoffentlich). (143)
Weniger langsam - eine halbe Minute. (162)
Ausgabe in Revisionsprotokollen sichtbar.
quelle
206
Shell, Grep, Tr, Grep, Sortieren, Uniq, Sortieren, Kopf, Perl
hm, gerade oben gesehen:sort -nr
->sort -n
und dannhead
->tail
=> 208 :)update2: ähm, natürlich ist das obige albern, da es dann umgekehrt wird. Also, 209.
update3: optimiert den Ausschluss regexp -> 206
Zum Spaß hier eine Nur-Perl-Version (viel schneller):
quelle
Transact SQL Set-basierte Lösung (SQL Server 2005)
1063892873853827820783683647644630 ZeichenVielen 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.
Lesbare Version
Ausgabe
Und mit der langen Schnur
quelle
0.000
zu just zu wechseln0
und dann-C
anstelle von zu verwenden1.0/C
. Und machtFLOAT
inREAL
wird auch einen Schlaganfall zu speichern. Das Größte ist jedoch, dass es so aussieht, als hätten Sie vieleAS
Instanzen, die optional sein sollten.SELECT [ ] FROM (SELECT $0 O, ' '+REPLICATE('_', MAX(C)*@F)+' ' [ ] FROM # UNION SELECT $1/C, '|'+REPLICATE('_',C*@F)+'| '+W FROM #)X ORDER BY O
?Ruby
207213211210207203201200 ZeichenEine Verbesserung gegenüber Anurag, die Vorschläge von rfusca enthält. Entfernt auch Argumente zum Sortieren und einige andere kleinere Golfe.
Ausführen als:
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
s
in-place.Edit6: M schweben lassen, 1.0 entfernt. EDIT: Funktioniert nicht, ändert die Länge. EDIT: Nicht schlechter als zuvor
Edit7: Verwenden
STDIN.read
.quelle
Mathematica (
297284248244242199 Zeichen) Pure Functionalund Zipf's Law Testing
Schau Mama ... keine Vars, keine Hände, ... kein Kopf
Bearbeiten Sie 1> einige definierte Abkürzungen (284 Zeichen)
Einige Erklärungen
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
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"
Bearbeiten Sie 7 → 199 Zeichen
f
durchTranspose
undSlot
(#1
/#2
) Argumente.f@x
stattf[x]
wo möglich)quelle
|i|
ist in Ihrer Regex überflüssig, weil Sie bereits haben.|
.C # -
510451436446434426422 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.
422 Zeichen mit Lendivisor inline (was es 22-mal langsamer macht) in der folgenden Form (Zeilenumbrüche für ausgewählte Leerzeichen):
quelle
Perl,
237229209 Zeichen(Wieder aktualisiert die Ruby - Version mit mehr schmutzig Golf Tricks zu schlagen, ersetzen
split/[^a-z/,lc
mitlc=~/[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
print
durchsay
und verwenden Sie~~
, um a zu vermeidenmap
. Dies muss in der Kommandozeile als aufgerufen werdenperl -E '<one-liner>' alice.txt
. Da sich das gesamte Skript in einer Zeile befindet, sollte das Schreiben als Einzeiler keine Schwierigkeit darstellen :).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-Z
den 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:
Das Folgende ist ungefähr so kurz wie es nur geht, während es relativ lesbar bleibt. (392 Zeichen).
quelle
foreach
s können alsfor
s geschrieben werden . Das sind 8 Zeichen weniger. Dann haben Sie diegrep{!($_~~@s)}map{lc=~/[a-z]+/g}<>
, von der ich glaube, dass sie geschrieben werden könntegrep{!(/$_/i~~@s)}<>=~/[a-z]+/g
, um 4 weitere nach unten zu gehen. Ersetzen Sie die" "
durch$"
und Sie sind unten 1 weitere ...sort{$c{$b}-$c{$a}}...
zwei weitere zu retten. Sie können auch einfach%c
anstellekeys %c
dersort
Funktion übergeben und vier weitere speichern.Windows PowerShell, 199 Zeichen
(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:
Geschichte
Entspannte Version (137), da dies anscheinend inzwischen separat gezählt wird:
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 .
quelle
-split("\b(?:the|and|of|to|a|i[tns]?|or)\b|[^a-z]")
? Für mich geht das."|$('_'*($w*$_.count/$x[0].count))| $($_.name) "
(oder entfernen Sie das letzte Leerzeichen, da dies automatisch erfolgt). Und Sie können verwenden-split("(?:\b(?:the|and|of|to|a|i[tns]?|or)\b|[^a-z])+")
, um ein paar mehr zu speichern, indem Sie Leerzeichen (oder Verwendung[-2..-23]
) nicht einschließen .Ruby, 215,
216,218,221,224,236,237ZeichenUpdate 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
,map
um 1 Zeichen zu speichern :)Update 3: Geändert
File.read
zuIO.read
+2.Array.group_by
war nicht sehr fruchtbar, geändert aufreduce
+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 +15Update 4:
[0]
anstatt.first
+3. (@ Shtééf)Update 5: Variable
l
an Ort und Stelle erweitern, +1. Erweitern Sie die Variables
an Ort und Stelle, +2. (@ Shtééf)Update 6: Verwenden Sie für die erste Zeile +2 die Zeichenfolgenaddition anstelle der Interpolation. (@ Shtééf)
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)
Lesbare Version
Benutzen:
Ausgabe:
quelle
scan
gab mir jedoch eine bessere Idee, so dass ich wieder weiterkam :).Python 2.x, latitudinarianer Ansatz =
227183 ZeichenUnter 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"s
undt
aus dem Beispiel ausschließt - und den Ausschluss füran, 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:itheandtoforinis
undandithetoforinis
.PS. von anderen Lösungen ausgeliehen, um den Code zu verkürzen.
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
or
in die Ignorierliste des Problems aufgenommen wurde, wo es ~ 30 in der Popularität ist, wenn das Wortthat
(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 =
277243 ZeichenDas 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:
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, is
werden 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.
quelle
\W
oder\b
eine Regex-Verwendung verwenden, da diese höchstwahrscheinlich nicht den Spezifikationen entsprechen. Dies bedeutet, dass sie nicht auf Ziffern aufgeteilt werden oder_
Stoppwörter nicht aus Zeichenfolgen entfernt werden wiethe_foo_or123bar
. Sie erscheinen möglicherweise nicht im Testtext, aber die Spezifikation ist in diesem Fall ziemlich klar.sys.argv
re.findall(r'\b(?!(?:the|and|.|of|to|i[tns]|or)\b)\w+',sys.stdin.read().lower())
Haskell -
366351344337333 Zeichen(Ein Zeilenumbruch wurde
main
zur besseren Lesbarkeit hinzugefügt, und am Ende der letzten Zeile ist kein Zeilenumbruch erforderlich.)Wie es funktioniert, lässt sich am besten anhand des Arguments
interact
rü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 (
notElemwords "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 Funktionb
ordnetc x
überx
, wox
die Liste der Histogramme ist. Die gesamte Liste wird an übergebenc
, so dass jeder Aufruf vonc
den Skalierungsfaktor durch Aufrufen für sich selbst berechnen kannu
. 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,reverse
diesort
seit Sortierung (aufsteigend)-frequency
werden Orte der Worte mit der größten Frequenz zuerst. Später in der Funktionu
werden zwei-frequency
Werte multipliziert, wodurch die Negation aufgehoben wird.quelle
div
eigentlich nicht bewegen ! Probieren Sie es aus - die Ausgabe ist falsch. Der Grund ist, dass dasdiv
vor dem*
Verlieren die Präzision verliert.JavaScript 1.8 (SpiderMonkey) - 354
Leider
for([k,v]in z)
scheint die Version aus der Rhino-Version nicht in SpiderMonkey funktionieren zu wollen undreadFile()
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:
Verwendung:
js golf.js < input.txt
Ausgabe:
(Basisversion - behandelt Balkenbreiten nicht richtig)
JavaScript (Rhino) -
405395387377368343304 ZeichenIch denke, meine Sortierlogik ist aus, aber ... ich weiß nicht.Brainfart behoben.Minimiert (Missbrauch wird manchmal
\n
als interpretiert;
):quelle
i[tns]?
bisschen. Sehr hinterhältig..replace(/[^\w ]/g, e).split(/\s+/).map(
kann durch.replace(/\w+/g,
dieselbe Funktion ersetzt werden und diese verwenden, die Sie.map
getan haben ... Auch nicht sicher, ob Rhinofunction(a,b)b.c-a.c
anstelle Ihrer Sortierfunktion unterstützt (Spidermonkey tut dies), aber das wird rasieren{return }
...b.c-a.c
ist eine bessere Sorte alsa.c<b.c
übrigens ... Bearbeiten einer Spidermonkey-Version unten mit diesen Änderungen?:
großartiger Basis zum Arbeiten gespielt!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:
Für Menschen lesbar:
Ausgabe:
Wenn es ein langes Wort gibt, werden die Balken richtig eingestellt:
quelle
Python 3.1 -
245229 ZeichenIch 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.
Druckt aus:
Ein Teil des Codes wurde aus der AKX-Lösung "entlehnt".
quelle
open('!')
von stdin zu lesen - auf welcher Version / welchem Betriebssystem ist das? oder müssen Sie die Datei '!' benennen?Perl,
205191189 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:
Neueste Version mit bis zu191 Zeichen:Neueste Version mit bis zu 189 Zeichen:
Diese Version (205 Zeichen) berücksichtigt die Zeilen mit Wörtern, die länger sind als die später gefundenen.
quelle
Perl:
203202201198195208203/231 ZeichenAlternative, 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 ):
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:
Alternative Implementierung im pathologischen Fallbeispiel:
quelle
is|in|it|i
ini[snt]?
- und dann gibt es keinen Unterschied mit der optionalen Regel mehr. (Hm, ich hätte nie darüber nachgedacht, einem Perl-Typ zu sagen, wie man Regex macht: D) - einziges Problem jetzt: Ich muss schauen, wie ich drei Bytes von meiner eigenen Lösung abschneiden kann, um wieder besser als Perl zu sein: - |F #, 452 Zeichen
Unkompliziert: Holen Sie sich eine Folge
a
von Wortzahlpaaren , finden Sie den besten Multiplikator für die Wortzahl pro Spaltek
und drucken Sie die Ergebnisse.Beispiel (Ich habe andere Freq-Zählungen als Sie, unsicher warum):
quelle
float
s brauchen würden .|>
?Python 2.6, 347 Zeichen
Ausgabe:
quelle
bm=(76.-len(W[0][0]))/W[0][1]
da Sie bm nur einmal verwenden (machen Sie die nächste ZeileU=lambda n:"_"*int(n*(76.-len(W[0][0]))/W[0][1])
, rasieren Sie 5 Zeichen ab. Außerdem: Warum sollten Sie beim Code-Golfen einen 2-stelligen Variablennamen verwenden? ;-)* 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:
quelle
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:
Zeilenumbrüche dienen nur der Übersichtlichkeit: Sie sind nicht erforderlich und sollten nicht gezählt werden.
Ausgabe:
Lesbar; 633 Zeichen (ursprünglich 949):
quelle
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).
kann zum Beispiel mit ausgeführt werden
cat alice.txt | clisp -C golf.lisp
.In lesbarer Form ist
quelle
C (828)
Es sieht sehr nach verschleiertem Code aus und verwendet glib für Zeichenfolge, Liste und Hash. Char count mit
wc -m
sagt 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.
quelle
*v=*v*(77-lw)/m
. B. 929. .. aber ich denke, es kann in Ordnung sein, wenn ich nicht einen Weg finde, es viel kürzer zu machen)int c
in diemain
Erklärung verschieben undmain
ist implizitint
(wie alle untypisierten Argumente, afaik) :main(c){...}
. Sie könnten wahrscheinlich auch einfach schreiben0
stattNULL
.-Wall
oder mit-std=c99
Flagge ausgelöst ... aber ich nehme an, dass dies für einen Code-Golf sinnlos ist, oder?Without freeing memory stuff, it reaches 866 (removed some other unuseful space)
zu etwas anderem wechseln , um die Leute nicht glauben zu lassen, dass der Unterschied zur Version mit freiem Speicher darin besteht: Jetzt hat die Version ohne freien Speicher eine Menge mehr "Verbesserungen".Perl, 185 char
200 (leicht gebrochen)199197195193187185 Zeichen. Die letzten beiden Zeilenumbrüche sind von Bedeutung. Entspricht der Spezifikation.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.
quelle
Java -
886865756744742744752742714680 ZeichenAktualisierungen 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
und
\\s
gekürzt werden konnte ( in Regex ersetzt durchArrayList
ersetzt durchVector
). 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
public
ein 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)
durchm.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 entfernenreplaceAll()
.Lesbarere Version:
Ausgabe:
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:
Der komprimierte Code ist
688711684 Zeichen lang:Die schnelle Version (
720693 Zeichen)Lesbarere Version:
Die Version ohne Verhaltensverbesserungen besteht aus 615 Zeichen:
quelle
IOUtils
anstatt ihn zu importieren? Soweit ich sehen kann, verwenden Sie es sowieso nur einmal.b
einen String anstelle eines StringBuffers erstellen. Ich möchte jedoch nicht darüber nachdenken, wie die Leistung aussehen würde (zumal Sie jeweils einen Charakter hinzufügen).Scala 2.8, 311
314320330332336341375Zeicheneinschließlich Langworteinstellung. Ideen aus den anderen Lösungen entlehnt.
Jetzt als Skript (
a.scala
):Laufen Sie mit
Übrigens entfernt die Bearbeitung von 314 auf 311 Zeichen tatsächlich nur 1 Zeichen. Jemand hat die Zählung vorher falsch verstanden (Windows CRs?).
quelle
Clojure 282 streng
Etwas leserlicher:
quelle
Scala, 368 Zeichen
Zunächst eine lesbare Version mit 592 Zeichen:
Die Konsolenausgabe sieht folgendermaßen aus:
Wir können aggressiv minimieren und es auf 415 Zeichen reduzieren:
Die Konsolensitzung sieht folgendermaßen aus:
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:
Lesbar mit 375 Zeichen:
quelle
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}}
Java - 896 Zeichen
931 Zeichen1233 Zeichen unlesbar gemacht1977 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.
"Lesbar":
Ausgabe von Alice:
Ausgabe von Don Quijote (ebenfalls aus Gutenberg):
quelle