किसी दिए गए पाठ में सबसे अधिक इस्तेमाल किए जाने वाले शब्दों का ASCII चार्ट बनाएं [बंद]

156

चुनौती:

किसी दिए गए पाठ में सबसे अधिक इस्तेमाल किए जाने वाले शब्दों के 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)।

  • वैकल्पिक रूप से (अब विनिर्देशों को औपचारिक रूप से बदलते हुए बहुत देर हो चुकी है) आप सभी एकल-अक्षर 'शब्द' को छोड़ सकते हैं (यह संभवतः अनदेखी सूची को छोटा करने के लिए भी बना सकता है)।

दिए गए पार्स text(कमांड लाइन आर्ग्युमेंट्स के माध्यम से निर्दिष्ट कोई फ़ाइल पढ़ें या उसमें अनुमान लगाया गया है us-ascii) और word frequency chartनिम्नलिखित विशेषताओं के साथ हमें बनाएँ :

  • 22 सबसे सामान्य शब्दों (अवरोही आवृत्ति द्वारा आदेशित) के लिए चार्ट (नीचे का उदाहरण भी देखें) प्रदर्शित करें।
  • बार widthशब्द के आनुपातिक (आवृत्ति) की संख्या (आनुपातिक) का प्रतिनिधित्व करता है। एक स्थान को जोड़ें और शब्द प्रिंट करें।
  • सुनिश्चित करें कि ये बार (प्लस स्पेस-वर्ड-स्पेस) हमेशा फिट होते हैं : bar+ [space]+ word+ [space]हमेशा होना चाहिए <= 80वर्ण (सुनिश्चित करें कि आप अलग-अलग बार और शब्द की लंबाई के लिए खाते हैं: उदाहरण के लिए: दूसरा सबसे आम शब्द अब बहुत हो सकता है पहले जबकि आवृत्ति में इतना अंतर नहीं)। इन अवरोधों के भीतर बार की चौड़ाई को अधिकतम करें और सलाखों को उचित रूप से मापें (वे प्रतिनिधित्व की आवृत्तियों के अनुसार)।

एक उदाहरण:

उदाहरण के लिए पाठ यहां पाया जा सकता है ( एलिस एडवेंचर्स इन वंडरलैंड, लुईस कैरोल द्वारा )।

यह विशिष्ट पाठ निम्नलिखित चार्ट प्राप्त करेगा:

 _________________________________________________________________________
| _________________________________________________________________________ | वह
| _______________________________________________________________ | आप
| ____________________________________________________________ | कहा हुआ
| ____________________________________________________ | ऐलिस
| ______________________________________________ | था
| __________________________________________ | उस
| ___________________________________ | जैसा
| _______________________________ | उसके
| ____________________________ | साथ में
| ____________________________ | पर
| ___________________________ | रों
| ___________________________ | टी
| _________________________ | पर
| _________________________ | सब
| ______________________ | यह
| ______________________ | के लिये
| ______________________ | था
| _____________________ | परंतु
| ____________________ | होना
| ____________________ | नहीं
| ___________________ | वे
| __________________ | इसलिए

आपकी जानकारी के लिए: ये आवृत्तियाँ हैं ऊपर चार्ट बनाया गया है:

[('वह', ५५३), ('आप', ४1१), ('कहा', ४६२), ('ऐलिस', ४०३), ('था', ३५)), (''
', 330), (' as ', 274), (' her ', 248), (' with ', 227), (' at ', 227), (' s ', 219), (' t ')
, 218), ('ऑन', 204), ('ऑल', 200), ('दिस', 181), ('फॉर', 179), ('हैव', 178), ('
लेकिन '175), (' हो ', 167), (' नहीं ', 166), (' वे ', 155), (' ऐसा ', 152)]

एक दूसरा उदाहरण (यह जांचने के लिए कि क्या आपने पूरी कल्पना लागू की है):you लिंक किए गए ऐलिस की हर घटना को वंडरलैंड फाइल में बदलें superlongstringstring:

 ________________________________________________________________
| ________________________________________________________________ | वह
| _______________________________________________________ | superlongstringstring
| _____________________________________________________ | कहा हुआ
| ______________________________________________ | ऐलिस
| ________________________________________ | था
| _____________________________________ | उस
| ______________________________ | जैसा
| ___________________________ | उसके
| _________________________ | साथ में
| _________________________ | पर
| ________________________ | रों
| ________________________ | टी
| ______________________ | पर
| _____________________ | सब
| ___________________ | यह
| ___________________ | के लिये
| ___________________ | था
| __________________ | परंतु
| _________________ | होना
| _________________ | नहीं
| ________________ | वे
| ________________ | इसलिए

विजेता:

सबसे छोटा समाधान (वर्ण गणना के अनुसार, प्रति भाषा)। मज़े करो!

संपादित करें : अब तक के परिणामों को सारांशित करते हुए (2012-02-15) (मूल रूप से उपयोगकर्ता नास बानोव द्वारा जोड़ा गया):

लैंग्वेज रिलैक्स्ड स्ट्रिक्ट
========= ======= ======
गोल्फस्क्रिप्ट 130 143
पर्ल 185
विंडोज पॉवरशेल 148 199
गणितज्ञ 199
रूबी 185 205
यूनिक्स टूलचैन 194 228
अजगर 183 243
क्लोजर 282
स्काला 311
हास्केल 333
अवाक ३३६
आर 298
जावास्क्रिप्ट 304 354
ग्रोवी 321
मतलब 404
सी # 422
स्मालटाक 386
PHP 450
एफ # 452
TSQL 483 507

संख्या एक विशिष्ट भाषा में सबसे छोटे समाधान की लंबाई का प्रतिनिधित्व करती है। "स्ट्रिक्ट" एक ऐसे समाधान को संदर्भित करता है जो कल्पना को पूरी तरह से लागू करता है ( |____|बार खींचता है, एक ____पंक्ति के साथ शीर्ष पर पहली पट्टी को बंद करता है , उच्च आवृत्ति आदि के साथ लंबे शब्दों की संभावना के लिए खाता है)। "रिलैक्स्ड" का अर्थ है कि समाधान के लिए कुछ स्वतंत्रताएँ ली गईं।

केवल छोटे समाधान तो 500 वर्ण शामिल हैं। भाषाओं की सूची को 'सख्त' समाधान की लंबाई के अनुसार क्रमबद्ध किया गया है। 'यूनिक्स टूलचिन ’का उपयोग विभिन्न समाधानों को दर्शाने के लिए किया जाता है जो पारंपरिक * निक्स खोल के साथ-साथ औजारों के मिश्रण (जैसे कि जीआरपी, ट्र, सॉर्ट, यूनीक, हेड, पर्ल, ऑक) का उपयोग करते हैं।

language-agnostic  code-golf 
— क्रिस्टोफीडी
स्रोत
4
ठीक है, 'सबसे लंबी पट्टी' + शब्द = 80 80 कॉल के भीतर फिट नहीं हो सकता है यदि दूसरा-सबसे आम-शब्द बहुत लंबा शब्द है। मुझे लगता है कि 'अधिकतम बाधा' की तलाश है।
— ब्रायन
1
क्या हम आवरण को सामान्य करते हैं? 'वह' = 'वह'?
— ब्रायन
2
निष्पादन समय और मेमोरी उपयोग दोनों के संदर्भ में, IMO इस प्रदर्शन को बनाते हुए, चरित्र गणना की तुलना में अधिक दिलचस्प चुनौती लगती है।
— फ्रैंक किसान
81
मुझे यह देखकर खुशी हुई कि मेरे पसंदीदा शब्द sऔर tप्रतिनिधित्व हैं।
— इंडीव
8
@indiv, @Nas Banov - मूर्खतापूर्ण बहुत ही सरल टोकेनाइज़र पढ़ता है "नहीं" के रूप में {didn, t} और "वह" के रूप में {she, s} :)
— hobbs

जवाबों:

123

