एक पासवर्ड जनरेट करें

26

मेरे पासवर्ड को याद रखना बहुत कठिन है, इसलिए मैं पासवर्ड बनाने का तरीका लेकर आया हूं।

जिस तरह से मैं अपना पासवर्ड उत्पन्न करता हूं वह इन चरणों का पालन करते हुए एक शब्द या एक वाक्य से होता है:

  1. बाएं से दाएं शुरू करें

  2. प्रत्येक अक्षर की गिनती ज्ञात कीजिए

  3. एक क्रम में इसकी गिनती के साथ पत्र रखो

    • उच्च पुनरावृत्ति वाले पत्र अंत में होंगे

    • उसी पुनरावृत्ति वाले पत्रों को वर्णानुक्रम में आदेश दिया जाएगा

  4. व्हाट्सएप सहित नंबरों और विशेष अक्षरों को नजरअंदाज किया जाएगा (उदाहरण 9, 4, @, (, *, आदि की अनदेखी की जाती है)

  5. समूह पत्र मामले की अनदेखी। आउटपुट में, इनपुट में अंतिम घटना के मामले का उपयोग करें

  6. पत्र की गिनती किसी भी संख्या हो सकती है जैसे 5H17M345K
  7. यदि इनपुट सभी संख्याएँ या विशेष अक्षर हैं तो आउटपुट खाली स्ट्रिंग होगा जैसे इनपुट "12 $ * 34 ^!" तब आउटपुट ""
  8. जब एक ही घटना के लिए आदेश वर्णानुक्रम में कोई फर्क नहीं पड़ता उदाहरण के लिए 1a1B1c

उदाहरण:

Input: Kitkat Tango
(2k / 1i / 3T / 2a / 1n / 1g / 1o)
Output: 1g1i1n1o2a2k3T

एक और उदाहरण:

Input: Database Partitions Task
(1D / 5a / 4T / 1b / 3s / 1e / 1P / 1r / 2i / 1o / 1n / 3s / 1k)
Output: 1b1D1e1k1n1o1P1r2i3s4T5a

नोट: 1 रिपीट वाले अक्षर शुरुआत में वर्णानुक्रम में होते हैं और फिर अधिक प्रतिनिधि वाले अक्षर

यह कोड-गोल्फ है , सबसे छोटा कोड जीतता है।

code-golf  word-puzzle 
— asmgx
स्रोत
16
क्या एक पत्र 9 से अधिक बार दिखाई दे सकता है?
— झबरा
3
@manatwork: लेकिन यह अस्पष्ट नहीं है (ध्यान दें, उनका जवाब यह नहीं मानता था कि पत्र 10 बार से कम दिखाई देते हैं), यह सिर्फ इनपुट प्रतिबंधों को ढीला करने की कोशिश कर रहा है।
— ბიმო
4
इन स्पष्टीकरणों को वास्तविक प्रश्न निकाय में जोड़ना सुनिश्चित करें, इसलिए उत्तरदाताओं को टिप्पणियों के माध्यम से शिकार करने की आवश्यकता नहीं है
— जो राजा
2
टिप्पणियाँ एक विनिर्देश नहीं बनाते हैं। आपको 1.कम से कम 1 परीक्षण मामले को जोड़ने के लिए चुनौती को अपडेट करने की आवश्यकता है जिसमें एक या अधिक अक्षरों की 9 से अधिक घटनाएं शामिल हैं, यह 2.निर्दिष्ट करें कि आउटपुट एक स्ट्रिंग होना चाहिए (हालांकि मैं उस सख्त होने के खिलाफ दृढ़ता से अनुशंसा करूंगा; यह चुनौती के लिए कुछ भी नहीं जोड़ता है; ), 3.निर्दिष्ट करें कि हमें बिना किसी अक्षर वाले इनपुट को संभालने में सक्षम होना चाहिए, और, 4.स्पष्ट करें कि इनपुट के रूप में हमें खाली स्ट्रिंग को संभालने की आवश्यकता है या नहीं।
— शागी
1
एक बार जब आप ऐसा कर लेते हैं, तब आपको सभी मौजूदा समाधानों का परीक्षण करना होगा और उन्हें सूचित करना होगा कि क्या उन्हें कोई बदलाव करने की आवश्यकता है। मुझे पहले से ही काफी समाधान मिल गए हैं जो बिंदु पर विफल होते हैं 1। इसके अलावा, भविष्य में आप एक चुनौती पोस्ट करने से पहले इस तरह के मुद्दों से लोहा लेने की कोशिश करने के लिए हमारे सैंडबॉक्स का उपयोग करने पर विचार कर सकते हैं ।
— झबरा

जवाबों:

7

जाप v2.0a0 -P, 14 बाइट्स

f\l üv ñÊ®ÌiZÊ

कोशिश करो

f\l üv ñÊ®ÌiZÊ     :Implicit input of string
                   > e.g., "Kitkat Tango"

f                  :Split to an array of characters
 \l                :  Matching RegEx /[a-z]/gi
                   > ["K","i","t","k","a","t","T","a","n","g","o"]

    ü              :Sort & group (Preserves original order within each group)
     v             :  By lowercase
                   > [["a","a"],["g"],["i"],["K","k"],["n"],["o"],["t","t","T"]]

       ñ           :Sort
        Ê          :  By length
                   > [["g"],["i"],["n"],["o"],["a","a"],["K","k"],["t","t","T"]]

         ®         :Map each Z
          Ì        :  Last element of Z
                   >   ["g","i","n","o","a","k","T"]
           i       :  Prepend
            ZÊ     :    Length of Z
                   >   ["1g","1i","1n","1o","2a","2k","3T"]

                   :Implicitly join & output
                   > "1g1i1n1o2a2k3T"
— झबरा
स्रोत
10

05AB1E , 19 17 16 बाइट्स

केविन क्रूज़सेन को 1 बाइट धन्यवाद दिया

áΣl}.γl}éεgyθJ}J

