ความท้าทาย:

สร้างแผนภูมิ ASCII ของคำที่ใช้บ่อยที่สุดในข้อความที่กำหนด

กฎระเบียบ:

• ยอมรับa-zและA-Z(ตัวอักษร) เป็นส่วนหนึ่งของคำเท่านั้น
• ไม่สนใจเคส ( She== sheสำหรับจุดประสงค์ของเรา)
• ไม่ต้องสนใจคำต่อไปนี้ (ฉันรู้โดยนัย) the, and, of, to, a, i, it, in, or, is

• การชี้แจง: การพิจารณาdon't: สิ่งนี้จะถูกนำมาเป็น 'คำศัพท์' ที่ต่างกัน 2 รายการในช่วงa-zและA-Z: ( donและt)

• เป็นทางเลือก (มันสายเกินไปที่จะเปลี่ยนแปลงข้อกำหนดอย่างเป็นทางการในตอนนี้) คุณอาจเลือกที่จะทิ้งคำว่า 'word' ตัวอักษรตัวเดียวทั้งหมด (ซึ่งอาจทำให้การเพิกเฉยรายการเพิกเฉยสั้นลง)

แยกวิเคราะห์ที่กำหนดtext(อ่านไฟล์ที่ระบุผ่านอาร์กิวเมนต์บรรทัดคำสั่งหรือ piped ใน; เข้าใจus-ascii) และสร้างเราword frequency chartด้วยคุณสมบัติดังต่อไปนี้:

• แสดงแผนภูมิ (ดูตัวอย่างด้านล่าง) สำหรับคำที่พบบ่อยที่สุด 22 คำ (เรียงลำดับตามความถี่จากมากไปน้อย)
• แถบwidthแสดงจำนวนการเกิดขึ้น (ความถี่) ของคำ (ตามสัดส่วน) ต่อท้ายหนึ่งช่องว่างและพิมพ์คำ
• ตรวจสอบให้แน่ใจว่าแถบเหล่านี้ (บวก space-word-space) พอดีเสมอ: bar+ [space]+ word+ [space]ควรเสมอ <= 80ตัวอักษร (ตรวจสอบให้แน่ใจว่าคุณคำนึงถึงแถบที่แตกต่างและความยาวของคำที่เป็นไปได้: เช่น: คำทั่วไปที่สอง ครั้งแรกในขณะที่ไม่แตกต่างกันมากในความถี่) ขยายความกว้างของแถบให้ใหญ่สุดภายในข้อ จำกัด เหล่านี้และปรับขนาดแท่งให้เหมาะสม (ตามความถี่ที่แสดง)

ตัวอย่าง:

ข้อความตัวอย่างสามารถพบได้ที่นี่ ( การผจญภัยของอลิซในแดนมหัศจรรย์โดย Lewis Carroll )

ข้อความเฉพาะนี้จะให้ผลแผนภูมิดังต่อไปนี้:

 _________________________________________________________________________
| _________________________________________________________________________ | เธอ
| _______________________________________________________________ | คุณ
| ____________________________________________________________ | กล่าว
| ____________________________________________________ | อลิซ
| ______________________________________________ | เป็น
| __________________________________________ | ที่
| ___________________________________ | เช่น
| _______________________________ | เธอ
| ____________________________ | กับ
| ____________________________ | ที่
| ___________________________ | s
| ___________________________ | เสื้อ
| _________________________ | บน
| _________________________ | ทั้งหมด
| ______________________ | นี้
| ______________________ | สำหรับ
| ______________________ | มี
| _____________________ | แต่
| ____________________ | เป็น
| ____________________ | ไม่
| ___________________ | พวกเขา
| __________________ | ดังนั้น

สำหรับข้อมูลของคุณ: ความถี่เหล่านี้เป็นแผนภูมิด้านบนที่สร้างขึ้น:

