वर्णमाला हिस्टोग्राम

33

एक या अधिक शब्दों [a-z]+और शून्य या अधिक स्थानों से युक्त एक इनपुट वाक्य को देखते हुए, इनपुट वाक्य के अक्षर वितरण के एक ASCII- कला हिस्टोग्राम (बार ग्राफ) का उत्पादन करता है।

हिस्टोग्राम को क्षैतिज रूप से रखा जाना चाहिए, अर्थात अक्षर कुंजी के साथ बाईं ओर से नीचे की ओर वर्णमाला क्रम में, वाई-अक्ष लेबल 1-और प्रत्येक 5 इकाइयों के साथ। Y- अक्ष पांच में से सबसे छोटी बहु होनी चाहिए जो कम से कम सबसे ऊँची पट्टी जितनी लंबी हो, और दाईं ओर झुकी हुई होनी चाहिए। एक्स-अक्ष को इनपुट अक्षरों के साथ लेबल किया गया है, जिनके बीच कोई अंतराल नहीं है। उदाहरण के लिए, इनपुट a bb ddमें लेबल होना चाहिए , abdन ab dकि स्किप करना c। सलाखों को स्वयं किसी भी सुसंगत ASCII वर्ण से बनाया जा सकता है - मैं Xयहाँ अपने उदाहरणों में उपयोग करूँगा ।

test example

5-

   X
   X   X
1-XXXXXXXX
  aelmpstx

चूंकि तीन e, दो tऔर एक हैं almsx।

और ज्यादा उदाहरण:

the quick brown fox jumped over the lazy dogs

5-
      X         X
      X         X
     XX  X      X  X XX
1-XXXXXXXXXXXXXXXXXXXXXXXXXX
  abcdefghijklmnopqrstuvwxyz


now is the time for all good men to come to the aid of their country

10-
              X
              X
              X  X
      X       X  X
 5-   X       X  X
      X   X   X  X
      X  XX XXXX X
   XXXXX XXXXXXX X
 1-XXXXXXXXXXXXXXXXXX
   acdefghilmnorstuwy

a bb ccc dddddddddddd

15-


      X
      X
10-   X
      X
      X
      X
      X
 5-   X
      X
     XX
    XXX
 1-XXXX
   abcd

a bb ccccc

5-  X
    X
    X
   XX
1-XXX
  abc

I / O और नियम

  • इनपुट को किसी भी उचित प्रारूप में और किसी भी सुविधाजनक विधि द्वारा लिया जा सकता है । इसका मतलब यह भी है कि आप ऑल-अपरकेस में इनपुट ले सकते हैं, अगर यह आपके कोड के लिए अधिक समझ में आता है।
  • लीडिंग / ट्रेलिंग न्यूलाइन्स या अन्य व्हाट्सएप वैकल्पिक हैं, बशर्ते कि वर्ण उचित रूप से पंक्तिबद्ध हों।
  • या तो एक पूर्ण कार्यक्रम या एक समारोह स्वीकार्य हैं। यदि कोई फ़ंक्शन है, तो आप इसे प्रिंट करने के बजाय आउटपुट वापस कर सकते हैं।
  • आउटपुट कंसोल के लिए हो सकता है, स्ट्रिंग्स की सूची के रूप में लौटाया जाता है, एकल स्ट्रिंग के रूप में लौटाया जाता है, आदि।
  • मानक खामियों को मना किया जाता है।
  • यह कोड-गोल्फ है इसलिए सभी सामान्य गोल्फिंग नियम लागू होते हैं, और सबसे छोटा कोड (बाइट्स में) जीतता है।
code-golf  ascii-art  counting 
— AdmBorkBork
स्रोत
3
मुझे लगता है कि यह हिस्टोग्राम के बजाय एक बार ग्राफ होगा, क्योंकि यह संख्यात्मक डेटा के बजाय स्पष्ट है, लेकिन मैं ज्यादातर पांडित्यपूर्ण हूं।
— ग्यूसेप
क्या इनपुट गैर-रिक्त होने की गारंटी है?
— दाजिमा
2
बस एक लटकन है, लेकिन यह हिस्टोग्राम नहीं है , यह एक बार चार्ट है। हालांकि अभी भी एक अच्छी चुनौती!
— caird coinheringaahing
4
एक Tuftian दृष्टिकोण का प्रतिनिधित्व वर्णों से बाहर करने के लिए होगा और एक अलग लेबल पंक्ति नहीं होगी।
— dmckee
2
हिस्टोग्राम चरित्र के अनुरूप होना चाहिए, लेकिन मामलों में या प्रत्येक मामले के भीतर?
— आदम

जवाबों:

7

आर , 239 230 बाइट्स