इसे ऑनलाइन आज़माएं! या टेस्ट सूट के रूप में

व्याख्या

á                  # keep only letters in input
 Σl}               # sort by lower-case
    .γl}           # group by lower-case
        é          # sort by length (stable)
         ε    }    # map each to
          g        # its length
             J     # joined with
           yθ      # the last letter
               J   # join to string
— Emigna
स्रोत
आप ‚एक «(कंटेस्ट / मर्ज) के साथ (जोड़ी) को बदलकर एक बाइट को बचा सकते हैं , इसलिए दोनों में से एक (जोड़) को Jहटाया जा सकता है।
— केविन क्रूज़सेन
@ केविनक्रूजसेन: वाह। मुझे अब बेवकूफ लग रहा है :) मैं सिर्फ Jअंदर क्यों नहीं गया? संपादित करें: वास्तव में, मुझे 19-बाइट संस्करण में एक जोड़ी के रूप में उनकी आवश्यकता थी और जब मैंने 17: P
— Emigna
आप इस प्रश्नJ के उत्तर पर निर्भर करते हुए दूसरा ओइन गिराने में सक्षम हो सकते हैं
— झबरा
8

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 105 बाइट्स

x=>x.Where(char.IsLetter).GroupBy(a=>a%32).OrderBy(a=>(a.Count(),a.Key)).Select(a=>a.Count()+""+a.Last())

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

138 बाइट्स से 105 बाइट्स तक लाने के लिए दाना का धन्यवाद।

— अज्ञान का अवतार
स्रोत
सिर्फ क्यों नहीं .OrderBy(a=>a)?
— हड़बड़ी में
1
105 ?
— दाना
6

रेटिना , 67 66 41 39 बाइट्स

\P{L}

O$`.
$l$0
ir`\1*(.)
$.0$1
N`\d+.

-25 बाइट्स और @Neil के लिए एक मामूली बग-फिक्स धन्यवाद ।
-2 बाइट्स @Neil और @ शागी को एक साथ धन्यवाद ।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

ऊपरी और निचले अक्षरों को छोड़कर सब कुछ हटा दें:
यानी Kitkat Tango 123!→KitkatTango

\P{L}

व्यक्तिगत अक्षरों के मामले को असंवेदनशील ( इसके लिए @MartinEnder के लिए धन्यवाद ) क्रमबद्ध करें :
यानी KitkatTango→aagiKknottT

O$`.
$l$0