[('เธอ', 553), ('คุณ', 481), ('พูดว่า', 462), ('อลิซ', 403), ('คือ', 358), ('นั่น
', 330), (' as ', 274), (' her ', 248), (' with ', 227), (' at ', 227), (' s ', 219), (' t '
, 218), ('บน', 204), ('ทั้งหมด', 200), ('สิ่งนี้', 181), ('สำหรับ', 179), ('มี', 178), ('
แต่ ', 175), (' be ', 167), (' not ', 166), (' พวกเขา ', 155), (' so ', 152)]

ตัวอย่างที่สอง (เพื่อตรวจสอบว่าคุณใช้ข้อมูลจำเพาะทั้งหมดหรือไม่): แทนที่ทุกครั้งที่เกิดขึ้นในไฟล์Alice in Wonderland ที่youลิงก์ด้วย:superlongstringstring

 ________________________________________________________________
| ________________________________________________________________ | เธอ
| _______________________________________________________ | superlongstringstring
| _____________________________________________________ | กล่าว
| ______________________________________________ | อลิซ
| ________________________________________ | เป็น
| _____________________________________ | ที่
| ______________________________ | เช่น
| ___________________________ | เธอ
| _________________________ | กับ
| _________________________ | ที่
| ________________________ | s
| ________________________ | เสื้อ
| ______________________ | บน
| _____________________ | ทั้งหมด
| ___________________ | นี้
| ___________________ | สำหรับ
| ___________________ | มี
| __________________ | แต่
| _________________ | เป็น
| _________________ | ไม่
| ________________ | พวกเขา
| ________________ | ดังนั้น

ผู้ชนะ:

วิธีแก้ปัญหาที่สั้นที่สุด (ตามจำนวนตัวอักษรต่อภาษา) มีความสุข!

แก้ไข : ตารางสรุปผลลัพธ์จนถึงขณะนี้ (2012-02-15) (เพิ่มโดยผู้ใช้ Nas Banov):

ภาษาที่ผ่อนคลายอย่างเข้มงวด
========= ======= ======
GolfScript 130 143
Perl 185
Windows PowerShell 148 199
Mathematica 199
ทับทิม 185 205
Unix Toolchain 194 228
Python 183 243
Clojure 282
สกาล่า 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

ตัวเลขแสดงความยาวของคำตอบสั้นที่สุดในภาษาเฉพาะ "เข้มงวด" หมายถึงโซลูชันที่ใช้ข้อมูลจำเพาะอย่างสมบูรณ์ (ดึง|____|แท่งปิดแถบแรกด้านบนด้วย____บรรทัดบัญชีสำหรับความเป็นไปได้ของคำยาวที่มีความถี่สูง ฯลฯ ) "ผ่อนคลาย" หมายถึงสิทธิบางอย่างที่ถูกทำให้สั้นลงเพื่อแก้ปัญหา

มีเพียงโซลูชันที่สั้นกว่า 500 ตัวเท่านั้น รายการภาษาจะเรียงตามความยาวของโซลูชัน 'เข้มงวด' 'Unix Toolchain' ใช้เพื่อแสดงถึงวิธีการแก้ปัญหาต่าง ๆ ที่ใช้ * nix shell แบบดั้งเดิมพร้อมด้วยเครื่องมือหลายอย่าง (เช่น grep, tr, sort, uniq, perl, awk)

LabVIEW 51 โหนด 5 โครงสร้าง 10 แผนภาพ

การสอนช้างในการเต้นแท็ปไม่เคยสวย ฉันจะข้ามการนับตัวละคร

โปรแกรมไหลจากซ้ายไปขวา:

Ruby 1.9, 185 chars

(ขึ้นอยู่กับโซลูชัน Ruby อื่น ๆ เป็นอย่างมาก)

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

แทนที่จะใช้สวิตช์บรรทัดคำสั่งใด ๆ เช่นโซลูชันอื่น ๆ คุณสามารถส่งชื่อไฟล์เป็นอาร์กิวเมนต์ได้ (เช่นruby1.9 wordfrequency.rb Alice.txt)

เนื่องจากฉันใช้ตัวอักษรตัวอักษรตรงนี้โซลูชันนี้ใช้งานได้ใน Ruby 1.9 เท่านั้น

แก้ไข: แทนที่อัฒภาคโดยแบ่งบรรทัดสำหรับ "การอ่าน" : P

แก้ไข 2: Shtéfชี้ให้เห็นฉันลืมพื้นที่ต่อท้าย - แก้ไขที่

แก้ไข 3: ลบพื้นที่ต่อท้ายอีกครั้ง;)

GolfScript, 177 175 173 167 164 163 144 131 130 ตัวอักษร

ช้า - 3 นาทีสำหรับข้อความตัวอย่าง (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*'| '@}/

คำอธิบาย:

{           #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
}/

"ถูกต้อง" (หวังว่า) (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*'| '@}/

ช้าน้อยลง - ครึ่งนาที (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*'| '@}/

เอาต์พุตสามารถมองเห็นได้ในบันทึกการแก้ไข

206

เชลล์, grep, tr, grep, เรียงลำดับ, uniq, เรียงลำดับ, หัว, 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

อืมเพิ่งเห็นด้านบน: sort -nr-> sort -nและจากนั้นhead-> tail=> 208 :)
update2: เอ่อแน่นอนข้างต้นเป็นโง่เพราะมันจะกลับรายการแล้ว 209 ดังนั้น
update3: เพิ่มประสิทธิภาพการแยก 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$_"'

เพื่อความสนุกนี่เป็นเวอร์ชั่น perl เท่านั้น (เร็วกว่ามาก):

~ % 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 โซลูชันที่ใช้ (SQL Server 2005) 1063 892 873 853 827 820 783 683 647 644 630 ตัวอักษร

ขอบคุณ Gabe สำหรับคำแนะนำที่เป็นประโยชน์เพื่อลดจำนวนตัวอักษร

หมายเหตุ: เพิ่มตัวแบ่งบรรทัดเพื่อหลีกเลี่ยงแถบเลื่อนเท่านั้นที่จำเป็นต้องมีตัวแบ่งบรรทัดสุดท้าย

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 @

เวอร์ชันที่อ่านได้

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 @

เอาท์พุต

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

และด้วยสายยาว

 _______________________________________________________________ 
|_______________________________________________________________| 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 ตัวอักษร

การปรับปรุง Anurag รวมคำแนะนำจาก rfusca ลบการโต้แย้งเพื่อเรียงลำดับและการเล่นกอล์ฟอื่น ๆ อีกเล็กน้อย

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

ดำเนินการเป็น:

ruby GolfedWordFrequencies.rb < Alice.txt

แก้ไข: ใส่ 'Put' กลับเข้าไปข้างในต้องอยู่ที่นั่นเพื่อหลีกเลี่ยงการใส่เครื่องหมายคำพูดในผลลัพธ์
Edit2: Changed File-> IO
Edit3: remove / i
Edit4: ลบวงเล็บที่อยู่รอบ ๆ (f * 1.0), เล่าใหม่
Edit5: ใช้การเพิ่มสตริงสำหรับบรรทัดแรก; ขยายsในสถานที่
แก้ไข 6: ทำ m float, ลบ 1.0 แก้ไข: ใช้งานไม่ได้เปลี่ยนความยาว แก้ไข: ไม่เลวร้ายยิ่งกว่าก่อน
Edit7: STDIN.readใช้

Mathematica ( 297 284 248 244 242 199 ตัวอักษร) Pure Functional

และการทดสอบกฎหมายของ Zipf

ดู Mamma ... ไม่มี vars, no มือ, .. ไม่มีหัว

แก้ไข 1> กำหนดชวเลขบางส่วน (284 ตัวอักษร)

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]

คำอธิบายบางอย่าง

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)

เอาท์พุต

alt text http://i49.tinypic.com/2n8mrer.jpg