LabVIEW 51 नोड्स, 5 संरचनाएं, 10 आरेख

हाथी को टैप-डांस सिखाना कभी भी सुंदर नहीं होता है। मैं, आह, चरित्र गिनती छोड़ दूंगा।

LabVIEW कोड

परिणाम

कार्यक्रम बाएं से दाएं बहता है:

labVIEW कोड समझाया

— जो ज़ोलर
स्रोत
10
यह इसके लायक नहीं है
4
LabVIEW अपने हार्डवेयर नियंत्रण और माप आला में बहुत खुश है, लेकिन स्ट्रिंग हेरफेर के लिए वास्तव में बहुत भयानक है।
— जो जेड
19
सबसे अच्छा कोड गोल्फ उत्तर मैंने देखा है। बॉक्स के बाहर सोचने के लिए +1!
— ब्लेयर होलोवे
1
हमारे लिए तत्वों को गिना जाएगा ... हर बॉक्स और विजेट को आपको स्क्रीन काउंट पर ड्रैग करना था।
— dmckee --- पूर्व-मध्यस्थ ने बिल्ली का बच्चा
1
क्या उन चार्ट के एक बड़े संस्करण के लिए लिंक जोड़ना संभव होगा?
— स्विश जूल 7'10
42

रूबी 1.9, 185 वर्ण

(अन्य रूबी समाधानों पर आधारित)

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)

चूंकि मैं यहां चरित्र-शाब्दिक का उपयोग कर रहा हूं, यह समाधान केवल रूबी 1.9 में काम करता है।

संपादित करें: "पठनीयता" के लिए लाइन ब्रेक द्वारा प्रतिस्थापित अर्धवृत्त। : पी

संपादित करें 2: Shtééf ने बताया कि मैं अनुगामी स्थान को भूल गया था - वह निश्चित।

संपादित करें 3: फिर से पीछे आने वाले स्थान को हटा दिया;)

— वेंटरो को प्रकट करता है
स्रोत
यह प्रत्येक शब्द के बाद अनुगामी स्थान को याद कर रहा है।
— स्टीफन कोचन
Aww शूट, कि उपेक्षा। लगता है कि गोल्फ को केवल अपडेट किया गया था, अब अंतरिक्ष की आवश्यकता नहीं है। :)
— स्टीफन कोचन
2 या बाद की स्थिति में 'सुपरलॉन्गस्ट्रिंगस्ट्रिंग' के लिए साथ नहीं लगता है? (समस्या का वर्णन देखें)
— Nas Banov
2
यह वास्तव में रखरखाव योग्य है।
— लाश
39

गोल्फस्क्रिप्ट, 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*'| '@}/

संशोधन लॉग में दिखाई देने वाला आउटपुट।

— रिवाइज किया
स्रोत
2
GolfScript के बारे में: golfscript.com/golfscript
— Assaf Lavie
2
सही नहीं है, कि अगर दूसरा शब्द वास्तव में लंबा है तो यह अगली पंक्ति में जाएगा।
— गाबे
5
"शून्य से विभाजित करें" ... GolfScript कि अनुमति देता है?
— JAB
35

206

खोल, grep, tr, grep, सॉर्ट, यूनीक, सॉर्ट, हेड, पर्ल

~ % 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: erm, बेशक ऊपर मूर्खतापूर्ण है, क्योंकि यह उलटा हो जाएगा। तो, 209.
अपडेट 3: अपवर्जन रीजेक्सप -> 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$_"'



मनोरंजन के लिए, यहां एक पर्ल-ओनली संस्करण (बहुत तेज):

~ % 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
— स्टॉर
स्रोत
35

Transact SQL सेट आधारित समाधान (SQL Server 2005) 1063 892 873 853 827 820 783 683 647 644 630 वर्ण

कैरेक्टर काउंट को कम करने के लिए कुछ उपयोगी सुझावों के लिए गैबी का धन्यवाद।

NB: स्क्रॉलबार से बचने के लिए लाइन ब्रेक को जोड़ा जाता है केवल अंतिम लाइन ब्रेक की आवश्यकता होती है।

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
— मार्टिन स्मिथ
स्रोत
12
मैंने आपको एक +1 दिया क्योंकि आपने इसे टी-एसक्यूएल में किया था, और टीम अमेरिका को उद्धृत करने के लिए - "आपके पास गेंदें हैं। मुझे गेंदें पसंद हैं।"
मैंने इसे अधिक पठनीय बनाने के लिए कुछ स्थानों को नई कहानियों में परिवर्तित करने की स्वतंत्रता ली। उम्मीद है कि मैंने चीजों को गड़बड़ नहीं किया। मैंने इसे थोड़ा और छोटा कर दिया।
— गाबे
3
वह कोड मुझ पर चिल्ला रहा है! : ओ
— जॉय
1
बचत करने का एक अच्छा तरीका है , 0.000बस के लिए बदलकर 0, -Cइसके बजाय का उपयोग करके 1.0/C। और बनाने FLOATसे REALएक स्ट्रोक भी बच जाएगा। हालांकि, सबसे बड़ी बात यह है कि ऐसा लगता है कि आपके पास बहुत सारे ASउदाहरण हैं जो वैकल्पिक होना चाहिए।
— गेब
1
ठीक है, कैसे SELECT [ ] FROM (SELECT $0 O, ' '+REPLICATE('_', MAX(C)*@F)+' ' [ ] FROM # UNION SELECT $1/C, '|'+REPLICATE('_',C*@F)+'| '+W FROM #)X ORDER BY O?
— गाबे
34

रूबी 207 213 211 210 207 203 201 200 चरस

अनुराग पर एक सुधार, 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

संपादित करें: पुट में 'पुट' डालता है, आउटपुट में उद्धरण होने से बचने के लिए वहाँ रहने की आवश्यकता है।
Edit2: परिवर्तित फ़ाइल-> IO
Edit3: remove / i
Edit4: चारों ओर से हटाए गए कोष्ठक (f * 1.0), recounted
Edit5: पहली पंक्ति के लिए स्ट्रिंग जोड़ का उपयोग करें; sजगह में विस्तार ।
एडिट 6: एम फ्लोट बनाया, 1.0 निकाला। संपादित करें: काम नहीं करता है, लंबाई बदलता है। संपादित करें:
Edit7 से पहले कोई भी बदतर नहीं : उपयोग करें STDIN.read।

— आर्कगून
स्रोत
+1 - सॉर्टिंग भाग से प्यार, बहुत चालाक :)
— अनुराग
हे, पहली बार में इसके साथ आने के मुकाबले छोटे अनुकूलन। :)
— तीरंदाज
अच्छा! मैंने अनुराग के संस्करण में भी दो बदलाव किए। एक और बंद करता है 4.
— स्टीफन कोचन
समाधान मूल आउटपुट से भटक गया है, मैं टोट्री जा रहा हूं और यह पता लगाऊंगा कि कहां हुआ था।
— तीरंदाज
1
इसके आगे एक छोटा संस्करण है।
— तीरंदाज
28

गणितज्ञ ( 297 284 248 244 242 199 वर्ण) शुद्ध क्रियात्मक

और जिपफ का विधि परीक्षण

देखो मम्मा ... न कोई वर, न कोई हाथ, न कोई सिर

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

