พิจารณาสตริงที่มีความยาว N เช่นPeanut ButterN = 13 ขอให้สังเกตว่ามีอักขระ N-1 คู่ที่อยู่ติดกันในสตริง สำหรับPeanut Butterครั้งแรกของ 12 คู่เป็นPeที่สองคือการมีที่ผ่านมาeaer

chUnkyเมื่อคู่เป็นตัวละครที่แตกต่างกันส่วนใหญ่สตริงมีคุณภาพอ้วนเช่น เมื่อคู่เหล่านี้ส่วนใหญ่จะเป็นตัวละครเดียวกันสตริงที่มีคุณภาพได้อย่างราบรื่นเช่น
sssmmsss

กำหนดความหนาของสตริงเป็นอัตราส่วนของจำนวนคู่ที่มีอักขระสองตัวที่แตกต่างกันต่อจำนวนคู่ทั้งหมด (N-1)

กำหนดความนุ่มนวลของสตริงให้เป็นอัตราส่วนของจำนวนคู่ที่มีอักขระสองตัวที่เหมือนกันต่อจำนวนคู่ทั้งหมด (N-1)

ตัวอย่างเช่นPeanut Butterมีเพียงหนึ่งคู่ที่มีอักขระเหมือนกัน ( tt) ดังนั้นความลื่นของมันคือ 1/12 หรือ 0.0833 และความหนาของมันคือ 11/12 หรือ 0.9167

สตริงและสตริงที่ว่างเปล่าที่มีอักขระเพียงตัวเดียวเท่านั้นที่ถูกกำหนดให้มีความราบรื่น 100% และเป็นก้อน 0%

ท้าทาย

เขียนโปรแกรมที่ใช้สตริงที่มีความยาวตามอำเภอใจและส่งผลให้อัตราส่วนความต่อเนื่องหรือความราบรื่นเป็นค่าทศนิยม

• รับอินพุตผ่าน stdin หรือบรรทัดคำสั่งหรือคุณอาจเขียนฟังก์ชันที่รับสตริง
• คุณสามารถสมมติว่าสตริงอินพุตมีอักขระ ASCII ที่พิมพ์ได้เท่านั้น(และเป็นบรรทัดเดียว)
• พิมพ์ทศนิยมเพื่อ stdout ถึง 4 หรือมากกว่าตำแหน่งทศนิยมหรือคุณสามารถเลือกที่จะกลับมาถ้าคุณเขียนฟังก์ชั่น ตำแหน่งทศนิยมที่ถ่ายทอดไม่มีข้อมูลที่ไม่จำเป็นเช่นจะปรับแทน00.0000
• เลือกความนุ่มหรือเรียบตามที่คุณต้องการ เพียงแค่บอกว่าโปรแกรมของคุณออกมาไหน

รหัสที่สั้นที่สุดในหน่วยไบต์ชนะ

ตัวอย่าง

Peanut Butter→ Chunkiness: 0.91666666666เรียบ: 0.08333333333
chUnky→ Chunkiness: 1.0เรียบ: 0.0
sssmmsss→ Chunkiness: 0.28571428571เรียบ: 0.71428571428
999→ Chunkiness: 0.0เรียบ: 1.0
AA→ Chunkiness: 0.0เรียบ: 1.0
Aa→ Chunkiness: 1.0เรียบ: 0.0
!→ Chunkiness: 0.0เรียบ: 1.0
[ว่างสตริง] → Chunkiness: 0.0, เรียบ:1.0

คำถามโบนัส: ท่านใดที่ต้องการ,อ้วนหรือเรียบสตริง?

APL, 10 ไบต์

สิ่งนี้อ่านอินพุตจาก stdin และพิมพ์ chunkiness ไปที่ stdout อัลกอริทึมเป็นวิธีเดียวกับที่ใช้สำหรับโซลูชัน J

(+/÷⍴)2≠/⍞

CJam, 19 ไบต์

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

รหัสที่มาอ้วน 100% ที่คำนวณchunkiness

ลองสิ่งที่ดีงามทางออนไลน์

มันทำงานอย่างไร

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.