Mathematica นั้นไม่เหมาะสำหรับการเล่นกอล์ฟและนั่นเป็นเพราะชื่อฟังก์ชันที่มีความยาวและอธิบายได้ ฟังก์ชั่นเช่น "RegularExpression []" หรือ "StringSplit []" แค่ทำให้ฉันสะอื้น :(

การทดสอบกฎหมายของ Zipf

กฎหมาย Zipfคาดการณ์ว่าสำหรับข้อความภาษาธรรมชาติเข้าสู่ระบบ (ลำดับ) VS เข้าสู่ระบบ (เกิดขึ้น)พล็อตต่อไปนี้การเชิงเส้นความสัมพันธ์

กฎหมายถูกนำมาใช้ในการพัฒนาอัลกอริทึมสำหรับ criptography และการบีบอัดข้อมูล (แต่ไม่ใช่ "Z" ในอัลกอริทึม LZW)

ในเนื้อหาของเราเราสามารถทดสอบได้ดังต่อไปนี้

 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]

ผลที่ได้คือ (เป็นเส้นตรงค่อนข้างดี)

alt text http://i46.tinypic.com/33fcmdk.jpg

แก้ไข 6> (242 ตัวอักษร)

การปรับโครงสร้าง Regex อีกครั้ง (ไม่เลือกฟังก์ชั่นอีกต่อไป) การ
วางคำ char 1 คำ
นิยามที่มีประสิทธิภาพยิ่งขึ้นสำหรับฟังก์ชั่น "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]

แก้ไข 7 → 199 ตัวอักษร

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]

• แทนที่fด้วยTransposeและSlot( #1/ #2) อาร์กิวเมนต์
• เราไม่ต้องการวงเล็บเหลี่ยมของ stinkin (ใช้f@xแทนf[x]ตำแหน่งที่เป็นไปได้)

C # - 510 451 436 446 434 426 422 ตัวอักษร (ย่อขนาด)

ไม่สั้น แต่ตอนนี้อาจถูกต้อง! หมายเหตุรุ่นก่อนหน้าไม่แสดงบรรทัดแรกของแถบไม่ปรับขนาดแท่งให้ถูกต้องดาวน์โหลดไฟล์แทนการรับจาก stdin และไม่ได้รวม C # verbosity ที่จำเป็นทั้งหมด คุณสามารถโกนหนวดได้หลายครั้งหาก C # ไม่ต้องการอึมากขึ้น Powershell อาจทำได้ดีกว่านี้

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 chars ที่มีlendivisor inlined (ซึ่งทำให้ช้ากว่า 22 เท่า) ในรูปแบบด้านล่าง (บรรทัดใหม่ที่ใช้สำหรับการเว้นวรรคที่เลือก):

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 ตัวอักษร

(อัปเดตอีกครั้งเพื่อเอาชนะรุ่น Ruby ด้วยลูกกอล์ฟที่สกปรกกว่าแทนที่split/[^a-z/,lcด้วยlc=~/[a-z]+/gและกำจัดการตรวจสอบสตริงว่างในที่อื่นสิ่งเหล่านี้ได้รับแรงบันดาลใจจากรุ่น Ruby ดังนั้นเครดิตที่ถึงกำหนดชำระ)

อัพเดท: ตอนนี้พร้อม Perl 5.10! แทนที่printด้วยsayและใช้เพื่อหลีกเลี่ยงการ~~ นี้จะต้องมีการเรียกในบรรทัดคำสั่งเป็นmap perl -E '<one-liner>' alice.txtเนื่องจากสคริปต์ทั้งหมดอยู่ในหนึ่งบรรทัดการเขียนเป็นหนึ่งบรรทัดไม่ควรมีปัญหาใด ๆ :)

 @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];

โปรดทราบว่ารุ่นนี้ปกติสำหรับกรณี วิธีนี้จะไม่ทำให้โซลูชันสั้นลงเนื่องจากการลบ,lc(สำหรับปลอกต่ำ) ทำให้คุณต้องเพิ่มA-Zใน regex แยกดังนั้นจึงเป็นการล้าง

\nหากคุณอยู่ในระบบที่ขึ้นบรรทัดใหม่เป็นตัวละครตัวหนึ่งและสองไม่ได้คุณสามารถร่นนี้โดยอีกสองตัวอักษรโดยใช้ตัวอักษรขึ้นบรรทัดใหม่ในสถานที่ของ อย่างไรก็ตามฉันไม่ได้เขียนตัวอย่างข้างต้นด้วยวิธีนี้เนื่องจากเป็น "ชัดเจน" (ฮ่า!) ด้วยวิธีดังกล่าว

นี่คือส่วนใหญ่ถูกต้อง แต่ไม่สั้นพอ perl ทางออก:

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

สั้น ๆ ดังต่อไปนี้จะได้รับในขณะที่ยังเหลือค่อนข้างอ่านได้ (392 ตัวอักษร)

%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 ตัวอักษร

$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]

(ตัวแบ่งบรรทัดสุดท้ายไม่จำเป็น แต่รวมไว้ที่นี่เพื่อให้อ่านได้ง่าย)