K=table(el(strsplit(gsub(" ","",scan(,"")),"")));m=matrix(" ",L<-sum(K|1)+1,M<-(M=max(K))+-M%%5+1);m[2:L,M]=names(K);m[1,M-g]=paste0(g<-c(1,seq(5,M,5)),"-");m[1,]=format(m[1,],j="r");for(X in 2:L)m[X,M-1:K[X-1]]=0;write(m,1,L,,"")

इसे ऑनलाइन आज़माएं!

table यहाँ भारी उठाने, पात्रों को विशिष्ट बनाने, उन्हें छाँटने और उनकी गिनती लौटाने का काम करता है।

बाकी सब कुछ सिर्फ यह सुनिश्चित करना है कि ऑफसेट छपाई के लिए सही हैं, जो एक आस्की-कला चुनौती का "वास्तविक" काम है।

बग को इंगित करने के लिए @dylnan का धन्यवाद ।

दृष्टिकोण के लिए @rturnbullscan , 2 बाइट्स छोड़ने के लिए धन्यवाद ।

— ग्यूसेप
स्रोत
— rturnbull
@rturnbull मैं उसके बाद कुछ और बाइट्स को बंद करने में कामयाब रहा, धन्यवाद!
— Giuseppe
6

ग्नू सेड -आर, 516 490 278 249 + 1 बाइट्स

s/$/:ABCDEFGHIJKLMNOPQRSTUVWXYZ /
:a
s/(.)(:.*\1)/\2\1/I
ta
s/[A-Z]+/ /g
h
z
:b
s/ \w/ /g
G
s/:/&I/g
/:II{5}+ *$/M!bb
s/[a-z]/X/g
G
s/:(I{5}+|I)\b/0\1-/g
s/:I*/  /g
s/ (\w)\1*/\1/g
s/$/; 10123456789I0/
:c
s/(.)I(.*\1(I?.))|;.*/\3\2/
/\nI/s/^/ /Mg
tc

इसे ऑनलाइन आज़माएं!

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

s/$/:ABCDEFGHIJKLMNOPQRSTUVWXYZ /
:a
s/(.)(:.*\1)/\2\1/I
ta
s/[A-Z]+/ /g
h
z

यह इनपुट को सॉर्ट करता है और समूहों को रिक्त स्थान के साथ अलग करता है। यह पहले एक अपरकेस वर्णमाला प्लस अंतरिक्ष में एक बृहदान्त्र द्वारा अंत तक अलग करके काम करता है। फिर यह बृहदान्त्र के सामने प्रत्येक वर्ण को एक लूप में केस-असंवेदनशील प्रतिस्थापन का उपयोग करके बृहदान्त्र के पीछे एक मिलान चरित्र में ले जाता है। फिर अपरकेस अक्षरों को स्थान से बदल दिया जाता है और स्ट्रिंग को पकड़े हुए स्थान पर कॉपी कर लिया जाता है।

:b
s/ \w/ /g
G
s/:/&I/g
/:II{5}+ *$/M!bb

यह लूप एक-एक करके प्रत्येक वर्ण समूह के आकार को कम करके, सॉर्ट किए गए मूल लाइन को जोड़कर और कॉलिंग से बने रहने वाले बृहदान्त्र के बाद एकरी काउंटर को बढ़ाता है। यह 5 * n + 1 की संख्या के साथ एक खाली रेखा तक पहुंच जाता है (अंतिम पंक्ति के बाद से व्हॉट्सएप में परिणाम हो जाता है)। लूप के बाद पैटर्न स्पेस कुछ इस तरह दिखता है:

:IIIIII           
:IIIII           
:IIII           
:III  e         
:II  ee     t    
:I a eee l m p s tt x

तब स्वरूपण निम्नानुसार है:

s/[a-z]/X/g            # makes bars consistent
G                      # appends line that becomes x-axis
s/:(I{5}+|I)\b/0\1-/g  # moves zero in front of line 1 or 5-divisible
                       # lines for the decimal conversion and adds -
s/:I*/  /g             # removes numbers from other lines
s/ (\w)\1*/\1/g        # collapses groups of at least 1 into 1
                       # character, deleting the space before it
                       # so that only size-0-groups have spaces

और अंत में, दशमलव कनवर्टर के लिए एकजुट रहता है:

s/$/; 10123456789I0/
:c
s/(.)I(.*\1(I?.))|;.*/\3\2/
/\nI/s/^/ /Mg
tc

