Considere uma sequência de comprimento N, como Peanut ButterN = 13. Observe que há N-1 pares de caracteres vizinhos na sequência. Pois Peanut Butter, o primeiro dos 12 pares é Pe, o segundo é ea, o último é er.

Quando os pares são principalmente caracteres diferentes, a corda tem uma qualidade robusta, por exemplo chUnky.
Quando esses pares são basicamente o mesmo caractere, a corda tem uma qualidade suave, por exemplo sssmmsss.

Defina a fragilidade de uma sequência como a proporção do número de pares com dois caracteres diferentes para o número total de pares (N-1).

Defina a suavidade de uma sequência de caracteres para ser a proporção do número de pares com dois caracteres idênticos ao número total de pares (N-1).

Por exemplo, Peanut Butterpossui apenas um par com caracteres idênticos ( tt), portanto, sua suavidade é 1/12 ou 0,0833 e sua robustez é 11/12 ou 0,9167.

Seqüências de caracteres vazias e com apenas um caractere são definidas como 100% suaves e 0% robustas.

Desafio

Escreva um programa que tenha uma sequência arbitrária de comprimento e produza sua proporção de fragilidade ou suavidade como um valor de ponto flutuante.

• Tome entrada via stdin ou pela linha de comando, ou você pode escrever uma função que aceita uma string.
• Você pode assumir que a sequência de entrada contém apenas caracteres ASCII imprimíveis (e, portanto, é uma linha).
• Imprima o float para stdout com 4 ou mais casas decimais, ou você pode optar por devolvê-lo se tiver escrito uma função. Casas decimais que não transmitem informações não são necessárias, por exemplo, 0é bom em vez de 0.0000.
• Escolha robustez ou suavidade como preferir. Apenas certifique-se de dizer qual o seu programa gera.

O código mais curto em bytes vence.

Exemplos

Peanut Butter→ chunkiness: 0.91666666666, Lisura: 0.08333333333
chUnky→ chunkiness: 1.0, Lisura: 0.0
sssmmsss→ chunkiness: 0.28571428571, Lisura: 0.71428571428
999→ chunkiness: 0.0, Lisura: 1.0
AA→ chunkiness: 0.0, Lisura: 1.0
Aa→ chunkiness: 1.0, Lisura: 0.0
!→ chunkiness: 0.0, Lisura: 1.0
[cadeia vazia] → chunkiness: 0.0, Suavidade:1.0

Pergunta bônus: Qual você prefere , cordas grossas ou suaves ?

APL, 10 bytes

Isso lê a entrada de stdin e imprime a fragilidade em stdout. O algoritmo é o mesmo usado para a solução J.

(+/÷⍴)2≠/⍞

CJam, 19 bytes

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

Código fonte 100% robusto que calcula a robustez .

Experimente esta bondade robusta online.

Como funciona

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.

Obviamente, o NaN arredondado para 4 casas decimais é 0.

Pitão, 13 12 bytes

csJnVztz|lJ1

Código totalmente robusto calculando robustez.

Demonstração. Equipamento de teste.

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,x3fornece a substring da string x1iniciando (com base) em número x2e terminando em número e x3, em seguida, seq(cria uma sequência.

Dá o valor de suavidade. A Ansvariável é 0por padrão, portanto, não precisamos de um Elsena Ifinstrução ou armazenamos qualquer coisa Ansantes.

Matlab ( 37 36 bytes)

Isso pode ser feito com a seguinte função anônima, que retorna fragilidade:

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

Comentários:

• Nas versões antigas do Matlab (como o R2010b), você precisa +converter o array char xem um array duplo:

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

  Mas esse não é o caso nas versões recentes (testadas no R2014b), que economizam um byte. Obrigado a Jonas por seu comentário.

• A expressão with maxmanipula os casos de um e zero caracteres (para robustez)

Exemplo:

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

Este programa retorna a fragilidade de uma sequência.

Explicação

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

Submissão anterior (37 + 3 = 40 bytes)

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

Este programa retorna a suavidade de uma string. A entrada é feita através da -sbandeira, por exemplo

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

C #, 94 89 bytes

Sub 100 bytes, então eu acho que é alguma forma de vitória em si?

Esta é uma definição de função (permitida conforme a especificação) que retorna a suavidade da sequência de entrada:

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

Bem direto, se o comprimento for 0 ou 1, ele retornará 1; caso contrário, ele comparará a sequência menos o primeiro caractere e retornará o número de pares idênticos dividido pelo número de pares.

Editar - substituiu Substring por Ignorar. Erro de novato!

J, 14 13 bytes

Calcula a fragilidade. Parabéns a J por definir 0 % 0como igual a 0.

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

Experimente online

Aqui está uma explicação:

   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/

Explicação:

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

Isso gera a taxa de suavidade.

CJam, 16 bytes

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

Código fonte Cheaty que calcula a suavidade .

Para entradas de comprimento 0 ou 1, isso imprime o resultado correto antes de sair com um erro. Com o interpretador Java, a saída de erro vai para STDERR ( como deveria ).

Se você tentar o código online , ignore tudo, menos a última linha de saída.

Como funciona

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

Suavidade!

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

Isso cria uma função sem nome que aceita uma string e retorna um valor numérico.

Se o comprimento da entrada for menor que 2, a suavidade será 1; caso contrário, calcularemos a proporção de caracteres adjacentes idênticos, calculando a média de uma matriz de lógica.

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

Tentando aprender Nim. Isso calcula a fragilidade de uma sequência.

^{( Se eu tentar ler isso como Python, o recuo ficará todo bagunçado ... Agora parece mais com Ruby ...)}

Python 3, 63 bytes

Esta é uma função lambda anônima que recebe uma string como argumento e retorna sua fragilidade.

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

Para usá-lo, dê um nome e chame-o.

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)

