Программа должна вывести букву, которая больше всего сопряжена. Например, если вашей программе была задана следующая строка:

"Sally's friend Bobby searched for seashells."

он должен выводить, Lпотому что "ll"происходит дважды, что чаще, чем у другой пары "bb".

Правила:

• Если более чем одна буква занимает 1-е место для вхождений, выведите все из них в алфавитном порядке (например, "Sally's friends Jimmy and Bobby rummaged for seashells."следует вывести оба LAND M[или, "LM"если хотите], потому что они оба встречаются чаще, чем другие пары).
• Буквы, которые утроены, четырехкратно и т. Д., Считаются одной парой (например, "lll"in "willless"считается только одной парой L).
• Буквенные пары должны быть в одном слове (например, "Sally's sociable friends Sammy and Bobby searched for fabulous seashells."должны выводиться, Lа не Sпотому, что, несмотря на "ss"наличие большего числа вхождений, чем "ll"они, они разделены пробелами.)
• Считайте только буквы от английского алфавита
• Случай не имеет значения (например "Ss", то же самое, что и "SS"или "ss", и все они считаются одной парой S.)

Вы можете прочитать свой вклад, где угодно. Самый короткий код выигрывает.

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

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

Testcases:

$ 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 байт

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

Спасибо @Optimizer за удаление 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.

Pyth - 23 22 21 20 байт

Использует подстановку регулярных выражений, чтобы заменить все два или более алфавита на временное значение, и использует .Maximal, чтобы получить все значения с наивысшим вхождением. Спасибо @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

Попробуйте это онлайн здесь .

С, 155

Что-то другое, без регулярных выражений.

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 байта

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

CJam, 37 байт

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

Попробуйте онлайн

Боюсь, без поддержки регулярных выражений будет сложно конкурировать с Pyth. Это лучшее, что я придумал на первом проходе.

Объяснение:

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)

Относительно читабельно для загрузки:

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

R, 105 байт

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

Это читает строку текста из STDIN и печатает список наиболее распространенных парных букв в STDOUT с разделителями пробелами.

Ungolfed + объяснение:

# 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

Вы можете попробовать это онлайн !

Руби, 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_byсоздает хэш (словарную) структуру, где ключи - это выходные данные блока, а значения - списки букв, которые приводят к каждому ключу. В этом случае ключи - это число от 2+ повторений буквы без учета регистра. maxсравнивает каждый [key,value]кортеж лексикографически, поэтому он просто находит максимальный ключ. Затем [1]возвращает часть списка значений кортежа.

Питон 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])

Принимает ввод в виде строки в кавычках.

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

RS, 146 байт

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

Попытайся! Пожалуйста! У меня ушло навсегда, чтобы сделать кнопки даже с полем вывода на этой странице ...

Ну, это было довольно ... сумасшедшим. Логика здесь довольно странная; Я только отправлю объяснение, если кто-то спросит. (Конечно, я также сказал, что для ответа INTERCAL, чье объяснение было запрошено ... что я никогда не объяснял ...;)

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 символов

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 (вместо sed), 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

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

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