यह मूल रूप से एक स्ट्रिंग को जोड़ता है जहां रूपांतरण का ज्ञान है। आप इसे इस रूप में व्याख्या कर सकते हैं: अंतरिक्ष: -> 1 और 0-> 1-> 2-> 3-> 4-> 5-> 6-> 7-> 8-> 8-> 9-> I0। प्रतिस्थापन अभिव्यक्ति s/(.)I(.*\1(I?.))|;.*/\3\2/छँटाई के समान काम करती है, वर्णों के स्थान पर I के [ (.)I] चरित्र के सामने जो रूपांतरण स्ट्रिंग में I के सामने से एक के बगल में होता है [ (.*\1(I?.))] और यदि कोई नहीं बचा है, तो इसे हटा देता है जोड़ा स्ट्रिंग [ |;.*]। /\nI/s/^/ /Mgयदि आवश्यक हो तो प्रतिस्थापन [ ] गद्दी जोड़ता है।

26 बाइट्स के आकार को कम करने और छोटी छँटाई एल्गोरिथ्म के लिए गायों के लिए धन्यवाद ।

— सैड सैड
स्रोत
PPCG में आपका स्वागत है, और पहला अच्छा जवाब!
— कृतिका लिथोस
आप \wकुछ बाइट्स को बचाने के लिए कई स्थानों पर (शब्द वर्णों का मिलान) कर सकते हैं । साथ :b ... tbही बस बन सकता है s/\B\w/X/g। आप s/:/:,/gपहले वाले प्रतिस्थापन को संशोधित करके, इसके बाद आने वाली लाइन को हटा सकते हैं । आप goo.gl/JvD7Rs (sed कार्यक्रम के लिए छोटा TIO लिंक) देख सकते हैं कि मेरा क्या मतलब है।
— कृति लिथोस
1
आप छँटाई एल्गोरिथ्म पर सुधार कर सकते हैं, संकेत: zyx...cbaइनपुट में संलग्न करने का प्रयास करें ।
— कृतिका लिथोस
दशमलव कनवर्टर के लिए शानदार एकता! तुम्हारा कम से कम 30 बाइट्स है जो कि सीड में गोल्फिंग के लिए टिप्स
— क्रिति लिथोस
5

डायलॉग एपीएल , 109 97 96 95 93 88 बाइट्स

{⊖(⍉r),⍨⍕↑(⊂'')@{1@0~⍵∊1,5×⍵}⍳≢⍉↑r←↑r,⍨⊂' -','   - '⍴⍨5×⌈5÷⍨≢1↓⍉↑r←↓{⍺,∊⍕¨0×⍵}⌸⍵[⍋⍵]∩⎕A}

इसे ऑनलाइन आज़माएं!

आवश्यक है ⎕IO←0

जिस तरह से कई बाइट्स ने Adám और Cows quack को धन्यवाद बचाया !

