एक प्रोग्राम लिखें जो एक स्ट्रिंग में सबसे अधिक होने वाली युग्मित पत्र पाता है

Question

कार्यक्रम को उस पत्र को आउटपुट करना होगा जो सबसे अधिक जोड़ा जाता है। उदाहरण के लिए, यदि आपके प्रोग्राम को निम्नलिखित स्ट्रिंग दी गई थी:

"Sally's friend Bobby searched for seashells."

इसका आउटपुट होना चाहिए Lक्योंकि "ll"दो बार होता है, जो अन्य जोड़ी की तुलना में अधिक बार होता है "bb"।

नियम:

• यदि एक से अधिक अक्षर में घटनाओं के लिए 1 स्थान होता है, तो उन सभी को वर्णानुक्रम में क्रमबद्ध करें (जैसे "Sally's friends Jimmy and Bobby rummaged for seashells."कि दोनों को आउटपुट करना चाहिए Lऔर M[या "LM"यदि आप कृपया] क्योंकि वे दोनों अन्य जोड़ियों की तुलना में अधिक बार होते हैं।]
• पत्र जो तिगुना, चौगुना है, आदि को एक जोड़ी के रूप "lll"में "willless"गिना जाता है (जैसे कि केवल एक जोड़ी के रूप में गिना जाता है L)।
• पत्र जोड़े एक शब्द में होने चाहिए (जैसे "Sally's sociable friends Sammy and Bobby searched for fabulous seashells."आउटपुट होना चाहिए Lऔर Sइसलिए नहीं कि "ss"तुलना में अधिक होने के बावजूद "ll", वे रिक्त स्थान से अलग हो जाते हैं)
• केवल अंग्रेजी वर्णमाला के अक्षरों को गिनें
• मामला मायने नहीं रखता (जैसे "Ss"कि एक ही है "SS"या "ss", और सभी को एक जोड़ी के रूप में गिना जाता है S।)

आप जहां चाहें वहां से अपना इनपुट पढ़ सकते हैं। सबसे छोटा कोड जीतता है।

Comments

क्या हम यह मान सकते हैं कि जोड़े में केवल अक्षर होंगे या इनपुट में डबल स्पेस या डबल 'आदि हो सकता है?

— मार्टिन एंडर

क्या हम मान सकते हैं कि कम से कम एक अक्षर दो बार दिखाई देता है?

— मार्टिन एंडर

@ मार्टिनबटनर हां, आप मान सकते हैं कि कम से कम एक अक्षर युग्म होता है। हालाँकि, अन्य वर्ण जोड़े में भी दिखाई दे सकते हैं। केवल अक्षरों की गिनती।

— अय्यन

यहां तक ​​कि अगर केवल एक जोड़ी है, तो क्या मैं अभी भी इसे एक सूची में प्रिंट कर सकता हूं ['l']?

— माल्टीसेन

@ मैलेटेन हां, आप ऐसा कर सकते हैं।

— अय्यन

Answer 1

पायथ, 26 25 24 16 15 बाइट्स

.M/sfthTrrz08ZG

इसे ऑनलाइन आज़माएँ: प्रदर्शन

स्पष्टीकरण:

.M/sfthTrrz08ZG   implicit: z = input string
         rz0      convert z to lower-char
        r   8     run-length-encoding (into tuples [count, char])
    f             filter for tuples T, which satisfy:
     thT            T[0]-1 != 0 (count > 1)
   s              join to a string
.M            G   find the elements Z of "abcd...z", which produce the highest value:
  /...........Z       count of Z in ...

Comments

eC-> sएक बाइट बचाता है।

— isaacg

क्या आप किसी अच्छे संसाधन को जानते हैं, जिसका उपयोग मैं सीखने के लिए कर सकता हूँ?

— बीटा डेके

@BetaDecay आप pyth.readthedocs.org पर Pyth के बारे में एक ट्यूटोरियल पा सकते हैं। यह सभी फंक्शंस और ट्रिक्स को कवर नहीं करता है, लेकिन यह एक अच्छी शुरुआत है। और यदि आपके कोई प्रश्न हैं, तो बस चैट में पूछें ।

— जकूबे

