Peanut ButterN = 13 などの長さNの文字列を考えてみましょう。文字列にはN-1組の隣接文字があることに注意してください。ためにPeanut Butter12対の最初でありPe、第二はea、最後ですer。

ペアは主に異なる文字である場合は、文字列は、例えば、分厚い品質を持っていますchUnky。
これらのペアがほとんど同じ文字である場合、文字列は滑らかな品質になりsssmmsssます。

ペアの合計数（N-1）に対する2つの異なる文字を持つペアの数の比率になるように、文字列のチャンクネスを定義します。

ペアの合計数（N-1）に対する2つの同一の文字を持つペアの数の比率になるように、文字列の滑らかさを定義します。

たとえば、Peanut Butter同一の文字（tt）のペアが1つしかないため、その滑らかさは1/12または0.0833で、チャンクネスは11/12または0.9167です。

空の文字列と1文字のみの文字列は、100％スムーズで0％チャンキーと定義されます。

チャレンジ

任意の長さの文字列を取り込んで、そのチャンクネスまたはスムーズ比を浮動小数点値として出力するプログラムを作成します。

• stdinまたはコマンドラインを介して入力を取得するか、文字列を取得する関数を作成できます。
• 入力文字列には、印刷可能なASCII文字のみが含まれていると想定できます（したがって、単一行です）。
• floatを標準出力に小数点以下4桁以上で印刷するか、関数を作成した場合に返すように選択できます。情報を伝えない小数点以下の場所は必要ありません。たとえば、の0代わりに使用でき0.0000ます。
• 必要に応じて、チャンクネスまたは滑らかさを選択します。プログラムが出力するものを必ず言ってください。

バイト単位の最短コードが優先されます。

例

Peanut Butter→チャンクネス：0.91666666666、滑らかさ：0.08333333333
chUnky→チャンクネス：1.0、滑らかさ：0.0
sssmmsss→チャンクネス：0.28571428571、滑らかさ：0.71428571428
999→チャンクネス：0.0、滑らかさ：1.0
AA→チャンクネス：0.0、滑らかさ：1.0
Aa→チャンクネス：1.0、滑らかさ：0.0
!→チャンクネス：0.0、滑らかさ：1.0
[空の文字列]→チャンクネス：0.0、滑らかさ：1.0

ボーナス質問：あなたはどちらを好みますか、分厚いか滑らかな文字列ですか？

APL、10バイト

これは標準入力から入力を読み取り、標準出力にチャンクを出力します。このアルゴリズムは、Jソリューションで使用されるものと同じです。

(+/÷⍴)2≠/⍞

CJam、19バイト

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

chunkinessを計算する100％チャンキーソースコード。

このチャンキーな良さをオンラインで試してください。

使い方

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.

明らかに、小数点以下4桁に丸められたNaNは0です。

Pyth、13 12バイト

csJnVztz|lJ1

チャンクネスを計算する完全にチャンキーなコード。

デモンストレーション。 テストハーネス。

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バイト

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,x3x1（1から始まる）number x2で始まり、number x3で終わる文字列の部分文字列seq(を指定し、シーケンスを作成します。

滑らかさの値を与えます。Ans変数は、0私たちが必要としないので、デフォルトでElseのIf陳述、またはへのストア何にもAns事前に。

Matlab（37 36バイト）

これは、チャンクネスを返す次の匿名関数を使用して実行できます。

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

コメント：

• 古いバージョンのMatlab（R2010bなど）では+、char配列xをdouble配列にキャストする必要があります。

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

  しかし、1バイトを節約する最近のバージョン（R2014bでテスト済み）ではそうではありません。彼のコメントをありがとう。

• の式maxは、1文字の場合と0文字の場合を処理します（チャンク性のため）

例：

>> 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バイト

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

このプログラムは、文字列のチャンクネスを返します。

説明

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

以前の送信（37 + 3 = 40バイト）

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

このプログラムは、文字列の滑らかさを返します。入力は-sフラグを介して、例えば

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

C＃、 94 89バイト

サブ100バイトなので、それ自体が何らかの形の勝利だと思いますか？

これは、入力文字列の滑らかさを返す関数定義です（仕様に従って許可されています）。

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

長さが0または1の場合は1を返します。そうでない場合は、文字列と最初の文字を差し引いた文字列を比較し、同一のペアの数をペアの数で割って返します。

編集-サブストリングをスキップに置き換えました。ルーキーの間違い！

J、14 13バイト

チャンクネスを計算します。0 % 00に等しくなるように定義することに対するJへの称賛。

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

オンラインで試す

説明は次のとおりです。

   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バイト

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

説明：

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

これにより、平滑度比が出力されます。

CJam、16バイト

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

滑らかさを計算するチートソースコード。

長さ0または1の入力の場合、これはエラーで終了する前に正しい結果を出力します。Javaインタープリターを使用すると、エラー出力はSTDERRに送られます（あるべきです）。

コードをオンラインで試す場合、出力の最後の行以外はすべて無視してください。

使い方

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.

ジュリア、52バイト

滑らかさ！

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

これにより、文字列を受け入れて数値を返す名前のない関数が作成されます。

入力の長さが2未満の場合、平滑度は1になります。それ以外の場合、論理の配列の平均を取ることにより、同一の隣接する文字の割合を計算します。

Nim、105 96 91バイト

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

ニムを学ぼうとしています。これは、文字列のチャンク性を計算します。

^{（これをPythonとして読み込もうとすると、インデントはすべてめちゃくちゃになります...今ではRubyのように見えます...）}

Python 3、63バイト

これは、引数として文字列を取り、そのチャンクネスを返す匿名ラムダ関数です。

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

使用するには、名前を付けて呼び出します。

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バイト

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

これにより、チャンク性が計算さ-0.0れ、空の文字列が出力されます。負のゼロが気に入らない場合は、追加のバイトでいつでも修正できます。

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

Haskell、64バイト

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

滑らかさを出力します。例f "Peanut Butter"-> 8.333333333333333e-2。

使い方：

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])はxの長さですが、Haskellの強い型システムはに分数を供給する必要があるため/、length整数を返すものは使用できません。整数を小数に変換するのfromInteger$length xは長すぎます。

