Betrachten Sie eine Zeichenfolge der Länge N, wie z Peanut Butter mit N = 13. Beachten Sie, dass die Zeichenfolge N-1 Paare benachbarter Zeichen enthält. Denn Peanut Butterdas erste der 12 Paare ist Pe, das zweite ist ea, das letzte ister .

Wenn es sich bei den Paaren hauptsächlich um verschiedene Zeichen handelt, hat die Zeichenfolge eine klobige Qualität, z chUnky.
Wenn diese Paare zumeist dasselbe Zeichen sind, hat die Zeichenfolge eine glatte Qualität, zsssmmsss .

Definiere das Klumpigkeit eines Strings als das Verhältnis der Anzahl der Paare mit zwei verschiedenen Zeichen zur Gesamtzahl der Paare (N-1).

Definiere das Glätte einer Zeichenfolge als Verhältnis der Anzahl der Paare mit zwei identischen Zeichen zur Gesamtzahl der Paare (N-1).

Beispielsweise, Peanut ButterttHat nur ein Paar mit identischen Zeichen ( ), so beträgt seine Glätte 1/12 oder 0,0833 und seine Klumpigkeit 11/12 oder 0,9167.

Leere Zeichenfolgen und Zeichenfolgen mit nur einem Zeichen werden als 100% glatt und 0% klobig definiert.

Herausforderung

Schreiben Sie ein Programm, das eine Zeichenfolge beliebiger Länge verwendet und entweder das Chunkiness- oder das Smoothness-Verhältnis als Gleitkommawert ausgibt.

• Nehmen Sie die Eingabe über stdin oder die Befehlszeile vor, oder schreiben Sie eine Funktion, die eine Zeichenfolge akzeptiert.
• Sie können davon ausgehen, dass die Eingabezeichenfolge nur druckbare ASCII- Zeichen enthält (und daher einzeilig ist).
• Geben Sie den Gleitkommawert auf 4 oder mehr Dezimalstellen aus, oder geben Sie ihn zurück, wenn Sie eine Funktion geschrieben haben. Nachkommastellen, die keine Informationen übermitteln, sind nicht erforderlich, z. B. 0ist in Ordnung statt 0.0000.
• Wählen Sie nach Belieben Chunkiness oder Smoothness. Stellen Sie nur sicher, welches Ihr Programm ausgibt.

Der kürzeste Code in Bytes gewinnt.

Beispiele

Peanut ButterChunkiness →: 0.91666666666, Glätte: 0.08333333333
chUnky→ chunkiness: 1.0, Glätte: 0.0
sssmmsss→ chunkiness: 0.28571428571, Glätte: 0.71428571428
999→ chunkiness: 0.0, Glätte: 1.0
AA→ chunkiness: 0.0, Glätte: 1.0
Aa→ chunkiness: 1.0, Glätte: 0.0
!→ chunkiness: 0.0, Glätte: 1.0
[empty string] → chunkiness: 0.0, Glätte:1.0

Bonusfrage: Welche bevorzugen Sie , klobige oder glatte Saiten ?

APL, 10 Bytes

Dies liest die Eingabe von stdin und druckt die Chunkiness zu stdout. Der Algorithmus ist der gleiche wie für die J-Lösung.

(+/÷⍴)2≠/⍞

CJam, 19 Bytes

q_1>_@.=:!1b\,d/4mO

100% klobiger Quellcode, der die Klumpigkeit berechnet .

Versuchen Sie diese klobige Güte online.

Wie es funktioniert

q_                  e# Read from STDIN and push a copy.
  1>_               e# Discard the first character and push a copy.
     @              e# Rotate the original on top.
      .=            e# Vectorized comparison (1 if equal, 0 if not).
        :!          e# Mapped logical NOT (0 if equal, 1 if not).
          1b        e# Base 1 conversion (sum).
            \,      e# Swap with the shortened string and push its length.
              d/    e# Cast to double and divide.
                4mO e# Round to four decimal places.

Offensichtlich ist NaN auf 4 Dezimalstellen gerundet 0.

Pyth, 13 12 Bytes

csJnVztz|lJ1

Völlig klobiger Code, der die Klumpigkeit berechnet.

Demonstration. Kabelbaum testen.