Answer 2

बैश + जीएनयू कोरुटिल्स, 133

grep -Eo '([A-Z])\1+'<<<"${1^^}"|cut -c1|sort|uniq -c|sort -rn|while read n l
do((a-n&&a-0))&&exit||echo $l&&a=$n
done|sort|tr -d \\n

परीक्षण के मामलों:

$ for t in "Sally's friend Bobby searched for seashells." \
> "Sally's friends Jimmy and Bobby rummaged for seashells." \
> "willless" \
> "Sally's sociable friends Sammy and Bobby searched for fabulous seashells." \
> "11ss11aa"
> do
> ./mostpaired.sh "$t"
> echo
> done
L
LM
LS
L
AS
$ 

Comments

क्या यह केवल अक्षरों को गिनता है? ( 11ss11aa

— टेस्टकेस

@ edc65 वहाँ मैं इसे ;-) दरअसल, 11ss11aa-> एएस :)

— डिजिटल ट्रामा

मुझे लगता है कि यदि आपके पास 10 या अधिक युग्मित पत्र हैं, तो आपकी sort -rजरूरत है sort -rn।

— टोबे स्पाइट

@TobySpeight। हाँ। फिक्स्ड।

— डिजिटल ट्रामा

AWK के साथ इसे कम समय के बजाय छोटा बना सकते हैं: awk '! n {n = $ 1}; n == $ 1' | grep -o। $

— Nik O'Lai

Answer 3

सीजेएम, 29 27 बाइट्स

leue`{2a>},s_el-$e`$z~\)-,>

2 बाइट्स से गोल्फिंग के लिए @ ऑप्टिमाइज़र का धन्यवाद!

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

यह काम किस प्रकार करता है

leu    e# Read a line from STDIN and covert to uppercase.
e`     e# Perform run-length encoding.
       e# Example: "AABBBC!!" -> [[2 'A] [3 'B] [1 'C] [2 '!]]
{2a>}, e# Filter out all pairs that are less of equal to [2].
s      e# Stringify.
       e# Example: [[2 'A] [3 'B] [2 '!]] -> "2A3B2!"
_el    e# Push a copy of the string and convert to lowercase.
       e# Example: "2A3B2!" -> "2a3b2!"
-      e# Remove all character from the second string from the first.
       e# Example: "2A3B2!" "2a3b2!" - -> "AB"
$e`$   e# Sort, perform run-length encoding and sort again.
       e# Example: "ABACABDBC" -> "AAABBBCCD"
       e#                      -> [[3 'A] [3 'B] [2 'C] [1 'D]]
                               -> [[1 'D] [2 'C] [3 'A] [3 'B]]
z~     e# Zip and dump.
       e# Example: [[1 'D] [2 'C] [3 'A] [3 'B]] -> [1 2 3 3] ['D 'C 'A 'B]
\)     e# Pop out the last element from the first array.
       e# Example: [1 2 3 3] -> [1 2 3] 3
-      e# Remove all occurrences of the popped element from the array.
       e# Example: [1 2 3] 3 -> [1 2]
,      e# Compute the length of the remainder.
>      e# Skip that many elements from the character array.

Comments

z~\)-,>जहाँ तक मैं देख सकता हूँ काम करना चाहिए।

— ऑप्टिमाइज़र

@ ऑप्टिमाइज़र: छोटा और बहुत अधिक सहज। धन्यवाद!

— डेनिस

Answer 4

पायथ - 23 22 21 20 बाइट्स

दो या सभी से अधिक वर्णमाला को अस्थायी मान में .Mबदलने के लिए रेगेक्सपी प्रतिस्थापन का उपयोग करता है, और सभी उच्चतम घटना होने के लिए एक्सिमल का उपयोग करता है। एक बाइट को सॉर्ट करने और सहेजने के अतिरेक को इंगित करने के लिए @Jakube का धन्यवाद।

.M/:rz0+Z"{2,}"KC0KG

स्टड से इनपुट लेता है और आउटपुट स्टडआउट ['l', 'm']को पसंद करता है।

