Hãy xem xét một chuỗi có độ dài N, chẳng hạn như Peanut Buttervới N = 13. Lưu ý rằng có N-1 cặp ký tự lân cận trong chuỗi. Đối với Peanut Butter, cặp đầu tiên trong số 12 cặp là Pe, cặp thứ hai là ea, cặp cuối cùng là er.

Khi các cặp chủ yếu là các ký tự khác nhau, chuỗi có chất lượng chunky, ví dụ chUnky.
Khi các cặp này chủ yếu là cùng một ký tự, chuỗi có chất lượng trơn tru, ví dụ sssmmsss.

Xác định độ chói của một chuỗi là tỷ lệ của số cặp có hai ký tự khác nhau trên tổng số cặp (N-1).

Xác định độ mịn của chuỗi là tỷ lệ của số cặp có hai ký tự giống hệt nhau trên tổng số cặp (N-1).

Ví dụ: Peanut Butterchỉ có một cặp có các ký tự giống hệt nhau ( tt), do đó độ mịn của nó là 1/12 hoặc 0,0833 và độ chụm của nó là 11/12 hoặc 0,9167.

Chuỗi rỗng và chuỗi chỉ có một ký tự được xác định là mịn 100% và chunky 0%.

Thử thách

Viết chương trình lấy một chuỗi có độ dài tùy ý và đưa ra tỷ lệ độ mịn hoặc độ mịn của nó dưới dạng giá trị dấu phẩy động.

• Lấy đầu vào thông qua stdin hoặc dòng lệnh, hoặc bạn có thể viết một hàm lấy một chuỗi.
• Bạn có thể giả sử chuỗi đầu vào chỉ chứa các ký tự ASCII có thể in được (và do đó là một dòng).
• In dấu phao tới thiết bị xuất chuẩn đến 4 vị trí thập phân trở lên hoặc bạn có thể chọn trả về nếu bạn đã viết một hàm. Các vị trí thập phân không truyền tải thông tin là không bắt buộc, ví dụ như 0là tốt thay vì 0.0000.
• Chọn độ chần hoặc mịn như bạn muốn. Chỉ cần chắc chắn để nói cái nào chương trình của bạn đầu ra.

Mã ngắn nhất tính bằng byte thắng.

Ví dụ

Peanut Butter→ Chunkiness: 0.91666666666, Smoothness: 0.08333333333
chUnky→ Chunkiness: 1.0, Smoothness: 0.0
sssmmsss→ Chunkiness: 0.28571428571, Smoothness: 0.71428571428
999→ Chunkiness: 0.0, Smoothness: 1.0
AA→ Chunkiness: 0.0, Smoothness: 1.0
Aa→ Chunkiness: 1.0, Smoothness: 0.0
!→ Chunkiness: 0.0, Smoothness: 1.0
[trống chuỗi] → Chunkiness: 0.0, Độ mịn:1.0

Câu hỏi thưởng: Bạn thích loại nào , dây chunky hay trơn ?

APL, 10 byte

Điều này đọc đầu vào từ stdin và in sự chunkness đến stdout. Thuật toán là cùng một thuật toán được sử dụng cho giải pháp J.

(+/÷⍴)2≠/⍞

CJam, 19 byte

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

100% mã nguồn chunky tính toán độ chói .

Hãy thử lòng tốt chunky trực tuyến này.

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

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.

Rõ ràng, NaN làm tròn đến 4 chữ số thập phân là 0.

Bình thường, 13 12 byte

csJnVztz|lJ1