(รหัสปัจจุบันและไฟล์ทดสอบของฉันที่มีอยู่ในพื้นที่เก็บข้อมูล SVNของฉันฉันหวังว่ากรณีทดสอบของฉันจะพบข้อผิดพลาดที่พบบ่อยที่สุด (ความยาวของบาร์ปัญหาเกี่ยวกับการจับคู่ regex และอื่น ๆ )

สมมติฐาน:

• ASCII สหรัฐเป็นอินพุต มันอาจจะแปลกกับ Unicode
• อย่างน้อยสองคำที่ไม่หยุดยั้งในข้อความ

ประวัติศาสตร์

รุ่นที่ผ่อนคลาย (137) เนื่องจากถูกนับแยกตอนนี้:

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

• ไม่ปิดแถบแรก
• ไม่ได้คำนึงถึงความยาวของคำที่ไม่ใช่คำแรก

การแปรผันของความยาวแท่งของอักขระหนึ่งตัวเมื่อเทียบกับโซลูชันอื่น ๆ เป็นเพราะ PowerShell ใช้การปัดเศษแทนการตัดปลายเมื่อแปลงตัวเลขทศนิยมเป็นจำนวนเต็ม เนื่องจากงานที่ต้องการเพียงความยาวบาร์ที่มีสัดส่วนเท่านั้นจึงควรใช้ได้

เมื่อเปรียบเทียบกับโซลูชันอื่น ๆ ฉันใช้แนวทางที่แตกต่างกันเล็กน้อยในการกำหนดความยาวของแถบที่ยาวที่สุดโดยเพียงแค่ลองและใช้ความยาวสูงสุดดังกล่าวโดยที่ไม่มีบรรทัดใดยาวเกิน 80 อักขระ

รุ่นเก่าอธิบายสามารถพบได้ที่นี่

Ruby, 215, 216 , 218 , 221 , 224 , 236 , 237ตัวอักษร

อัปเดต 1: Hurray ! มันผูกกับJS ผมม้า ' วิธีการแก้ปัญหา นึกไม่ออกว่าจะตัดทอนอะไรอีก :)

ปรับปรุง 2: เล่นกลกอล์ฟสกปรก เปลี่ยนeachเป็นmapบันทึก 1 ตัวอักษร :)

อัปเดต 3: เปลี่ยนFile.readเป็นIO.read+2 Array.group_byไม่ได้ผลมากเปลี่ยนเป็นreduce+6 ไม่จำเป็นต้องตรวจสอบขนาดตัวพิมพ์เล็กและตัวพิมพ์ใหญ่หลังจากปลอกต่ำลงdowncaseใน regex +1 การเรียงลำดับจากมากไปน้อยทำได้ง่าย ๆ โดยลบค่า +6 รวมเงินออม +15

อัปเดต 4: [0]แทนที่จะเป็น.first+3 (@ Shtééf)

อัปเดต 5: ขยายตัวแปรlแบบแทนที่ +1 ขยายตัวแปรsในตำแหน่ง +2 (@ Shtééf)

อัปเดต 6: ใช้การเพิ่มสตริงแทนการแก้ไขสำหรับบรรทัดแรก +2 (@ 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} "}

อัปเดต 7: ฉันผ่าน hoopla จำนวนมากเพื่อตรวจสอบการวนซ้ำครั้งแรกในลูปโดยใช้ตัวแปรอินสแตนซ์ ทั้งหมดที่ฉันได้รับคือ +1 แม้ว่าอาจจะมีศักยภาพ รักษาเวอร์ชั่นก่อนหน้านี้ไว้เพราะฉันเชื่อว่าอันนี้เป็นมนต์ดำ (@ 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} "}

เวอร์ชันที่อ่านได้

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

ใช้:

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

เอาท์พุท:

 _________________________________________________________________________
|_________________________________________________________________________| 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 วิธี latitudinarian = 227 183 ตัวอักษร

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

อนุญาตให้มีอิสระในการใช้งานฉันได้สร้างการต่อสายอักขระที่มีคำทั้งหมดที่ขอยกเว้น ( the, and, of, to, a, i, it, in, or, is) - รวมทั้งยังแยกคำว่า "คำ" ที่น่าอับอายทั้งสองsและtจากตัวอย่าง - และฉันโยนเพื่อยกเว้นสำหรับan, for, heฟรี ฉันลองเรียงลำดับคำทั้งหมดเหล่านั้นกับคลังข้อมูลของคำจาก Alice, King James 'Bible และไฟล์ Jargon เพื่อดูว่ามีคำใดบ้างที่จะถูกแยกออกจากสตริง และนั่นคือวิธีที่ผมจบลงด้วยสองสายการยกเว้น: และitheandtoforinisandithetoforinis

PS ยืมจากโซลูชันอื่น ๆ เพื่อย่อรหัส

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

พูดจาโผงผาง

เกี่ยวกับคำที่ไม่สนใจใครจะคิดว่าคำเหล่านั้นจะถูกนำมาจากรายการคำศัพท์ที่ใช้มากที่สุดในภาษาอังกฤษ รายการนั้นขึ้นอยู่กับคลังข้อความที่ใช้ ต่อหนึ่งในรายการยอดนิยม ( 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 ) คำ 10 อันดับแรกคือ:the be(am/are/is/was/were) to of and a in that have I

คำ 10 อันดับแรกจากข้อความของ Alice in Wonderland คือthe and to a of it she i you said
คำ 10 อันดับแรกจากไฟล์ Jargon (v4.4.7)the a of to and in is that or for

ดังนั้นคำถามคือสาเหตุที่orรวมอยู่ในรายการเพิกเฉยของปัญหาซึ่งเป็นที่นิยมในยุคที่ 30 ~ เมื่อคำthat(ที่ใช้มากที่สุดอันดับ 8) ไม่ได้ ฯลฯ เป็นต้นดังนั้นฉันเชื่อว่าควรเพิกเฉยต่อรายการลิสต์แบบไดนามิก (หรืออาจถูกละเว้น)

แนวคิดทางเลือกนั้นเป็นเพียงการข้ามคำ 10 อันดับแรกจากผลลัพธ์ซึ่งอันที่จริงจะทำให้การแก้ปัญหาสั้นลง (ระดับประถมศึกษา - ต้องแสดงรายการที่ 11 ถึง 32 เท่านั้น)

Python 2.x วิธีที่ชาญฉลาด = 277 243 ตัวอักษร

แผนภูมิที่วาดในโค้ดด้านบนนั้นง่ายขึ้น (ใช้อักขระเพียงตัวเดียวสำหรับบาร์) หากใครต้องการทำซ้ำแผนภูมิจากคำอธิบายปัญหา (ซึ่งไม่จำเป็น) รหัสนี้จะทำ:

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