केस-संवेदी के हर हिस्सा कैप्चर दोहराया आसन्न पत्र:
यानी aagiKknottT→ [ aa, g, i, Kk, n, o, ttT]

ir`\1*(.)

हर मैच की लंबाई प्रारंभ में लगा है, और केवल हर हिस्सा के अंतिम अक्षर रखें:
यानी [ aa, g, i, Kk, n, o, ttT] →2a1g1i2k1n1o3T

$.0$1

संख्या के आधार पर संख्या और अक्षर समूहों को क्रमबद्ध करें:
2a1g1i2k1n1o3T→1g1i1n1o2a2k3T

N`\d+.

जिसके बाद परिणाम अनुमानित रूप से आउटपुट होता है।

— केविन क्रूज़सेन
स्रोत
क्या आप सुनिश्चित हैं कि यह एक बग है? क्या यह सिर्फ लेक्सोग्राफिक रूप से छांटना नहीं है? ( "aA" < "aa")
— झबरा
1
@ शैगी मुझे यकीन नहीं है कि यह हो सकता है। क्योंकि \wऔर .में यह O`\w.इंगित करने के लिए उपयोग किया जाता था कि हम पात्रों के जोड़े को छांट रहे हैं। निश्चित नहीं है कि हम हर जोड़ी को क्रमबद्ध कर सकते हैं, लेकिन केवल इसे पहले वर्ण के आधार पर क्रमबद्ध करें। लेकिन अच्छी तरह से, मार्टिन एक प्रतिस्थापन के आधार पर प्रत्येक चरित्र को सॉर्ट करने का सुझाव (जो मैच का निचला संस्करण है) एक आकर्षण की तरह काम करता है। :)
— केविन क्रूज़सेन
1
क्या यह 41 बाइट्स में किया जा सकता है या मुझे कुछ याद आ रहा है?
— नील
1
— नील
2
@ शैगी वास्तव में आगे पढ़ रही है, \P{L}काम कर सकती है, जो 2 बाइट्स बचाता है।
— नील
4

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 102 96 93 87 बाइट्स

""<>Map@ToString/@Sort[(r=Reverse)/@Tally[r@#/." "->Nothing,Equal@@ToLowerCase@{##}&]]&

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

Tally[r@#/." "->Nothing,Equal@@ToLowerCase@{##}&]      Start with a char list
        #/." "->Nothing                                Remove spaces
      r@                                               Reverse the result
Tally[                 ,Equal@@ToLowerCase@{##}&]
                                             Make a list of letters and multiplicities,
                                             where two letters are considered the same if
                                             their lowercase values are equal. Then:

""<>Map@ToString/@Sort[(r=Reverse)/@ ... ]&
                       (r=Reverse)           Reverse each {letter, freq} to {freq,letter}.
                                             Then the standard Wolfram order function sorts
                                               lower frequencies first, with ties broken by
                                               by letters earlier in the alphabet,
                  Sort[                  ]     exactly what we want.

    Map@ToString/@                           @ has higher precedence than /@, so
                                               this effectively does Map[Map[ToString]].
""<>                                         StringJoin the nested list into a single string.
— lirtosiast
स्रोत
4

पायथ, 27 24 22 बाइट्स

ssrD0m,lded.gr0k@+Gr1G

इसे यहाँ ऑनलाइन आज़माएँ ।

ssrD0m,lded.gr0k@+Gr1GQ   Implicit: Q=eval(input()), G=lowercase alphabet
                          Trailing Q inferred
                   r1G    Uppercase alphabet
                 +G       Concatenate with lowercase alphabet
                @     Q   Keep those characters in Q which are also in the above
           .g             Group the remaining characters, as k, using:
             r0k             Convert k to lowercase
                              (Grouping preserves relative order)
     m                    Map the sorted groups, as d, using:
       ld                   Length of d
      ,                     Pair the above with...
         ed                 ... last element of d
   D                      Sort the above...
  r 0                     ... by their lowercase values
ss                        Flatten, then concatenate the result of the above into a string, implicit print

संपादित करें: समूह, पिछले संस्करण से पहले चरित्र द्वारा क्रमबद्ध करके 3 बाइट्स: sm+ldedo,lNr0eN.gr0kf}r0TGQ

संपादित करें 2: किसी भी आदेश, पिछले संस्करण से पहले आउटपुट स्वरूपित करके एक और 2 बाइट्स को बंद कर दिया: sm+ldedlD.gr0krD0f}r0TGQ

संपादन 3: फ़िल्टर को बदलकर एक अन्य बाइट को बंद किया, धन्यवाद @FryAmTheEggman को। जब ओपी ने स्पष्ट किया कि एक बग को ठीक करना है तो एक ही अक्षर 9 से अधिक बार दिखाई दे सकता है, जो कि बाइट पर वापस जुड़ गया: o (पिछला संस्करण:srD0m+lded.gr0kf}r0TGQ

— सोक
स्रोत
@FryAmTheEggman महान कॉल, धन्यवाद!
— सोक
4

एपीएल (Dyalog विस्तारित) , 28 बाइट्स SBCS

बेनामी tacit उपसर्ग समारोह।

(∊⍤∧⌊(⊂⍕⍤≢,⊢/)⍤⊢⌸⊢)'\PL'⎕R''

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

'\PL' गैर-अक्षर
⎕R PCRE R
''  खाली तारों के साथ निकाला गया

(… ) निम्नलिखित टैसिट फ़ंक्शन लागू करें:

 ⌊ कुंजियों के रूप में लोअरकेस के साथ,
 … ⌸ प्रत्येक कुंजी और उसके मूल्यों के संगत सेट के नीचे दिए गए टैकिट फ़ंक्शन को लागू करें, अर्थात्
 ⊢ तर्क:

  (…  मानों की सूची के  लिए ) निम्नलिखित कार्य समारोह लागू करें :
  ⍤
  ⊢

   ⊢/ अंतिम मूल्य

   … , उस के लिए निम्नलिखित प्रस्तुत करें:

    ⍕ stringification
    ⍤ की
    ≢ संख्या

   ⊂ संलग्न करें (चरित्र सूची को एकल स्ट्रिंग के रूप में मानें)

 ∊ ϵ nlist (समतल)
 ⍤ उस का
 ∧ क्रमबद्ध-आरोही संस्करण

— एडम
स्रोत
1
@ शगुन थैंक्स। +1 बाइट पर फिक्स्ड।
— एडम
3

पर्ल 5, 74 68 66 बाइट्स

-6 बदलते बाइट्स -pकरने के लिए -nऔर का उपयोग कर sayके बजाय $_=join"", -2 का उपयोग कर अबीगैल के लिए धन्यवाद बाइट्स \pLके बजाय[a-z]

s/\pL/($h{lc$&}+=1).=$&/gie;say sort{$a-$b||lc$a cmp lc$b}values%h

TIO

59 बाइट्स, मामले में प्रत्येक चरित्र की 9 से अधिक घटना नहीं है

s/\pL/($h{lc$&}+=1).=$&/gie;say sort{lc$a cmp lc$b}values%h
— नहुएल फौलीउल
स्रोत
@ एबिगेल, धन्यवाद, दूसरे कार्यक्रम में यह एक अद्यतन के बाद एक निरीक्षण था
— नहुएल फौइउल
3

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

def f(s):a=s.lower();return''.join(`n`+s[a.rfind(c)] for n,c in sorted((a.count(c),c)for c in set(a)if c.isalpha()))

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

— TFeld
स्रोत
के लिए उत्पादन के Database Partitions Taskबराबर नहीं है1b1D1e1k1n1o1P1r2i3s4T5a
— mdahmoune
@mdahmoune धन्यवाद, तय किया जाना चाहिए।
— टीफेल्ड
In the output, use the case of the last occurrence in the inputrfindइसके findलिए आपको आवश्यकता होगी । हालांकि यह ऑफसेट ...] forहो सकता है ...]for।
— अरबो
3

हास्केल , 114/113 105 बाइट्स

-9 करने के लिए धन्यवाद बाइट्स Laikoni (का उपयोग कर सूची-समझ और (||)के बजाय filterसाथ elemऔर छोटा lengthबदसूरत से छुटकारा पाने के zip)!

f s=id=<<[show(h r)++[last r]|l<-[1..h s],a<-['A'..'Z'],r<-[[x|x<-s,x==a||x==[a..]!!32]],h r==l]
h=length

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

— ბიმო
स्रोत
— लाकोनी
1
— लाकोनी
@ लिकोनी: अब आयात के मुकाबले कम, बहुत अच्छा !!
— ბიმო
3

लाल , 220 196 206 बाइट्स

func[s][a: charset[#"a"-#"z"#"A"-#"Z"]trim/all form sort/skip collect[foreach c sort
unique reverse rejoin parse s[collect[any[keep[a]| skip]]][i: 0
foreach d s[if(c% 32)=(d% 32)[i: i + 1]]keep i keep c]]2]

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

बग ढूंढने के लिए झबरा का धन्यवाद।

— गैलेन इवानोव
स्रोत
1
@ शिग्गी यह इंगित करने के लिए धन्यवाद, मैं इसे ठीक करने की कोशिश करूंगा।
— गैलेन इवानोव
2

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

fØẠµŒlĠLÞịµL,Ṫ)

निर्दिष्ट के रूप में पासवर्ड को मुद्रित करने वाला एक पूरा कार्यक्रम (एक विवादास्पद लिंक के रूप में यह एक पूर्णांक और एक चरित्र वाले प्रत्येक सूची की सूची देता है)।

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

— जोनाथन एलन
स्रोत
2

भूसी , 15 बाइट्स

आयात के साथ कोई समस्या नहीं है जब भूसी का उपयोग कर, इसलिए हम इस तरह के रूप में विभिन्न काम कार्यों का उपयोग कर सकते हैं groupOn, sortOn, toLowerआदि:

ṁ§:osL→ÖLSġÖ_f√

ऑनलाइन यह कोशिश करो या उन सब की कोशिश करो!

व्याख्या

ṁ§:(sL)→ÖLSġÖ_f√  -- example input: "Kitkat Tango"
              f√  -- `filter isAlpha`: "KitkatTango"
          S  _    -- apply _ to .. then ..
            Ö     -- | sortOn: `sortOn toLower`
           ġ      -- | groupOn: `groupOn toLower`
                  -- .. compose: `groupOn toLower . sortOn toLower`
                  -- `sortOn toLower` (stable): "aagiKknottT"
                  -- `groupOn toLower`: ["aa","g","i","Kk","n","o","ttT"]
        ÖL        -- `sortOn length` (stable): ["g","i","n","o","aa","Kk","ttT"]
ṁ                 -- map and flatten (`concatMap`)
 §                -- | fork argument ..
       →          -- | | `last`: ['g','i','n','o','a','k','T']
   (sL)           -- | | `show . length`: ["1","1","1","1","2","2","3"]
  :               -- | .. and `snoc`: ["1g","1i","1n","1o","2a","2k","3T"]
                  -- : "1g1i1n1o2a2k3T"
— ბიმო
स्रोत
2

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

s=>[...s].sort(o=(x,y)=>p(0+x,36)-p(0+y,36),p=parseInt).join``.match(/([a-z])\1*/ig).map(x=>(l=x.length)+x[l-1]).sort(o).join``

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

  • parseInt(numberAsString, radix)स्ट्रिंग की शुरुआत में पूर्णांक पार्स करने की कोशिश करेंगे। उदाहरण के लिए, parseInt('120px', 10)120 आउटपुट करेगा। जब पार्सिंग विफल हो गया, तो NaNइसके बजाय वापस आ जाता है। हम '0'प्रत्येक वर्ण की शुरुआत से कनेक्ट करते हैं ताकि यह 0किसी भी गैर-संख्यात्मक-अल्फा वर्ण के लिए वापस आ जाए । और हम इस एल्गोरिथम द्वारा शुरुआत में एक ही अक्षर और गैर-अल्फा चरित्र को सॉर्ट कर सकते हैं।
  • बाद sortऔर join, "Hello world!123"बन जाएगा " !123deHllloorw"। एक मेल के खिलाफ /([a-z])\1*/igकिसी भी गैर-अल्फा चरित्र को अनदेखा करेगा और स्ट्रिंग को समान अक्षरों में विभाजित करेगा। `।
  • mapप्रश्न में आवश्यकतानुसार परिवर्तित "aaa"करें "3a"।
  • दूसरा प्रकार पहले वाले के समान फ़ंक्शन का उपयोग करता है। संख्या प्रणाली के लिए धन्यवाद, बेस 36 की "3b"तुलना "12a"में कम होगा जैसा कि हम उम्मीद करते हैं: यह पहले की तुलना करता है ( n div 36), और बाद में ( n mod 36) की तुलना करें ।
  • अंत में joinउन्हें एक साथ।

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