गणितज्ञ गोल्फ के लिए अच्छी तरह से अनुकूल नहीं है, और यह सिर्फ लंबे, वर्णनात्मक फ़ंक्शन नामों के कारण है। "RegularExpression []" या "StringSplit []" जैसे फ़ंक्शंस मुझे बस sob :( बनाते हैं।

जिपफ का विधि परीक्षण

Zipf के नियम है कि एक प्राकृतिक भाषा पाठ के लिए, भविष्यवाणी के लिए लॉग (रैंक) बनाम लॉग (आवृत्तियां) प्लॉट एक प्रकार है रैखिक संबंध।

कानून का उपयोग क्रिप्टोग्राफी और डेटा संपीड़न के लिए एल्गोरिदम विकसित करने में किया जाता है। (लेकिन यह LZW एल्गोरिथ्म में "Z" नहीं है)।

हमारे पाठ में, हम निम्नलिखित के साथ इसका परीक्षण कर सकते हैं 

 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 (अब कोई फ़ंक्शन का चयन न करें) को फिर से
दिखाना 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साथ प्रतिस्थापितTransposeSlot#1#2 ) तर्क।
  • हमें स्टिंकिन ब्रैकेट्स की आवश्यकता नहीं है ( जहां संभव हो f@xइसके बजाय उपयोग करें f[x])
— बेलीज़ेरियस
स्रोत
9
आपको लगता है कि "RegularExpression" खराब है? जब मैंने C # संस्करण में "System.Text.RegularExpressions.Regex.Split" टाइप किया, तब तक रोया जब तक कि मैंने Objective-C कोड नहीं देखा: "stringWithContentsOfFile", "EnumerateSubstringsInRange", "NSStringEnumerationByWords", "SortAr"। " ।
— गाबे
2
@Gabe धन्यवाद ... मैं अब बेहतर महसूस करता हूं। स्पैनिश में हम कहते हैं "mal de muchos, consuelo de tontos" .. कुछ इस तरह "बहुत परेशान, मूर्खों ने राहत दी": D
— डॉ। बेलिसियस
1
|i|क्योंकि आपके पास पहले से अपने regex में अनावश्यक है .|।
— गाबे
1
मुझे वह स्पेनिश कहावत पसंद है। अंग्रेजी में सबसे करीबी चीज "दुख प्यार कंपनी" है। यहाँ मेरा अनुवाद प्रयास है: "यह एक मूर्ख व्यक्ति है, जब पीड़ित होता है, उसी स्थिति में दूसरों के बारे में सोचकर सांत्वना लेता है।" गणित के कार्यान्वयन पर अद्भुत काम, btw।
— जूल 5'10
@dreeves मूर्खता आसानी से भाषा की बाधा को पार कर जाती है ... खुशी है कि आप मेरे छोटे गणित कार्यक्रम की तरह देख सकते हैं, मैं बस भाषा सीखना शुरू कर रहा हूं
— डॉ। बेलिसियस
26

C # - 510 451 436 446 434 426 422 वर्ण (छोटा)

यह छोटा नहीं है, लेकिन अब शायद सही है! ध्यान दें, पिछले संस्करण ने सलाखों की पहली पंक्ति नहीं दिखाई थी, सलाखों को सही ढंग से स्केल नहीं किया, फ़ाइल को स्टड से प्राप्त करने के बजाय डाउनलोड किया, और सभी आवश्यक सी # वर्बोसिटी को शामिल नहीं किया। आप आसानी से कई स्ट्रोक दाढ़ी कर सकते हैं अगर C # को बहुत अधिक बकवास की आवश्यकता नहीं थी। शायद पॉवरशेल बेहतर कर सकती थी।

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

नीचे दिए गए फॉर्म में लेंडवाइज़र इनलाइन (जो इसे 22 गुना धीमा बनाता है) के साथ 422 चार्ट

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));}}
— गेबे
स्रोत
फ़ाइल इनलाइन डाउनलोड करने वाले स्मार्ट-गधे के लिए +1। :)
— सरनोल
1
मैट के उत्तर से संक्षिप्त URL चोरी करें।
— indiv
2
युक्ति ने कहा कि फ़ाइल को पाइप करना चाहिए या एक आर्ग के रूप में पास होना चाहिए। यदि आप यह मान रहे थे कि args [0] में स्थानीय फ़ाइल नाम है, तो आप (new WebClient ()) के बजाय args [0] का उपयोग करके इसे काफी छोटा कर सकते हैं। DownloadString (@ " gutenberg.org/files/11/11) txt " ) -> यह आपको लगभग 70 वर्णों को
— बचाएगा
1
यहाँ एक संस्करण की जगह WebClient कॉल को args 0, StreamReader के लिए कॉल और कुछ अतिरिक्त रिक्त स्थान को हटा दिया गया है। कुल चार गिनती = 413 var a = Regex.Replace ((नया StreamReader (args [0]))। ReadToEnd (), "[^ a-zA-Z]", "") .TTLower ()। स्प्लिट (') ) .Where (x =>! (नई [] { "" "और" "का", "करने के लिए", "एक", "मैं", "यह", "में", "या" " कि "})। शामिल (x))। GroupBy (x => x) .Select (छ => नई {w = g.Key, ग = g.Count ()})। OrderByDescending (x => XC)। छोड़ें (1) .Take (22) .TLList (); var m = a.OrderByDescending (x => xc) .First (); a.ForEach (x => Console.Writebine (")" + new String (') _ ', xc * (80-mLength 4) / mc) + "|" + xw));
— थोरिया
"new StreamReader" बिना "Use" के गंदा है। File.ReadAllText (args [0]) या Console.In.ReadToEnd () बहुत बेहतर हैं। बाद के मामले में आप अपने मुख्य () से तर्क को हटा भी सकते हैं। :)
— रॉटस्टर
25

पर्ल, 237 229 209 चार्ट

(रूबी संस्करण को और अधिक गंदे गोल्फ ट्रिक्स के split/[^a-z/,lcसाथ बदलने, फिर से बदलने lc=~/[a-z]+/gऔर दूसरी जगह खाली स्ट्रिंग के लिए एक चेक को समाप्त करने के लिए अपडेट किया गया । ये रूबी संस्करण से प्रेरित थे, इसलिए क्रेडिट जहां क्रेडिट की वजह से है।)

अद्यतन: अब पर्ल 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विभाजन रेगेक्स में जोड़ने की आवश्यकता होती है , इसलिए यह धोना है।

यदि आप एक ऐसी प्रणाली पर हैं जहाँ एक नई पंक्ति एक वर्ण है और दो नहीं है, तो आप इसके स्थान पर शाब्दिक नई पंक्ति का उपयोग करके एक और दो वर्णों द्वारा इसे छोटा कर सकते हैं \n। हालाँकि, मैंने उस तरह का नमूना नहीं लिखा है, क्योंकि यह "क्लियर" (हा!) है।

यहाँ एक अधिकतर सही है, लेकिन दूरस्थ रूप से पर्याप्त नहीं, पर्ल समाधान:

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;
— JSB का खुलासा किया
स्रोत
अभी कुछ कीड़े हैं; ठीक करना और छोटा करना।
— JSB JS
4
यह मामला कवर नहीं करता है जब दूसरा शब्द पहले की तुलना में अधिक लंबा है, है ना?
— जॉय
1
दोनों को foreachएस के रूप में लिखा जा सकता है for। वह 8 चंवर नीचे है। फिर आपके पास है grep{!($_~~@s)}map{lc=~/[a-z]+/g}<>, जो मेरा मानना ​​है कि grep{!(/$_/i~~@s)}<>=~/[a-z]+/g4 और नीचे जाने के लिए लिखा जा सकता है । बदलें " "के साथ $"है और आपको अधिक 1 नीचे रहे हैं ...
— ज़ैद
sort{$c{$b}-$c{$a}}...दो और बचाने के लिए। आप, साथ ही पारित कर सकते हैं %cके बजाय keys %cकरने के लिए sortसमारोह और चार बचाने अधिक।
— भीड़
20

विंडोज पॉवरशेल, 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]

(अंतिम पंक्ति विराम आवश्यक नहीं है, लेकिन पठनीयता के लिए यहां शामिल है।)

(वर्तमान कोड और मेरी एसवीएन रिपॉजिटरी में उपलब्ध मेरी परीक्षण फाइलें । मुझे आशा है कि मेरे परीक्षण मामलों में सबसे आम त्रुटियां हैं (बार की लंबाई, रेगेक्स मिलान की समस्या और कुछ अन्य))

