El programa debe generar la letra que está más emparejada. Por ejemplo, si su programa recibió la siguiente cadena:

"Sally's friend Bobby searched for seashells."

debe salir Lporque "ll"ocurre dos veces, lo cual es más frecuente que el otro par "bb".

Reglas:

• Si más de una letra tiene el primer lugar para las ocurrencias, escríbalas todas en orden alfabético (p. Ej., "Sally's friends Jimmy and Bobby rummaged for seashells."Debería emitir ambas LY M[o "LM"si lo desea] porque ambas aparecen con más frecuencia que otros pares).
• Las letras que se triplican, cuadruplican, etc. cuentan como un par (por ejemplo, "lll"en "willless"se cuenta como un solo par de L).
• Los pares de letras deben estar en una palabra (p. Ej. "Sally's sociable friends Sammy and Bobby searched for fabulous seashells.", Deben aparecer Ly no Sporque, a pesar de "ss"tener más ocurrencias "ll", están separados por espacios).
• Cuente solo letras del alfabeto inglés
• El caso no importa (por ejemplo, "Ss"es el mismo que "SS"o "ss", y todos se cuentan como un par de S).

Puede leer su opinión desde donde quiera. El código más corto gana.

Pyth, 26 25 24 16 15 bytes

.M/sfthTrrz08ZG

Pruébelo en línea: demostración

Explicación:

.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

Casos de prueba:

$ 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~\)-,>

¡Gracias a @Optimizer por jugar golf en 2 bytes!

Pruébelo en línea en el intérprete de CJam .

Cómo 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.

Pyth - 23 22 21 20 bytes

Utiliza la sustitución regexp para reemplazar todos los dos o más del alfabeto a un valor temporal, y utiliza el .Mmáximo para obtener todos los que tienen la mayor ocurrencia. Gracias a @Jakube por señalar la redundancia de ordenar y guardar un byte.

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

Toma entradas de stdin y salidas como ['l', 'm']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

Pruébelo en línea aquí .

C, 155

Algo diferente, sin expresiones regulares.

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

Ejemplo de ejecución:

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

CJam, 37 bytes

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

Pruébalo en línea

Sin el apoyo de expresiones regulares, me temo que será difícil competir con Pyth. Esto es lo mejor que se me ocurrió en un primer pase.

Explicación:

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 legible para arrancar:

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

Esto lee una línea de texto de STDIN e imprime una lista delimitada por espacios de las letras emparejadas más comunes a STDOUT.

Ungolfed + explicación:

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

Ejemplos:

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

¡Puedes probarlo en línea !

Rubí, 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_bycrea una estructura hash (diccionario) donde las claves son la salida del bloque y los valores son listas de letras que resultan en cada clave. En este caso, las claves son recuentos de 2+ corridas de una letra, sin distinción entre mayúsculas y minúsculas. maxcompara cada [key,value]tupla lexicográficamente, por lo que solo encuentra la clave máxima. Luego [1]devuelve la parte de la lista de valores de la 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])

Toma la entrada como una cadena entre comillas.

C # 160 bytes

¿Dónde sestá la 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_)/
_/

¡Intentalo! ¡Por favor! Me llevó una eternidad hacer los botones incluso con el cuadro de salida en esa página ...

Bueno, esto fue bastante ... loco. La lógica aquí es un poco extraña; Solo publicaré una explicación si alguien pregunta. (Por supuesto, también dije que para una respuesta INTERCAL cuya explicación fue solicitada ... que nunca expliqué ...;)

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 (en lugar 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 probarlo, primero asigne s

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

R, 98 bytes

Muy similar a la solución de Alex, pero utiliza una sustitución en lugar de una coincidencia para determinar letras consecutivas. La exploración se usa para obtener la entrada y también para dividir el resultado de la sustitución en espacios.

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

Un par de pruebas

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