f=(s,...a)=>(s=s.replace(/[^a-z]/ig,''))?f(s.replace(RegExp(s[c=0],'ig'),x=>(l=++c+x,'')),...a,l):a.sort((x,y)=>p(x,36)-p(y,36),p=parseInt).join``

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

— TSH
स्रोत
छोटे समाधान को अपने मुख्य समाधान के रूप में क्यों न प्रस्तुत करें? इसके अलावा, यह 2 बाइट्स कम हो सकता है क्योंकि यह पुनरावर्ती नहीं है।
— झबरा
@ शग्गी आह, पूरी तरह से निकालना भूल गई f=। पहले एक छोटा हुआ करता था। लेकिन यह 4 बाइट्स से अधिक हो जाता है क्योंकि ओपी ने पूछा कि उत्पादन खाली स्ट्रिंग हो सकता है। और मैं सिर्फ उन्हें वहाँ रखा ...
— TSH
1
@ शागिर्द ओके, अभी पता लगाओ एक दूसरा और भी छोटा हो सकता है। और मैंने इसे पहले की तरह रखा।
— TSH
2

जावा 10, 223 209 301 बाइट्स

s->{int i=32,t;String M[]=new String[i],r,R="";for(var c:s)M[c%32]+=c>64&c<91|c>96&c<123?c:R;for(;i-->0;M[i]=(t=r.length()-4)>0?t+r.split(R)[t+3]:R)r=M[i]+R;java.util.Arrays.sort(M);for(var p:M)R+=p;return R;}