Mã chunky đầy đủ tính chunkky.

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

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 byte

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đưa ra chuỗi con của chuỗi x1bắt đầu (dựa trên một) ở số x2và kết thúc ở số x3, sau đó seq(xây dựng một chuỗi.

Cho giá trị độ mịn. Các Ansbiến là 0theo mặc định, vì vậy chúng tôi không cần phải có Elseđể các Iftuyên bố, hoặc để lưu trữ bất cứ điều gì để Anstrước.

Matlab ( 37 36 byte)

Điều này có thể được thực hiện với hàm ẩn danh sau, trả về độ chói:

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

Bình luận:

• Trong các phiên bản Matlab cũ (như R2010b), bạn cần +truyền mảng char xthành một mảng kép:

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

  Nhưng đó không phải là trường hợp trong các phiên bản gần đây (được thử nghiệm trong R2014b), giúp tiết kiệm một byte. Cảm ơn Jonas cho nhận xét của mình.

• Biểu thức maxxử lý các trường hợp một ký tự và không có ký tự (cho độ chói)

Thí dụ:

>> 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 byte

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

Chương trình này trả về độ chói của một chuỗi.

Giải trình

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

Gửi trước đó (37 + 3 = 40 byte)

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

Chương trình này trả về độ trơn của chuỗi. Đầu vào là thông qua -scờ, vd

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

C #, 94 89 byte

Sub 100 byte, vì vậy tôi đoán đó là một hình thức chiến thắng trong chính nó?

Đây là một định nghĩa hàm (được cho phép theo thông số kỹ thuật) trả về độ mượt của chuỗi đầu vào:

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

Khá đơn giản, nếu độ dài là 0 hoặc 1, nó trả về 1, nếu không, nó sẽ so sánh chuỗi với chính ký tự đầu tiên, sau đó trả về số lượng các cặp giống nhau chia cho số lượng cặp.

Chỉnh sửa - thay thế Chuỗi con bằng Bỏ qua. Lỗi tân binh!

J, 14 13 byte

Tính toán độ chói. Kudos đến J để xác định 0 % 0bằng 0.

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

Dùng thử trực tuyến

Đây là một lời giải thích:

   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 byte

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

Giải trình:

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

Điều này tạo ra tỷ lệ mịn.

CJam, 16 byte

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

Mã nguồn gian lận mà tính toán độ trơn tru .

Đối với các đầu vào có độ dài 0 hoặc 1, điều này sẽ in kết quả chính xác trước khi thoát với một lỗi. Với trình thông dịch Java, đầu ra lỗi chuyển sang STDERR ( nếu cần ).

Nếu bạn thử mã trực tuyến , chỉ cần bỏ qua mọi thứ trừ dòng đầu ra cuối cùng.

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

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 byte

Mịn màng!

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

Điều này tạo ra một hàm không tên chấp nhận một chuỗi và trả về một giá trị số.

Nếu độ dài của đầu vào nhỏ hơn 2, độ mịn là 1, nếu không, chúng ta tính tỷ lệ của các ký tự liền kề giống hệt nhau bằng cách lấy giá trị trung bình của một mảng logic.

Nim, 105 96 91 byte

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

Cố gắng học Nim. Điều này tính toán độ chói của một chuỗi.

^{( Nếu tôi cố đọc nó khi Python thì vết lõm trông có vẻ rối tung ... Bây giờ nó trông giống Ruby hơn ...)}

Python 3, 63 byte

Đây là một hàm lambda ẩn danh, lấy một chuỗi làm đối số và trả về độ chói của nó.

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

Để sử dụng nó, đặt tên cho nó và gọi 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 byte

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

Điều này tính toán độ chói và đầu ra -0.0cho chuỗi trống. Nếu không thích các số 0 âm, bạn luôn có thể sửa lỗi đó bằng một byte thừa:

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

Haskell, 64 byte

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

Đầu ra mượt mà. ví dụ: f "Peanut Butter"> 8.333333333333333e-2.

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

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])là độ dài của x, nhưng vì hệ thống loại mạnh của Haskell yêu cầu cung cấp phân số cho /, tôi không thể sử dụng lengthtrả về số nguyên. Chuyển đổi số nguyên sang phân số qua fromInteger$length xquá dài.

JavaScript (ES6), 55 byte

Độ mượt, 56 byte

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

Chunkness, 55 byte

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

Bản giới thiệu

Tính toán độ mịn, vì đó là những gì tôi thích. Hiện tại chỉ hoạt động trong Firefox, vì nó là 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

Trả lại sự mượt mà.

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

Giải trình

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

Kiểm tra

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 byte

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

Hãy thử trực tuyến!

Cạo một vài byte với ý kiến ​​từ IMP. Ngoài ra, với phiên bản 2.7.0 sắp tới của Ruby, có thể lưu một số byte bằng cách thay thế |x,y|x!=ybằng@1!=@2

Python 3, 69 byte

Chưa có ai đăng một giải pháp Python, vì vậy đây là một triển khai khá đơn giản của chức năng "chunkiness". Nó ngắn mạch trên một chuỗi độ dài 1và in 0(là số nguyên chứ không phải là số float nhưng dường như được cho phép theo quy tắc).

Trên một chuỗi rỗng, nó xuất ra -0.0chứ không phải 0.0. Có thể cho rằng điều này có thể được coi là chấp nhận được, vì -0.0 == 0 == 0.0lợi nhuận True.

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

