Considere una cadena de longitud N, como Peanut Buttercon N = 13. Observe que hay N-1 pares de caracteres vecinos en la cadena. Para Peanut Butter, el primero de los 12 pares es Pe, el segundo es ea, el último es er.

Cuando los pares son en su mayoría caracteres diferentes, la cadena tiene una calidad gruesa, por ejemplo chUnky.
Cuando estos pares son en su mayoría del mismo carácter, la cadena tiene una calidad suave, por ejemplo sssmmsss.

Defina la fragmentación de una cadena para que sea la relación entre el número de pares con dos caracteres diferentes y el número total de pares (N-1).

Defina la suavidad de una cadena como la relación entre el número de pares con dos caracteres idénticos y el número total de pares (N-1).

Por ejemplo, Peanut Buttersolo tiene un par con caracteres idénticos ( tt), por lo que su suavidad es 1/12 o 0.0833 y su fragmentación es 11/12 o 0.9167.

Las cadenas vacías y las cadenas con un solo carácter se definen como 100% suaves y 0% gruesas.

Reto

Escriba un programa que tome una cadena de longitud arbitraria y genere su relación de fragmentación o suavidad como un valor de coma flotante.

• Tome la entrada a través de stdin o la línea de comando, o puede escribir una función que tome una cadena.
• Puede asumir que la cadena de entrada solo contiene caracteres ASCII imprimibles (y, por lo tanto, es de una sola línea).
• Imprima el flotador en stdout a 4 o más decimales, o puede elegir devolverlo si escribió una función. No se requieren lugares decimales que no transmitan información, por ejemplo, 0está bien en lugar de 0.0000.
• Elija el grueso o la suavidad que prefiera. Solo asegúrese de decir cuál es el resultado de su programa.

El código más corto en bytes gana.

Ejemplos

Peanut Butter→ chunkiness: 0.91666666666, Suavidad: 0.08333333333
chUnky→ chunkiness: 1.0, Suavidad: 0.0
sssmmsss→ chunkiness: 0.28571428571, Suavidad: 0.71428571428
999→ chunkiness: 0.0, Suavidad: 1.0
AA→ chunkiness: 0.0, Suavidad: 1.0
Aa→ chunkiness: 1.0, Suavidad: 0.0
!→ chunkiness: 0.0, Suavidad: 1.0
[cadena vacía] → chunkiness: 0.0, Suavidad:1.0

Pregunta extra: ¿Qué prefieres , cuerdas gruesas o suaves ?

APL, 10 bytes

Esto lee la entrada de stdin e imprime la fragmentación en stdout. El algoritmo es el mismo utilizado para la solución J.

(+/÷⍴)2≠/⍞

CJam, 19 bytes

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

Código fuente 100% grueso que calcula fragilidad .

Prueba esta bondad gruesa en línea.

Cómo 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, NaN redondeado a 4 decimales es 0.

Pyth, 13 12 bytes

csJnVztz|lJ1

Código completamente grueso que calcula la fragilidad.

Demostración. Prueba de arnés.

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,x3da la subcadena de cadena que x1comienza (basada en uno) en número x2y termina en númerox3 , luego seq(construye una secuencia.

Da el valor de suavidad. La Ansvariable es 0por defecto, por lo que no necesitamos un Elsea la Ifdeclaración, ni almacenar nada de Ansantemano.

Matlab ( 37 36 bytes)

Esto se puede hacer con la siguiente función anónima, que devuelve fragmentación:

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

Comentarios:

• En versiones antiguas de Matlab (como R2010b) necesita +convertir el conjunto de caracteres xen un conjunto doble:

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

  Pero ese no es el caso en las versiones recientes (probadas en R2014b), que ahorra un byte. Gracias a Jonas por su comentario.

• La expresión con max maneja los casos de un carácter y cero caracteres (para fragmentación)

Ejemplo:

>> 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 devuelve la fragmentación de una cadena.

Explicació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

Presentación previa (37 + 3 = 40 bytes)

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

Este programa devuelve la suavidad de una cadena. La entrada es a través de la -sbandera, por ejemplo

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

DO#, 94 89 bytes

Sub 100 bytes, así que supongo que es una forma de victoria en sí misma.

Esta es una definición de función (permitida según la especificación) que devuelve la suavidad de la cadena 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);

Bastante sencillo, si la longitud es 0 o 1, devuelve 1; de lo contrario, compara la cadena consigo misma menos el primer carácter, luego devuelve el número de pares idénticos dividido por el número de pares.

Editar: subcadena reemplazada por Omitir. ¡Error de principiante!

J, 14 13 bytes

Calcula la fragilidad. Felicitaciones a J por definir 0 % 0que es igual a 0.

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

Pruébalo en línea

Aquí hay una explicación:

   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/

Explicación:

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

Esto genera la relación de suavidad.

CJam, 16 bytes

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

Cheaty código fuente que calcula la suavidad .

Para entradas de longitud 0 o 1, esto imprime el resultado correcto antes de salir con un error. Con el intérprete de Java, la salida de error va a STDERR ( como debería ).

Si prueba el código en línea , simplemente ignore todo menos la última línea de salida.

Cómo 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

¡Suavidad!

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

Esto crea una función sin nombre que acepta una cadena y devuelve un valor numérico.