+92 एक ही अक्षर के 9 से अधिक इनपुट के लिए एक फिक्स के रूप में बाइट करता है .. यह देखेगा कि क्या मैं एक अलग दृष्टिकोण के साथ फिर से नीचे ला सकता हूं।

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

स्पष्टीकरण:

s->{                        // Method with character-array parameter and String return-type
  int i=32,                 //  Index-integer, starting at 32
      t;                    //  Temp-integer, uninitialized
  String M[]=new String[i], //  Create a String-array of size 32, filled with null by default
         R="",              //  Result-String, starting empty
         r;                 //  Temp-String, uninitialized
  for(var c:s)              //  Loop over the characters of the input-array:
    M[c%32]+=               //   Append the string at index code-point of `c` modulo-32 with:
     c>64&c<91|c>96&c<123?  //    If the character is a letter:
      c                     //     Append the character
     :                      //    Else:
      R;                    //     Append an empty String
  for(;i-->0                //  Loop `i` in the range (32, 0]:
      ;                     //    After every iteration:
       M[i]=                //     Replace the String at index `i` with:
        (t=r.length()-4)    //      Set `t` to the length of String `r` minus 4
                            //      (the minus 4 is for the prepended "null")
         >0?                //      If this length minus 4 is larger than 0:
          t                 //       Set the String to this length minus 4
          +r.split(R)[t+3]  //       Appended with the last character of `r` as String
         :                  //      Else:
          R)                //       Make the String at index `i` empty
    r=M[i]                  //   Set `r` to the `i`'th String
          +R;               //  Converted to String
                            // (null becomes "null", to prevent NullPointerException-errors)
  java.util.Arrays.sort(M,  //  Now sort the array of Strings on:
   (a,b)->                  //   For each pair of two Strings:
     new Byte(              //    Convert the first String to a number
      (0+a).replaceAll("\\D",""))
                            //    after we've added a leading 0 and removed all non-digits
    .compareTo(             //   And compare it to:
     new Byte(              //    The second String converted to a number
      (0+b).replaceAll("\\D",""))));
                            //    after we've added a leading 0 and remove all non-digits
  for(var p:M)              //  Loop over the Strings of the array:
    R+=p;                   //   And append each to the result-String `R`
  return R;}                //  And finally return the result-String `R`