मान्यताओं:

  • इनपुट के रूप में US ASCII। यह शायद यूनिकोड के साथ अजीब हो जाता है।
  • पाठ में कम से कम दो गैर-रोक शब्द

इतिहास

आराम से संस्करण (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 वर्णों से अधिक लंबी न हो।

समझाया गया एक पुराना संस्करण यहां पाया जा सकता है ।

— , 2 यूजर्स 98%
स्रोत
प्रभावशाली, लगता है कि पॉवरशेल गोल्फ के लिए उपयुक्त वातावरण है। बार की लंबाई पर विचार करते हुए आपका दृष्टिकोण बिल्कुल वही है जो मैंने वर्णन करने की कोशिश की (न कि शानदार ढंग से, मैं मानता हूं) कल्पना में।
— क्रिस्टोफडी
1
@ChristopheD: मेरे अनुभव में (अनार्की गोल्फ, कुछ प्रोजेक्ट यूलर टास्क और कुछ और टास्क सिर्फ इसके मजे के लिए), पॉवरशेल आमतौर पर केवल रूबी से थोड़ा खराब होता है और अक्सर पर्ल और पायलॉन के साथ बंधा या बेहतर होता है। भले ही GolfScript का कोई मुकाबला नहीं है। लेकिन जहां तक ​​मैं देख सकता हूं, यह सबसे छोटा समाधान हो सकता है जो बार की लंबाई के लिए सही रूप से खाता है ;-)
— जॉय
जाहिर है मैं सही था। पॉवरशेल बेहतर कर सकते हैं - बहुत बेहतर! कृपया टिप्पणियों के साथ एक विस्तारित संस्करण प्रदान करें।
— गाबे
जोहान्स: क्या आपने कोशिश की -split("\b(?:the|and|of|to|a|i[tns]?|or)\b|[^a-z]")? इससे मेरा काम बनता है।
— गाबे
आउटपुट स्ट्रिंग को प्रक्षेपित करना न भूलें: "|$('_'*($w*$_.count/$x[0].count))| $($_.name) "(या अंतिम स्थान को समाप्त कर दें, क्योंकि यह स्वचालित है)। और आप -split("(?:\b(?:the|and|of|to|a|i[tns]?|or)\b|[^a-z])+")रिक्त (या उपयोग [-2..-23]) को शामिल करके कुछ और बचाने के लिए उपयोग कर सकते हैं ।
— गाबे
19

रूबी, 215, 216 , 218 , 221 , 224 , 236 , 237 वर्ण

अद्यतन 1: हुर्रे ! यह जेएस बैंग्स के समाधान के साथ एक टाई है । किसी भी तरह से कटौती करने का तरीका नहीं सोच सकते :)

अद्यतन 2: एक गंदा गोल्फ चाल खेला। 1 वर्ण बचाने के eachलिए बदला गया map:)

अद्यतन 3: परिवर्तित File.readIO.read +2 में गया । Array.group_byबहुत फलदायी नहीं था, reduce+6 में बदल गया । downcaseरेगेक्स +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: मैं पहले पुनरावृत्ति का पता लगाने के लिए पूरी तरह से घेरा के माध्यम से चला गया उदाहरण के चर का उपयोग करते हुए, लूप के अंदर । मेरे पास सभी +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
— अनुराग
स्रोत
3
क्या "p" "put" का शॉर्टकट नहीं है? कि कुछ दाढ़ी कर सकता है।
— rfusca
1
अच्छा लगा। scanहालाँकि, आपके उपयोग ने मुझे एक बेहतर विचार दिया, इसलिए मैं फिर से आगे बढ़ गया :)।
— JSB JS
2
आपको सलाखों को स्केल करने की आवश्यकता है इसलिए सबसे लंबा शब्द प्लस इसकी बार 80 अक्षरों पर फिट बैठता है। जैसा कि ब्रायन ने सुझाव दिया, एक लंबा दूसरा शब्द आपके कार्यक्रम को तोड़ देगा।
— गाबे
3
मुझे आश्चर्य है कि यह अभी भी वोट क्यों इकट्ठा कर रहा है। समाधान गलत है (सामान्य स्थिति में) और दो तरह से छोटे रूबी समाधान यहां अब तक हैं।
— जॉय
1
अब, अगर मैं गलत हूं तो मुझे सुधारें, लेकिन "डाउनकेस" का उपयोग करने के बजाय, आप REGEXP केस असंवेदनशील झंडे का उपयोग क्यों नहीं करते हैं, जो 6-7 बाइट्स बचाता है, क्या ऐसा नहीं होता है?
— जूल 3'10
19

पायथन 2.x, अक्षांशीय दृष्टिकोण = 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। मैंने ऐलिस, किंग जेम्स की बाइबल और शब्दजाल से शब्द के कॉर्पस के खिलाफ उन शब्दों के सभी निष्कर्षों को देखने की कोशिश की कि क्या कोई ऐसे शब्द हैं जो स्ट्रिंग द्वारा गलत तरीके से बाहर रखा जाएगा। और इस तरह मैंने दो बहिष्करण स्ट्रिंग्स के साथ समाप्त किया:itheandtoforinis और andithetoforinis।

पुनश्च। कोड को छोटा करने के लिए अन्य समाधानों से उधार लिया गया।

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

एलिस इन वंडरलैंड टेक्स्ट के the and to a of it she i you said
शीर्ष 10 शब्द, जारगॉन फाइल के शीर्ष 10 शब्द हैं (v4.4.7)the a of to and in is that or for

तो सवाल यह है कि orसमस्या की अनदेखी सूची में शामिल क्यों किया गया, जहां यह लोकप्रियता में ~ 30 वें स्थान पर है जब शब्द that(8 वां सबसे अधिक इस्तेमाल किया गया) नहीं है। आदि, इसलिए मेरा मानना ​​है कि अनदेखा सूची को गतिशील रूप से प्रदान किया जाना चाहिए (या छोड़ा जा सकता है)।

वैकल्पिक विचार केवल परिणाम से शीर्ष 10 शब्दों को छोड़ने के लिए होगा - जो वास्तव में समाधान को कम कर देगा (प्राथमिक - केवल 11 वीं से 32 वीं प्रविष्टियों को दिखाना होगा)।

पायथन 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 पर पारित "मूल" उपेक्षा सूची के लिए खाते हैं

पुनश्च। दूसरा कोड सभी शीर्ष शब्दों की लंबाई के लिए "समायोजन" भी करता है, इसलिए उनमें से कोई भी पतित मामले में अतिप्रवाह नहीं करेगा।

 _______________________________________________________________
|_______________________________________________________________| she
|_______________________________________________________| superlongstringstring
|_____________________________________________________| said
|______________________________________________| alice
|_________________________________________| was
|______________________________________| that
|_______________________________| as
|____________________________| her
|__________________________| at
|__________________________| with
|_________________________| s
|_________________________| t
|_______________________| on
|_______________________| all
|____________________| this
|____________________| for
|____________________| had
|____________________| but
|___________________| be
|___________________| not
|_________________| they
|_________________| so
— नेस बानोव को प्रकट किया
स्रोत
अब तक अच्छा समाधान हालांकि शब्द की अनदेखी सूची को लागू नहीं किया गया है (अभी तक) और बार इस समय थोड़ा अशिष्ट हैं।
— क्रिस्टोफडी
@ChristopheD: यह वहाँ था, लेकिन कोई "उपयोगकर्ता गाइड" नहीं था। बस गुच्छा पाठ जोड़ा
— Nas Banov
अपनी भाषाओं और समाधानों की सूची के बारे में: कृपया उन समाधानों की तलाश करें जो बंटवारे का उपयोग करते हैं \Wया \bएक रेगेक्स में उपयोग करते हैं क्योंकि वे बहुत संभव नहीं हैं, जो कि अनुमान के अनुसार नहीं हैं , जिसका अर्थ है कि वे अंकों पर विभाजित नहीं होंगे या _वे स्टर्लिंग से शब्द रोक भी नहीं सकते हैं। जैसे कि the_foo_or123bar। वे परीक्षण पाठ में दिखाई नहीं दे सकते हैं, लेकिन उस मामले में विनिर्देश स्पष्ट है।
— जॉय
कमाल का काम एनएएस, मैंने एक दोपहर बिताई थी इसे अनुकूलित करने की कोशिश में और केवल एक सुधार पाया। आप sys.argvहैक को हटाकर और उपयोग करके 239 वर्णों तक इसे काट सकते हैं :re.findall(r'\b(?!(?:the|and|.|of|to|i[tns]|or)\b)\w+',sys.stdin.read().lower())
— एकीकृत करें
12