ฉันมีปัญหากับตัวเลือกที่ค่อนข้างสุ่มของ 10 คำที่จะแยกออกthe, and, of, to, a, i, it, in, or, isดังนั้นสิ่งเหล่านั้นจะถูกส่งผ่านเป็นพารามิเตอร์บรรทัดคำสั่งเช่น:
python WordFrequencyChart.py the and of to a i it in or is <"Alice's Adventures in Wonderland.txt"

นี่คือ 213 ตัวอักษร + 30 ถ้าเราบัญชีสำหรับรายการ "ดั้งเดิม" ไม่สนใจถูกส่งผ่านทางบรรทัดคำสั่ง = 243

PS รหัสที่สองยัง "ปรับ" สำหรับความยาวของคำพูดทั้งหมดดังนั้นไม่มีใครจะล้นในกรณีเลว

 _______________________________________________________________
|_______________________________________________________________| 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 ตัวละคร

( mainเพิ่มตัวแบ่งหนึ่งบรรทัดเพื่อให้สามารถอ่านได้และไม่จำเป็นต้องมีตัวแบ่งบรรทัดที่ท้ายบรรทัดสุดท้าย)

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

มันทำงานได้ดีที่สุดโดยการอ่านอาร์กิวเมนต์ไปinteractข้างหลัง:

• map f ตัวอักษรตัวพิมพ์เล็กแทนทุกอย่างอื่นด้วยช่องว่าง
• words สร้างรายการคำวางช่องว่างแยก
• filter (notElem words "the and of to a i it in or is")ละเว้นรายการทั้งหมดด้วยคำที่ต้องห้าม
• group . sort เรียงคำและจัดกลุ่มคำที่เหมือนกันเป็นรายการ
• map hแผนที่รายชื่อของคำที่เหมือนกันแต่ละ tuple (-frequency, word)ของรูปแบบ
• take 22 . sort เรียงลำดับ tuples ตามความถี่จากมากไปน้อย (รายการ tuple แรก) และเก็บเฉพาะ tuples 22 อันดับแรก
• b แมป tuples กับบาร์ (ดูด้านล่าง)
• a เพิ่มบรรทัดแรกของขีดล่างเพื่อทำให้แถบด้านบนสุดสมบูรณ์
• unlines รวมทุกบรรทัดเหล่านี้เข้าด้วยกันด้วยการขึ้นบรรทัดใหม่

บิตที่ยากจะทำให้ความยาวของบาร์ถูกต้อง ฉันสันนิษฐานว่าขีดเส้นใต้เท่านั้นที่นับรวมกับความยาวของแท่งดังนั้น||จะเป็นแท่งที่มีความยาวเป็นศูนย์ ฟังก์ชั่นbแผนที่c xเหนือxซึ่งxเป็นรายการของฮิสโทแกรม รายการทั้งหมดจะถูกส่งไปcเพื่อให้การภาวนาของแต่ละสามารถคำนวณปัจจัยขนาดสำหรับตัวเองโดยการเรียกc uด้วยวิธีนี้ฉันหลีกเลี่ยงการใช้เลขทศนิยมหรือปันส่วนซึ่งฟังก์ชันการแปลงและการนำเข้าจะกินอักขระจำนวนมาก

หมายเหตุ: -frequencyเคล็ดลับของการใช้ สิ่งนี้จะลบความจำเป็นในreverseการsortเรียงลำดับ (เรียงลำดับขึ้น) -frequencyจะวางคำที่มีความถี่มากที่สุดก่อน ต่อมาในฟังก์ชั่นuสอง-frequencyค่าจะถูกคูณซึ่งจะยกเลิกการปฏิเสธ

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

น่าเสียดายที่for([k,v]in z)รุ่น Rhino ดูเหมือนจะไม่ต้องการทำงานใน SpiderMonkey และreadFile()ง่ายกว่าการใช้เล็กน้อยreadline()แต่การขยับไปที่ 1.8 ช่วยให้เราสามารถใช้ฟังก์ชั่นการปิดเพื่อตัดบรรทัดเพิ่มเติมเล็กน้อย ...

การเพิ่มช่องว่างสำหรับการอ่าน:

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

การใช้งาน: js golf.js < input.txt

เอาท์พุท:

 _________________________________________________________________________ 
| _________________________________________________________________________ | เธอ
| _______________________________________________________________ | คุณ
| ____________________________________________________________ | กล่าว
| ____________________________________________________ | อลิซ
| ______________________________________________ | เป็น
| ___________________________________________ | ที่
| ___________________________________ | เช่น
| ________________________________ | เธอ
| _____________________________ | ที่
| _____________________________ | กับ
| ____________________________ | s
| ____________________________ | เสื้อ
| __________________________ | บน
| _________________________ | ทั้งหมด
| _______________________ | นี้
| ______________________ | สำหรับ
| ______________________ | มี
| ______________________ | แต่
| _____________________ | เป็น
| _____________________ | ไม่
| ___________________ | พวกเขา
| ___________________ | ดังนั้น

(เวอร์ชันพื้นฐาน - ไม่สามารถจัดการกับความกว้างของแถบได้อย่างถูกต้อง)

JavaScript (แรด) - 405 395 387 377 368 343 304 ตัวอักษร

ฉันคิดว่าตรรกะการเรียงลำดับของฉันปิดอยู่ แต่ .. ฉันทำไปแล้ว แก้ไข Brainfart แล้ว

Minified ( บางครั้ง\nตีความผิดของ;บางครั้ง):

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 (450 ตัวอักษร)

วิธีการแก้ปัญหานี้คำนึงถึงข้อกำหนดสุดท้ายที่นักพิถีพิถันส่วนใหญ่เลือกที่จะไม่สนใจ นั่นราคา 170 ตัวอักษร!

การใช้งาน: php.exe <this.php> <file.txt>

minified:

<?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";?>

คนอ่านได้:

<?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";

?>

เอาท์พุท:

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

เมื่อมีคำยาวแถบจะถูกปรับอย่างเหมาะสม:

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

