Program musi wypisać najbardziej sparowaną literę. Na przykład, jeśli twój program otrzymał następujący ciąg:

"Sally's friend Bobby searched for seashells."

musi generować dane wyjściowe, Lponieważ "ll"występuje dwukrotnie, co jest częstsze niż w przypadku drugiej pary "bb".

Zasady:

• Jeśli więcej niż jedna litera ma 1. miejsce na wystąpienia, wypisz je wszystkie w kolejności alfabetycznej (np. "Sally's friends Jimmy and Bobby rummaged for seashells."Powinieneś podać zarówno LORAZ M[lub "LM"jeśli chcesz], ponieważ oba występują częściej niż inne pary.)
• Litery które trzykrotnie, czterokrotnie itp traktowane jako jedna para (np "lll"w "willless"liczony jako tylko jedną parę L).
• Pary liter muszą być w jednym słowie (np. "Sally's sociable friends Sammy and Bobby searched for fabulous seashells."Powinny wypisywać, La nie Sdlatego, że pomimo "ss"większej liczby wystąpień "ll"są one oddzielone spacjami).
• Policz tylko litery z alfabetu angielskiego
• Wielkość liter nie ma znaczenia (np. "Ss"Jest taka sama jak "SS"lub "ss"i wszystkie są liczone jako jedna para S.)

Możesz przeczytać swój wkład z dowolnego miejsca. Najkrótszy kod wygrywa.

Pyth, 26 25 24 16 15 bajtów

.M/sfthTrrz08ZG

Wypróbuj online: demonstracja

Wyjaśnienie:

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

Bash + GNU coreutils, 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

Przypadki testowe:

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

CJam, 29 27 bajtów

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

Dzięki @Optimizer za grę w golfa z 2 bajtów!

Wypróbuj online w interpretatorze CJam .

Jak to działa

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.

Pyth - 23 22 21 20 bajtów

Używa podstawienia .Mwyrażenia regularnego, aby zamienić wszystkie dwa lub więcej alfabetów na wartość tymczasową, i używa aximal, aby uzyskać wszystkie, które mają najwyższe wystąpienie. Dzięki @Jakube za zwrócenie uwagi na nadmiarowość sortowania i oszczędzania bajtu.

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

Pobiera dane wejściowe ze standardowego wejścia i wyjścia takie jak standardowe ['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

Wypróbuj online tutaj .

C 155

Coś innego, bez wyrażeń regularnych.

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

Python 2, 132 143 bajty

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

Przykładowy przebieg:

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

CJam, 37 bajtów

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

Wypróbuj online

Obawiam się, że bez obsługi wyrażeń regularnych ciężko będzie konkurować z Pyth. To najlepsze, co wymyśliłem przy pierwszym podaniu.

Wyjaśnienie:

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.

Q (66)

Względnie czytelny do uruchomienia:

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

R, 105 bajtów

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

Odczytuje wiersz tekstu ze STDIN i drukuje rozdzieloną spacjami listę najczęściej sparowanych liter do STDOUT.

Niegolfowane + wyjaśnienie:

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

Przykłady:

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

Możesz spróbować online !

Ruby, 60 lat

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_bytworzy strukturę hash (słownik), w której klucze są wynikiem bloku, a wartościami są listy liter, które dają każdy klucz. W tym przypadku klucze są liczone od ponad 2 serii listu, bez rozróżniania wielkości liter. maxporównuje [key,value]leksykograficznie każdą krotkę, więc znajduje tylko maksymalny klucz. Następnie [1]zwraca część listy wartości krotki.

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

Pobiera dane wejściowe jako cytowany ciąg.

C # 160 bajtów

Gdzie sjest dane wejściowe:

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

rs, 146 bajtów

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

Spróbuj! Proszę! Zajęło mi wieczność, aby tworzyć przyciski nawet z polem wyjściowym na tej stronie ...

To było dość ... szalone. Logika tutaj jest trochę dziwna; Wyślę wyjaśnienie tylko, jeśli ktoś zapyta. (Oczywiście powiedziałem również, że w przypadku odpowiedzi INTERCAL, której wyjaśnienia zażądano ... nigdy nie wyjaśniłem ...;)

JavaScript 156 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(""))

Bash + textutils (grep, sed), 111 znaków

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

Bash + awk (zamiast sed), 97 znaków

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

aby to przetestować, najpierw przypisz s

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

R, 98 bajtów

Bardzo podobny do rozwiązania Alexa, ale używa zastępowania zamiast dopasowania, aby określić kolejne litery. Skanowanie służy do uzyskania danych wejściowych, a także do podziału wyniku podstawienia na spacje.

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

Kilka testów

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