हास्केल - 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 (notElemwords "the and of to a i it in or is") निषिद्ध शब्दों के साथ सभी प्रविष्टियों को ।
  • group . sort शब्दों को सॉर्ट करें, और समूहों को समान सूची में रखें।
  • map h समान शब्दों की प्रत्येक सूची को प्रपत्र के टपल को मैप करता है (-frequency, word) ।
  • take 22 . sort अवरोही आवृत्ति (पहली टुपल प्रविष्टि) द्वारा ट्यूपल्स को छाँटते हैं, और केवल पहले 22 ट्यूपलों को रखते हैं।
  • b मैप्स टुपल्स टू बार (नीचे देखें)।
  • a सबसे ऊपरी पट्टी को पूरा करने के लिए, अंडरस्कोर की पहली पंक्ति तैयार करता है।
  • unlines इन सभी लाइनों को एक साथ जोड़कर नई रेखाएँ बनाता है।

मुश्किल बिट बार लंबाई सही हो रही है। मैंने मान लिया कि केवल अंडरस्कोर की गिनती बार की लंबाई की ओर होती है, इसलिए ||यह शून्य लंबाई की पट्टी होगी। फंक्शन bमैप्स c xखत्म हो जाता है x, जहां xहिस्टोग्राम्स की सूची है। पूरी सूची को पारित कर दिया जाता है c, ताकि प्रत्येक आह्वान cकॉल करके अपने लिए स्केल कारक की गणना कर सके u। इस तरह, मैं फ्लोटिंग-पॉइंट गणित या तर्कसंगतता का उपयोग करने से बचता हूं, जिनके रूपांतरण कार्य और आयात कई पात्रों को खा जाते हैं।

उपयोग करने की चाल पर ध्यान दें -frequency। इसके बाद से छंटनी (आरोही) की आवश्यकता को हटा दिया जाता है reverse, पहले शब्दों को सबसे बड़ी आवृत्ति के साथ रखा जाएगा। बाद में, फ़ंक्शन में , दो मान गुणा किए जाते हैं, जो नकार को रद्द कर देगा।sort-frequencyu-frequency

— थॉमस
स्रोत
बहुत अच्छा काम (upvote होगा लेकिन आज के लिए वोट से बाहर भाग गया इस महान जवाब के साथ सभी में)।
— क्रिस्टोफडी
यह मेरी आँखों को इस तरह से चोट पहुँचाता है कि वर्णन करने के बारे में सोचने के लिए भी दर्दनाक है, लेकिन मैंने इसे रिवर्स-इंजीनियरिंग द्वारा हास्केल को बहुत कुछ सीखा। अच्छा हुआ, सर। :-)
— ओवेन एस।
यह वास्तव में काफी मुहावरेदार हैस्केल है, यद्यपि वास्तव में कुशल नहीं है। संक्षिप्त नाम यह वास्तव में की तुलना में कहीं अधिक बदतर दिखते हैं।
— थॉमस
@ थोमस: आप फिर से कह सकते हैं। :-)
— ओवेन एस।
1
divवास्तव में स्थानांतरित नहीं कर सकते ! यह कोशिश करो- आउटपुट गलत है। कारण यह है कि divपहले कर *सटीक खो देता है।
— MtnViewMark
11

जावास्क्रिप्ट 1.8 (स्पाइडरमोनी) - 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)राइनो संस्करण से स्पाइडरमोंकी में काम करना नहीं चाहता है, और 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

आउटपुट:

 _________________________________________________________________________ 
| _________________________________________________________________________ | वह
| _______________________________________________________________ | आप
| ____________________________________________________________ | कहा हुआ
| ____________________________________________________ | ऐलिस
| ______________________________________________ | था
| ___________________________________________ | उस
| ___________________________________ | जैसा
| ________________________________ | उसके
| _____________________________ | पर
| _____________________________ | साथ में
| ____________________________ | रों
| ____________________________ | टी
| __________________________ | पर
| _________________________ | सब
| _______________________ | यह
| ______________________ | के लिये
| ______________________ | था
| ______________________ | परंतु
| _____________________ | होना
| _____________________ | नहीं
| ___________________ | वे
| ___________________ | इसलिए

(आधार संस्करण - बार चौड़ाई को सही ढंग से नहीं संभालता है)

जावास्क्रिप्ट (राइनो) - 405 395 387 377 368 343 304 चार

मुझे लगता है कि मेरी छंटनी का तर्क बंद है, लेकिन .. मुझे लगता है। ब्रेनफार्ट तय।

कम से कम ( कभी-कभी \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)}
— मैट
स्रोत
आह, सर। मुझे विश्वास है कि यह आपका गौंटलेट है। अपनी दूसरी बात मेरे साथ करो।
— dmckee --- पूर्व मॉडरेटर
2
BTW-- मुझे i[tns]?बिट पसंद है । बहुत डरपोक।
— dmckee --- पूर्व-मध्यस्थ ने बिल्ली का बच्चा
@ मिक्की - अच्छी तरह से खेला, मुझे नहीं लगता कि मैं आपके 336 को हरा सकता हूं, आपके बहुत-से उत्थान का आनंद लेंगे :)
— मैट
आप निश्चित रूप से 336 को हरा सकते हैं ... एक 23 कैरेक्टर कट उपलब्ध है - जिसे आपके द्वारा किए गए समान फ़ंक्शन के .replace(/[^\w ]/g, e).split(/\s+/).map(साथ बदला जा सकता है .replace(/\w+/g,और उपयोग किया जा सकता है .map... यह भी सुनिश्चित नहीं है कि राइनो function(a,b)b.c-a.cआपके सॉर्ट फ़ंक्शन (स्पिडरमोनकी करता है) के बजाय समर्थन करता है, लेकिन यह होगा शेव {return }... b.c-a.cएक बेहतर सॉर्ट है जो a.c<b.cbtw ... इन बदलावों के साथ सबसे नीचे एक स्पाइडरमोंकी संस्करण का संपादन
— gnff
मैंने अपने स्पाइडरमोंकी संस्करण को ऊपर तक स्थानांतरित किया क्योंकि यह बार चौड़ाई की बाधा के अनुरूप है ... साथ ही एक एकल प्रतिस्थापन (), के लिए अनुमति देने वाले शब्दों को नकारने के लिए एक नकारात्मक लुकहैड regexp का उपयोग करके अपने मूल संस्करण में कुछ और वर्णों को काटने में कामयाब रहा। और कुछ ?:आधार के साथ काम करने के लिए महान आधार के साथ कुछ अगर गोल्फ !
— गर्नफ
11

PHP CLI संस्करण (450 वर्ण)

यह समाधान अंतिम आवश्यकता को ध्यान में रखता है जिसे ज्यादातर शुद्धतावादियों ने अनदेखा करने के लिए चुना है। जिसमें 170 अक्षर थे!

उपयोग: php.exe <this.php> <file.txt>

न्यूनतम किया गया:

<?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
— रेव्स , 2 उपयोगकर्ता 99% user382874
स्रोत
11

पायथन 3.1 - 245 229 चरस

मुझे लगता है कि काउंटर का उपयोग करना धोखा देने की तरह है :) मैंने अभी इसके बारे में एक सप्ताह पहले पढ़ा था, इसलिए यह देखने का सही मौका था कि यह कैसे काम करता है। 

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 के समाधान से "उधार" लिए गए थे।

— sdolan
स्रोत
पहली लाइन गायब है। और बार की लंबाई सही नहीं है।
— जॉय
आपके कोड में ऐसा लगता है कि open('!')स्टड से पढ़ता है - वह कौन सा संस्करण / ओएस है? या क्या आपको फ़ाइल का नाम देना है '!'
— नास बानोव
फ़ाइल का नाम "!" :) खेद है कि बहुत अस्पष्ट था, और मुझे इसका उल्लेख करना चाहिए था।
— सैम डोलन
11