JavaScript（ES6）、55バイト

滑らかさ、56バイト

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

チャンクネス、55バイト

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

デモ

それが私が好むものであるので、滑らかさを計算します。ES6であるため、現時点ではFirefoxでのみ機能します。

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

滑らかさを返します。

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

説明

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

テスト

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

ルビー、69 66バイト

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

オンラインでお試しください！

IMPからのコメントで数バイト削ります。また、Rubyの次期バージョン2.7.0では|x,y|x!=y、@1!=@2

Python 3、69バイト

まだ誰もPythonソリューションを投稿していないので、ここに「チャンキーネス」関数のかなり簡単な実装を示します。lengthの文字列で短絡し、1出力します0（フロートではなく整数ですが、規則に従って許可されているようです）。

空の文字列では、-0.0ではなく出力します0.0。ほぼ間違いなく、これはreturnとして受け入れられると考えられ-0.0 == 0 == 0.0ますTrue。

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

例：

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

（Python 3は、デフォルトのフロート分割に使用されます。）

C、83バイト

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

chunkinessを返す関数。

説明

float f(char *s) {

C文字列を受け入れて、floatを返します（doubleは機能しますが、charsよりも多くなります）。

int a=0, b=0;

カウンター- a合計ペア、b一致しないペア。を使用intすると、文字列の「任意の長さ」が制限されますが、それは要件に対する軽微な違反に過ぎず、修正するつもりはありません。

if (*s)

特別な場合、空の文字列-両方のカウンターをゼロのままにします。

    while (s[++a])

空ではない文字列-事前インクリメントで繰り返し処理します（したがって、ループを最初に通過するときs[a]は2番目の文字になります。文字列に1文字しかない場合、ループ本体は入力されず、a1になります。

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

現在の文字が前の文字と異なる場合、incrementしますb。

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

ループの後、3つの可能性があります。空の入力の場合は「a == 0、b == 0」、単一文字の入力の場合は「a == 1、b == 0」、または「a> 1、b>複数文字入力の場合= 0。a（?演算子はシーケンスポイントなので安全です）から1を減算し、ゼロの場合は2番目のケースがあるため、ゼロを返す必要があります。それ以外の場合b/aは必要ですが、b最初に浮動小数点型にプロモートする必要があります。そうしないと整数除算が行われます。空の文字列の場合、負のゼロになりますが、ルールはそれを許可しません。

テスト：

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

与えるもの：

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

要求に応じ。

Perl、69

滑らかさを返す関数：

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

説明

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

テスト

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 72バイト

これはサイズについては何も勝ちませんが、簡単です：

滑らかさ

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

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

Out[177]= 0.285714

GeL：76 73文字

滑らかさ。

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

サンプル実行：

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バインディング。はるかに優れていますが、それでも勝つにはほど遠いです。）

GEMA：123の 120文字

滑らかさ。

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

サンプル実行：

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

（浮動小数点数のサポートと一般的に苦痛な算術サポートのない言語でそれを解決する可能性があるかどうかを確認するためのより多くの演習でし\Pた。

Java 8、84 82バイト

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

滑らかさを出力します。

オンラインでお試しください。

説明：

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

ココナッツ、38バイト

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

オンラインでお試しください！

Python 3ポートは50バイトになります。

PowerShell、55バイト

滑らかさ

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

stdinで変数を取得して識別子を与えるのは少しばかげているように見えますが、関数を持つよりも高速です。

Python 3、61バイト

チャンクネスを計算する：

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

K（22）

WooiKentのQソリューションを調整しました。

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

ルビー、63バイト

チャンクを出力します。

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

@danieroのソリューションと似ていますが、文字列の長さ-1で直接除算し、長さ0と1の文字列で.countをゼロにすると、わずかに短縮されます（.maxは0または-1で除算しないことを保証します）。

Mathematica、107バイト

各有向グラフとその逆の間のレーベンシュタイン距離の半分を取ることにより、チャンクネスを計算します。

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

正確な合理的な回答を希望する場合は、ペナルティなしで削除.5し/2て最後の前に配置し&ます。プログラム自体のチャンク性は103/106、つまり約.972です。