ฉันเดาว่าการใช้Counterเป็นการโกง :) ฉันเพิ่งอ่านเกี่ยวกับเรื่องนี้ประมาณหนึ่งสัปดาห์ที่ผ่านมาดังนั้นนี่จึงเป็นโอกาสที่สมบูรณ์แบบในการดูว่ามันทำงานอย่างไร

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

พิมพ์ออกมา:

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

รหัสบางส่วนถูก "ยืม" จากโซลูชันของ AKX

perl, 205 191 189 ตัวอักษร / 205 ตัวอักษร (ดำเนินการอย่างเต็มที่)

บางส่วนได้รับแรงบันดาลใจจากการส่ง perl / ruby ​​ก่อนหน้านี้คู่ความคิดที่คล้ายกันก็มาถึงที่อิสระส่วนอื่น ๆ เป็นต้นฉบับ เวอร์ชันที่สั้นกว่ายังรวมเอาบางสิ่งที่ฉันเห็น / เรียนรู้จากการส่งอื่น ๆ

เดิม:

$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];

รุ่นล่าสุดจนถึง 191 ตัวอักษร:

/^(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]

เวอร์ชั่นล่าสุดมีความยาวไม่เกิน 189 อักขระ:

/^(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]

รุ่นนี้ (205 ถ่าน) บัญชีสำหรับบรรทัดที่มีคำยาวกว่าสิ่งที่จะได้พบในภายหลัง

/^(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 ตัวอักษร

$/=\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]

อีกทางหนึ่งการใช้งานเต็มรูปแบบรวมถึงพฤติกรรมที่ระบุไว้ (bar-squishing ทั่วโลก) สำหรับกรณีทางพยาธิวิทยาซึ่งคำรองเป็นที่นิยมและยาวพอที่จะรวมกันมากกว่า 80 ตัวอักษร ( การใช้งานนี้คือ 231 ตัวอักษร ):

$/=\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"}

สเปคไม่ได้ระบุว่าจะต้องไปที่ STDOUT เลยดังนั้นฉันจึงใช้คำเตือนของ perl () แทนที่จะพิมพ์ - บันทึกตัวอักษรสี่ตัวที่นั่น แผนที่ที่ใช้แทน foreach แต่ฉันรู้สึกว่ายังมีการประหยัดอีกมากในการแบ่ง (เข้าร่วม ()) ถึงกระนั้นก็ให้มันลงไปที่ 203 - อาจนอนหลับอยู่ อย่างน้อย Perl ตอนนี้ภายใต้ "เชลล์, grep, tr, grep, sort, uniq, sort, head, perl" ถ่านนับสำหรับตอนนี้;)

PS: Reddit บอกว่า "สวัสดี";)

อัปเดต: ลบการเข้าร่วม () เพื่อสนับสนุนการเข้าร่วมและการแปลงสเกลาร์โดยนัย ลงไปที่ 202 โปรดทราบว่าฉันใช้ประโยชน์จากกฎ "ละเว้นคำ 1 ตัวอักษร" ที่เป็นตัวเลือกเพื่อโกนอักขระ 2 ตัวดังนั้นโปรดจำไว้ว่าการนับความถี่จะสะท้อนถึงสิ่งนี้

อัปเดต 2: สลับการมอบหมายและเข้าร่วมโดยปริยายสำหรับการฆ่า $ / เพื่อรับไฟล์ในหนึ่งอึกโดยใช้ <> ในตอนแรก ขนาดเท่ากัน แต่น่ารังเกียจ สลับออกหาก (! $ y) {} สำหรับ $ y || {} && บันทึกได้อีก 1 ถ่าน => 201

อัปเดต 3: เข้าควบคุมการลดขนาดต้น (lc <>) โดยการย้าย lc ออกจากบล็อกแผนที่ - สลับทั้ง regexes ไปที่ไม่ใช้ตัวเลือก / i อีกต่อไปตามที่ไม่ต้องการอีกต่อไป เปลี่ยนเงื่อนไขที่ชัดเจน x? y: z สำหรับ perlgolf แบบดั้งเดิม || การสร้างแบบมีเงื่อนไขโดยนัย - /^...$/i?1:$x{$ } ++ สำหรับ /^...$/||$x{$ } ++ บันทึกสามอักขระ! => 198, ทำลายสิ่งกีดขวาง 200 ครั้ง อาจจะหลับเร็ว ๆ นี้ ... บางที

อัปเดต 4: การอดนอนทำให้ฉันเป็นบ้า ดี. บ้ามากขึ้น เมื่อคิดว่านี่เป็นเพียงการแยกไฟล์ข้อความแฮปปี้ปกติฉันทำให้มันยอมแพ้ถ้ามันเป็นโมฆะ บันทึกอักขระสองตัว แทนที่ "length" ด้วย 1-char ที่สั้นลง (และ golfish มากขึ้น) y /// c - คุณได้ยินฉัน GolfScript หรือไม่ ฉันจะมาเพื่อคุณ !!! ร้องไห้

อัปเดต 5: การนอนหลับทำให้ฉันลืมเรื่องวงเงิน 22row และการ จำกัด บรรทัดถัดไป สำรองสูงสุด 208 ด้วยการจัดการเหล่านั้น ไม่เลวเกินไป 13 ตัวอักษรที่จะจัดการกับมันไม่ใช่จุดจบของโลก เล่นรอบกับ regex ของ inline eval แต่มีปัญหาในการทำให้ทั้งงานและบันทึกตัวอักษร ... ฮ่า ๆ อัปเดตตัวอย่างเพื่อให้ตรงกับเอาต์พุตปัจจุบัน

อัปเดต 6: ลบวงเล็บปีกกาที่ไม่จำเป็นออกเพื่อปกป้อง (... ) สำหรับเนื่องจากลูกอมวากยสัมพันธ์ ++ ช่วยให้การผลักมันขึ้นมาเพื่อความสุข ขอบคุณข้อมูลจาก Chas โอเว่น (เตือนสมองที่เหนื่อยล้าของฉัน) ได้รับตัวละคร i แก้ปัญหาในนั้น กลับไปที่ 203