csJnVztz|lJ1
                 Implicit: z = input()
   nV            n, !=, vectorized over
     z           z
      tz         z[:-1]
                 V implitly truncates.
  J              Store it in J.
 s               sum J
c                floating point divided by
         |       logical or
          lJ     len(J)
            1    1

TI-BASIC, 46 Bytes

Input Str1
If 2≤length(Str1
mean(seq(sub(Str1,X,1)=sub(Str1,X-1,1),X,2,length(Str1
Ans

sub(x1,x2,x3Gibt den Teilstring eines Strings x1an, der mit der Nummer beginnt (eins) und mit der Nummer x2endet x3, und erstellt dann seq(eine Sequenz.

Gibt den Glättungswert an. Die AnsVariable ist 0standardmäßig, so dass wir nicht ein brauchen , Elseum die IfAussage, oder zum Speichern von etwas Ansvorher.

Matlab ( 37 36 Bytes)

Dies kann mit der folgenden anonymen Funktion erfolgen, die Chunkiness zurückgibt:

f=@(x)nnz(diff(x))/max(numel(x)-1,1)

Bemerkungen:

• In alten Matlab-Versionen (wie R2010b) müssen Sie +das char-Array xin ein double-Array umwandeln :

  f=@(x)nnz(diff(+x))/max(numel(x)-1,1)`
  

  Dies ist jedoch in neueren Versionen (getestet in R2014b) nicht der Fall, wodurch ein Byte eingespart wird. Vielen Dank an Jonas für seinen Kommentar.

• Der Ausdruck mit maxbehandelt die Groß- und Kleinschreibung (für Chunkiness)

Beispiel:

>> f=@(x)nnz(diff(x))/max(numel(x)-1,1)
f = 
    @(x)nnz(diff(x))/max(numel(x)-1,1)

>> f('Peanut Butter')
ans =
   0.9167

> <> , 40 36 Bytes

00ii:0(?v:@=1$-{+{1+}}20.
~:0=+,n;>~

Dieses Programm gibt die Chunkiness eines Strings zurück.

Erläuterung

00i         Push 0 (# unequal pairs), 0 (length of string - 1) and read first char

[main loop]

i           Read a char
:0(?v       If we've hit EOF, go down a row
:@=1$-      Check (new char != previous char)
{+          Add to unequal pairs count
{1+         Increment length by 1
}}20.       Continue loop

[output]

~~          Pop last two chars (top one will be -1 for EOF)
:0=+        Add 1 to length if zero (to prevent division by zero errors)
,           Divide, giving chunkiness
n;          Output and halt

Vorherige Einreichung (37 + 3 = 40 Bytes)

l1)?v1n;
n,$&\l1-}0& \;
l2(?^$:@=&+&>

Dieses Programm gibt die Glätte eines Strings zurück. Die Eingabe erfolgt über das -sFlag, z

py -3 fish.py chunkiness.fish -s "Peanut Butter"

C #, 94 89 Bytes

Sub 100 Bytes, also denke ich, das ist eine Art Sieg für sich?

Dies ist eine Funktionsdefinition (gemäß Spezifikation zulässig), die die Glätte der Eingabezeichenfolge zurückgibt :

Func<string,float>(s=>s.Length>1?s.Zip(s.Skip(1),(a,b)=>a==b?1f:0).Sum()/(s.Length-1):1);

Ziemlich einfach, wenn die Länge 0 oder 1 ist, gibt es 1 zurück, andernfalls vergleicht es die Zeichenkette mit sich selbst abzüglich des ersten Zeichens und gibt dann die Anzahl identischer Paare dividiert durch die Anzahl der Paare zurück.

Bearbeiten - Ersetzte Teilzeichenfolge durch Überspringen. Anfängerfehler!

J, 14 13 Bytes

Berechnet die Chunkiness. Ein großes Lob an J für die Definition 0 % 0, dass er gleich 0 ist.

(]+/%#)2~:/\]

Probieren Sie es online aus

Hier ist eine Erklärung:

   NB. sample input
   in =. 'sssmmsss'

   NB. all infixes of length 2
   2 ]\ in
ss
ss
sm
mm
ms
ss
ss

    NB. are the parts of the infix different?
    2 ~:/\ in
0 0 1 0 1 0 0

    NB. sum and item count of the previous result
    (+/ , #) 2 ~:/\ in
2 7

    NB. arithmetic mean: chunkiness
    (+/ % #) 2 ~:/\ in
0.285714

    NB. as a tacit verb
    (] +/ % #) 2 ~:/\ ]

    NB. 0 divided by 0 is 0 in J
    0 % 0
0

CJam, 23 Bytes

q_,Y<SS+@?2ew_::=:+\,d/

Erläuterung:

q                           e# read input
 _,                         e# its length
   Y<                       e# is less than 2?
     SS+                    e# then a smooth string
        @?                  e# otherwise the input
          2ew               e# pairs of consecutive characters
             _::=           e# map to 1 if equal, 0 if not
                 :+         e# sum (number of equal pairs)
                   \,       e# total number of pairs
                     d/     e# divide

Dies gibt das Glättungsverhältnis aus.

CJam, 16 Bytes

1q2ew::=_:+\,d/*

Cheaty Quellcode, der Glätte berechnet .

Bei Eingaben der Länge 0 oder 1 wird das richtige Ergebnis ausgegeben, bevor der Vorgang mit einem Fehler beendet wird. Mit dem Java-Interpreter wird die Fehlerausgabe an STDERR gesendet ( wie es sollte ).

Wenn Sie den Code online ausprobieren , ignorieren Sie einfach alles außer der letzten Ausgabezeile.

Wie es funktioniert

1q               e# Push a 1 and read from STDIN.
  2ew            e# Push the overlapping slices of length 2.
                 e# This will throw an error for strings of length 0 or 1,
                 e# so the stack (1) is printed and the program finishes.
     ::=         e# Twofold vectorized comparision.
        _:+      e# Push a copy and add the Booleans.
           \,    e# Swap with the original and compute its length.
             d/  e# Cast to double and divide.
               * e# Multiply with the 1 on the bottom of the stack.

Julia, 52 Bytes

Glätte!

s->(n=length(s))<2?1:mean([s[i]==s[i+1]for i=1:n-1])

Dadurch wird eine unbenannte Funktion erstellt, die eine Zeichenfolge akzeptiert und einen numerischen Wert zurückgibt.

Wenn die Länge der Eingabe kleiner als 2 ist, ist die Glätte 1, andernfalls berechnen wir den Anteil identischer benachbarter Zeichen aus dem Mittelwert eines Arrays von Logikzeichen.

Nim, 105 96 91 Bytes

proc f(s):any=
 var a=0;for i,c in s[.. ^2]:a+=int(s[i+1]!=c)
 a.float/max(s.len-1,1).float

Ich versuche Nim zu lernen. Dies berechnet die Chunkiness eines Strings.

^{( Wenn ich versuche, dies als Python zu lesen, sieht der Einzug völlig durcheinander aus ... Jetzt sieht er eher aus wie Ruby ...)}

Python 3, 63 Bytes

Dies ist eine anonyme Lambda-Funktion, die einen String als Argument verwendet und dessen Klumpigkeit zurückgibt.

lambda n:~-len(n)and sum(x!=y for x,y in zip(n,n[1:]))/~-len(n)

Um es zu benutzen, gib ihm einen Namen und rufe es an.

f=lambda n:~-len(n)and sum(x!=y for x,y in zip(n,n[1:]))/~-len(n)
f("Peanut Butter") -> 0.08333333333333333
f("!")             -> 0
f("")              -> -0.0

Python 3, 52 Bytes

lambda s:sum(map(str.__ne__,s,s[1:]))/(len(s)-1or 1)

Dies berechnet die Chunkiness und gibt -0.0die leere Zeichenfolge aus. Wenn Sie negative Nullen nicht mögen, können Sie dies jederzeit mit einem zusätzlichen Byte beheben:

lambda s:sum(map(str.__ne__,s,s[1:]))/max(len(s)-1,1)

Haskell, 64 Bytes

f[]=1
f[_]=1
f x=sum[1|(a,b)<-zip=<<tail$x,a==b]/(sum(x>>[1])-1)

Gibt Glätte aus. zB f "Peanut Butter"-> 8.333333333333333e-2.

Wie es funktioniert:

f[]=1                               -- special case: empty list
f[_]=1                              -- special case: one element list

f x=                                -- x has at least two elements
         (a,b)<-zip=<<tail$x        -- for every pair (a,b), drawn from zipping x with the tail of itself
                            ,a==b   -- where a equals b
      [1|                        ]  -- take a 1
   sum                              -- and sum it
              /                     -- divide  by
                   (x>>[1])         -- map each element of x to 1
               sum                  -- sum it
                           -1       -- and subtract 1

sum(x>>[1])ist die Länge von x, aber da Haskells starkes Typensystem die Eingabe von Brüchen erfordert /, kann ich nicht verwenden, lengthwelche Ganzzahlen zurückgeben. Die Konvertierung von ganzen Zahlen in Bruchzahlen über fromInteger$length xist viel zu lang.

JavaScript (ES6), 55 Byte

Glätte 56 Bytes

f=x=>(z=x.match(/(.)(?=\1)/g))?z.length/--x.length:+!x[1]

Chunkiness, 55 Bytes

f=x=>(z=x.match(/(.)(?!\1)/g))&&--z.length/--x.length||0

Demo

Berechnet die Glätte, da ist es das, was ich bevorzuge. Funktioniert momentan nur in Firefox, da es sich um ES6 handelt.

f=x=>(z=x.match(/(.)(?=\1)/g))?z.length/--x.length:+!x[1]

O.innerHTML += f('Peanut Butter') + '\n';
O.innerHTML += f('chUnky') + '\n';
O.innerHTML += f('sssmmsss') + '\n';
O.innerHTML += f('999') + '\n';
O.innerHTML += f('AA') + '\n';
O.innerHTML += f('Aa') + '\n';
O.innerHTML += f('!') + '\n';
O.innerHTML += f('') + '\n';

<pre id=O></pre>

KDB (Q), 30

Gibt Glätte zurück.

{1^sum[x]%count x:1_(=':)(),x}

Erläuterung

                         (),x    / ensure input is always list
                x:1_(=':)        / check equalness to prev char and reassign to x
   sum[x]%count                  / sum equalness divide by count N-1
 1^                              / fill null with 1 since empty/single char will result in null
{                             }  / lamdba

Prüfung

q){1^sum[x]%count x}1_(=':)(),x}"Peanut Butter"
0.08333333
q){1^sum[x]%count x:1_(=':)(),x}"sssmmsss"
0.7142857
q){1^sum[x]%count x:1_(=':)(),x}"Aa"
0f
q){1^sum[x]%count x:1_(=':)(),x}"aa"
1f
q){1^sum[x]%count x:1_(=':)(),x}"chUnky"
0f
q){1^sum[x]%count x:1_(=':)(),x}"!"
1f
q){1^sum[x]%count x:1_(=':)(),x}""
1f

Ruby , 69 66 Bytes

->s{(c=s.chars.each_cons(2).count{|x,y|x!=y}.to_f/~-s.size)>0?c:0}

Probieren Sie es online!

Shaved of a few bytes with comments from IMP. Also, with the upcoming version 2.7.0 of Ruby it's possible to save some bytes by replacing |x,y|x!=y with @1!=@2

Python 3, 69 Bytes

Bislang hat noch niemand eine Python-Lösung veröffentlicht. Hier ist eine recht einfache Implementierung einer "Chunkiness" -Funktion. Es 1schließt auf einer Reihe von Längen kurz und druckt0 (which is an integer rather than a float but seems to be allowed according to the rules).

Bei einer leeren Zeichenfolge wird -0.0eher als ausgegeben 0.0. Wohl ist dies könnte als akzeptabel angesehen werden, als -0.0 == 0 == 0.0zurückkehrt True.

def c(s):l=len(s)-1;return l and sum(s[i]!=s[i+1]for i in range(l))/l

Beispiele:

>>> c(''); c('a'); c('aaa'); c("Peanut Butter")
-0.0
0
0.0
0.916666666667
>>> -0.0 == 0 == 0.0
True

(Python 3 wird für die Standard-Float-Division verwendet.)

C 83 Bytes

float f(char*s){int a=0,b=0;if(*s)while(s[++a])b+=s[a]!=s[a-1];return--a?1.*b/a:b;}

Eine Funktion, die Klumpen zurückgibt .

Erläuterung

float f(char *s) {

Akzeptieren Sie einen C-String und geben Sie einen float zurück (double würde funktionieren, ist aber mehr Zeichen).

int a=0, b=0;

Zähler - afür Gesamtpaare, bfür nicht übereinstimmende Paare. Durch intdie Verwendung wird die "willkürliche Länge" der Zeichenfolge begrenzt, dies ist jedoch nur eine geringfügige Verletzung der Anforderungen, und ich werde es nicht beheben.

if (*s)

Sonderfall die leere Zeichenfolge - lassen Sie beide Zähler auf Null.

    while (s[++a])

Nicht leere Zeichenfolge - durchlaufen Sie die Zeichenfolge mit einem vorbereitenden Inkrement (also wird beim ersten Durchlaufen der Schleife s[a]das zweite Zeichen verwendet. Wenn die Zeichenfolge nur ein Zeichen enthält, wird der Schleifenkörper nicht eingegeben und aist 1.

        b += s[a]!=s[a-1];

Wenn sich das aktuelle Zeichen vom vorherigen unterscheidet, erhöhen Sie es b.

return --a ? 1.*b/a : b;
}

Nach der Schleife gibt es drei Möglichkeiten: 'a == 0, b == 0' für eine leere Eingabe, 'a == 1, b == 0' für eine Eingabe mit einem Zeichen oder 'a> 1, b> = 0 'für die Eingabe mehrerer Zeichen. Wir subtrahieren 1 von a(der ?Operator ist ein Sequenzpunkt, damit wir sicher sind), und wenn es Null ist, haben wir den zweiten Fall, also sollten wir Null zurückgeben. Andernfalls b/aist es das , was wir wollen, aber wir müssen zuerst bauf einen Gleitkommatyp heraufstufen, sonst erhalten wir eine Ganzzahldivision. Für eine leere Zeichenfolge erhalten wir eine negative Null, aber die Regeln verbieten dies nicht.

Tests:

#include <stdio.h>
int main(int argc, char **argv)
{
    while (*++argv)
        printf("%.6f %s\n", f(*argv), *argv);
}

Welches gibt:

./chunky 'Peanut Butter' chUnky sssmmsss 999 AA Aa '!' ''
0.916667 Peanut Butter
1.000000 chUnky
0.285714 sssmmsss
0.000000 999
0.000000 AA
1.000000 Aa
0.000000 !
-0.000000 

nach Bedarf.

Perl, 69

Funktion, die Glätte zurückgibt :

sub f{($_)=@_;$s=s/(.)(?!\1)//sgr;chop;!$_||length($s)/length;}

Erläuterung

sub f {
    # read argument into $_
    ($_) = @_;

    # copy $_ to $s, removing any char not followed by itself
    # /s to handle newlines as all other characters
    $s = s/(.)(?!\1)//sgr;

     # reduce length by one (unless empty)
    chop;

    # $_ is empty (false) if length was 0 or 1
    # return 1 in that case, else number of pairs / new length
    !$_ || length($s)/length;
}

Tests

printf "%.6f %s\n", f($a=$_), $a foreach (@ARGV);

0.083333 Peanut Butter
0.000000 chUnky
0.714286 sssmmsss
1.000000 999
1.000000 AA
0.000000 Aa
1.000000 !
1.000000 

Mathematica, 73 Bytes

Das bringt nichts für die Größe, aber es ist ganz einfach:

Glätte

N@Count[Differences@#,_Plus]/(Length@#-1)&@StringSplit[#,""]&

In[177]:= N@Count[Differences@#,_Plus]/(Length@#-1)&@StringSplit[#,""] &@"sssmmsss"

Out[177]= 0.285714

GeL: 76 73 Zeichen

Glätte.

@set{d;0}
?\P$1=@incr{d}
?=
\Z=@lua{c=@column -1\;return c<1and 1or $d/c}

Probelauf:

bash-4.3$ for i in 'Peanut Butter' 'chUnky' 'sssmmsss' '999' 'AA' 'Aa' '!' ''; do
>     echo -n "$i -> "
>     echo -n "$i" | gel -f smooth.gel
>     echo
> done
Peanut Butter -> 0.083333333333333
chUnky -> 0
sssmmsss -> 0.71428571428571
999 -> 1
AA -> 1
Aa -> 0
! -> 1
 -> 1

(GeL = Gema + Lua-Bindungen. Viel besser, aber noch lange nicht gewonnen.)

Gema: 123 120 Zeichen

Glätte.

@set{d;0}
?\P$1=@incr{d}
?=
\Z=@subst{\?\*=\?.\*;@cmpn{@column;1;10;10;@fill-right{00000;@div{$d0000;@sub{@column;1}}}}}

Probelauf:

bash-4.3$ for i in 'Peanut Butter' 'chUnky' 'sssmmsss' '999' 'AA' 'Aa' '!' ''; do
>     echo -n "$i -> "
>     echo -n "$i" | gema -f smooth.gema
>     echo
> done
Peanut Butter -> 0.0833
chUnky -> 0.0000
sssmmsss -> 0.7142
999 -> 1.0000
AA -> 1.0000
Aa -> 0.0000
! -> 1.0
 -> 1.0

(War für mich eher eine Übung, um zu sehen, wie hoch die Chancen sind, sie in einer Sprache ohne Gleitkommazahlunterstützung und allgemein schmerzhafte Rechenunterstützung zu lösen. Die zweite Zeile, insbesondere die \PSequenz, ist reine Magie, die letzte Zeile ist echte Folter.)

Java 8, 84 82 Bytes

s->{float l=s.length()-1,S=s.split("(.)(?=\\1)").length-1;return l<1?1:S<1?0:S/l;}

Gibt Glätte aus.

Probieren Sie es online aus.

Erläuterung:

s->{                     // Method with String parameter and float return-type
  float l=s.length()-1,  //  Length of the input-String minus 1 (amount of pairs in total)
        S=s.split("(.)(?=\\1)").length-1;
                         //  Length of the input split by duplicated pairs (with lookahead)
  return l<1?            //  If the length of the input is either 0 or 1:
          1              //   Return 1
         :S<1?           //  Else-if `S` is -1 or 0:
          0              //   Return 0
         :               //  Else:
          S/l;}          //   Return duplicated pairs divided by the length-1

Kokosnuss , 38 Bytes

s->sum(map((!=),s,s[1:]))/-~len(s[2:])

Probieren Sie es online!

Ein Python 3-Port wäre 50 Bytes .

PowerShell, 55 Byte

Glätte

%{$s=$_;@([char[]]$s|?{$_-eq$a;$a=$_;$i++}).count/--$i}

Scheint ein bisschen albern, eine Variable in stdin zu bekommen und ihr dann einen Bezeichner zu geben, aber es ist schneller als eine Funktion zu haben.

Python 3, 61 Bytes

Berechnen Sie die Chunkiness:

f=lambda s: sum(a!=b for a,b in zip(s,s[1:]))/max(len(s)-1,1)

K (22)

Die Q-Lösung von WooiKent wurde überarbeitet:

{1^(+/x)%#x:1_=':(),x}

Rubin, 63 Bytes

Gibt Chunkiness aus.

f=->s{s.chars.each_cons(2).count{|x,y|x!=y}/[s.size-1.0,1].max}

Ähnlich wie bei der Lösung von @ daniero, jedoch leicht verkürzt durch direktes Teilen durch die Zeichenfolgenlänge - 1 und anschließendes Verlassen auf .count auf Null bei Zeichenfolgen der Länge 0 und 1 (mit .max wird sichergestellt, dass ich nicht durch 0 oder -1 dividiere).

Mathematica, 107 Bytes

Berechnet die Klumpigkeit, indem die Hälfte des Levenshtein-Abstands zwischen jedem Digraphen und seiner Rückseite genommen wird.

f[s_]:=.5EditDistance@@{#,StringReverse@#}&/@StringCases[s,_~Repeated~{2},Overlaps->All]//Total@#/Length[#]&

Wenn Sie eine genaue rationale Antwort bevorzugen, löschen Sie .5und platzieren Sie ein /2vor dem letzten &für keine Strafe. Das Programm selbst hat Chunkiness 103/106 oder ungefähr .972.