पर्ल, 205 191 189 अक्षर / 205 अक्षर (पूरी तरह से लागू)

कुछ हिस्से पहले के पर्ल / रूबी सबमिशन से प्रेरित थे, कुछ इसी तरह के विचार स्वतंत्र रूप से आए थे, अन्य मूल हैं। छोटे संस्करण में कुछ चीजें भी शामिल हैं, जिन्हें मैंने अन्य सबमिशन से देखा / सीखा है।

मूल:

$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 char) बाद में पाए जाने वाले शब्दों की तुलना में लंबी लाइनों वाले खातों के लिए है।

/^(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]
— रेव्ह पदेहन
स्रोत
10

पर्ल: 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]

वैकल्पिक, पूर्ण कार्यान्वयन जिसमें पैथोलॉजिकल केस के लिए संकेतित व्यवहार (वैश्विक बार-स्क्विशिंग) शामिल है, जिसमें द्वितीयक शब्द दोनों लोकप्रिय है और 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 पर जाना था, इसलिए मैंने प्रिंट के बजाय पर्ल के चेतावनी () का उपयोग किया - चार लोगों ने वहां बचाया। फ़ॉर्च के बजाय मैप का उपयोग किया गया है, लेकिन मुझे लगता है कि विभाजन (जुड़ाव ()) में अभी भी कुछ और बचत हो सकती है। फिर भी, यह 203 तक कम हो गया - इस पर सो सकते हैं। कम से कम पर्ल के अब "शेल, grep, tr, grep, सॉर्ट, यूनीक, सॉर्ट, हेड, पर्ल" के तहत अब के लिए "गणना";

पुनश्च: Reddit कहते हैं "हाय";)

अद्यतन: निकाले गए जुड़ाव () असाइनमेंट के पक्ष में और अंतर्निहित स्केलर रूपांतरण में शामिल हों। 202 से नीचे। कृपया ध्यान दें कि मैंने 2 अक्षरों को बंद करने के लिए वैकल्पिक "1-अक्षर वाले शब्दों को अनदेखा" नियम का लाभ उठाया है, इसलिए आवृत्ति गिनती को ध्यान में रखते हुए इसे सहन करेंगे।

अद्यतन 2: पहले स्थान पर <> का उपयोग करके एक चक्कर में फ़ाइल प्राप्त करने के लिए $ / की हत्या करने के लिए असाइनमेंट और निहितार्थ मिलाएं। समान आकार, लेकिन नास्टियर। अगर ($!) {} $ Y के लिए {} और} बचा लिया गया, तो 1 और चार्ट => 201 बचा।

अपडेट 3: मैप ब्लॉक से lc को आगे बढ़ाते हुए लोअरकेसिंग अर्ली (lc <>) का नियंत्रण ले लिया - दोनों रेगेक्स को अब उपयोग / i विकल्प में स्वैप नहीं किया, क्योंकि अब ज़रूरत नहीं है। स्पष्ट परिशिष्ट x की अदला-बदली? Y: z पारंपरिक पर्लग्लॉफ़ के लिए निर्माण || अंतर्निहित सशर्त निर्माण - / ^...///??::xxatalog$ } ++ के लिए / ^...// पर / विकिपीडिया, } ++ तीन वर्ण सहेजे गए! => 198, 200 बैरियर को तोड़ा। शायद जल्दी सो जाए ... शायद।

अद्यतन 4: नींद की कमी ने मुझे पागल बना दिया है। कुंआ। अधिक पागल। यह जानते हुए कि यह केवल सामान्य खुश पाठ फ़ाइलों को पार्स करने के लिए है, मैंने इसे एक शून्य देने पर छोड़ दिया। दो पात्रों को बचाया। बदला गया "लंबाई" 1-char छोटी (और बहुत अधिक गोल्फ के साथ) y /// c - आप मुझे सुनते हैं, GolfScript ?? मै तुम्हारे लिए आ रहा हु!!! सिसकी

अपडेट 5: स्लीप डिप ने मुझे 22row की सीमा और उसके बाद की लाइन सीमित करने के बारे में बताया। 208 तक वापस उन लोगों के साथ। बहुत बुरा नहीं, 13 पात्रों को संभालने के लिए यह दुनिया का अंत नहीं है। पर्ल के रेगेक्स इनलाइन इवैल के साथ खेला गया, लेकिन इसे दोनों काम करने और चार्ट को बचाने में परेशानी हो रही है ... लोल। वर्तमान आउटपुट से मिलान करने के लिए उदाहरण को अपडेट किया।

अद्यतन 6: हटाए गए अनावश्यक ब्रेसिज़ की रक्षा (...) के लिए, क्योंकि सिंटैक्टिक कैंडी ++ खुशी के लिए इसके खिलाफ शोर करने की अनुमति देता है। चास से इनपुट के लिए धन्यवाद। ओवेन्स (मेरे थके हुए मस्तिष्क की याद दिलाते हुए), चरित्र वर्ग मैं [tns] वहाँ में समाधान मिला। 203 पर वापस।

अद्यतन 7: काम का दूसरा टुकड़ा, चश्मे का पूर्ण कार्यान्वयन (माध्यमिक लंबे शब्दों के लिए पूर्ण बार-स्क्विशिंग व्यवहार सहित, ट्रंकेशन के बजाय जो ज्यादातर लोग कर रहे हैं, पैथोलॉजिकल उदाहरण मामले के बिना मूल कल्पना पर आधारित है)

उदाहरण:

 _________________________________________________________________________
|_________________________________________________________________________| 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
— सिंटेरा को प्रकट करता है
स्रोत
आप गिर द्वारा रोक शब्दों के लिए रेगुलर एक्सप्रेशन से छोटा कर सकते हैं is|in|it|iमें i[snt]?- और फिर वहाँ वैकल्पिक नियम के साथ कोई अंतर नहीं अब और है। (हम्म, मैंने कभी नहीं सोचा था कि एक पर्ल व्यक्ति को रेगेक्स कैसे करना है: डी) के बारे में - अब केवल समस्या: मुझे यह देखना होगा कि कैसे मैं पर्ल से फिर से बेहतर होने के लिए अपने स्वयं के समाधान से तीन बाइट्स काट सकता हूं: - |
— जॉय
ठीक है, जो मैंने पहले कहा था, उसकी उपेक्षा करें। एक-अक्षर के शब्दों को नज़रअंदाज़ करना वास्तव में एक बाइट है जो इसे न करने से कम है।
— जॉय
हर बाइट मायने रखता है;) मैंने न्यूलाइन ट्रिक को करने पर विचार किया, लेकिन मुझे लगा कि यह वास्तव में बाइट्स की समान संख्या है, भले ही यह कम मुद्रण योग्य वर्ण था। फिर भी यह देखते हुए काम करना कि क्या मैं इसे कुछ और कम कर सकता हूँ :)
— Syntaera
आह ठीक है, मामले के सामान्यीकरण ने मुझे वापस 209 पर फेंक दिया। मैं नहीं देखता कि मैं और क्या काट सकता हूं। हालाँकि PowerShell Perl से छोटी हो सकती है। ;-)
— जॉय
मैं यह नहीं देखता कि आप आउटपुट को शीर्ष 22 शब्दों में कैसे सीमित करते हैं, और न ही आप यह सुनिश्चित करते हैं कि एक लंबा दूसरा शब्द लपेटता नहीं है।
— गाबे
9

