Gần đây có một câu hỏi về Stack Overflow nơi OP đang cố gắng viết một hàm để tìm từ trong một chuỗi có nhiều chữ cái lặp đi lặp lại. Tất nhiên không khó để viết một bài trong vài giây và tôi đã viết một bài bằng Javascript ngắn nhất có thể để giải trí. Nhưng tôi không phải là một chuyên gia về chơi golf mã, vì vậy tôi tự hỏi chương trình đơn giản này có thể ngắn hơn bao nhiêu!

Thử thách

Viết chương trình hoặc hàm lấy một chuỗi từ và trả lại hoặc in từ có nhiều chữ cái lặp lại nhất.

Quy tắc:

• Chọn từ có số lượng chữ cái lặp lại nhiều nhất (xem ví dụ bên dưới)

• Nếu không có từ nào lặp lại các chữ cái, trả về -1.

• Nếu hai từ có cùng số lượng chữ cái lặp lại tối đa, hãy chọn một từ gần với đầu chuỗi.

• Đệ trình ngắn nhất tính bằng byte thắng.

Đầu vào

Lấy làm đầu vào một chuỗi bao gồm một hoặc nhiều từ được phân tách bằng dấu cách. Đầu vào có thể từ STDIN (hoặc thay thế gần nhất), tham số dòng lệnh hoặc đối số chức năng.

Đầu ra

In đầu ra ra STDOUT để trả lại.

Ví dụ

Hãy xem xét chuỗi aaabbb cccc. Điều này có chứa hai từ: aaabbbvà cccc. Từ aaabbbnày có 3 a's và 3 b' s, và cccccó 4 c's. Vì vậy, số lượng chữ cái lặp lại tối đa aaabbblà 3 và tối đa cccclà 4. Chúng tôi muốn chọn từ có số lượng chữ cái lặp lại tối đa, do đó, đầu ra aaabbb ccccphải là cccc.

Các trường hợp thử nghiệm khác:

Today, is the greatest day ever!  --> greatest
This is a great day               --> -1
aaabbb cccc                       --> cccc

C - GCC - 159 145 135 byte

x=0,w=0,i,j,c;main(int _,char**z){while(--_)for(j=i=0;_[z][i];j=++i,x=c>x?w=_,c:x)for(c=0;j--;)c+=z[_][i]==z[_][j];puts(x?z[w]:"-1");}

Sẽ cập nhật khi tôi có thể cắt nó một chút

Cách biên dịch: gcc -w cg.c

Cách chạy: ./a.out word1 word2 aass ddaaa ssdddd

Đầu ra: ssdddd

Không đầu ra / Không khớp: -1

Trước hết, tôi đã lừa dối một chút, bằng cách lấy các từ làm đối số chương trình, nhưng để GCC phân tích các từ và cho tôi một số từ miễn phí là quá nhiều phần thưởng để vượt qua.

Làm thế nào nó hoạt động?

Chúng ta có 3 vòng lặp lồng nhau. Gia tăng đầu tiên thông qua mỗi từ, hai từ tiếp theo đang bắt chước một loại bong bóng để so sánh các giá trị. Chữ cái đầu tiên không bao giờ được so sánh với chính nó và mỗi chữ cái tiếp theo được so sánh với mỗi chữ cái trước đó. Bất cứ khi nào một từ có nhiều chữ cái giống với từ trước đó, từ đó được lưu trữ trong x và số lượng bao nhiêu chữ cái cũng được lưu trữ.

Lạm dụng GCC

Chúng tôi sử dụng ẩn tự động int int toàn cầu cho số nguyên của chúng tôi. Chúng tôi cho phép argv là một int thay vì char (hiện tại là char, đây là TODO). Chúng tôi sử dụng các chức năng mặc định như put và getchar. Chúng tôi cũng sử dụng toán tử dấu phẩy để quá tải toán tử ba (điều kiện) của chúng tôi.

Muốn có 2 byte ít hơn?

Thay thế "-1" bằng * z và đặt tên cho tệp -1

Chương trình không được kiểm tra và chưa được kiểm tra:

int main(int argc, char * argv[])
{
    int word = 0           // Current most repeat letters word
    int count = 0;        // Current most repeat letters
    int i, j, increment; // Counter variables

    while(--argc != 0) // While we have words from program parameters
    {
        for(j = i = 0; argv[argc][i] != '\0'; j = ++i) // Iterate through each letter until end of word
        {
            for(increment = 0; j > 0; j--) // Iterative backwards through each letter
            {
                if(argv[argc][i] == argv[argc][j])
                {
                    increment++;
                }
            }
            if(increment > count) // New greatest lettered word
            {
                word = argc;
                count = increment;
            }
        }
    }

    if(word == 0)
    {
        puts("-1");
    }
    else
    {
        puts(argv[word]);
    }

    return 0;
}

Bình thường, 14 byte

eoeS/LNN+czd_1

Trình diễn. Khai thác thử nghiệm.