— केविन क्रूज़सेन
स्रोत
1
@ शागि डांग .. 92 बाइट्स की लागत से तय ..>। <अगर मैं तुलनित्र को सॉर्ट करने के लिए नहीं बल्कि बाद में मैन्युअल रूप से खुद को बाद में सॉर्ट कर सकता हूं, तो यह देखेगा कि
— केविन क्रूज़सेन
आउच! उसके लिए माफ़ करना!
— झबरा
2

स्विफ्ट 4.2.1 / एक्सकोड 10.1 , 1054 1050 1048 370 368 364 बाइट्स

s.map{String($0)}.filter{$0.rangeOfCharacter(from:.letters) != nil}.reversed().reduce(into:[String:Int]()){d,s in if let l=[s.uppercased(),s.lowercased()].first(where:{d[$0] != nil}){d[l]=d[l]!+1}else{d[s]=1}}.sorted{let c=$0.value-$1.value;return c==0 ?$0.key.compare($1.key,options:.caseInsensitive) == .orderedAscending:c<0}.map{"\($0.value)\($0.key)"}.joined()

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

@ केविनक्रूजसेन ने कुछ रिक्त स्थान भी निकाले।

— रोमन पोडिमोव
स्रोत
नमस्ते, PPCG में आपका स्वागत है! मैं स्विफ्ट नहीं जानता, लेकिन ऐसा लगता है कि आप कुछ रिक्त स्थान निकालना भूल गए हैं, और आप सभी falseको 0>1और trueकरने के लिए गोल्फ भी कर सकते हैं 1>0। इसे ऑनलाइन 1027 बाइट्स आज़माएं । संभवत: लोड अधिक हो सकता है, जैसे if let v=$0.key.escaped(asASCII:0>1).lowercased().unicodeScalars.first?.value{return v<$1.key.value}else{return 0>1}आपके पास डुप्लिकेट है, लेकिन मैं उसे छोड़ दूंगा जो वास्तव में स्विफ्ट जानता है।
— केविन क्रूज़सेन
1
इसके अलावा, अगर आपने इसे अभी तक नहीं देखा है: सभी भाषाओं में गोल्फिंग के लिए टिप्स > और स्विफ्ट में गोल्फिंग के लिए टिप्स को पढ़ने के लिए दिलचस्प हो सकता है। फिर से स्वागत है, और अपने प्रवास का आनंद लें! :)
— केविन क्रूज़सेन
नमस्कार @KevinCruijssen। सुझावों के लिए धन्यवाद, मैंने हटा दिया trueऔर falseअपने उत्तर से।
— रोमन पोडियमोव
1
अच्छा, आपने इसे अपने शुरुआती 1000+ बाइट्स से काफी आगे बढ़ाया है। :) मैं 6 और रिक्त स्थान देखता हूं जिन्हें सभी =-साइनों के बाद / उससे पहले हटाया जा सकता है : इसे ऑनलाइन 364 बाइट्स आज़माएं । यहां रहने का आनंद! :)
— केविन क्रूज़सेन
1

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