Si la longitud de la entrada es menor que 2, la suavidad es 1; de lo contrario, calculamos la proporción de caracteres adyacentes idénticos tomando la media de una matriz de lógicas.

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

Tratando de aprender Nim. Esto calcula la fragmentación de una cadena.

^{( Si trato de leer esto como Python, la sangría parece desordenada ... Ahora se parece más a Ruby ...)}

Python 3, 63 bytes

Esta es una función lambda anónima que toma una cadena como argumento y devuelve su fragilidad.

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

Para usarlo, asígnele un nombre y llámelo.

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)

Esto calcula la fragmentación y las salidas -0.0para la cadena vacía. Si no le gustan los ceros negativos, siempre puede arreglar eso con un byte adicional:

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)

Salidas de suavidad. por ejemplo f "Peanut Butter"-> 8.333333333333333e-2.

Cómo 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])es la longitud de x, pero debido a que el sistema de tipo fuerte de Haskell requiere alimentar fracciones /, no puedo usar lengthqué devuelve enteros. La conversión de enteros a fracciones vía fromInteger$length xes demasiado larga.

JavaScript (ES6), 55 bytes

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

Manifestación

Calcula la suavidad, ya que eso es lo que prefiero. Solo funciona en Firefox por ahora, ya que es 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

Devuelve suavidad.

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

Explicación

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

Prueba

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}

Pruébalo en línea!

Afeitado de unos pocos bytes con comentarios de IMP. Además, con la próxima versión 2.7.0 de Ruby, es posible guardar algunos bytes reemplazándolos |x,y|x!=ypor@1!=@2

Python 3, 69 bytes

Nadie ha publicado una solución Python todavía, así que aquí hay una implementación bastante sencilla de una función de "fragmentación". Cortocircuita una cadena de longitud 1e imprime0 (que es un número entero en lugar de un flotador pero parece estar permitido de acuerdo con las reglas).

En una cadena vacía, genera -0.0más que 0.0. Podría decirse que esto podría considerarse aceptable, como los -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

Ejemplos:

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

(Python 3 se usa para su división flotante predeterminada).

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

Una función que regresa fragilidad .

Explicación

float f(char *s) {

Acepte una cadena C y devuelva un flotante (el doble funcionaría pero es más caracteres).

int a=0, b=0;

Contadores: apara pares totales, bpara pares no coincidentes. El uso intlimita la "longitud arbitraria" de la cadena, pero eso es solo una violación menor de los requisitos y no voy a arreglarlo.

if (*s)

Caso especial de la cadena vacía: deje ambos contadores en cero.

    while (s[++a])

Cadena no vacía: repítala con un incremento previo (por lo que la primera vez a través del bucle s[a]será el segundo carácter. Si la cadena tiene solo un carácter, el cuerpo del bucle no se ingresará y aserá 1.

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

Si el carácter actual difiere del anterior, incremente b.

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

Después del ciclo, hay tres posibilidades: 'a == 0, b == 0' para una entrada vacía, 'a == 1, b == 0' para una entrada de un solo carácter o 'a> 1, b> = 0 'para entrada de caracteres múltiples. Restamos 1 de a(el ?operador es un punto de secuencia, por lo que estamos a salvo), y si es cero, tenemos el segundo caso, por lo que debería devolver cero. De otra manera,b/a lo es lo que queremos, pero debemos promoverb primero a un tipo de punto flotante o obtendremos una división entera. Para una cadena vacía, terminaremos con un cero negativo, pero las reglas no lo rechazan.

Pruebas:

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

Lo que da:

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

según sea necesario.

Perl, 69

Función que devuelve suavidad :

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

Explicación

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

Pruebas

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

Esto no gana nada por tamaño, pero es sencillo:

Suavidad

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

Suavidad.

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

Ejecución de muestra:

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

(Enlaces GeL = Gema + Lua. Mucho mejor, pero aún lejos de ganar).

Gema: 123 120 caracteres

Suavidad.

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

Ejecución de muestra:

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

(Fue más un ejercicio para mí ver cuáles son las posibilidades de resolverlo en un idioma sin soporte de números de coma flotante y soporte aritmético generalmente doloroso. La segunda línea, especialmente la \Psecuencia, es pura magia, la última línea es una verdadera 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;}

Salidas Suavidad.

Pruébalo en línea.

Explicación:

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:])

Pruébalo en línea!

Un puerto Python 3 tendría 50 bytes .

PowerShell, 55 bytes

Suavidad

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

Parece un poco tonto obtener una variable en stdin y luego darle un identificador, pero es más rápido que tener una función.

Python 3, 61 bytes

calcular la fragilidad:

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

K (22)

modificó la solución Q de WooiKent:

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

Rubí, 63 bytes

Salidas en trozos.

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

Similar a la solución de @ daniero, pero ligeramente acortada dividiendo directamente por la longitud de la cadena - 1 y luego confiando en que .count sea cero con las cadenas de longitud 0 y 1 (.max asegura que no dividiré entre 0 o -1).

Mathematica, 107 bytes

Calcula la fragmentación tomando la mitad de la distancia de Levenshtein entre cada dígrafo y su reverso.

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

Si prefiere una respuesta racional exacta, elimine .5y coloque un /2antes del último &sin penalización. El programa en sí tiene fragilidad 103/106, o aproximadamente .972.