एफ #, 452 चार्ट

भयावह: 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
— दर्शाता है
स्रोत
पता चला है कि मेरा अपना समाधान वास्तव में एक छोटा सा था (थोड़ा अलग कल्पना के कारण), समाधान अब अनुरूप हैं ;-)
— क्रिस्टोफ़ेद
अब तक एकमात्र सही बार स्केलिंग कार्यान्वयन के लिए +1
— Rotsor
2
(@ रॉटर्स: विडंबना, यह देखते हुए कि मेरा सबसे पुराना समाधान है।)
— ब्रायन
मुझे विश्वास है कि आप विभाजन, मानचित्र और फ़िल्टर चरणों को मर्ज करके इसे काफी छोटा कर सकते हैं। मुझे यह भी उम्मीद है कि आपको इतने सारे floatएस की आवश्यकता नहीं होगी ।
— गाबे
क्या पाइप लाइन ऑपरेटर के उपयोग से घोंसले के कार्य आमतौर पर कम नहीं होते हैं |>?
— जॉय
8

पायथन 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
— AKX को रिवील किया
स्रोत
1
bm=(76.-len(W[0][0]))/W[0][1]जब से आप केवल एक बार bm का उपयोग कर रहे हैं तब से आप लाइन खो सकते हैं (अगली पंक्ति बना सकते हैं U=lambda n:"_"*int(n*(76.-len(W[0][0]))/W[0][1]), 5 वर्णों को बंद कर सकते हैं। इसके अलावा: आप कोड गोल्फिंग में 2-वर्ण चर नाम का उपयोग क्यों करेंगे? ;-)
— ChristopheD
अंतिम पंक्ति में प्रिंट के बाद का स्थान आवश्यक नहीं है, एक पात्र को बंद कर देता है
— क्राइस्टोफेड
1
उस मामले पर विचार नहीं करता है जब दूसरा सबसे लगातार शब्द बहुत लंबा है, है ना?
— जॉय
@ChristopheD: क्योंकि मैं उस कोड को बहुत लंबे समय से देख रहा था। : पी गुड पकड़। @ जोहान्स: यह भी तय किया जा सकता है, हाँ। यह निश्चित नहीं है कि अन्य सभी कार्यान्वयनों ने ऐसा किया जब मैंने यह लिखा था।
— AKX
7

* श (+ कर्ल), आंशिक समाधान

यह अधूरा है, लेकिन इसके नरक के लिए, यहां 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
— फ्रैंक किसान
स्रोत
7

गौक - 336 (मूल रूप से 507) अक्षर

(आउटपुट स्वरूपण को ठीक करने के बाद; संकुचन चीज़ को ठीक करना; ट्विक करना; फिर से ट्विक करना; पूरी तरह से सॉर्टिंग स्टेप को हटाना; अभी तक फिर से ट्विक करना; और फिर से (यह एक स्वरूपण को तोड़ देता है); कुछ और ट्विस्ट करें; मैट मैट की चुनौती को लेते हुए मैं सख्त रूप से ट्विक करता हूं। और अधिक, कुछ बचाने के लिए एक और जगह मिली, लेकिन बार की लंबाई को ठीक करने के लिए दो वापस दिए गए)

हे हे! मैं पल भर में [मैट के जावास्क्रिप्ट] [1] समाधान काउंटर चुनौती से आगे हूं ! ;) और [एकेएक्स के अजगर] [2]।

यह समस्या ऐसी भाषा के लिए कहलाती है जो देशी साहचर्य सरणियों को लागू करती है, इसलिए निश्चित रूप से मैंने उन पर ऑपरेटरों की एक बहुत ही कमी के साथ चुना है। विशेष रूप से, आप उस क्रम को नियंत्रित नहीं कर सकते हैं जिसमें हैश मानचित्र के तत्वों को जागृत करता है, इसलिए मैं बार-बार पूरे मानचित्र को स्कैन करता हूं ताकि वर्तमान में सबसे अधिक आइटम मिल जाए, इसे प्रिंट करें और इसे सरणी से हटा दें।

यह सब बहुत ही अयोग्य है, मैंने जितने भी गोल्फ के खिलाड़ी बनाए हैं, वह बहुत ही भयानक हो गए हैं।

न्यूनतम किया गया:

{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]
    }
}
— dmckee
स्रोत
अच्छा काम, अच्छा है जिसमें आपने एक इंडेंटेड / टिप्पणी वाला संस्करण शामिल किया ;-)
— क्रिस्टोफ़ डी
7

आम 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)))))
— 6502
स्रोत
क्या आपने कुछ इनपुट आकार को दाढ़ी बनाने के लिए एक कस्टम रीडर मैक्रो स्थापित करने की कोशिश की है?
— एरोन
@ अरोन वास्तव में यह मेरे लिए मामूली नहीं था यहां तक ​​कि यह काम कर रहा है ... :-) वास्तविक गोल्फ भाग के लिए मैंने सिर्फ एक-अक्षर वाले चर का उपयोग किया और यह सब है। वैसे भी समस्याओं के इस पैमाने के लिए सीएल में निहित कुछ उच्च क्रियात्मकता के अलावा ("समवर्ती 'स्ट्रिंग", "सेटफ" या "गेटश" हत्यारे हैं ... अजगर में वे "+", "=", "[]" हैं ) फिर भी मुझे यह बहुत बुरा लगा कि मैंने तार्किक स्तर पर भी उम्मीद की होगी। एक मायने में मैंने महसूस किया है कि लिस्प ठीक है, लेकिन आम लिस्प तो ऐसा है और यह नामकरण से परे है (सीएल के साथ मेरा अनुभव शून्य के करीब है क्योंकि यह एक बहुत ही अनुचित टिप्पणी है)।
— 6502
सच। योजना एकल नाम स्थान के साथ गोल्फ को थोड़ा आसान बना देगी। सभी जगह स्ट्रिंग-अपेंड के बजाय, आप लेट्रेक ((एक स्ट्रिंग-एपेंड) (बी गेटश)) ... (एक "x" "yz") कर सकते हैं ...
— हारून
6

सी (828)

यह मोटे कोड जैसा दिखता है, और स्ट्रिंग, सूची और हैश के लिए ग्लिब का उपयोग करता है। साथ चार गिनती 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);}
— शिनटेकेज़ो को दर्शाता है
स्रोत
न्यूलाइन्स को चरित्रों के रूप में गिना जाता है, लेकिन आप उन लाइनों से किसी को भी छीन सकते हैं जो प्रीप्रोसेसर निर्देश नहीं हैं। एक गोल्फ के लिए, मैं स्मृति को एक बुरे अभ्यास से मुक्त नहीं करने पर विचार करूंगा।
— स्टीफन कोचन
ठीक है ... सभी को एक पंक्ति में रखें (प्रीप्रोच मैक्रोज़ की अपेक्षा करें) और बिना किसी मेम को फ्री किए मेम (और दो अन्य रिक्त स्थान हटाए जाने के साथ) दिए गए ... "ओफ़्फ़्यूसेशन" पर थोड़ा सुधार किया जा सकता है, जैसे *v=*v*(77-lw)/m929 देगा। .. लेकिन मुझे लगता है कि यह ठीक हो सकता है जब तक कि मैं इसे बहुत छोटा करने का एक तरीका नहीं
— ढूंढता
मुझे लगता है कि आप कम से कम घोषणा int cमें आगे बढ़ सकते हैं mainऔर mainस्पष्ट intरूप से (जैसा कि किसी भी तरह के तर्क नहीं हैं, afaik) main(c){...}:। आप शायद 0इसके बजाय सिर्फ लिख सकते हैं NULL।
— जॉय
यह कर ... निश्चित रूप से -Wallया -std=c99पर ध्वज के साथ कुछ चेतावनी ट्रिगर करेगा ... लेकिन मुझे लगता है कि यह एक कोड-गोल्फ के लिए व्यर्थ है, है ना?
— शिनटकेज़ोउ
uff, शॉर्ट-गैप टाइम एडिट के लिए क्षमा करें, ... मुझे Without freeing memory stuff, it reaches 866 (removed some other unuseful space)लोगों को यह सोचने के लिए कुछ और बदलना चाहिए कि फ़्री-मेमोरी संस्करण के साथ अंतर सभी में है: अब नो-फ़्री-मेमोरी संस्करण में बहुत सारे हैं अधिक "सुधार"।
— शिनटेकजेउ
6