Ví dụ:

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

(Python 3 được sử dụng cho phân chia float mặc định của nó.)

C, 83 byte

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

Một chức năng trở lại chunkness .

Giải trình

float f(char *s) {

Chấp nhận một chuỗi C và trả về một float (double sẽ hoạt động nhưng nhiều ký tự hơn).

int a=0, b=0;

Bộ đếm - acho tổng số cặp, bcho cặp không khớp. Việc sử dụng intgiới hạn "độ dài tùy ý" của chuỗi, nhưng đó chỉ là một vi phạm nhỏ đối với các yêu cầu và tôi sẽ không sửa nó.

if (*s)

Trường hợp đặc biệt chuỗi rỗng - để lại cả hai số không.

    while (s[++a])

Chuỗi không trống - lặp qua chuỗi đó với mức tăng trước (vì vậy lần đầu tiên qua vòng lặp, s[a]sẽ là ký tự thứ hai. Nếu chuỗi chỉ có một ký tự, thân vòng lặp sẽ không được nhập và asẽ là 1.

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

Nếu ký tự hiện tại khác với trước, tăng dần b.

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

Sau vòng lặp, có ba khả năng: 'a == 0, b == 0' cho đầu vào trống, 'a == 1, b == 0' cho đầu vào một ký tự hoặc 'a> 1, b> = 0 'cho đầu vào đa ký tự. Chúng tôi trừ 1 từ a( ?toán tử là một điểm thứ tự, vì vậy chúng tôi an toàn) và nếu nó bằng 0, chúng tôi có trường hợp thứ hai, vì vậy sẽ trả về 0. Mặt khác, b/alà những gì chúng ta muốn, nhưng trước tiên chúng ta phải quảng bá bđến loại dấu phẩy động hoặc chúng ta sẽ có phân chia số nguyên. Đối với một chuỗi trống, chúng tôi sẽ kết thúc bằng số 0 âm, nhưng các quy tắc không cho phép điều đó.

Các xét nghiệm:

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

Cung cấp cho:

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

theo yêu cầu.

Perl, 69

Chức năng trở lại trơn tru :

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

Giải trình

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

Xét nghiệm

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 

Toán học, 73 72 byte

Điều này không giành được bất cứ điều gì cho kích thước, nhưng nó đơn giản:

Độ mịn

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

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

Out[177]= 0.285714

GeL: 76 73 ký tự

Độ mịn.

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

Chạy mẫu:

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 ràng buộc. Tốt hơn nhiều, nhưng vẫn còn xa chiến thắng.)

Gema: 123 120 ký tự

Độ mịn.

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

Chạy mẫu:

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

(Bản thân tôi là một bài tập để xem cơ hội giải quyết nó bằng ngôn ngữ nào mà không có hỗ trợ số dấu phẩy động và hỗ trợ số học nói chung đau đớn. Dòng thứ 2, đặc biệt là \Pchuỗi, là ma thuật thuần túy, dòng cuối cùng là cực hình.)

Java 8, 84 82 byte

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

Đầu ra Độ mịn.

Hãy thử trực tuyến.

Giải trình:

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

Dừa , 38 byte

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

Hãy thử trực tuyến!

Một cổng Python 3 sẽ là 50 byte .

PowerShell, 55 byte

Độ mịn

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

Có vẻ hơi ngớ ngẩn để có được một biến trong stdin và sau đó cung cấp cho nó một định danh, nhưng nó nhanh hơn là có một chức năng.

Python 3, 61 byte

tính chunkness:

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

K (22)

tinh chỉnh giải pháp Q của WooiKent:

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

Ruby, 63 byte

Đầu ra chunkness.

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

Tương tự như giải pháp của @ daniero, nhưng được rút ngắn một chút bằng cách chia trực tiếp cho độ dài chuỗi - 1 và sau đó dựa vào .count bằng 0 với độ dài chuỗi 0 & 1 (.max đảm bảo tôi sẽ không chia cho 0 hoặc -1).

Toán học, 107 byte

Tính độ chói bằng cách lấy một nửa khoảng cách Levenshtein giữa mỗi bản vẽ và ngược lại.

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

Nếu bạn muốn có một câu trả lời hợp lý chính xác, hãy xóa .5và đặt /2trước câu cuối &để không bị phạt. Bản thân chương trình có độ chói 103/106, tương đương khoảng 0,1972.