eoeS/LNN+czd_1
                  Implicit: z = input(), d = ' '
         czd      chop z on delimeter d.
        +   _1    Add an -1 to the end of the list.
 o                Order the list by
  eS              the maximum of
    /LN           the occurence count in the word
       N          of letters in the word.
                  (If we are mapping over -1, this will give -1/-1 = 1)
                  Since Python's sort is stable, this will leave -1 at the end if
                  all words have maximum repetition count 1.
e                 Take the final element of the resulting list and print it.

K, 35 byte (thiếu -1 yêu cầu, chỉ cần chú ý, nhưng thời gian để ngủ)

{1#w[>{|/{#:&:x=y}[x]'x}'w:" "\:x]}

làm thế nào nó hoạt động:

1 mất

1#

của những từ được lập chỉ mục bởi

w[

các chỉ số để đặt theo thứ tự tăng dần

>

giá trị lớn nhất

|/

đếm nơi

#:&:

chuỗi = char

x=y

cho mỗi char trong từ

'x

cho mỗi từ trong đó w(từ) là

'w:

chuỗi phân tách bởi dấu cách

\:x

Rõ ràng tôi đã hy sinh một chút chính xác cho tính biểu cảm và mức độ dễ đọc trong phần giải thích tiếng Anh. Tôi hy vọng nó là thú vị.

Haskell, 100 byte

import Data.List
f=g.last.sort.map((,)=<<last.sort.map length.group.sort).words
g(1,_)="-1"
g(_,w)=w

Ví dụ sử dụng: f "Today, is the greatest day ever!"->"greatest"

Làm thế nào nó hoạt động:

                                                words  -- split input at spaces into list of words
          map(                                 )       -- for each word
              (,)=<<                                   -- build a pair, where the second element is the word itself
                                                       -- and the first element is made by
                                           sort        -- sort the letters
                                      group            -- group equal letters
                            map length                 -- take length of each group
                        sort                           -- sort the lengths
                    last                               -- take the last
                                                       -- now we have a list of (l,w) pairs where l is how often the most frequent letter occurs for word w
     sort                                              -- sort the list
 last                                                  -- take last element
g                                                      -- call g which checks the "-1" case 

Haskell, 79 77 byte (chưa được kiểm tra)

import Data.List
last.sortOn(last.sort.map length.group.sort).words.(++" -1")

Cái này sử dụng sortOntừ Data.Listv4.8.0.0, cái mà tôi chưa cài đặt, vì vậy tôi không thể kiểm tra nó.

CJam, 25 byte

lS/{_$e`$W=0=(\}%2/$W=~W?

Dùng thử trực tuyến

Giải trình:

lS/   Get input and split at spaces.
{     Start of loop over all words.
  _     Copy, need to keep original word.
  $     Sort letters.
  e`    RLE.
  $     Sort RLE result. Sort is increasing by count.
  W=    Get last count/letter pair, which corresponds to largest count.
  0=    Extract count from pair.
  (     Decrement count, so that it has a falsy value when the count is 1.
  \     Swap count and word, so that we can sort the pairs by count.
}%    End of loop over words.
2/    Split list into pairs, which are the count/word pairs.
$     Sort the pairs.
W=    Get last one, which is the largest count.
~     Unwrap the pair.
W?    Output word if count is truthy, -1 otherwise.

Python 2, 97 77 byte

Giải pháp khá đơn giản, chỉ cần ánh xạ đầu vào (được bao quanh bởi dấu ngoặc kép) thành một bộ chứa từ và số lượng ký tự lặp lại. Lấy mức tối đa và in ra từ nếu chữ cái lặp đi lặp lại nhiều nhất, nếu không nó sẽ in -1.

Tôi đã lưu 20 byte (!) Bằng cách sắp xếp lại thứ tự đầu vào để tôi không cần khóa để tìm max.

j=max((max(map(x.count,x)),x)for x in input().split())
print[-1,j[1]][j[0]>1]

SWI-Prolog, 158 154 149 byte

a(A,R):-split_string(A," ","",B),findall(X:Z,(member(Z,B),string_codes(Z,D),length(D,L),sort(D,E),length(E,M),X is M-L,X<0),S),sort(S,[_:R|_]);R= -1.

Ví dụ: a("Today, is the greatest day ever!",R).đầu ra R = "greatest" ..

JavaScript, 86 111 108 byte

s=>(l=(x=s.split` `,r=x.map(l=>(/(.)\1+/.exec(l)||[''])[0].length),x)[r.indexOf(k=Math.max(...r))],k<2?-1:l)

Chắc chắn là có thể chơi gôn, toàn bộ -1 điều đã thêm khoảng 20 byte.

R, 107 byte

w=scan(,"");l=sapply(w,function(x)max(table(strsplit(x,"")[[1]])));cat(ifelse(max(l)>1,w[which.max(l)],-1))

Điều này đọc từ STDIN và in sang STDOUT.

Ungolfed + giải thích:

# Read a string and split it into a vector on spaces
w <- scan(, "")

# Get the maximum number of letter repeats in each element of w
l <- sapply(w, function(x) max(table(strsplit(x, "")[[1]])))

# If the largest number in l is 1, print -1, otherwise get the word
cat(ifelse(max(l) > 1, w[which.max(l)], -1)

C # 166 byte

string a(string i){var z=i.Split(' ');int g=1,c=0;var m="-1";foreach(var w in z)foreach(var l in w.Distinct()){c=w.Where(x=>x==l).Count();if(c>g){g=c;m=w;}}return m;}

Mã hóa đơn giản. Không có gì đặc biệt ở đây.

C # hút để chơi golf mã: - /

JavaScript ( ES7? ), 99

Sử dụng khả năng hiểu mảng, được triển khai trong Firefox nhưng không bao gồm trong EcmaScript 6.

Kiểm tra bằng đoạn trích bên dưới (chỉ dành cho Firefox)

f=s=>s.split(' ').map(w=>[for(c of(l=[m=0],w))(n=l[c]=-~l[c])>m?m=n:0]&&m>x&&(x=m,v=w),x=1,v=-1)&&v

// TEST
out=x=>O.innerHTML+=x+'\n';

test=x=>out(x+' -> '+f(x))

;["aaabbb cccc","This is a great day","Today, is the greatest  day ever a!"]
.forEach(t=>test(t));

<pre id=O></pre>
Try:<input id=I><button onclick='test(I.value),I.value=""'>-></button>

Ungolfed và tương thích hơn

function f(s)
{
  v = -1;
  x = 1;
  s.split(' ')
  .forEach(function(w){
    l=[];
    m=0;
    w.split('').forEach(function(c){
      n=l[c]=-~l[c];
      if (n>m) m=n;
    })
    if (m>x) x=m,v=w;
  })
  return v;
}

// TEST
out=function(x) { O.innerHTML+=x+'\n' }

test=function(x) { out(x+' -> '+f(x)) }

;["aaabbb cccc","This is a great day","Today, is the greatest  day ever a!"]
.forEach(function(t) { test(t)} );

<pre id=O></pre>
Try:<input id=I><button onclick='test(I.value),I.value=""'>-></button>

Con trăn, 58

max('-1',*input().split(),key=lambda w:len(w)-len(set(w)))

C (167)

double m,k,n=k=2,*O,V[256];char*f(char*c,char*s){return*c?((*O=!((n+=!(*c*=*c!=32))>1.1/modf(*(O=V+*c),&m))*m+1/n+1)>k)?f(c+!!(k=*O),c):f(c+1,s):s?!*s?s+1:f(c,s-1):0;}

THỬ NÓ

CÁI NÀY HOẠT ĐỘNG RA SAO?

• hàm là đệ quy bên trong bên trong một hàm đệ quy khác, hàm bên trong lấy ra phần đầu của chuỗi trong đó một ký tự bao gồm được trả về bởi hàm đầu tiên.
• số lượng tối đa được đưa ra bằng cách băm các ký tự trên bảng ascii.

Q (44 byte)

{w l?0|/l:{max(#:)'[(=)x]}'[w:" "vs"-1 ",x]}

vô dụng

{
    words:" " vs "-1 ",x;
    counts:{max count each group x} each words;
    : words counts ? max counts;
}

Haskell 96 byte

r o=(last.sort.map length$(group.sort)o,o)
w p=n$maximum(map(r)(words p))
n (1,_)="-1"
n (_,w)=w

`` `

rlà một hàm lấy một từ và trả về một tuple (n,w)trong đó nsố lần xuất hiện của char xuất hiện nhiều nhất trong từ đó w. Chẳng hạn x="norep", y="dnredundant", hãy đểr x=(1,norep), r y=(3,ndredundant)

w là một hàm lấy một chuỗi chứa một số từ được phân tách bằng dấu cách và:

1. Tách danh sách trên không gian words p

2. từ foreach tạo một danh sách (n,w)

3. lấy bộ có giá trị lớn nhất n(bộ đếm xuất hiện)

4. Nếu nó có n bằng 1, chỉ cần trả về chuỗi -1, từ đó được lưu trữ trong thành phần thứ hai của bộ dữ liệu).

Ví dụ: lấy p="Today, is the greatest day ever!"

1. sản xuất ["Today,","is","the","greatest","day","ever!"]

2. [(1,"Today,"),(1,"is"),(1,"the"),(2,"greatest"),(1,"day"),(2,"ever!")]

3. (2, "lớn nhất")

4. 2! = 1 thì greatestlà giải pháp!

Pure Bash (không có lệnh bên ngoài) 129 byte

Điều này khá dài, nhưng vẫn so sánh thuận lợi với một số mục dài hơn khác.

m=1
w=-1
for b;{
declare -A a
for((i=0;i<${#b};i++));{
c=${b:$i:1}
let a[$c]++
d=${a[$c]}
((d>m))&&w=$b&&m=$d
}
unset a
}
echo $w

Tôi không hoàn toàn hài lòng với một số cấu tạo, việc phải sử dụng vòng lặp bên trong đó là khó chịu. Bất kỳ đề xuất?