Ｆ⌈Ｅβ№↧θιＦβ¿⁼№↧θκ⊕ι⁺⊕ι§Φθ⁼↧λκ±¹

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

Ｆ⌈Ｅβ№↧θι

लोअरकेस वर्णमाला के माध्यम से चलाएं और लोअरकेस इनपुट में उच्चतम वर्ण गणना ढूंढें। अंतर्निहित सीमा पर लूप। (लूप वास्तव में से जाता 0है n-1इसलिए मुझे प्रत्येक उपयोग में लूप चर को बढ़ाना होगा।)

Ｆβ

लोअरकेस वर्णमाला पर फिर से लूप करें।

¿⁼№↧θκ⊕ι

यदि वर्तमान अक्षर की गिनती बाहरी लूप मान के बराबर है ...

⁺⊕ι§Φθ⁼↧λκ±¹

वर्तमान पत्र की अंतिम घटना और अंतर्निहित रूप से प्रिंट के साथ वर्तमान गणना को समेटें।

— नील
स्रोत
1

NodeJS, 299 बाइट्स; -6 बाइट्स @tsh को धन्यवाद देते हैं

इतनी खूबसूरती नहीं बल्कि काम!

(x,l={},g=p=>p.charCodeAt(),q=p=>p.toLowerCase())=>Object.entries([...x[R='replace'](/[^a-z]/gi,'')].reduce((m,n)=>(r=q(n),l[r]=g(n)>96?1:0,{...m,[r]:-~m[r]}),{})).sort((a,b)=>a[1]^b[1]?a[1]-b[1]:g(q(a[0]))-g(q(b[0]))).map(([m,n])=>[n,m]).join``[R](/,/g,'')[R](/[a-z]/g,v=>l[v]?q(v):v.toUpperCase())