.M        G         Values which yield maximal amount over lowercase alphabet
 /                  Count
  :                 Regexp substitution
   rz0              Lowercased input
   +Z               String concatenate current loop var         
    "{2,}"          Regexp 2 or more of previous group
   KCZ              Inline assign null byte to K and use value
  K                 Count K which is null byte

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

Answer 5

सी, 155

कुछ अलग, कोई regexps।

m=1,i=1,n[91];
main(c,a)char**a;
{
  char*t=a[1];
  for(;c=*t++;)(c&=95)>64&&c<91&&(c-(*t&95)?i=1:(c=(n[c]+=i),i=0,m=m<c?c:m));
  for(c=0;++c<91;)n[c]-m||putchar(c);
}

Answer 6

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

def f(x):import re;x=re.findall(r'(.)\1+',x.upper());s={l:x.count(l)for l in x};print "".join(sorted([l for l in s if s[l]==max(s.values())]))

उदाहरण रन:

f("Sally's friends Jimmy and Bobby rummaged for seashells.")
LM

Comments

शायद यह "पत्र जो तीन गुना, चौगुनी, आदि एक जोड़ी के रूप में गिना जाता है" को पूरा नहीं करता है

— गिंडन

आप सही हे! मैंने इसे ठीक करने की कोशिश की है। उस ओर इशारा करने के लिए धन्यवाद :)

— heo

Answer 7

सीजेएम, 37 बाइट्स

leue`{~_el-\(e&},1f=$e`$_W=0=f-{,1=},

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

नियमित अभिव्यक्ति समर्थन के बिना, मुझे डर है कि पाइथ के साथ प्रतिस्पर्धा करना कठिन होगा। यह सबसे अच्छा है जो मैं पहली पास के साथ आया हूं।

स्पष्टीकरण:

l     Get input.
eu    Convert it to upper case, since case does not matter.
e`    Run length encoding, to split into groups of same characters.
{     Start of block for filtering.
  ~     Unpack the length/letter pair.
  _     Copy the letter.
  el    Change copy to lower case.
  -     Subtract to compare. If result is non-zero, this is a letter.
  \     Swap count to top.
  (     Decrement to get truthy value for count > 1.
  e&    Logical and: It's a letter, and count is > 1.
},    End of filter.
1f=   Don't need the counts anymore, filter out the letters only from the RLE pairs.
$     Sort them, so that multiples of the same letter are sequential.
e`    RLE again, to count how many multiples of each letter we had.
$     And sort again, to get the count/letter pairs in order of incrementing count.
_     Copy list.
W=0=  Pick out count of last element, which is the highest count.
f-    Remove count from pairs that have the highest count. This leaves them
      as one member lists with letter only, while others still have count/letter.
{     Start block for filter.
  ,1=   Check for list length one.
},    End filter.

Answer 8

क्यू (66)

बूट करने के लिए अपेक्षाकृत पठनीय:

