Basato su stringhe spesse e morbide .

Gli squiggles /\_/\/\__/\/\/\/\_/\_/\sono divertenti da fare su una tastiera quando sei davvero annoiato. Ma non tutti gli squiggles sono creati uguali. Alcuni squiggles sono lisci, come \___/, e alcuni sono pesanti, come /\/\/\/\. Altri sono semplicemente distrutti, come////_\\\

All'interno di ogni scricchiolio di Npersonaggi, ci sono N-1giunzioni a squiggle. Ogni giunzione squiggle è classificata in uno di tre tipi:

• Smooth (angolo> "90 gradi"):

  \_ __ _/

• Grosso (angolo = "90 gradi")

  /\ \/

• Rotto (tutto ciò che non si collega)

  // \\ /_ _\

Definiamo la levigatezza sia la percentuale di giunzioni che sono lisce, con chunkiness e brokenness definite in modo simile. Ogni valore è compreso tra 0e 1. La somma di levigatezza, rigidità e fragilità di uno squiggle è sempre uguale a 1.

Ad esempio, lo squiggle /\/\\_//\_ha 3 giunzioni lisce, 4 giunzioni grosse e 2 giunzioni rotte. È quindi 0.3333liscio, 0.4444grosso e 0.2222rotto.

Le stringhe vuote e le stringhe con un solo carattere hanno valori non definiti, tutti gli input saranno lunghi almeno 2 caratteri.

Sfida

Scrivi un programma che assorbe una lunghezza irregolare e produca due valori di levigatezza, rigidezza e rottura.

• È possibile scrivere un programma o una funzione, con input tramite STDIN, riga di comando o come argomento stringa.
• È possibile supporre che l'input sia almeno di lunghezza> = 2 e sia composto solo da caratteri /\_con una nuova riga finale facoltativa.
• Stampa (o ritorna se una funzione) i due galleggianti con una precisione di almeno 4 decimali, arrotondati o troncati. Se il valore vero è 2/3, i valori accettabili includono qualsiasi valore tra 0.6666e 0.6667, anche cose del genere 0.666637104. Se il valore esatto è 1/3, qualsiasi risposta contenente 0.3333è valida. È possibile lasciare gli zeri finali o lo zero iniziale se il valore è inferiore a uno.
• Emetti qualsiasi coppia dei tre valori come preferisci, assicurati di indicare quali due e in quale ordine.

Vince il codice più breve in byte.

Esempi

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

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

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

Domanda bonus: quale preferisci, squiggles lisci o pesanti o rotti?

Pyth, 25 byte

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

Suite di test

Produce morbidezza, robustezza. Fondamentalmente, prende la stringa hard coded e la taglia a metà. Ogni metà viene scomposta nelle sue sottostringhe di 2 caratteri e lo stesso viene fatto per l'input. Prendiamo l'incrocio, risultando nelle coppie sud e grosso. Quindi, prendiamo la lunghezza, dividiamo per il numero di coppie e stampiamo.

Japt, 42 byte

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

Emette rotture, grosso. Provalo online!

Come funziona

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

Versione non competitiva, 36 byte

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

Funziona praticamente allo stesso modo dell'altro, con alcune piccole modifiche:

• äora funziona su stringhe. I caratteri vengono passati nella funzione in ordine (X, Y, X+Y).
• è conta il numero di occorrenze dell'argomento nella stringa / matrice.

Python 3, 149 byte

Ciò produce morbidezza e robustezza.

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

Produce morbidezza, robustezza.

Prende le stringhe lisce e grosse minime e le cerca per ogni stringa di due caratteri nella stringa iniziale.

Grazie a Kevin Lau per OTTO byte!

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