Kürzlich gab es eine Frage zu Stack Overflow, bei der das OP versuchte, eine Funktion zu schreiben, um das Wort in einer Zeichenfolge mit den am häufigsten wiederholten Buchstaben zu finden. Es ist natürlich nicht schwer, einen in Sekunden zu schreiben, und ich habe einen zum Spaß so kurz wie möglich in Javascript geschrieben . Aber ich bin kein Experte für Code-Golf, also frage ich mich, wie viel kürzer dieses einfache Programm sein kann!

Herausforderung

Schreiben Sie ein Programm oder eine Funktion, die eine Wortfolge aufnimmt, und geben Sie das Wort mit den sich am häufigsten wiederholenden Einzelbuchstaben zurück oder drucken Sie es aus.

Regeln:

• Wählen Sie das Wort mit der größten Anzahl an Wiederholungs einzelne Buchstaben (siehe Beispiele unten)

• Wenn kein Wort sich wiederholende Buchstaben enthält, geben Sie -1 zurück.

• Wenn zwei Wörter die gleiche maximale Anzahl sich wiederholender Buchstaben haben, wählen Sie das Wort, das näher am Anfang der Zeichenfolge liegt.

• Die kürzeste Übermittlung in Bytes gewinnt.

Eingang

Nehmen Sie als Eingabe eine Zeichenfolge, die aus einem oder mehreren durch Leerzeichen getrennten Wörtern besteht. Die Eingabe kann über STDIN (oder die nächstgelegene Alternative), Befehlszeilenparameter oder Funktionsargumente erfolgen.

Ausgabe

Drucken Sie die Ausgabe an STDOUT, um sie zurückzugeben.

Beispiele

Betrachten Sie die Zeichenfolge aaabbb cccc. Dies enthält zwei Wörter: aaabbbund cccc. Das Wort aaabbbhat 3 aund 3 bund cccchat 4 c. Die maximale Anzahl wiederholter Buchstaben in aaabbbist also 3 und die maximale Anzahl in cccc4. Wir möchten das Wort mit der maximalen Anzahl wiederholter Einzelbuchstaben auswählen, daher sollte die Ausgabe für aaabbb ccccsein cccc.

Andere Testfälle:

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

C - GCC - 159 145 135 Bytes

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

Wird aktualisiert, wenn ich es etwas abschneiden kann

So kompilieren Sie: gcc -w cg.c.

So führen Sie aus: ./a.out word1 word2 aass ddaaa ssdddd

Ausgabe: ssdddd

No-Output / No-Match: -1

Zuerst habe ich ein bisschen geschummelt, indem ich die Wörter als Programmargumente aufgenommen habe, aber GCC dazu zu bringen, die Wörter zu analysieren und mir eine kostenlose Wortzählung zu geben, war zu viel Belohnung, um darauf zu verzichten.

Wie funktioniert es?

Wir haben 3 verschachtelte Schleifen. Das erste Inkrementieren durch jedes Wort, die nächsten beiden ahmen eine Blasensortierung nach, um Werte zu vergleichen. Der erste Buchstabe wird niemals mit sich selbst verglichen, und jeder nachfolgende Buchstabe wird mit jedem vorherigen Buchstaben verglichen. Immer wenn ein Wort mehr gleiche Buchstaben als ein vorheriges Wort hat, wird das Wort in x gespeichert und die Anzahl der gleichen Buchstaben wird ebenfalls gespeichert.

GCC-Missbrauch

Wir verwenden implizite globale Auto-Int-Delkarationen für unsere ganzen Zahlen. Wir erlauben, dass argv ein int anstelle eines Zeichens ist (derzeit ein Zeichen, dies ist ein TODO). Wir verwenden Standardfunktionen wie Puts und Getchar. Wir verwenden auch den Kommaoperator, um unseren trinären (bedingten) Operator zu überlasten.

Willst du 2 weniger Bytes?

Ersetzen Sie "-1" durch * z und benennen Sie die Datei -1

Programm unverhüllt und ungetestet:

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

Pyth, 14 Bytes

eoeS/LNN+czd_1

Demonstration. Kabelbaum prüfen.

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 Bytes (fehlende -1-Anforderung, gerade bemerkt, aber Zeit zum Schlafen)

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

wie es funktioniert:

Ich nehme

1#