जावास्क्रिप्ट (ES8) (फ़ायरफ़ॉक्स या क्रोम), 294 बाइट्स, -1 बाइट @tsh के लिए धन्यवाद

नई .flatविधि के साथ , मैं 10 बाइट्स बचा सकता हूं:

(x,l={},g=p=>p.charCodeAt(),q=p=>p.toLowerCase())=>Object.entries([...x[R='replace'](/[^a-z]/gi,'')].reduce((m,n)=>(r=q(n),l[r]=g(n)>96?1:0,{...m,[r]:-~m[r]}),{})).sort((a,b)=>a[1]^b[1]?a[1]-b[1]:g(q(a[0]))-g(q(b[0]))).map(([m,n])=>[n,m]).flat().join``[R](/[a-z]/g,v=>l[v]?q(v):v.toUpperCase())

इसे ऑनलाइन आज़माएं: https://repl.it/repls/ConcernedHoristentHypothesis

— चाउ जियांग
स्रोत
नमस्कार और पीपीसीजी में आपका स्वागत है। यह अच्छा होगा यदि आप अपने सबमिशन को टेस्ट करने का एक तरीका प्रदान करते हैं, जैसे एक ऑनलाइन दुभाषिया से लिंक करना।
— जोनाथन फ्रेच
@JonathanFrech मैंने अभी-अभी परीक्षण मामले जोड़े हैं, धन्यवाद!
— चौ जियांग
.replacex 3 बार -> [R='replace]और [R]x 2 बार
— tsh
.charCodeAt(0)-> .charCodeAt()( 0डिफ़ॉल्ट है)
— tsh
@tsh आपके सभी अच्छे सुझावों के लिए बहुत-बहुत धन्यवाद, मैंने अभी अपना उत्तर अपडेट किया है!
— चाऊ जियांग
1

जूलिया 1.0 , 158 बाइट्स

¬t=(c=Dict();C=Dict();for i=eachmatch(r"\w",t);l=i.match;k=lowercase(l);c[k]=get(c,k,0)+1;C[k]=l;end;*(["$v$(C[k])" for (v,k)=sort([(v,k) for (k,v)=c])]...))

एक ही तर्क के साथ मूल ungolfed संस्करण:

function password(text)
    letter_counts = Dict()
    cases = Dict()

    for i in eachmatch(r"\w", text)
        letter = i.match[1]
        letter_key = lowercase(letter)
        letter_counts[letter_key] = get(letter_counts, letter_key, 0) + 1
        cases[letter_key] = letter
    end

    sorted_counts = sort([(value, key) for (key, value) in letter_counts])

    return string(["$v$(cases[k])" for (v,k) in sorted_counts]...)
end

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

— niczky12
स्रोत
0

पर्ल 6, 86 82 बाइट्स

{[~] flat map *[0,2],sort map {+$^b,$^a,$b[*-1]},kv classify &lc,.comb: /<alpha>/}
— bb94
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.