อัปเดต 7: เพิ่มชิ้นส่วนที่สองของการใช้งานเต็มรูปแบบของสเปค (รวมถึงพฤติกรรม squishing เต็มรูปแบบสำหรับคำยาวรองแทนการตัดทอนที่คนส่วนใหญ่กำลังทำอยู่บนพื้นฐานของสเป็คดั้งเดิมโดยไม่มีกรณีตัวอย่างทางพยาธิวิทยา)

ตัวอย่าง:

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

การประยุกต์ใช้ทางเลือกในตัวอย่างกรณีทางพยาธิวิทยา:

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

F #, 452 ตัวอักษร

Strightforward: รับลำดับaของคู่คำนับค้นหาตัวคูณคำต่อคอลัมน์ที่ดีที่สุดkแล้วพิมพ์ผลลัพธ์

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

ตัวอย่าง (ฉันมีจำนวนความถี่แตกต่างจากคุณไม่แน่ใจว่าทำไม):

% 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 ตัวอักษร

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

เอาท์พุท:

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

* sh (+ curl) วิธีแก้ปัญหาบางส่วน

สิ่งนี้ไม่สมบูรณ์ แต่สำหรับนรกของมันนี่คือครึ่งคำนับความถี่ของปัญหาใน 192 ไบต์:

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 ตัวอักษร (เดิมคือ 507)

(หลังจากแก้ไขการจัดรูปแบบผลลัพธ์, แก้ไขสิ่งที่หดตัว, tweaking; tweaking อีกครั้ง, ลบขั้นตอนการเรียงลำดับที่ไม่จำเป็นทั้งหมด, tweaking เลยอีกครั้ง, และอีกครั้ง (oops อันนี้ทำให้การจัดรูปแบบแตกสลาย); มากขึ้นพบที่อื่นที่จะบันทึกไม่กี่แห่ง แต่ให้สองกลับมาเพื่อแก้ไขข้อผิดพลาดความยาวบาร์)

เฮ้เฮ้! ฉันรออยู่เบื้องหน้า [การจาวาสคริปต์ของแมตต์] [1] การ^{ท้าทายการ} แก้ปัญหาตัว^{นับ! ;)} และ [AKX's python] [2]

ปัญหาน่าจะโทรออกสำหรับภาษานั้นการดำเนินการเชื่อมโยงอาร์เรย์พื้นเมืองดังนั้นแน่นอนฉันได้เลือกอย่างใดอย่างหนึ่งกับชุดที่ขาดน่ากลัวของผู้ประกอบการเกี่ยวกับพวกเขา โดยเฉพาะคุณไม่สามารถควบคุมลำดับที่ awk นำเสนอองค์ประกอบของแผนที่แฮชได้ดังนั้นฉันจึงสแกนแผนที่ทั้งหมดซ้ำ ๆเพื่อค้นหารายการที่มีจำนวนมากที่สุดในปัจจุบันพิมพ์และลบออกจากอาร์เรย์

มันเป็นสิ่งที่ไม่มีประสิทธิภาพอย่างมากกับ golfifcations ทั้งหมดที่ฉันได้ทำให้มันได้รับที่จะน่ากลัวสวยเช่นกัน

minified:

{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]}}

การแบ่งบรรทัดเพื่อความชัดเจนเท่านั้นไม่จำเป็นและไม่ควรนับ

เอาท์พุท:

$ 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

สามารถอ่านได้; 633 ตัวอักษร (แต่เดิม 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]
    }
}

LISP ทั่วไป 670 ตัวอักษร

ฉันเป็นมือใหม่ LISP และนี่คือความพยายามในการใช้ตารางแฮชเพื่อนับ (ดังนั้นอาจไม่ใช่วิธีที่กะทัดรัดที่สุด)

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

cat alice.txt | clisp -C golf.lispสามารถทำงานบนเช่นกับ

ในรูปแบบที่อ่านได้คือ

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

ดูเหมือนรหัสที่ยุ่งเหยิงมากและใช้ glib สำหรับ string, list และ hash นับ Char กับwc -mพูดว่า828 มันไม่ได้พิจารณาคำศัพท์เดี่ยว ในการคำนวณความยาวสูงสุดของแถบมันจะพิจารณาคำที่ยาวที่สุดเท่าที่จะเป็นไปได้ไม่เพียง แต่ใน 22 ข้อแรกนี่คือการเบี่ยงเบนจากสเป็คหรือไม่

ไม่จัดการกับความล้มเหลวและไม่ปล่อยหน่วยความจำที่ใช้แล้ว

#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 ตัวอักษร

200 (หักเล็กน้อย) 199 197 195 193 187 185 ตัวอักษร การขึ้นบรรทัดใหม่สองครั้งล่าสุดมีความสำคัญ สอดคล้องกับสเป็ค

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

%Xเป็นครั้งแรกนับโหลดสายของคำที่ถูกต้องลงไปใน

บรรทัดที่สองคำนวณปัจจัยการปรับสเกลขั้นต่ำเพื่อให้บรรทัดเอาต์พุตทั้งหมดเป็น <= 80 อักขระ

บรรทัดที่สาม (มีอักขระขึ้นบรรทัดใหม่สองตัว) สร้างเอาต์พุต

Java - 886 865 756 744 742 744 752 742 714 680 ตัวอักษร

• การอัพเดตก่อน 742 : ปรับปรุง regex ลบประเภทพารามิเตอร์ฟุ่มเฟือยลบช่องว่างที่ฟุ่มเฟือย

• อัปเดต 742> 744 ตัวอักษร : แก้ไขแฮ็คที่มีความยาวคงที่ มันขึ้นอยู่กับคำที่ 1 เท่านั้นไม่ใช่คำอื่น ๆ (ยัง) พบสถานที่หลายแห่งเพื่อย่อรหัส ( \\sใน regex ถูกแทนที่ด้วย และArrayListแทนที่ด้วยVector) ตอนนี้ฉันกำลังมองหาวิธีสั้น ๆ ในการลบการพึ่งพา Commons IO และการอ่านจาก stdin