der Wörter indiziert durch

w[

die Indizes in aufsteigender Reihenfolge

>

das Maximum

|/

zählen wo

#:&:

string = char

x=y

für jedes Zeichen in Wort

'x

für jedes Wort, wo w(Wörter) sind

'w:

Die Zeichenfolge wird durch Leerzeichen geteilt

\:x

Offensichtlich habe ich in der englischen Erklärung ein wenig Präzision für Ausdruckskraft und Lesbarkeit geopfert. Ich hoffe es war interessant.

Haskell, 100 Bytes

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

Anwendungsbeispiel: f "Today, is the greatest day ever!"->"greatest"

Wie es funktioniert:

                                                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 Bytes (ungetestet)

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

Dies wird sortOnab Data.ListVersion 4.8.0.0 verwendet, die ich nicht installiert habe, sodass ich sie nicht testen kann.

CJam, 25 Bytes

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

Probieren Sie es online aus

Erläuterung:

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 Bytes

Ziemlich einfache Lösung: Ordnen Sie die Eingabe (umgeben von Anführungszeichen) einfach einem Tupel zu, das das Wort und die Anzahl der wiederholten Zeichen enthält. Ruft das Maximum ab und druckt das Wort aus, wenn der am häufigsten wiederholte Buchstabe überhaupt wiederholt wird, andernfalls wird -1 ausgegeben.

Ich habe 20 (!) Bytes gespart, indem ich die Reihenfolge der Eingabe neu geordnet habe, sodass ich keinen Schlüssel zum Ermitteln der 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 Bytes

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.

Beispiel: a("Today, is the greatest day ever!",R).Ausgänge R = "greatest" ..

JavaScript, 86 111 108 Bytes

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)

Auf jeden Fall golffähig, fügte das Ganze -1 etwa 20 Bytes hinzu.

R, 107 Bytes

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

Dies liest von STDIN und druckt zu STDOUT.

Ungolfed + Erklärung:

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

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

Einfache Codierung. Hier gibt es nichts Besonderes.

C # saugt für Code-Golf: - /

JavaScript ( ES7? ), 99

Unter Verwendung des Array-Verständnisses ist dies in Firefox implementiert, jedoch nicht mehr in EcmaScript 6 enthalten.

Testen Sie mit dem folgenden Snippet (nur 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 und kompatibler

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>

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

VERSUCH ES

WIE FUNKTIONIERT DAS?

• Die Funktion ist innerlich rekursiv innerhalb einer anderen rekursiven Funktion. Die Insider-Funktion ruft den Anfang einer Zeichenfolge ab, bei der ein inklusive Zeichen von der ersten Funktion zurückgegeben wird.
• Die maximale Anzahl wird durch Hashing-Zeichen über einer ASCII-Tabelle angegeben.

Q (44 Bytes)

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

ungolfed

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

Haskell 96 Bytes

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

`` `

rist eine Funktion, die ein Wort nimmt und ein Tupel zurückgibt, (n,w)wobei ndie Anzahl der Vorkommen des am häufigsten vorkommenden Zeichens im Wort ist w. Zum Beispiel x="norep", y="dnredundant"dann lassenr x=(1,norep), r y=(3,ndredundant)

w ist eine Funktion, die eine Zeichenfolge verwendet, die mehrere durch Leerzeichen getrennte Wörter enthält und:

1. Teilen Sie die Liste auf Leerzeichen words p

2. Für jedes Wort erstellen Sie eine Liste von (n,w)

3. nimm das Tupel mit dem größten n(Vorkommenszähler)

4. Wenn n gleich 1 ist, geben Sie einfach die Zeichenfolge zurück -1, andernfalls das Wort selbst (in der zweiten Komponente des Tupels gespeichert).

Zum Beispiel nehmen p="Today, is the greatest day ever!"

1. produziert ["Today,","is","the","greatest","day","ever!"]

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

3. (2, "am größten")

4. 2! = 1 dann greatestist die Lösung!

Pure Bash (keine externen Befehle) 129 Bytes

Dies ist ziemlich lang, aber im Vergleich zu einigen anderen längeren Einträgen immer noch günstig.

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

Ich bin mit einigen Konstrukten nicht ganz zufrieden, es ist ärgerlich, diese innere for-Schleife verwenden zu müssen. Irgendwelche Vorschläge?