Basado en Chunky vs. Smooth Strings .

/\_/\/\__/\/\/\/\_/\_/\Es divertido hacer garabatos en un teclado cuando estás realmente aburrido. Pero no todos los garabatos son iguales. Algunos garabatos son suaves, como \___/, y algunos son gruesos, como /\/\/\/\. Otros están simplemente rotos, como////_\\\

Dentro de cada garabato de Npersonajes, hay N-1uniones de garabatos. Cada cruce de garabatos se clasifica en uno de tres tipos:

• Lisa (ángulo> "90 grados"):

  \_ __ _/

• Grueso (ángulo = "90 grados")

  /\ \/

• Roto (todo lo que no se conecta)

  // \\ /_ _\

Definamos la suavidad como la proporción de uniones que son lisas, con la fragilidad y la fragilidad definidas de manera similar. Cada valor oscila entre 0y 1. La suma de la suavidad, la fragilidad y la fragilidad de un garabato siempre es igual a 1.

Por ejemplo, el garabato /\/\\_//\_tiene 3 uniones lisas, 4 uniones gruesas y 2 uniones rotas. Por lo tanto 0.3333, es suave, 0.4444grueso y 0.2222roto.

Las cadenas vacías y las cadenas con un solo carácter tienen valores indefinidos, todas las entradas tendrán al menos 2 caracteres de longitud.

Desafío

Escriba un programa que tome un garabato de longitud arbitraria y genere dos de sus valores de suavidad, fragmentación y fragilidad.

• Puede escribir un programa o función, con entrada a través de STDIN, línea de comando o como un argumento de cadena.
• Puede suponer que la entrada tiene al menos una longitud> = 2 y consiste solo en los caracteres /\_con una nueva línea final opcional.
• Imprima (o devuelva si es una función) los dos flotantes con una precisión de al menos 4 decimales, redondeados o truncados. Si el valor verdadero es 2/3, los valores aceptables incluyen cualquier valor entre 0.6666e 0.6667incluso cosas como 0.666637104. Si el valor exacto es 1/3, cualquier respuesta que contenga 0.3333es válida. Puede omitir los ceros finales o el cero inicial si el valor es menor que uno.
• Imprima cualquier par de los tres valores que prefiera, solo asegúrese de indicar cuáles dos y en qué orden.

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

Ejemplos

/\/\\/\//\\→ Suavidad 0, Chunkiness 0.7, Brokenness0.3

_/\\_/\\/__/\\\//_→ Suavidad 0.29411764705, Chunkiness 0.29411764705, Brokenness0.41176470588

//\\__/_\/→ Suavidad 0.3333333, Chunkiness 0.2222222, Brokenness0.4444444

Pregunta extra: ¿Qué prefieres, garabatos suaves, gruesos o rotos?

Pyth, 25 bytes

mcl@.:d2.:z2tlzc2"\__//\/

Banco de pruebas

Produce suavidad, aspereza. Básicamente, toma la cuerda codificada y la corta por la mitad. Cada mitad se descompone en sus subcadenas de 2 caracteres, y lo mismo se hace para la entrada. Tomamos la intersección, dando como resultado los pares sur y grueso. Luego, tomamos la longitud, la dividimos por el número de pares e imprimimos.

Japt, 42 bytes

U=U¬ä@2+"\\/\\__/"bX+Y)f2};[T2]£U¬fX l /Ul

Salidas roturas, gruesas. Pruébalo en línea!

Cómo funciona

            // Implicit: U = input string
U=UŠ@   }  // Set U to U split into chars, with each pair mapped by this function:
"..."bX+Y)  // Take the index in this string of the two chars concatenated.
            // This is 0-1 for chunky, 2-4 for smooth, and -1 for broken.
2+    f2    // Add two and floor to the nearest multiple of 2.
            // This is now 2 for chunky, 4 or 6 for smooth, and 0 for broken.
[T2]£       // Map each item X in [0,2] through this function:
U¬fX l      //  Count the occurances of X in U.
/Ul         //  Divide by U.length.
            // Implicit: output last expression

Versión no competitiva, 36 bytes

U=Uä@2+"\\/\\__/"bZ)f2};[T2]£UèX /Ul

Funciona básicamente de la misma manera que el otro, con algunos cambios menores:

• äahora funciona con cuerdas. Los caracteres se pasan a la función en orden (X, Y, X+Y).
• è cuenta el número de ocurrencias del argumento en la cadena / matriz.

Python 3, 149 bytes

Esto produce suavidad y firmeza.

def f(s):
 for i in"012":s=s.replace("\_/"[int(i)],i)
 a=len(s)-1;t=["bscbssbbc"[int(s[i:i+2],3)]for i in range(a)]
 for x in"sc":print(t.count(x)/a)

Sin golf:

def f(s):
    for i in "012":
        s = s.replace("\_/"[int(i)], i)
    a = len(s) - 1
    t = []
    for i in range(a):
        t.append("bscbssbbc"[int(s[i:i+2],3)])
    for x in "sc":
        print(t.count(x) / a)

Rubí, 71

Produce suavidad, aspereza.

Toma las cadenas suaves y gruesas mínimas y las busca por cada cadena de dos caracteres en la cadena inicial.

¡Gracias a Kevin Lau por OCHO bytes!

->x{%w{\\__/ /\\/}.map{|t|(0..n=x.size-2).count{|i|t[x[i,2]]}/(n+1.0)}}