• อัปเดต 744> 752 ตัวอักษร : ฉันลบการอ้างอิงทั่วไป ตอนนี้อ่านจาก stdin วางข้อความใน stdin และกดCtrl+Zเพื่อรับผลลัพธ์

• อัปเดต 752> 742 ตัวอักษร : ฉันลบpublicและเว้นวรรคแล้วทำให้ชื่อ class 1 ถ่านแทน 2 และตอนนี้ก็ไม่สนใจคำตัวอักษรหนึ่งตัว

• อัปเดต 742> 714 ตัวอักษร : อัปเดตตามความคิดเห็นของคาร์ล: ลบการมอบหมายซ้ำซ้อน (742> 730) แทนที่m.containsKey(k)ด้วยm.get(k)!=null(730> 728) แนะนำการร้อยสายย่อยของบรรทัด (728> 714)

• อัพเดท 714> 680 ตัวอักษร : อัปเดตตามความคิดเห็นของ Rotsor: การคำนวณขนาดของบาร์ที่ดีขึ้นในการลบหล่อที่ไม่จำเป็นและปรับปรุงให้ดีขึ้นในการลบที่ไม่จำเป็นsplit()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);}}

รุ่นที่อ่านเพิ่มเติมได้:

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

เอาท์พุท:

 _________________________________________________________________________
| _________________________________________________________________________ | เธอ
| _______________________________________________________________ | คุณ
| ____________________________________________________________ | กล่าว
| _____________________________________________________ | อลิซ
| _______________________________________________ | เป็น
| ___________________________________________ | ที่
| ____________________________________ | เช่น
| ________________________________ | เธอ
| _____________________________ | กับ
| _____________________________ | ที่
| __________________________ | บน
| __________________________ | ทั้งหมด
| _______________________ | นี้
| _______________________ | สำหรับ
| _______________________ | มี
| _______________________ | แต่
| ______________________ | เป็น
| _____________________ | ไม่
| ____________________ | พวกเขา
| ____________________ | ดังนั้น
| ___________________ | มาก
| __________________ | อะไร

มันค่อนข้างแย่ที่ Java ไม่มีString#join()และปิด (ยัง)

แก้ไขโดย Rotsor:

ฉันได้ทำการเปลี่ยนแปลงโซลูชันของคุณหลายประการ:

• รายการแทนที่ด้วยสตริง []
• นำอาร์กิวเมนต์ 'args' มาใช้ซ้ำแทนที่จะประกาศอาเรย์สตริงของฉันเอง ใช้เป็นอาร์กิวเมนต์สำหรับ. ToArray ()
• แทนที่ StringBuffer ด้วยสายอักขระ (ใช่, ใช่, ประสิทธิภาพแย่มาก)
• แทนที่การเรียงลำดับ Java ด้วยการเรียงลำดับการเลือกด้วยการหยุดก่อน
• รวมการประกาศ int บางคำในคำสั่งเดียว
• ใช้อัลกอริทึมที่ไม่โกงเพื่อค้นหาบรรทัดที่ จำกัด ที่สุดของเอาต์พุต ดำเนินการโดยไม่มี FP
• แก้ไขปัญหาของโปรแกรมหยุดทำงานเมื่อมีคำที่แตกต่างกันน้อยกว่า 22 คำในข้อความ
• ใช้อัลกอริทึมใหม่ของอินพุตการอ่านซึ่งรวดเร็วและมีความยาวเพียง 9 ตัวอักษรเท่านั้น

รหัสย่อคือ688 711 684ตัวอักษร:

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

รุ่นที่รวดเร็ว ( 720 693ตัวอักษร)

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

รุ่นที่อ่านเพิ่มเติมได้:

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

รุ่นที่ไม่มีการปรับปรุงพฤติกรรมคือ615ตัวอักษร:

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

สกาล่า 2.8, 311 314 320 330 332 336 341 375ตัวอักษร

รวมถึงการปรับคำยาว แนวคิดที่ยืมมาจากโซลูชันอื่น

ตอนนี้เป็นสคริปต์ ( 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)

ทำงานด้วย

scala -howtorun:script a.scala alice.txt

BTW การแก้ไขจาก 314 ถึง 311 ตัวอักษรจริงลบเพียง 1 ตัวอักษร มีใครบางคนที่นับผิดก่อนหน้านี้ (Windows CRs)

Clojure 282 เข้มงวด

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

ค่อนข้างชัดเจนมากขึ้น:

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

สกาลา, 368 ตัวอักษร

ครั้งแรกรุ่นที่ชัดเจนในตัวอักษร 592:

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

เอาต์พุตคอนโซลมีลักษณะดังนี้:

$ 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

เราสามารถทำการลดขนาดเชิงรุกและทำให้เหลือ 415 ตัวอักษร:

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

เซสชันคอนโซลมีลักษณะดังนี้:

$ 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

ฉันแน่ใจว่าผู้เชี่ยวชาญสกาล่าสามารถทำได้ดีกว่านี้

ปรับปรุง:ในความคิดเห็นที่โทมัสให้รุ่นที่สั้นกว่าที่ความยาว 368 ตัวอักษร:

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

ชัดเจนที่ 375 ตัวอักษร:

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 ตัวอักษร

ตัวอักษร 931

1233 chars ไม่สามารถอ่านได้

ตัวอักษร 1977 "ไม่บีบอัด"

อัปเดต: ฉันลดจำนวนตัวละครลงอย่างมาก ละเว้นคำตัวอักษรเดียวต่อข้อมูลจำเพาะที่อัปเดต

ฉันอิจฉา C # และ LINQ มาก

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)+" ");}}}

"อ่าน"

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)+" ");
      }
   }
}

ผลลัพธ์ของ Alice:

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

ผลลัพธ์ของ Don Quixote (เช่นจาก Gutenberg):

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