{where g=max g:.Q.A#count each group y where not differ y:upper x}

Answer 9

आर, 105 बाइट्स

cat(substr(names(b<-table(regmatches(s<-toupper(readline()),gregexpr("([A-Z])\\1+",s))))[b==max(b)],1,1))

यह एसटीडीआईएन से पाठ की एक पंक्ति को पढ़ता है और एसटीडीयूएसटी के लिए सबसे आम युग्मित पत्रों की एक अंतरिक्ष सीमांकित सूची को प्रिंट करता है।

असंगठित + स्पष्टीकरण:

# Read a string from STDIN, convert to uppercase
s <- toupper(readline())

# Get each match of the regex /([A-Z])\1+/
matches <- regmatches(s, gregexpr("([A-Z])\\1+", s))

# Compute the frequency of each match
freq <- table(matches)

# Get the matches with the highest frequency
highest <- names(freq)[freq == max(freq)]

# Each element of highest is the literal pair, so take the first character
first <- substr(highest, 1, 1)

# Print to STDOUT
cat(first)

उदाहरण:

> (code)
Sally's friends Jimmy and Bobby rummaged for seashells.
L M

> (code)
Sally's friend Bobby searched for seashells.
L

> (code)
Sally's sociable friends Sammy and Bobby searched for fabulous seashells.
L

> (code)
11ss11nn
N S

आप इसे ऑनलाइन आज़मा सकते हैं !

Comments

toupperयदि आप मामले को नजरअंदाज करते हैं और अपने में पर्ल का उपयोग करते हैं , तो आप शायद छुटकारा पा सकते हैं gregexpr। जैसेcat(substr(names(b<-table(regmatches(s<-readline(),gregexpr("(\\w)\\1+",s,T,T))))[b==max(b)],1,1))

— मिकट

@ मिक्की: मैंने उस बारे में सोचा था, लेकिन ऐसा लग रहा है कि ओपी चाहता है कि आउटपुट अपरकेस हो, इसलिए इसका इस्तेमाल toupperवैसे भी सुनिश्चित करने के लिए करना होगा।

— एलेक्स ए।

यह शर्म की बात है, मुझे याद है कि जब मैंने प्रश्न पढ़ा।

— मिकटी

बेला की कोशिश की, लेकिन यह फ़ायरफ़ॉक्स में कोई आउटपुय के साथ हमेशा के लिए चलाने के लिए लगता है। टेस्टकेस: 11ss11nn?

— edc65

@ edc65 यह R-Fiddle की समस्या है; कुछ भी नहीं काम करता है। मैंने इस समस्या की रिपोर्ट करने के लिए उनके व्यवस्थापक से संपर्क किया। मेरा रेगेक्स फिक्स्ड और अब आपका टेस्ट उम्मीद के मुताबिक काम करता है, लेकिन इसकी कीमत मुझे 2 बाइट्स चुकानी पड़ी। इस सामान को इंगित करने के लिए धन्यवाद, मैं इसकी सराहना करता हूं!

— एलेक्स ए।

Answer 10

रूबी, ६०

f=->s{(?a..?z).group_by{|l|s.scan(/#{l*2}+/i).size}.max[1]}

p f["Sally's friends Jimmy and Bobby rummaged for seashells."]

group_byएक हैश (शब्दकोश) संरचना बनाता है जहाँ कुंजियाँ ब्लॉक का आउटपुट होती हैं और मान उन अक्षरों की सूची होते हैं जिनके परिणामस्वरूप प्रत्येक कुंजी होती है। इस मामले में, चाबियाँ एक पत्र के 2+ रन, केस-असंवेदनशील हैं। maxप्रत्येक [key,value]टपल की तुलनात्मक रूप से करता है , इसलिए यह केवल अधिकतम कुंजी पाता है। फिर [1]टपल का मान सूची भाग लौटाता है।

Answer 11

पायथन 2, 185 159 153

i=input().lower()
d=sorted({l:len(i.split(l+l))for l in map(chr,range(97,123))}.items(),None,lambda x:x[1],1)
print sorted(c for c,k in d if k==d[0][1])

एक उद्धृत स्ट्रिंग के रूप में इनपुट लेता है।

Answer 12

C # 160 बाइट्स

sइनपुट कहां है:

char? d(string s){s=s.ToUpper();return s.Select((x,i)=>new{y=x,z=i==0?(char?)null:s[i-1]}).Where(x=>x.y==x.z).GroupBy(x=>x.z).OrderBy(x=>x.Count()).Last().Key;}

Answer 13

आरएस, 146 बाइट्स

[^A-Za-z]/
*(.)\1+/\1\1
*(.)(?!\1)/
$/#
+*(.)#(?!.*?\1)/#\1
+*(.)(.*)#(.*)\1/\2#\3\1\1
#/
*(.)(\1*)/\1(_)^^((^^\1\2))
([^_])(_+)(?!_)(?=.*\2_)/
_/

कोशिश करो! कृप्या! यह मुझे हमेशा के लिए उस पृष्ठ पर भी आउटपुट बॉक्स के साथ बटन बनाने के लिए ले गया ...

खैर, यह काफी ... पागल था। यहाँ तर्क अजीब तरह का है; अगर कोई पूछता है तो मैं केवल एक स्पष्टीकरण पोस्ट करूँगा। (निश्चित रूप से, मैंने यह भी कहा कि एक आंतरिक जवाब के लिए जिसकी व्याख्या का अनुरोध किया गया था ... कि मैंने कभी समझाया नहीं ...);

Comments

मुझे दुभाषिया पसंद है, लेकिन आप डिबग चेकबॉक्स को उसी पंक्ति में रखना चाह सकते हैं जैसे बटन या कुछ और। यह थोड़े अजीब तरह से उनके ऊपर लग रहा है। फिर भी मस्त! +1

— माल्टीसेन

इसकी कोशिश की गई (त्रुटियाँ ...) i.stack.imgur.com/mTioT.png

— edc65

@ मैलेटेन मैं इस पर विचार करूंगा। धन्यवाद!

— kirbyfan64sos

@ edc65 धिक्कार है ... पूर्ण त्रुटि संदेश क्या था? ऐसा लगता है कि यह PyPy.js बग हो सकता है। या सिर्फ तथ्य यह है कि मैंने कभी फ़ायरफ़ॉक्स पर यह परीक्षण नहीं किया ...

— kirbyfan64sos

Answer 14

जावास्क्रिप्ट 156 153 153

var x=prompt(),f={},a=0,o
x.toUpperCase().replace(/([A-Z])\1+/g,function(m,s){m=f[s]=-~f[s]
if(a==m)o.push(s)
if(a<m)a=m,o=[s]})
alert(o.sort().join(""))

Comments

f[s]?f[s]+1:1->-~f[s]

— edc65

यह गैर-पत्रों के साथ विफल रहता है:Count only letters from the English alphabet

— edc65

धन्यवाद @ edc65 मैंने शॉर्टकट और AZ जाँच जोड़ी है।

— वॉल्फहैमर

आपका सटीक कोड, सुव्यवस्थित और ES6: f=x=>{x.toUpperCase(f={},a=0,o).replace(/([A-Z])\1+/g,(m,s)=>a<(m=f[s]=-~f[s])?(a=m,o=[s]):a>m?0:o.push(s));alert(o.sort().join'')}(अंतिम 2 '' वास्तव में

— बैकटिक्स हैं

Answer 15

बैश + टेक्सटाइल (grep, sed), 111 वर्ण

fold -1<<<$s|uniq -iD|sort -f|uniq -ic|sort -rn|grep -i [A-Z]|sed -n '1h;G;s/\(\s*\S\+\s\)\(.\)\n\1./\2/p'|sort

बैश + अवेक (सेड की बजाय), 97 वर्ण

fold -1<<<$s|uniq -iD|sort -f|uniq -ic|sort -rn|grep -i [A-Z]|awk '!n{n=$1};n==$1{print $2}'|sort

इसका परीक्षण करने के लिए, पहले एस असाइन करें

s="Sally's friends Jimmy ää and Bobby rummaged ää for seashells."

Answer 16

आर, 98 बाइट्स

एलेक्स के समाधान के समान, लेकिन लगातार पत्रों को निर्धारित करने के लिए एक मैच के बजाय एक प्रतिस्थापन का उपयोग करता है। स्कैन का उपयोग इनपुट प्राप्त करने और रिक्त स्थान पर प्रतिस्थापन परिणाम को विभाजित करने के लिए भी किया जाता है।

cat(names(a<-table(scan(,'',t=gsub('([A-z]?)(\\1?)[^A-z]*','\\U\\2 ',scan(,''),T,T))))[a==max(a)])

परीक्षण के एक जोड़े

> cat(names(a<-table(scan(,'',t=gsub('([A-z]?)(\\1?)[^A-z]*','\\U\\2 ',scan(,''),T,T))))[a==max(a)])
1: 11 was a race horse, 22 was one too. 11 won one race and 22 one won too.
19: 
Read 18 items
Read 2 items
O
> cat(names(a<-table(scan(,'',t=gsub('([A-z]?)(\\1?)[^A-z]*','\\U\\2 ',scan(,''),T,T))))[a==max(a)])
1: Sally's friends Jimmy and Bobby rummaged for seashells.
9: 
Read 8 items
Read 5 items
L M
> cat(names(a<-table(scan(,'',t=gsub('([A-z]?)(\\1?)[^A-z]*','\\U\\2 ',scan(,''),T,T))))[a==max(a)])
1: 11ss11nn
2: 
Read 1 item
Read 2 items
N S
>