पर्ल, 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 वर्ण हो जाएं।

तीसरी पंक्ति (दो न्यूलाइन वर्ण हैं) आउटपुट का उत्पादन करती है।

— जुटती है
स्रोत
यह "foo_the_bar" जैसे शब्दों को रोक नहीं पाएगा। लाइन की लंबाई भी बहुत लंबी है (कल्पना को फिर से पढ़ें: "बार + स्पेस + वर्ड + स्पेस <= 80 वर्ण")
— जॉय
5

जावा - 886 865 756 744 742 744 752 742 714 680 chars

  • पहले 742 से पहले के अपडेट : बेहतर रेगेक्स, हटाए गए सुपरफ़्लड पैरामीटराइज्ड प्रकार, हटाए गए फ़ालतू व्हाट्सएप।

  • 742> 744 चार्ट अपडेट करें : फिक्स्ड-लेंथ हैक। यह केवल 1 शब्द पर निर्भर है, अन्य शब्दों (अभी तक) पर नहीं। कोड को छोटा करने के लिए कई जगह मिली ( \\sregex द्वारा प्रतिस्थापित और उसके ArrayListद्वारा प्रतिस्थापित Vector)। मैं अब कॉमन्स IO निर्भरता को हटाने और स्टड से पढ़ने के लिए एक छोटा रास्ता ढूंढ रहा हूं।

  • अद्यतन 744> 752 वर्ण : मैंने कॉमन्स निर्भरता को हटा दिया। यह अब स्टड से पढ़ता है। स्टड में पाठ चिपकाएँ और Ctrl+Zपरिणाम प्राप्त करने के लिए हिट करें।

  • 752> 742 चार्ट अपडेट करें : मैंने हटा दिया publicऔर एक स्थान बनाया, वर्गनाम 2 के बजाय 1 चार्ट बनाया और यह अब एक-अक्षर के शब्दों को अनदेखा कर रहा है।

  • 742> 714 चार्ट अपडेट करें: कार्ल की टिप्पणियों के अनुसार अपडेट किया गया: अनावश्यक कार्य (742> 730) को हटा दिया m.containsKey(k)गया, m.get(k)!=null(730> 728) द्वारा प्रतिस्थापित , लाइन (728> 714) का विकल्प प्रस्तुत किया गया।

  • अपडेट 714> 680 वर्ण : रॉटसर की टिप्पणियों के अनुसार अपडेट किया गया: अनावश्यक कास्टिंग को हटाने के लिए बार आकार की गणना में सुधार और 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);
 }
}

आउटपुट:

 _________________________________________________________________________
| _________________________________________________________________________ | वह
| _______________________________________________________________ | आप
| ____________________________________________________________ | कहा हुआ
| _____________________________________________________ | ऐलिस
| _______________________________________________ | था
| ___________________________________________ | उस
| ____________________________________ | जैसा
| ________________________________ | उसके
| _____________________________ | साथ में
| _____________________________ | पर
| __________________________ | पर
| __________________________ | सब
| _______________________ | यह
| _______________________ | के लिये
| _______________________ | था
| _______________________ | परंतु
| ______________________ | होना
| _____________________ | नहीं
| ____________________ | वे
| ____________________ | इसलिए
| ___________________ | बहुत
| __________________ | क्या

यह बहुत बेकार है कि जावा में नहीं है String#join()और बंद (अभी तक) नहीं है।

Rotsor द्वारा संपादित करें:

मैंने आपके समाधान में कई बदलाव किए हैं:

  • एक स्ट्रिंग के साथ प्रतिस्थापित सूची []
  • अपने स्वयं के स्ट्रिंग ऐरे को घोषित करने के बजाय 'आर्ग्स' तर्क का पुन: उपयोग करें। इसे .ToArray () के तर्क के रूप में भी उपयोग किया जाता है
  • एक स्ट्रिंग के साथ बदल स्ट्रिंगर (हाँ, हाँ, भयानक प्रदर्शन)
  • प्रारंभिक रुकने के साथ एक चयन-प्रकार के साथ जावा को क्रमबद्ध करना (केवल पहले 22 तत्वों को ढूंढना होगा)
  • एक ही बयान में कुछ अंतर घोषणा व्यक्त की
  • गैर-धोखा एल्गोरिथ्म को कार्यान्वित किया गया जो आउटपुट की सबसे सीमित रेखा है। एफपी के बिना इसे लागू किया।
  • पाठ में 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);}}}
— BalusC
स्रोत
क्या आप IOUtilsइसे आयात करने के बजाय पूरी तरह से योग्य नाम का उपयोग नहीं कर सकते ? जहाँ तक मैं देख सकता हूँ कि आप इसे वैसे भी केवल एक बार उपयोग कर रहे हैं।
— जॉय
5
आप यह मानकर धोखा खा जाते हैं कि सबसे लंबी पट्टी ठीक 75 अक्षर की होगी। आपको यह सुनिश्चित करना होगा कि कोई भी बार + शब्द 80 वर्णों से अधिक लंबा न हो।
— गेब
आपको शब्द के बाद एक स्थान याद आ रहा है। ;)
— स्टूल ०
जैसा कि मैं अपने जवाब को कम कर रहा था, मुझे उम्मीद थी कि मैं बालूसी के सबमिशन को हरा दूंगा। मेरे पास अभी भी २०० अक्षर हैं, उह! मुझे आश्चर्य है कि कब तक यह कॉमन्स IO और 75 चार धारणा के बिना होगा।
— जोनाथन Faust
1
लगता है कि आप bस्ट्रिंगरबफर के बजाय स्ट्रिंग बनाकर कुछ पात्रों को शेव कर सकते हैं । मैं इस बारे में नहीं सोचना चाहता कि प्रदर्शन क्या होगा, हालाँकि (विशेषकर चूंकि आप एक समय में एक चरित्र जोड़ रहे हैं)।
— माइकल मायर्स
4

स्काला 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 वर्ण को हटाता है। किसी को पहले (विंडोज सीआरएस?) गिनती गलत मिली।

— mkneissl
स्रोत
4

क्लोजर 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)))
— एलेक्स टैगगार्ट
स्रोत
4

स्काला, 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)
  }
}
— pr1001
स्रोत
383 वर्ण: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}}
— थॉमस जुंग
बेशक, समझ के लिए कभी काम! अच्छा!
— pr1001
3

जावा - 896 वर्ण

931 वर्ण

1233 चार्ट अपठनीय बना

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

ऐलिस का आउटपुट:

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

डॉन क्विक्सोट का उत्पादन (गुटेनबर्ग से भी):

 ________________________________________________________________________
|________________________________________________________________________| that
|________________________________________________________| he
|______________________________________________| for
|__________________________________________| his
|________________________________________| as
|__________________________________| with
|_________________________________| not
|_________________________________| was
|________________________________| him
|______________________________| be
|___________________________| don
|_________________________| my
|_________________________| this
|_________________________| all
|_________________________| they
|________________________| said
|_______________________| have
|_______________________| me
|______________________| on
|______________________| so
|_____________________| you
|_____________________| quixote
— जोनाथन को दर्शाता है
स्रोत
8
पूरी तरह से कार्प, क्या वास्तव में जावा में इसे छोटा करने का कोई तरीका नहीं है? मुझे उम्मीद है कि आप लोगों को वर्णों की संख्या से भुगतान किया जाएगा और कार्यक्षमता से नहीं :-)
— Nas Banov
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.