Baseado em Chunky vs. Smooth Strings .

Rabiscos /\_/\/\__/\/\/\/\_/\_/\são divertidos de fazer no teclado quando você está realmente entediado. Mas nem todos os rabiscos são criados iguais. Alguns rabiscos são suaves, tipo \___/, e alguns são grossos, tipo /\/\/\/\. Outros são simplesmente quebrados, como////_\\\

Dentro de cada rabisco de Ncaracteres, há N-1junções de rabiscos. Cada junção de rabisco é classificada em um dos três tipos:

• Suave (ângulo> "90 graus"):

  \_ __ _/

• Robusto (ângulo = "90 graus")

  /\ \/

• Quebrado (qualquer coisa que não se conecte)

  // \\ /_ _\

Vamos definir a suavidade como a proporção de junções que são suaves, com robustez e quebra definidas de maneira semelhante. Cada valor varia entre 0e 1. A soma da suavidade, robustez e quebra de um rabisco é sempre igual a 1.

Por exemplo, o rabisco /\/\\_//\_possui 3 junções suaves, 4 junções grossas e 2 junções quebradas. É, portanto 0.3333, suave, 0.4444robusto e 0.2222quebrado.

Seqüências de caracteres vazias e com apenas um caractere têm valores indefinidos, todas as entradas terão pelo menos 2 caracteres.

Desafio

Escreva um programa que controla um comprimento arbitrário e produz dois de seus valores de suavidade, robustez e quebra.

• Você pode escrever um programa ou função, com entrada via STDIN, linha de comando ou como argumento de string.
• Você pode supor que a entrada tenha pelo menos comprimento> = 2 e consiste apenas nos caracteres /\_com uma nova linha à direita opcional.
• Imprima (ou retorne se uma função) os dois flutuarem com uma precisão de pelo menos 4 casas decimais, arredondadas ou truncadas. Se o valor verdadeiro for 2/3, valores aceitáveis ​​incluem qualquer valor entre 0.6666e 0.6667, até coisas como 0.666637104. Se o valor exato for 1/3, qualquer resposta que contenha 0.3333é válida. Você pode deixar zeros à direita ou o zero à esquerda se o valor for menor que um.
• Saída qualquer par dos três valores como você preferir, apenas certifique-se de indicar quais dois e em que ordem.

O código mais curto em bytes vence.

Exemplos

/\/\\/\//\\→ Suavidade 0, Robustez 0.7, Fragilidade0.3

_/\\_/\\/__/\\\//_→ Suavidade 0.29411764705, Robustez 0.29411764705, Fragilidade0.41176470588

//\\__/_\/→ Suavidade 0.3333333, Robustez 0.2222222, Fragilidade0.4444444

Pergunta bônus: Qual você prefere, rabiscos suaves, grossos ou quebrados?

Pitão, 25 bytes

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

Suíte de teste

Produz suavidade, robustez. Basicamente, ele pega a corda codificada e a corta pela metade. Cada metade é decomposta em suas substrings de 2 caracteres e o mesmo é feito para a entrada. Tomamos a interseção, resultando nos pares sul e robusto. Então, pegamos o comprimento, dividimos pelo número de pares e imprimimos.

Japonês, 42 bytes

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

Saídas quebradas, grossas. Experimente online!

Como 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

Versão não concorrente, 36 bytes

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

Funciona basicamente da mesma maneira que a outra, com algumas pequenas alterações:

• äagora funciona em strings. Os caracteres são passados ​​para a função em ordem (X, Y, X+Y).
• è conta o número de ocorrências do argumento na string / array.

Python 3, 149 bytes

Isso gera suavidade e robustez.

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)

Ungolfed:

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)

Ruby, 71

Produz suavidade, robustez.

Pega as seqüências suaves e robustas mínimas e as procura por cada sequência de dois caracteres na sequência inicial.

Agradecimentos a Kevin Lau por OITO bytes!

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