Cuerdas gruesas vs. suaves

29

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 ?

Pasatiempos de Calvin
fuente
8
-1 Sin etiqueta sobrecargada.
Dennis
22
+1 Prueba concluyente de que la mantequilla de maní con trozos debería ser la predeterminada.
BrainSteel
Algunos idiomas tienen dificultades para leer ninguna entrada. ¿Sería admisible suponer que la entrada está terminada en nueva línea?
Dennis
@ Dennis Sí, está bien.
Aficiones de Calvin
9
@BrainSteel Chunky solo debería ser el predeterminado si eres una computadora; les gusta tener trozos disponibles. La mantequilla de maní hecha para las personas debe ocultar esos detalles de implementación y ser suave como la seda para el usuario.
Geobits

Respuestas:

7

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≠/⍞
FUZxxl
fuente
19

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.

Dennis
fuente
1
No creo que necesite redondearlo a 4 dígitos. Dice "4 o más", y los ceros finales no son necesarios. Esto es mucho más elegante que el 2ewenfoque que probé. Los casos especiales de la carta 0/1 me estaban matando.
Reto Koradi
@RetoKoradi Rounding asigna NaN a 0. No conozco un camino más corto.
Dennis
Sí, mientras jugaba un poco más, me di cuenta de que obtienes un NaN para entradas de 1 carácter. Las entradas breves son, con mucho, la parte más dolorosa de esta. Por cierto, el enlace en línea tiene un código ligeramente diferente a la versión que publicó. Uno se _movió. No estoy seguro si importa.
Reto Koradi
@RetoKoradi Claro que sí. El código vinculado no es 100% grueso. : P
Dennis
3
@AlexA. La mermelada con trozos de fruta es al menos 10% gruesa.
Dennis
13

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
isaacg
fuente
En la versión en línea, recibo un error cuando dejo la entrada vacía. Por lo que puedo decir, falla el último caso de prueba.
Reto Koradi
@RetoKoradi Eso es extraño: funciona bien en la versión sin conexión. Probablemente sea un error con el sitio web en línea.
isaacg
@RetoKoradi confirmado: el uso de zcausa un error en la entrada vacía en línea. Iré a arreglar ese error. Este código está bien, sin embargo.
isaacg
Funciona si presiono regresar una vez en el cuadro de entrada. Pero otras cadenas no necesitan un retorno al final. Sin nada escrito en el cuadro de entrada, parece no tener ninguna entrada, y su código explota cuando intenta usar la entrada.
Reto Koradi
@RetoKoradi Gracias. Creo que conozco el problema, no debería ser difícil de solucionar.
isaacg
8

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.

lirtosiast
fuente
7

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
Luis Mendo
fuente
En R2014b, diff('abc')no generará una advertencia.
Jonas
6

> <> , 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"
Sp3000
fuente
6

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!

Sok
fuente
5

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
FUZxxl
fuente
(]+/%#)2~:/\]ahorra 1 byte.
FrownyFrog
@FrownyFrog ¡Genial! ¿Cómo podría perder esto?
FUZxxl
¿Podría agregar un enlace TIO con código de prueba?
Kevin Cruijssen
4

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.

Ypnypn
fuente
4

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.
Dennis
fuente
3

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.

Alex A.
fuente
3

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

Sp3000
fuente
3

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
Kade
fuente
En lugar de la función anónima, puede usar:, def f(n):que tiene exactamente el mismo número de caracteres que lambda n:. Esto elimina la necesidad de nombrar su función.
Tristan Reid
@TristanReid def f(n):también necesita unreturn
Sp3000
¡Uy! Buena captura: soy nuevo en codegolf, debería asumir que se ha pensado más en esto y probarlo localmente. Disculpas!
Tristan Reid
3

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)
Sp3000
fuente
2

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.

nimi
fuente
¿Intentaste trabajar con Rationals ?
recursion.ninja
@ recursion.ninja: no, no lo hice porque creo que un byte de 18 import Data.Ratioes demasiado caro.
nimi
2

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>

rink.attendant.6
fuente
2

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
WooiKent Lee
fuente
2

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

daniero
fuente
si mueve la .to_f/~-s.sizeasignación de c, puede eliminar un byte con la operación ternaria:f=->s{(c=s.chars.each_cons(2).count{|x,y|x!=y}.to_f/~-s.size)>0?c:0}
IMP1
Además, ¿necesitas el f=? No estoy al 100% en las reglas al respecto. El desafío dice que puede devolver una función que toma una cadena, que es una lambda stabby.
IMP1
Además , si bien la respuesta de Perl puede ser de la misma longitud, no tiene ese 100% de fragilidad que tiene esta respuesta.
IMP1
@ IMP1 Gracias :)
daniero
1

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

Mathmandan
fuente
1

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.

Toby Speight
fuente
1
Ignorar mi comentario eliminado anterior .. 80 bytes :a,b;float f(char*s){if(*s)for(a=b=0;s[++a];)b+=s[a]!=s[a-1];return--a?1.*b/a:b;}
Kevin Cruijssen
66 bytes usando la bandera del compilador (si te gusta ese tipo de cosas). editar: y lo
cambié
1

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 
Toby Speight
fuente
1

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
rcollyer
fuente
Length[#]-> Length@#guarda un trazo. Al igual que eliminar N@y cambiar 1a1.
hYPotenuser
@hYPotenuser sí. perdido.
rcollyer
1

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

hombre trabajando
fuente
1

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
Kevin Cruijssen
fuente
0

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.

Nacht - Restablece a Monica
fuente
0

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)
La cripta
fuente
0

K (22)

modificó la solución Q de WooiKent:

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

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

dgollahon
fuente
0

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.

hYPotenuser
fuente