Isso calcula a fragilidade e gera -0.0a sequência vazia. Se não gostar de zeros negativos, você sempre pode corrigir isso com um byte extra:

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)

Produz suavidade. por exemplo f "Peanut Butter"-> 8.333333333333333e-2.

Como funciona:

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])é o comprimento de x, mas como o sistema de tipo forte de Haskell exige alimentar fracionários /, não posso usar o lengthque retorna números inteiros. A conversão de números inteiros em fracionários fromInteger$length xé muito longa.

JavaScript (ES6), 55 bytes

Suavidade, 56 bytes

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

Robustez, 55 bytes

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

Demo

Calcula suavidade, como é o que eu prefiro. Por enquanto, só funciona no Firefox, pois é o 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

Retorna suavidade.

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

Explicação

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

Teste

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}

Experimente online!

Raspado de alguns bytes com comentários do IMP. Além disso, com a próxima versão 2.7.0 do Ruby, é possível salvar alguns bytes substituindo |x,y|x!=ypor@1!=@2

Python 3, 69 bytes

Ninguém postou uma solução Python ainda, então aqui está uma implementação bastante direta de uma função de "fragilidade". Faz um curto-circuito em uma sequência de comprimento 1e imprime 0(que é um número inteiro ao invés de um flutuador, mas parece ser permitido de acordo com as regras).

Em uma sequência vazia, ela gera, em -0.0vez de 0.0. Indiscutivelmente isso pode ser considerado aceitável, como -0.0 == 0 == 0.0retornos True.

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

Exemplos:

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

(Python 3 é usado para sua divisão de flutuação padrão.)

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

Uma função retornando robustez .

Explicação

float f(char *s) {

Aceite uma string C e retorne um float (double funcionaria, mas é mais chars).

int a=0, b=0;

Contadores - apara pares totais, bpara pares não correspondentes. O uso intlimita o "comprimento arbitrário" da string, mas isso é apenas uma violação menor dos requisitos e não vou corrigi-lo.

if (*s)

Caso especial da string vazia - deixe os dois contadores zero.

    while (s[++a])

Cadeia não vazia - itere-a com pré-incremento (então a primeira vez no loop, s[a]será o segundo caractere. Se a string tiver apenas um caractere, o corpo do loop não será inserido e aserá 1.

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

Se o caractere atual for diferente do anterior, aumente b.

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

Após o loop, existem três possibilidades: 'a == 0, b == 0' para uma entrada vazia, 'a == 1, b == 0' para uma entrada de caractere único ou 'a> 1, b> = 0 'para entrada de vários caracteres. Subtraímos 1 de a(o ?operador é um ponto de sequência, então estamos seguros) e, se for zero, temos o segundo caso, portanto, retornamos zero. Caso contrário, b/aé o que queremos, mas devemos primeiro promover bum tipo de ponto flutuante ou obteremos uma divisão inteira. Para uma string vazia, acabaremos com um zero negativo, mas as regras não o permitem.

Testes:

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

Que dá:

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

como requerido.

Perl, 69

Função retornando suavidade :

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

Explicação

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

Testes

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

Isso não ganha nada pelo tamanho, mas é direto:

Suavidade

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

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

Out[177]= 0.285714

GeL: 76 73 caracteres

Suavidade.

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

Exemplo de execução:

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

(Ligações GeL = Gema + Lua. Muito melhor, mas ainda longe de vencer.)

Gema: 123 120 caracteres

Suavidade.

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

Exemplo de execução:

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

(Foi mais um exercício para mim ver quais são as chances de resolvê-lo em um idioma sem suporte de número de ponto flutuante e suporte aritmético geralmente doloroso. A segunda linha, especialmente a \Psequência, é pura magia, a última linha é verdadeira tortura.)

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

Saída de suavidade.

Experimente online.

Explicação:

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

Coco , 38 bytes

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

Experimente online!

Uma porta Python 3 teria 50 bytes .

PowerShell, 55 bytes

Suavidade

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

Parece um pouco tolo obter uma variável no stdin e fornecer um identificador, mas é mais rápido do que ter uma função.

Python 3, 61 bytes

calcular robustez:

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

K (22)

ajustou a solução Q do WooiKent:

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

Ruby, 63 bytes

Produz robustez.

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

Semelhante à solução de @ daniero, mas ligeiramente reduzida ao dividir diretamente pelo comprimento da string - 1 e, em seguida, contar com .count como zero com o comprimento 0 e 1 (o .max garante que não dividirei por 0 ou -1).

Mathematica, 107 bytes

Calcula a irregularidade, tomando metade da distância de Levenshtein entre cada dígrafo e seu reverso.

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

Se você preferir uma resposta racional exata, exclua .5e coloque um /2antes do último, &sem penalidade. O programa em si tem fragilidade 103/106, ou cerca de 0,972.