Basé sur Chunky vs Smooth Strings .

Les gribouillis /\_/\/\__/\/\/\/\_/\_/\sont amusants à faire sur un clavier lorsque vous vous ennuyez vraiment. Mais tous les gribouillis ne sont pas créés égaux. Certains gribouillis sont lisses, comme \___/, et certains sont gros, comme /\/\/\/\. D'autres sont carrément cassés, comme////_\\\

À l'intérieur de chaque squiggle de Npersonnages, il y a N-1des jonctions de squiggle. Chaque jonction de gribouillis est classée dans l'un des trois types suivants:

• Lisse (angle> "90 degrés"):

  \_ __ _/

• Chunky (angle = "90 degrés")

  /\ \/

• Cassé (tout ce qui ne se connecte pas)

  // \\ /_ _\

Définissons la douceur d'être la proportion des jonctions qui sont lisses, avec chunkiness et brisement définis de façon similaire. Chaque valeur est comprise entre 0et 1. La somme de la douceur, de la grosseur et de la cassure d'un gribouillis est toujours égale à 1.

Par exemple, le squiggle /\/\\_//\_a 3 jonctions lisses, 4 jonctions grosses et 2 jonctions cassées. Il est donc 0.3333lisse, 0.4444trapu et 0.2222cassé.

Les chaînes vides et les chaînes avec un seul caractère ont des valeurs non définies, toutes les entrées auront au moins 2 caractères.

Défi

Écrivez un programme qui prend un gribouillis de longueur arbitraire et génère deux de ses valeurs de lissage, de grosseur et de cassure.

• Vous pouvez écrire un programme ou une fonction, avec une entrée via STDIN, une ligne de commande ou comme argument de chaîne.
• Vous pouvez supposer que l'entrée est au moins de longueur> = 2 et se compose uniquement des caractères /\_avec un retour à la ligne facultatif.
• Imprimer (ou retourner si une fonction) les deux flottants avec une précision d'au moins 4 décimales, arrondis ou tronqués. Si la vraie valeur est 2/3, les valeurs acceptables incluent toute valeur entre 0.6666et 0.6667, même des choses comme 0.666637104. Si la valeur exacte est 1/3, toute réponse contenant 0.3333est valide. Vous pouvez laisser des zéros de fin ou le zéro de tête si la valeur est inférieure à un.
• Sortez n'importe quelle paire des trois valeurs comme vous préférez, assurez-vous simplement d'indiquer lesquelles et dans quel ordre.

Le code le plus court en octets gagne.

Exemples

/\/\\/\//\\→ douceur 0, grosseur 0.7, cassure0.3

_/\\_/\\/__/\\\//_→ douceur 0.29411764705, grosseur 0.29411764705, cassure0.41176470588

//\\__/_\/→ douceur 0.3333333, grosseur 0.2222222, cassure0.4444444

Question bonus: Que préférez-vous, des gribouillis lisses ou trapus ou cassés?

Pyth, 25 octets

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

Suite de tests

Rend la douceur, la grosseur. Fondamentalement, il prend la chaîne codée en dur et la coupe en deux. Chaque moitié est décomposée en ses deux sous-chaînes de caractères, et il en est de même pour l'entrée. Nous prenons l'intersection, résultant dans les paires sud et chunky. Ensuite, nous prenons la longueur, divisons par le nombre de paires et imprimons.

Japt, 42 octets

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

Sorties cassure, chunkyness. Essayez-le en ligne!

Comment ça fonctionne

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

Version non concurrente, 36 octets

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

Fonctionne essentiellement de la même manière que l'autre, avec quelques modifications mineures:

• äfonctionne maintenant sur les chaînes. Les caractères sont passés dans la fonction dans l'ordre (X, Y, X+Y).
• è compte le nombre d'occurrences de l'argument dans la chaîne / tableau.

Python 3, 149 octets

Cela produit de la fluidité et de la grosseur.

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)

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

Rubis, 71

Rend la douceur, la grosseur.

Prend les chaînes lisses et épaisses minimales et les recherche pour chaque chaîne de deux caractères dans la chaîne initiale.

Merci à Kevin Lau pour HUIT octets!

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