O programa deve exibir a letra que está mais emparelhada. Por exemplo, se seu programa recebeu a seguinte string:

"Sally's friend Bobby searched for seashells."

deve sair Lporque "ll"ocorre duas vezes, o que é mais frequente que o outro par "bb".

Regras:

• Se mais de uma letra tiver o primeiro lugar para ocorrências, imprima todas elas em ordem alfabética (por exemplo, "Sally's friends Jimmy and Bobby rummaged for seashells."deve gerar LAND e M[ou, "LM"por favor], porque ambas ocorrem com mais frequência do que outros pares.)
• Letras que são triplicadas, quadruplicadas, etc. contam como um par (por exemplo, "lll"in "willless"é contado como apenas um par de L).
• Os pares de letras devem estar em uma palavra (por exemplo, "Sally's sociable friends Sammy and Bobby searched for fabulous seashells."devem ser exibidos Le não Sporque, apesar de "ss"terem mais ocorrências do que "ll", eles são separados por espaços).
• Contar apenas letras do alfabeto inglês
• O caso não importa (por exemplo, "Ss"é o mesmo que "SS"ou "ss", e todos são contados como um par de S.)

Você pode ler sua opinião de onde quiser. O menor código vence.

Pitão, 26 25 24 16 15 bytes

.M/sfthTrrz08ZG

Experimente online: Demonstração

Explicação:

.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 + coreUtil GNU, 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

Casos de teste:

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

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

Obrigado ao @Optimizer por jogar fora 2 bytes!

Experimente online no intérprete CJam .

Como funciona

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.

Pitão - 23 22 21 20 bytes

Usa substituição regexp para substituir todos os dois ou mais do alfabeto por um valor temporário e usa .Maximal para obter todos os que têm a maior ocorrência. Agradecemos ao @Jakube por apontar a redundância de classificar e salvar um byte.

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

Toma a entrada de stdin e as saídas gostam ['l', 'm']de stdout.

.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

Experimente online aqui .

C, 155

Algo diferente, sem 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);
}

Python 2, 132 143 bytes

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

Exemplo de execução:

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

CJam, 37 bytes

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

Experimente online

Sem o apoio da expressão regular, receio que seja difícil competir com Pyth. Este é o melhor que descobri no primeiro passe.

Explicação:

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)

Relativamente legível para inicializar:

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

R, 105 bytes

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

Isso lê uma linha de texto de STDIN e imprime uma lista delimitada por espaço das letras emparelhadas mais comuns para STDOUT.

Ungolfed + explicação:

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

Exemplos:

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

Você pode experimentá-lo online !

Ruby, 60

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_bycria uma estrutura de hash (dicionário) em que as chaves são a saída do bloco e os valores são listas de letras que resultam em cada chave. Nesse caso, as chaves são contagens de 2 ou mais execuções de uma letra, sem distinção entre maiúsculas e minúsculas. maxcompara cada [key,value]tupla lexicograficamente, para encontrar a chave máxima. Em seguida, [1]retorna a parte da lista de valores da tupla.

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

Recebe a entrada como uma string entre aspas.

C # 160 bytes

Onde sestá a entrada:

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 bytes

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

Tente! Por favor! Levei uma eternidade para fazer os botões, mesmo com a caixa de saída nessa página ...

Bem, isso foi bastante ... louco. A lógica aqui é meio estranha; Só vou postar uma explicação se alguém perguntar. (Claro, eu também disse que para uma resposta INTERCAL cuja explicação foi solicitada ... que eu nunca expliquei ...;)

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 caracteres

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 (em vez de sed), 97 caracteres

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

para testá-lo, primeiro atribua s

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

R, 98 bytes

Muito semelhante à solução de Alex, mas usa uma substituição em vez de uma correspondência para determinar letras consecutivas. A digitalização é usada para obter a entrada e também para dividir o resultado da substituição em espaços.

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

Alguns testes

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