เห็นได้ชัดว่า NaN ปัดเศษเป็นทศนิยม 4 ตำแหน่งคือ 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,x3ให้สตริงย่อยของการx1เริ่มต้นสตริง(หนึ่งตาม) ที่จำนวนx2และสิ้นสุดที่หมายเลขx3จากนั้นseq(สร้างลำดับ

ให้ค่าความเรียบเนียน Ansตัวแปร0โดยปริยายดังนั้นเราจึงไม่จำเป็นต้องElseไปที่Ifคำสั่งหรือการจัดเก็บอะไรให้Ansก่อน

Matlab ( 37 36 ไบต์)

สิ่งนี้สามารถทำได้ด้วยฟังก์ชันที่ไม่ระบุชื่อต่อไปนี้ซึ่งคืนค่าความหนา

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

ความคิดเห็นที่:

• ใน Matlab เวอร์ชั่นเก่า (เช่น R2010b) คุณจะต้อง+ใช้อาเรย์ถ่านxไปเป็นอาร์เรย์คู่:

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

  แต่ไม่ใช่ในรุ่นล่าสุด (ทดสอบใน R2014b) ซึ่งบันทึกหนึ่งไบต์ ขอบคุณ Jonas สำหรับความคิดเห็นของเขา

• การแสดงออกด้วย maxจัดการกรณีหนึ่งตัวละครและศูนย์ตัวละคร (สำหรับความกล้าหาญ)

ตัวอย่าง:

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

โปรแกรมนี้ส่งคืน chunkiness ของสตริง

คำอธิบาย

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 ไบต์

Sub 100 bytes ดังนั้นฉันเดาว่ามันเป็นชัยชนะในรูปแบบนั้นเอง?

นี่คือนิยามฟังก์ชั่น (ได้รับอนุญาตตามสเป็ค) ซึ่งจะส่งกลับความเรียบของสายป้อน:

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 ไบต์

คำนวณความอ้วน Kudos ถึง J สำหรับกำหนด0 % 0ให้เท่ากับ 0

(]+/%#)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/*

รหัสที่มา Cheaty ที่คำนวณเรียบเนียน

สำหรับอินพุตที่มีความยาว 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 มิฉะนั้นเราจะคำนวณสัดส่วนของอักขระที่อยู่ติดกันเหมือนกันโดยใช้ค่าเฉลี่ยของอาร์เรย์ของโลจิคัล

นิมิต, 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 แต่เนื่องจากระบบประเภท strong ของ 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

การสาธิต

คำนวณความนุ่มนวลตามที่ฉันต้องการ ใช้งานได้กับ Firefox ในตอนนี้เท่านั้นเนื่องจากเป็น ES6

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

Ruby , 69 66 ไบต์

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

ลองออนไลน์!

โกนสักสองสามไบต์ด้วยความคิดเห็นจาก IMP นอกจากนี้เมื่อใช้ทับทิมรุ่น 2.7.0 ที่กำลังจะมาถึงคุณสามารถบันทึกไบต์ได้ด้วยการแทนที่|x,y|x!=yด้วย@1!=@2

Python 3, 69 ไบต์

ยังไม่มีใครโพสต์โซลูชัน Python ดังนั้นนี่คือการใช้งานฟังก์ชั่น "chunkiness" ที่ค่อนข้างตรงไปตรงมา มันลัดวงจรบนสายยาว1และพิมพ์0 (ซึ่งเป็นจำนวนเต็มแทนที่จะเป็นแบบลอย แต่ดูเหมือนว่าจะได้รับอนุญาตตามกฎ)

บนสตริงที่ว่างเปล่ามันจะออกผลลัพธ์มากกว่า-0.0 0.0เนื้อหานี้ถูกอาจจะถือว่าได้รับการยอมรับเป็นผลตอบแทน-0.0 == 0 == 0.0True

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 จะได้ผล แต่มีตัวอักษรมากกว่า)

int a=0, b=0;

ตัวนับ - aสำหรับคู่ทั้งหมดสำหรับคู่ที่bไม่ตรงกัน การใช้intจำกัด "ความยาวโดยพลการ" ของสตริง แต่นั่นเป็นเพียงการละเมิดข้อกำหนดเล็กน้อยและฉันจะไม่แก้ไข

if (*s)

กรณีพิเศษสตริงว่าง - ปล่อยให้ทั้งสองศูนย์

    while (s[++a])

สตริงที่ไม่ว่าง - วนซ้ำโดยเพิ่มล่วงหน้า (ดังนั้นครั้งแรกที่ผ่านลูปs[a]จะเป็นอักขระที่สองหากสตริงมีอักขระเพียงตัวเดียวจะไม่ป้อนเนื้อความลูปและaจะเป็น 1

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

bถ้าตัวละครในปัจจุบันแตกต่างจากก่อนหน้านี้ที่เพิ่มขึ้น

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

หลังจากวนรอบมีความเป็นไปได้สามประการ: 'a == 0, b == 0' สำหรับอินพุตว่าง, 'a == 1, b == 0' สำหรับอินพุตอักขระเดี่ยวหรือ 'a> 1, b> = 0 'สำหรับอินพุตหลายอักขระ เราลบ 1 จากa(ตัว?ดำเนินการคือจุดลำดับดังนั้นเราจึงปลอดภัย) และถ้าเป็นศูนย์เรามีกรณีที่สองดังนั้นควรคืนค่าเป็นศูนย์ มิฉะนั้น,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 bindings ดีกว่ามาก แต่ก็ยังห่างไกลจากการชนะ)

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

(เป็นการออกกำลังกายมากขึ้นสำหรับฉันที่จะเห็นว่าอะไรคือโอกาสในการแก้ปัญหาในภาษาที่ไม่มีการสนับสนุนจำนวนจุดลอยตัวและการสนับสนุนทางคณิตศาสตร์ที่เจ็บปวดโดยทั่วไปบรรทัดที่ 2 โดยเฉพาะ\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:])

ลองออนไลน์!

หลาม 3 พอร์ตจะเป็น50 ไบต์

PowerShell ขนาด 55 ไบต์

เรียบเนียน

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

ดูเหมือนโง่เล็กน้อยที่จะได้รับตัวแปรใน stdin แล้วให้มันเป็นตัวระบุ แต่มันเร็วกว่ามีฟังก์ชั่น

Python 3, 61 Bytes

คำนวณความหนา:

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

K (22)

tweaked โซลูชัน Q ของ WooiKent:

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

Ruby, 63 ไบต์

เอาท์พุทเป็นก้อน

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

คล้ายกับโซลูชันของ @ daniero แต่สั้นลงเล็กน้อยโดยแบ่งโดยตรงด้วยความยาวสตริง - 1 จากนั้นพึ่งพา. นับเป็นศูนย์ที่มีความยาว 0 และ 1 สตริง (. max ทำให้แน่ใจว่าฉันจะไม่หารด้วย 0 หรือ -1)

Mathematica, 107 ไบต์

คำนวณความเป็นก้อนโดยใช้ระยะทางครึ่งหนึ่งของเลเวนส์เทนระหว่างแต่ละกราฟและจุดกลับด้าน

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

หากคุณต้องการคำตอบที่สมเหตุสมผลให้ลบ.5และวาง/2ก่อนหน้านั้นโดย&ไม่มีการลงโทษ โปรแกรมนี้มีความหนา 103/106 หรือประมาณ. 972