Considere una cadena de longitud N, como Peanut Butter
con 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 Butter
solo 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,
0
está bien en lugar de0.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
fuente
Respuestas:
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.
fuente
CJam, 19 bytes
Código fuente 100% grueso que calcula fragilidad .
Prueba esta bondad gruesa en línea.
Cómo funciona
Obviamente, NaN redondeado a 4 decimales es 0.
fuente
2ew
enfoque que probé. Los casos especiales de la carta 0/1 me estaban matando._
movió. No estoy seguro si importa.Pyth,
1312 bytesCódigo completamente grueso que calcula la fragilidad.
Demostración. Prueba de arnés.
fuente
z
causa un error en la entrada vacía en línea. Iré a arreglar ese error. Este código está bien, sin embargo.TI-BASIC, 46 bytes
sub(x1,x2,x3
da la subcadena de cadena quex1
comienza (basada en uno) en númerox2
y termina en númerox3
, luegoseq(
construye una secuencia.Da el valor de suavidad. La
Ans
variable es0
por defecto, por lo que no necesitamos unElse
a laIf
declaración, ni almacenar nada deAns
antemano.fuente
Matlab (
3736 bytes)Esto se puede hacer con la siguiente función anónima, que devuelve fragmentación:
Comentarios:
En versiones antiguas de Matlab (como R2010b) necesita
+
convertir el conjunto de caracteresx
en un conjunto doble:Pero ese no es el caso en las versiones recientes (probadas en R2014b), que ahorra un byte. Gracias a Jonas por su comentario.
max
maneja los casos de un carácter y cero caracteres (para fragmentación)Ejemplo:
fuente
diff('abc')
no generará una advertencia.> <> ,
4036 bytesEste programa devuelve la fragmentación de una cadena.
Explicación
Presentación previa (37 + 3 = 40 bytes)
Este programa devuelve la suavidad de una cadena. La entrada es a través de la
-s
bandera, por ejemplofuente
DO#,
9489 bytesSub 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:
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!
fuente
J,
1413 bytesCalcula la fragilidad. Felicitaciones a J por definir
0 % 0
que es igual a 0.Pruébalo en línea
Aquí hay una explicación:
fuente
(]+/%#)2~:/\]
ahorra 1 byte.CJam, 23 bytes
Explicación:
Esto genera la relación de suavidad.
fuente
CJam, 16 bytes
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
fuente
Julia, 52 bytes
¡Suavidad!
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.
fuente
Nim,
1059691 bytesTratando 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 ...)fuente
Python 3, 63 bytes
Esta es una función lambda anónima que toma una cadena como argumento y devuelve su fragilidad.
Para usarlo, asígnele un nombre y llámelo.
fuente
def f(n):
que tiene exactamente el mismo número de caracteres quelambda n:
. Esto elimina la necesidad de nombrar su función.def f(n):
también necesita unreturn
Python 3, 52 bytes
Esto calcula la fragmentación y las salidas
-0.0
para la cadena vacía. Si no le gustan los ceros negativos, siempre puede arreglar eso con un byte adicional:fuente
Haskell, 64 bytes
Salidas de suavidad. por ejemplo
f "Peanut Butter"
->8.333333333333333e-2
.Cómo funciona:
sum(x>>[1])
es la longitud de x, pero debido a que el sistema de tipo fuerte de Haskell requiere alimentar fracciones/
, no puedo usarlength
qué devuelve enteros. La conversión de enteros a fracciones víafromInteger$length x
es demasiado larga.fuente
import Data.Ratio
es demasiado caro.JavaScript (ES6), 55 bytes
Suavidad, 56 bytes
Chunkiness, 55 bytes
Manifestación
Calcula la suavidad, ya que eso es lo que prefiero. Solo funciona en Firefox por ahora, ya que es ES6.
fuente
KDB (Q), 30
Devuelve suavidad.
Explicación
Prueba
fuente
Ruby ,
6966 bytesPrué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!=y
por@1!=@2
fuente
.to_f/~-s.size
asignació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}
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.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
1
e 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.0
más que0.0
. Podría decirse que esto podría considerarse aceptable, como los-0.0 == 0 == 0.0
retornosTrue
.Ejemplos:
(Python 3 se usa para su división flotante predeterminada).
fuente
C, 83 bytes
Una función que regresa fragilidad .
Explicación
Acepte una cadena C y devuelva un flotante (el doble funcionaría pero es más caracteres).
Contadores:
a
para pares totales,b
para pares no coincidentes. El usoint
limita la "longitud arbitraria" de la cadena, pero eso es solo una violación menor de los requisitos y no voy a arreglarlo.Caso especial de la cadena vacía: deje ambos contadores en cero.
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á ya
será 1.Si el carácter actual difiere del anterior, incremente
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:
Lo que da:
según sea necesario.
fuente
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;}
Perl, 69
Función que devuelve suavidad :
Explicación
Pruebas
fuente
Mathematica,
7372 bytesEsto no gana nada por tamaño, pero es sencillo:
Suavidad
fuente
Length[#]
->Length@#
guarda un trazo. Al igual que eliminarN@
y cambiar1
a1.
GeL:
7673 caracteresSuavidad.
Ejecución de muestra:
(Enlaces GeL = Gema + Lua. Mucho mejor, pero aún lejos de ganar).
Gema:
123120 caracteresSuavidad.
Ejecución de muestra:
(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
\P
secuencia, es pura magia, la última línea es una verdadera tortura).fuente
Java 8,
8482 bytesSalidas Suavidad.
Pruébalo en línea.
Explicación:
fuente
Coco , 38 bytes
Pruébalo en línea!
Un puerto Python 3 tendría 50 bytes .
fuente
PowerShell, 55 bytes
Suavidad
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.
fuente
Python 3, 61 bytes
calcular la fragilidad:
fuente
K (22)
modificó la solución Q de WooiKent:
fuente
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).
fuente
Mathematica, 107 bytes
Calcula la fragmentación tomando la mitad de la distancia de Levenshtein entre cada dígrafo y su reverso.
Si prefiere una respuesta racional exacta, elimine
.5
y coloque un/2
antes del último&
sin penalización. El programa en sí tiene fragilidad 103/106, o aproximadamente .972.fuente