— dzaima
स्रोत
अंतिम बिट के लिए, आप कोशिश कर सकते हैं ⍵[⍋⍵]~' '(गुजरने से पहले रिक्त स्थान को ⌸
— छांटते हैं
'X'/⍨≢→∊⍕¨×
— एड्म
और ⍵>0→×⍵
— क्रॉसी लिथोस
आपके TIO लिंक में एक अनावश्यक हैडर है।
— एड्म
2⌷⍴→ ≢⍉दो बार
— एड्म
5

05AB1E , 58 47 बाइट्स

áê©S¢Z5‰`Ā+L5*1¸ì'-«ð5×ý#À¦Áí.Bís'X×ζ‚ζJR»,®3ú,

इसे ऑनलाइन आज़माएं!

-11 बाइट्स @Emigna की बदौलत

— जादू ऑक्टोपस Urn
स्रोत
शायद यह मदद कर सकता है? उन्हें एक साथ बांधने का समय नहीं है, लेकिन शायद वे कुछ प्रेरणा दे सकते हैं।
— एमिगा
@Eigna मैं एक नज़र, निश्चित रूप से मेरा से अलग होगा :)।
— मैजिक ऑक्टोपस Urn
@Emigna 57 बाइट्स के बाद मैंने इसे टांका लगाया ... दिया मैंने अनुकूलन के लिए बहुत कोशिश नहीं की। इसे ऑनलाइन आज़माएं!
— मैजिक ऑक्टोपस Urn
कुछ पुनर्गठन और अनुकूलन के साथ 47 बाइट्स ।
— एमिगा
आपके पत्र कुछ इनपुट के लिए X के साथ पंक्तिबद्ध नहीं हैं। tio.run/##AVUAqv8wNWFiMWX//……
— mbomb007
3

पायथन 2 , 192 बाइट्स

s=input()
d={c:s.count(c)for c in s if' '<c}
h=-max(d.values())/5*-5
for y in range(h,-1,-1):print('%d-'%y*(y%5==2>>y)).rjust(len(`-h`))+''.join(('X '[y>v],k)[y<1]for k,v in sorted(d.items()))

इसे ऑनलाइन आज़माएं!

व्याख्या

लाइन 2 हिस्टोग्राम मूल्यों को काफी सरल तरीके से गणना करता है, त्याग कर ' '।

पंक्ति 3 का उपयोग करता है की गणना के चाल ceil(x/5)के रूप में -(-x/5): हम सूत्र का उपयोग कर 5 के अगले गुणज तक अधिक से अधिक आवृत्ति दौर -x/5*-5। यह वह जगह है h।

पंक्ति 4 एक लूप काउंटिंग है जो hनीचे से 0समावेशी है, प्रत्येक पंक्ति को प्रिंट कर रही है:

  • यदि y%5==2>>yहम एक लेबल प्रिंट करते हैं। यह तब होता है जब y, {1, 5, 10, 15, 20,…}

    (यह सूत्र शायद छोटा हो सकता है। हमें {1, 5, 10,…}, और 0 के लिए 1 या True कुछ चाहिए या गलत या इसके अन्य सभी मानों के लिए एक नकारात्मक पूर्णांक भी चाहिए ।)y

  • हम रिक्त स्थान में लेबल (या खाली स्थान) को सही ठहराते हैं len(`-h`): यह एक साफ-बाइट से बचाने वाला है len(`h`)+1!

  • फिर, हम Xइस पंक्ति के लिए या तो रिक्त स्थान (यदि yor 1) या अक्षर (यदि y= 0) प्रिंट करते हैं, तो dआरोही क्रम में कुंजी-मूल्य जोड़े के माध्यम से चल रहे हैं ।

— लिन
स्रोत
1
साथ अच्छा टिक सृजन '%d-'%y*(y%5==2>>y)। अगर आप मेरे जवाब में इसका इस्तेमाल करते हैं तो क्या आपको बुरा लगता है?
— डायलाॅन
-~-(y%5*~-y)काम करता है, लेकिन यह दुर्भाग्य से एक बाइट है।
— dylnan
2

चारकोल , 62 बाइट्स

≔Ｅ²⁷⟦⟧ηＦθ⊞§η⌕βιι≔⊟ηθ≦ＬηＰ⭆β⎇§ηκιω↑↑ΦηιＦ÷⁺⁹⌈η⁵«≔∨×⁵ι¹ιＪ±¹±ι←⮌⁺ι-

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

≔Ｅ²⁷⟦⟧η

27 सूचियों की सूची बनाएं।

Ｆθ⊞§η⌕βιι

लोअरकेस वर्णमाला में अपनी स्थिति के अनुरूप सूची में प्रत्येक इनपुट चरित्र को पुश करें। गैर-लोअरकेस वर्ण 27 वीं सूची में धकेल दिए जाते हैं।

≔⊟ηθ

सूची के 27 वें तत्व को त्यागें।

≦Ｌη

सूची के सभी तत्वों की लंबाई लें।

Ｐ⭆β⎇§ηκιω

गैर-शून्य सूची तत्वों के अनुरूप निचले अक्षरों को प्रिंट करें।

↑↑Φηι

गैर-शून्य सूची तत्वों को ऊपर की ओर प्रिंट करें। चूंकि यह पूर्णांकों की एक सरणी है, प्रत्येक पूर्णांक एक (अब ऊर्ध्वाधर) रेखा के रूप में प्रिंट करता है, प्रत्येक एक अलग कॉलम में।

Ｆ÷⁺⁹⌈η⁵«

Y- अक्ष पर टिक चिह्नों की संख्या की गणना करें और उन पर लूप करें।

≔∨×⁵ι¹ι

अगले टिक मार्क की स्थिति की गणना करें।

Ｊ±¹±ι

अगले टिकमार्क पर जाएं।

←⮌⁺ι-

प्रभावी रूप से दाएं-संरेखित करते हुए, टिकमार्क उल्टा और पीछे से सामने की ओर प्रिंट करें।

— नील
स्रोत
2

जेली , 48 बाइट्स

क्या खदान-क्षेत्र को लांघना है!

J’⁶D;”-Ɗ%5^ỊƲ?€Uz⁶ZU
ḟ⁶ṢµĠ¬;⁶$L%5Ɗ¿€;"@Qz⁶Ç;"$ṚY

परिणाम को प्रिंट करने वाला एक पूर्ण-कार्यक्रम (एक राक्षसी लिंक के रूप में यह एक सूची होगी जिसमें वर्ण और पूर्णांक होंगे [0,9])

इसे ऑनलाइन आज़माएं! या परीक्षण-सूट देखें

कैसे?

J’⁶D;”-Ɗ%5^ỊƲ?€Uz⁶ZU - Link 1, get y-axis: list of columns (including x-axis & top-spaces)
J                    - range of length  [1,2,3,4,5,6,...,height+1] (+1 for x-axis)
 ’                   - decrement        [0,1,2,3,4,5,...] (line it up with the content)
             ?€      - if for €ach...
            Ʋ        - ...condition: last four links as a monad:
        %5           -   modulo by five
           Ị         -   insignificant? (1 for 0 and 1, else 0)
          ^          -   XOR (0 for 1 or multiples of 5 greater than 0, else 0)
  ⁶                  - ...then: literal space character
       Ɗ             - ...else: last three links as a monad:
   D                 -   decimal list of the number, e.g. 10 -> [1,0]
     ”-              -   literal '-' character
    ;                -   concatenate, e.g. [1,0,'-']
               U     - upend (reverse each)
                z⁶   - transpose with a filler of space characters
                  Z  - transpose
                   U - upend (i.e. Uz⁶ZU pads the left with spaces as needed)

ḟ⁶ṢµĠ¬;⁶$L%5Ɗ¿€;"@Qz⁶Ç;"$ṚY - Main link: list of characters
ḟ⁶                          - filter out space characters
  Ṣ                         - sort
   µ                        - start a new monadic chain, call that S
    Ġ                       - group indices of S by their values
     ¬                      - logical NOT (vectorises) (getting 0 for the X "characters")
             ¿€             - while for €ach...
            Ɗ               - ...condition: last three links as a monad:
         L                  -   length
          %5                -   modulo by five
        $                   - ...do: last two links as a monad:
      ;⁶                    -   concatenate a space character
                  Q         - deduplicate S (get the x-axis)
               ;"@          - zip with (") concatenation (;) with swapped arguments (@)
                   z⁶       - transpose a with filler of space characters
                        $   - last two links as a monad:
                     Ç      -   call last link (1) as a monad (get y-axis)
                      ;"    -   zip with concatenation (complete the layout)
                         Ṛ  - reverse (otherwise it'll be upside-down)
                          Y - join with newlines
                            - implicit print
— जोनाथन एलन
स्रोत
2

रूबी , 250 248 234 188 173 157 153 बाइट्स

->s{a=s.scan(/\w/).sort|[]
m=-(c=a.map{|l|s.count l}).max/5*-5
m.downto(1).map{|i|(i%5<1||i<2?"#{i}-":'').rjust(m)+c.map{|l|l<i ?' ':?X}*''}<<' '*m+a*''}

इसे ऑनलाइन आज़माएं!

करने के लिए धन्यवाद:

  • कम सख्त पैडिंग के साथ -16 बाइट्स के लिए डायलन
  • के साथ गोल करके -2 बाइट्स के लिए लिन-x/5*-5
  • के साथ अद्वितीय सरणी तत्व प्राप्त करके -2 बाइट्स के लिए किरिल एल|[]
— Nnnes
स्रोत
2

जावा (JDK 10) , 296 बाइट्स

s->{int d[]=new int[26],m=0;char a;for(int c:s.getBytes())m=c>32&&++d[c-=65]>m?(d[c]+4)/5*5:m;String r=m+"-",z=r.replaceAll("."," ");for(;m>0;r+="\n"+(--m%5<1|m==1&&m>0?z.format("%"+~-z.length()+"s-",m):z))for(a=0;a<26;a++)r+=d[a]>0?m>d[a]?" ":"x":"";for(a=64;a++<90;)r+=d[a-65]>0?a:"";return r;}

इसे ऑनलाइन आज़माएं!

क्रेडिट

— ओलिवियर ग्रेजायर
स्रोत
@ बेइमिका सही। मैंने ठीक कर दिया।
— ओलिवियर ग्रेजायर
1
यह ज्यादा नहीं है, लेकिन आप 2 बाइट्स बचा सकते हैं। --m%5==0हो सकता है --m%5<1, क्योंकि आपके पास &m>0चेक भी है । और m<=d[a]?"x":" "हो सकता है m>d[a]?" ":"x"।
— केविन क्रूज़सेन
@ केविनक्रूजसेन 2 बाइट्स 2 बाइट्स हैं! मुझे नहीं लगता कि एक अलग एल्गोरिथ्म को छोड़कर, अब गोल्फ में बहुत कुछ है।
— ओलिवियर ग्रेजायर
1
बदलकर 1 अधिक बाइट (--m%5<1|m==1)&m>0के लिए--m%5<1|m==1&&m>0
— केविन Cruijssen
1

पायथ, 65 बाइट्स

J.tm+ed*hd\Xr8S-Qd)=+J*]d%_tlJ5_.e+?q<k2%k5.F"{:{}d}-",klQ*dhlQbJ

इसे यहाँ आज़माएँ

व्याख्या

J.tm+ed*hd\Xr8S-Qd)=+J*]d%_tlJ5_.e+?q<k2%k5.F"{:{}d}-",klQ*dhlQbJ
J.tm+ed*hd\Xr8S-Qd)
     Get the bars.
                   =+J*]d%_tlJ5
     Round up the height to the next number that's 1 mod 5.
                               _.e+?q<k2%k5.F"{:{}d}-",klQ*dhlQbJ
     Stick the axis labels on.
1

जावास्क्रिप्ट (Node.js) , 262 256 बाइट्स

* 2 बाइट्स कम करने के लिए @ शगुन का शुक्रिया

a=>[...a].map(x=>x>" "&&(d=c[x]=(c[x]||x)+"X")[m]?m=d.length-1:0,c={},m=i=0)&&Object.keys(c).sort().map(x=>[...c[x].padEnd(m)].map((l,j)=>A[m-j-1]+=l),A=[...Array(m+=6-m%5)].map(x=>(++i>=m||((D=m-i)%5&&m-i^1)?"":D+"-").padStart((m+" ").length)))&&A.join`
`

इसे ऑनलाइन आज़माएं!

— DanielIndie
स्रोत
त्वरित बचत के कुछ जोड़े मैं अपने फोन पर देख सकता हूं: 1.व्यक्तिगत पात्रों की एक सरणी के रूप में इनपुट लें, साथ 2.बदलें । x!=" "x>" "
— झबरा
3.बदलें m=0के साथ i=m=0और map((x,i)=>साथ map(x=>।
— झबरा
1

पायथन 2 , 249 224 219 215 205 197 187 188 182 176 बाइट्स

def f(s):S=sorted(set(s)^{' '});C=map(s.count,S);P=max(C)+4;return zip(*(zip(*[('%d-'%y*(y%5==2>>y)).rjust(P)for y in range(P,0,-1)])+[(n*'#').rjust(P)for n in C]))+[[' ']*P+S]

इसे ऑनलाइन आज़माएं!

लाइनों का प्रतिनिधित्व करने वाले पात्रों की सूची की एक सूची लौटाता है।

  • कुछ बाइट्स को अतिरिक्त व्हाट्सएप सहित सहेजा।
  • map(list,yticks)वहाँ एक अनावश्यक था ।
  • कुछ बाइट्स को बचाने के लिए स्पेस पेडिंग को बदला।
  • मुझे लगा कि मैं छंटाई कर रहा हूं लेकिन मैं नहीं था: +2 बाइट्स। लेकिन मैंने उसी समय एक स्वतंत्र रूप से बचाया। y==1द्वारा प्रतिस्थापित किया गया y<2।
  • -6 बाइट्स लिन के लिए धन्यवाद के '%d-'%y*(y%5==2>>y)बजाय का उपयोग करके (`y`+'-')*(not y%5or y<2)।

थोड़ा अपराजित: 

def f(s):
	S=sorted(set(s)^{' '})  # sorted list of unique letters (without ' ')
	C=map(s.count,S)        # count of each unique letter in the input
	P=max(C)+4              # used for padding and getting highest y tick
	B=[(n*'#').rjust(P)for n in C]     # create bars
	yticks = [('%d-'%y*(y%5==2>>y)).rjust(P)for y in range(P,0,-1)]  # create y ticks at 1 and multiples of 5
	yticks = zip(*yticks)                      # need y ticks as columns before combining with bars
	return zip(*(yticks+B))+[[' ']*P+S]        # zip ticks+bars then add row of sorted unique letters.
— dylnan
स्रोत
1

सी # (.NET कोर) , 344 340 338 + 18 बाइट्स

के लिए 18 बाइट्स शामिल हैं using System.Linq;

सहेजे गए 6 बाइट @KevinCruijssen की बदौलत।

n=>{var l=n.Where(c=>c!=32).GroupBy(c=>c).OrderBy(c=>c.Key).ToDictionary(k=>k.Key,c=>c.Count());int h=(l.Values.Max()/5+1)*5,o=(h+"").Length+1,m=l.Keys.Count+o,t=h+1,i=0,j;var a=new string[t];for(string p,q;i<t;a[i++]=q)for(q=(p=i>0&i%5<1|i==1?i+"-":"").PadLeft(j=o);j<m;){var c=l.ElementAt(j++-o).Key;q+=i<1?c:l[c]>=i?'X':' ';}return a;}

इसे ऑनलाइन आज़माएं!

— इयान एच।
स्रोत
आपके पास एक स्थान है j< m;जिसे हटाया जा सकता है। और कुल में 4 बाइट्स के लिए अन्य ints के बाद के int i=0,jरूप में रखा जा सकता है ,i=0,j। फिर भी आपको 18 बाइट्स को शामिल करना होगा using System.Linq;..
— केविन क्रूज़सेन
@KevinCruijssen धन्यवाद, मुझे ये याद आया। और मैंने 18 बाइट्स जोड़े।
— इयान एच।
मुझ से +1। ओह, और आप को बदलने के द्वारा 2 अधिक बाइट्स बचा सकते हैं for(;i<t;){string p=i>0&i%5<1|i==1?i+"-":"",q=p.PadLeft(o);for(j=o;j<m;){...}a[i++]=q;}करने के लिए for(string p,q;i<t;)for(p=i>0&i%5<1|i==1?i+"-":"",q=p.PadLeft(j=o);j<m;a[i++]=q){...}। इसे ऑनलाइन आज़माएं।
— केविन क्रूज़सेन
@KevinCruijssen Thats वास्तव में चालाक है, धन्यवाद!
— इयान एच।
1

बैश + कोरुटिल्स, 332 324 323 318 312 302 298 296 293 291 बाइट्स

c()(cut -d\  -f$@)
p=printf
cd `mktemp -d`
grep -o [^\ ]<<<$@|sort|uniq -c|c 7->a
sort -k2<a>b
r=$[`c 1 <a|sort -n|tail -1`+5]
s=${#r}
t()($p \ ;((i++<s))&&t;i=)
for((;--r;));{
((r%5&&r>1))&&t||$p %${s}s- $r;IFS='
'
for l in `<b`;{ ((r<=`c 1 <<<$l`))&&$p X||$p \ ;}
echo
}
t
c 2 <b|tr -d \\n

इसे ऑनलाइन आज़माएं!

एनोटेट:

c()(cut -d\  -f$@)
p=printf              # saving a few bytes

cd `mktemp -d`        # for temp files

grep -o [^\ ]<<<$@    # grabs all non-space characters
    |sort|uniq -c     # get character frequency
    |c 7->a           # slightly hacky way of stripping leading spaces;
                      #     uniq -c adds 6 spaces in front of each line

sort -k2<a>b          # store frequencies sorted alphabetically in b

r=$[`                 # r = highest frequency +5:
    c 1 <a            #     get frequencies
    |sort -n|tail -1  #     get maximum frequency
    `+5]              #     +4 so at least one multiple of 5 is
                      #     labeled, +1 because r gets pre-decremented

s=${#r}                    # s = length of r as a string
t()($p \ ;((i++<s))&&t;i=) # pad line with s+1 spaces

for((;--r;));{         # while (--r != 0)
    ((r%5&&r>1))&&     # if r isn't 1 or a multiple of 5
        t||            #     then indent line 
        $p %${s}s- $r; # otherwise print right-aligned "${r}-"
        IFS='
'                      # newline field separator
    for l in `<b`;{          # for all letters and their frequencies:
        ((r<=`c 1 <<<$l`))&& #     if frequency <= current height 
            $p X||           #         then print an X
            $p \ ;}          #     otherwise print a space
    echo
}
t # indent x-axis labels
c 2 <b|tr -d \\n # print alphabetically sorted characters

3 बाइट बचाने के लिए @IMM_Matrix का शुक्रिया।

— user9549915
स्रोत
cat b<b3 पात्रों को सहेजा जा सकता है
— IanM_Matrix1
0

सी, 201 बाइट्स

char c[256],*p,d;main(int a,char **b){for(p=b[1];*p;p++)++c[*p|32]>d&*p>64?d++:0;for(a=(d+4)/5*5;a+1;a--){printf(!a||a%5&&a!=1?"    ":"%3i-",a);for(d=96;++d>0;c[d]?putchar(a?32|c[d]>=a:d):0);puts(p);}}

इनपुट कमांड लाइन (पहले तर्क) से लिया गया है। कोड आकार को और कम करने के लिए एक्स के बजाय विस्मयादिबोधक चिह्न का उपयोग करता है। बाईं ओर काउंटर हमेशा तीन वर्ण लंबा होता है।

जीसीसी और क्लैंग के साथ परीक्षण किया गया।

— साइमन
स्रोत
for(p=b[1];*p;p++)सबसे अधिक संभावना है for(p=b[1]-1;*++p;), main(int a,char **b)शायद करने के लिए गोल्फ हो सकता है m(a,b)char**b;।
— जोनाथन फ्रीच
चूंकि a!=1बूलियन होगा, या के a%5&&a!=1?बराबर होना चाहिए । a%5&a!=1?a%5&&~-a
— जोनाथन फ्रीच
0

एक्सेल VBA, 316 बाइट्स

एक अनाम VBE तत्काल विंडो फ़ंक्शन जो सेल से इनपुट लेता है [A1]और VBE तत्काल विंडो में आउटपुट करता है।

For i=1To 26:Cells(2,i)=Len(Replace([Upper(A1)],Chr(i+64),11))-[Len(A1)]:Next:m=-5*Int(-[Max(2:2)]/5):l=Len(m)+1:For i=-m To-1:?Right(Space(l) &IIf(i=-1Xor i Mod 5,"",-i &"-"),l);:For j=1To 26:?IIf(Cells(2,j),IIf(Cells(2, j) >= -i, "X", " "),"");:Next:?:Next:?Spc(l);:For i=1To 26:?IIf(Cells(2,i),Chr(i+96),"");:Next

Ungolfed संस्करण

Public Sub bar_graph()
    For i = 1 To 26
        ''  gather the count of the letter into cells
        Cells(2, i) = Len(Replace([Upper(A1)], Chr(i + 64), 11)) - [Len(A1)]
    Next
    m = -5 * Int(-[Max(2:2)] / 5)   ''  get max bar height
    l = Len(m) + 1                  ''  length of `m` + 1
    For i = -m To -1
        ''  print either a label or free space (y-axis)
        Debug.Print Right(Space(l) & IIf((i = -1) Xor i Mod 5, "", -i & "-"), l);
        For j = 1 To 26
            ''  print 'X' or ' ' IFF the count of the letter is positive
            If Cells(2, j) Then Debug.Print IIf(Cells(2, j) >= -i, "X", " ");
        Next
        Debug.Print                 ''  print a newline
    Next
    Debug.Print Spc(l);             ''  print spaces
    For i = 1 To 26
        ''  print the letters that were used (x-axis)
        Debug.Print IIf(Cells(2, i), Chr(i + 96), "");
    Next
End Sub
— टेलर स्कॉट
स्रोत
0

पायथन 3 , 177 बाइट्स

lambda s:[[list(("%d-"%i*(i%5==2>>i)).rjust(len(q)))+["* "[s.count(c)<i]for c in q]for i in range(max(map(s.count,q))+4,0,-1)]+[[" "]*len(q)+q]for q in[sorted(set(s)-{' '})]][0]

इसे ऑनलाइन आज़माएं!

यह पायथन में सबसे बाइट-कुशल दृष्टिकोण नहीं हो सकता है, लेकिन मैं वास्तव में इसे "सच्चे एक-लाइनर" लंबा के साथ हल करना चाहता था।

चरित्र सूची की सूची को आउटपुट करता है। हर किसी की तरह कई प्रमुख newlines और रिक्त स्थान का दुरुपयोग। यह वास्तव में 174 बाइट्स के लिए और कम हो सकता है यदि यह किसी अन्य सूची में परिणाम को लपेटने के लिए स्वीकार्य है, ताकि हम अंतिम [0]अनुक्रमण को पाद लेख में स्थानांतरित कर सकें ।

— किरिल एल।
स्रोत
0

जावास्क्रिप्ट (ईएस 8), 200 बाइट्स

वर्णों के एक सरणी के रूप में इनपुट लेता है। एक स्ट्रिंग लौटाता है।

s=>(s.sort().join``.replace(/(\w)\1*/g,s=>a.push(s[0]+'X'.repeat(l=s.length,h=h<l?l:h)),h=a=[]),g=y=>y--?(y<2^y%5?'':y+'-').padStart(`${h}_`.length)+a.map(r=>r[y]||' ').join``+`
`+g(y):'')(h+=5-~-h%5)

इसे ऑनलाइन आज़माएं!

टिप्पणी की गई

s => (                    // s[] = input array of characters (e.g. ['a','b','a','c','a'])
  s.sort()                // sort it in lexicographical order (--> ['a','a','a','b','c'])
  .join``                 // join it (--> 'aaabc')
  .replace(/(\w)\1*/g,    // for each run s of consecutive identical letters (e.g. 'aaa'):
    s => a.push(          //   push in a[]:
      s[0] +              //     the letter, which will appear on the X-axis
      'X'.repeat(         //     followed by 'X' repeated L times
        L = s.length,     //     where L is the length of the run (--> 'aXXX')
        h = h < L ? L : h //     keep track of h = highest value of L
    )),                   //   initialization:
    h = a = []            //     h = a = empty array (h is coerced to 0)
  ),                      // end of replace() (--> a = ['aXXX','bX','cX'] and h = 3)
  g = y =>                // g = recursive function taking y
    y-- ?                 //   decrement y; if there's still a row to process:
      (                   //     build the label for the Y-axis:
        y < 2 ^ y % 5 ?   //       if y != 1 and (y mod 5 != 0 or y = 0):
          ''              //         use an empty label
        :                 //       else:
          y + '-'         //         use a mark
      ).padStart(         //     pad the label with leading spaces,
        `${h}_`.length    //     using the length of the highest possible value of y
      ) +                 //     (padStart() is defined in ECMAScript 2017, aka ES8)
      a.map(r => r[y]     //     append the row,
                 || ' ')  //     padded with spaces when needed
      .join`` + `\n` +    //     join it and append a linefeed
      g(y)                //     append the result of a recursive call
    :                     //   else:
      ''                  //     stop recursion
)(h += 5 - ~-h % 5)       // call g() with h adjusted to the next multiple of 5 + 1
— Arnauld
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.