Peanut ButterN = 13 과 같이 길이가 N 인 문자열을 고려하십시오. 문자열에 N-1 쌍의 인접 문자가 있습니다. 들면 Peanut Butter12 쌍 제이며 Pe, 두 번째는 ea상기 마지막이다 er.

쌍이 대부분 다른 문자 인 경우 문자열의 품질은 다음과 같습니다 chUnky.
이러한 쌍이 대부분 같은 문자 인 경우 문자열의 품질이 매끄 럽습니다 (예 :) sssmmsss.

문자열 의 청크도 를 두 개의 다른 문자가있는 쌍 수와 총 쌍 수 (N-1)의 비율로 정의하십시오 .

문자열 의 부드러움 을 동일한 문자가있는 쌍 수와 총 쌍 수 (N-1)의 비율로 정의하십시오 .

예를 들어 Peanut Butter동일한 문자 ( tt)를 가진 한 쌍만 있으므로 매끄러움은 1/12 또는 0.0833이고 청크는 11/12 또는 0.9167입니다.

하나의 문자 만있는 빈 문자열과 문자열은 100 % 매끄럽고 0 % 청키 한 것으로 정의됩니다.

도전

임의의 길이의 문자열을 가져와 청크 또는 부드러움 비율을 부동 소수점 값으로 출력하는 프로그램을 작성하십시오.

• stdin 또는 명령 행을 통해 입력하거나 문자열을 사용하는 함수를 작성할 수 있습니다.
• 입력 문자열에 인쇄 가능한 ASCII 문자 만 포함되어 있다고 가정 할 수 있습니다 (따라서 단일 행임).
• float를 stdout에 소수점 이하 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 바이트

이것은 stdin에서 입력을 읽고 청크를 stdout에 인쇄합니다. 알고리즘은 J 솔루션에 사용 된 것과 동일합니다.

(+/÷⍴)2≠/⍞

CJam, 19 바이트

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

청크 를 계산하는 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

청크를 계산하는 완전히 chunky 코드.

데모. 테스트 하니스.

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 문자열의 부분 문자열을 제공합니다 x1number에서 시작하고 number x2에서 끝나는x3 다음 seq(시퀀스 를 작성합니다.

평활도 값을 제공합니다. Ans변수는 0우리가 필요하지 않도록, 기본적으로 Else받는 If문, 또는에 저장 아무것도에 Ans사전.

MATLAB ( 37 36 바이트)

이는 다음 익명 함수를 사용하여 수행 할 수 있습니다.

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

코멘트:

• 이전 Matlab 버전 (예 : R2010b) +에서는 char 배열 x을 이중 배열 로 캐스트 해야 합니다 .

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

  그러나 1 바이트를 절약하는 최신 버전 (R2014b에서 테스트)의 경우에는 그렇지 않습니다. 그의 의견에 감사합니다.

• with 표현식 max은 한 문자와 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"

기음#, 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 바이트

청크를 계산합니다. 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 bytes

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

Explanation:

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

This outputs the smoothness ratio.

CJam, 16 bytes

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

Cheaty source code that calculates smoothness.

For inputs of length 0 or 1, this prints the correct result before exiting with an error. With the Java interpreter, error output goes to STDERR (as it should).

If you try the code online, just ignore everything but the last line of output.

How it works

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

Smoothness!

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

This creates an unnamed function that accepts a string and returns a numeric value.

If the length of the input is less than 2, the smoothness is 1, otherwise we calculate the proportion of identical adjacent characters by taking the mean of an array of logicals.

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

Trying to learn Nim. This calculates the chunkiness of a string.

^{(If I try to read this as Python the indentation looks all messed up... Now it looks more like Ruby...)}

Python 3, 63 Bytes

This is an anonymous lambda function which takes a string as the argument, and returns it's chunkiness.

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

To use it, give it a name and call it.

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)

This calculates chunkiness, and outputs -0.0 for the empty string. If don't like negative zeroes you can always fix that with an extra byte:

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)

Outputs smoothness. e.g. f "Peanut Butter" -> 8.333333333333333e-2.

How it works:

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]) is the length of x, but because Haskell's strong type system requires to feed fractionals to /, I can't use length which returns integers. Converting integers to fractionals via fromInteger$length x is far too long.

JavaScript (ES6), 55 bytes

Smoothness, 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

Calculates smoothness, as that is what I prefer. Only works in Firefox for now, as it is 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

Returns smoothness.

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

Explanation

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

Test

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}

Try it 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

No one has posted a Python solution yet, so here's a fairly straightforward implementation of a "chunkiness" function. It short-circuits on a string of length 1, and prints 0 (which is an integer rather than a float but seems to be allowed according to the rules).

On an empty string, it outputs -0.0 rather than 0.0. Arguably this is could be considered acceptable, as -0.0 == 0 == 0.0 returns True.

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

Examples:

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

(Python 3 is used for its default float division.)

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

A function returning chunkiness.

Explanation

float f(char *s) {

Accept a C string, and return a float (double would work but is more chars).

int a=0, b=0;

Counters - a for total pairs, b for non-matching pairs. Using int limits the "arbitrary length" of the string, but that's only a minor violation of the requirements and I'm not going to fix it.

if (*s)

Special case the empty string - leave both counters zero.

    while (s[++a])

Non-empty string - iterate through it with pre-increment (so first time through the loop, s[a] will be the second character. If the string has only one character, the loop body will not be entered, and a will be 1.

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

If the current character differs from the previous, increment b.

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

After the loop, there are three possibilities: 'a==0,b==0' for an empty input, 'a==1,b==0' for a single-character input or 'a>1,b>=0' for multi-character input. We subtract 1 from a (the ? operator is a sequence point, so we're safe), and if it's zero, we have the second case, so should return zero. Otherwise, b/a is what we want, but we must promote b to a floating-point type first or we'll get integer division. For an empty string, we'll end up with a negative zero, but the rules don't disallow that.

Tests:

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

Which gives:

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

as required.

Perl, 69

Function returning smoothness:

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

Explanation

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 72 bytes

This doesn't win anything for size, but it's straightforward:

Smoothness

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

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

Out[177]= 0.285714

GeL: 76 73 characters

Smoothness.

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

Sample run:

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. Much better, but still far from winning.)

Gema: 123 120 characters

Smoothness.

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

Sample run:

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

(Was more an exercise for myself to see what are the chances to solve it in a language without floating point number support and generally painful arithmetic support. The 2nd line, especially the \P sequence, is pure magic, the last line is real torture.)

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

Outputs Smoothness.

Try it online.

Explanation:

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

Coconut, 38 bytes

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

Try it online!

A Python 3 port would be 50 bytes.

PowerShell, 55 bytes

Smoothness

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

Seems a little bit silly to get a variable in stdin and then give it an identifier, but its quicker than having a function.

Python 3, 61 Bytes

calculate chunkiness:

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

K (22)

tweaked WooiKent's Q solution:

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

Ruby, 63 Bytes

Outputs chunkiness.

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

Similar to @daniero's solution, but slightly shortened by directly dividing by the string length - 1 and then relying on .count to be zero with length 0 & 1 strings (the .max ensures I won't divide by 0 or -1).

Mathematica, 107 bytes

Calculates chunkiness by taking half of the Levenshtein distance between each digraph and its reverse.

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

If you'd prefer an exact rational answer, delete .5 and place a /2 before the last & for no penalty. The program itself has chunkiness 103/106, or about .972.