Considera una stringa di lunghezza N, come ad esempio Peanut ButterN = 13. Nota che nella stringa sono presenti coppie N-1 di caratteri adiacenti. Perché Peanut Butter, la prima delle 12 coppie è Pe, la seconda è ea, l'ultima è er.

Quando le coppie sono per lo più caratteri diversi, la stringa ha una qualità grossa, ad es chUnky.
Quando queste coppie hanno principalmente lo stesso carattere, la stringa ha una qualità uniforme, ad es sssmmsss.

Definire il blocco di una stringa in modo che sia il rapporto tra il numero di coppie con due caratteri diversi e il numero totale di coppie (N-1).

Definisci la scorrevolezza di una stringa in modo che sia il rapporto tra il numero di coppie con due caratteri identici e il numero totale di coppie (N-1).

Ad esempio, Peanut Butterha solo una coppia con caratteri identici ( tt), quindi la sua scorrevolezza è 1/12 o 0,0833 e la sua robustezza è 11/12 o 0,9167.

Le stringhe vuote e le stringhe con un solo carattere sono definite come morbide al 100% e grosse allo 0%.

Sfida

Scrivi un programma che accetta una stringa di lunghezza arbitraria e genera il suo valore di chunkiness o smoothness come valore in virgola mobile.

• Prendi l'input tramite stdin o la riga di comando, oppure potresti scrivere una funzione che accetta una stringa.
• Puoi supporre che la stringa di input contenga solo caratteri ASCII stampabili (e quindi sia una riga singola).
• Stampa il float su stdout su 4 o più cifre decimali oppure puoi scegliere di restituirlo se hai scritto una funzione. Le posizioni decimali che non trasmettono informazioni non sono necessarie, ad esempio 0va bene invece di 0.0000.
• Scegli il chunkiness o la scorrevolezza come preferisci. Assicurati di dire quale dei tuoi programmi genera.

Vince il codice più breve in byte.

Esempi

Peanut Butter→ chunkiness: 0.91666666666, Scorrevolezza: 0.08333333333
chUnky→ chunkiness: 1.0, Scorrevolezza: 0.0
sssmmsss→ chunkiness: 0.28571428571, Scorrevolezza: 0.71428571428
999→ chunkiness: 0.0, Scorrevolezza: 1.0
AA→ chunkiness: 0.0, Scorrevolezza: 1.0
Aa→ chunkiness: 1.0, Scorrevolezza: 0.0
!→ chunkiness: 0.0, Scorrevolezza: 1.0
[stringa vuota] → chunkiness: 0.0, Uniformità:1.0

Domanda bonus: quale preferisci , stringhe grosse o lisce ?

APL, 10 byte

Questo legge l'input da stdin e stampa il grosso su stdout. L'algoritmo è lo stesso usato per la soluzione J.

(+/÷⍴)2≠/⍞

CJam, 19 byte

q_1>_@.=:!1b\,d/4mO

Codice sorgente grosso al 100% che calcola il grosso .

Prova questa grande bontà online.

Come funziona

q_                  e# Read from STDIN and push a copy.
  1>_               e# Discard the first character and push a copy.
     @              e# Rotate the original on top.
      .=            e# Vectorized comparison (1 if equal, 0 if not).
        :!          e# Mapped logical NOT (0 if equal, 1 if not).
          1b        e# Base 1 conversion (sum).
            \,      e# Swap with the shortened string and push its length.
              d/    e# Cast to double and divide.
                4mO e# Round to four decimal places.

Ovviamente, NaN arrotondato al quarto decimale è 0.

Pyth, 13 12 byte

csJnVztz|lJ1

Codice grosso grosso che calcola il grosso.

Dimostrazione. Collaudare l'imbragatura.

csJnVztz|lJ1
                 Implicit: z = input()
   nV            n, !=, vectorized over
     z           z
      tz         z[:-1]
                 V implitly truncates.
  J              Store it in J.
 s               sum J
c                floating point divided by
         |       logical or
          lJ     len(J)
            1    1

TI-BASIC, 46 byte

Input Str1
If 2≤length(Str1
mean(seq(sub(Str1,X,1)=sub(Str1,X-1,1),X,2,length(Str1
Ans

sub(x1,x2,x3fornisce la sottostringa della stringa che x1inizia (a base singola) in numero x2e termina in numero x3, quindi seq(crea una sequenza.

Fornisce il valore di levigatezza. La Ansvariabile è 0di default, quindi non abbiamo bisogno Elsedi Ifun'istruzione o di archiviare nulla in Ansanticipo.

Matlab ( 37 36 byte)

Questo può essere fatto con la seguente funzione anonima, che restituisce il chunkiness:

f=@(x)nnz(diff(x))/max(numel(x)-1,1)

Commenti:

• Nelle vecchie versioni di Matlab (come R2010b) è necessario +eseguire il cast dell'array char xin un array doppio:

  f=@(x)nnz(diff(+x))/max(numel(x)-1,1)`
  

  Ma non è così nelle versioni recenti (testato in R2014b), che consente di risparmiare un byte. Grazie a Jonas per il suo commento.

• L'espressione con maxgestisce i casi di un carattere e zero caratteri (per blocco)

Esempio:

>> f=@(x)nnz(diff(x))/max(numel(x)-1,1)
f = 
    @(x)nnz(diff(x))/max(numel(x)-1,1)

>> f('Peanut Butter')
ans =
   0.9167

> <> , 40 36 byte

00ii:0(?v:@=1$-{+{1+}}20.
~:0=+,n;>~

Questo programma restituisce il grosso di una stringa.

Spiegazione

00i         Push 0 (# unequal pairs), 0 (length of string - 1) and read first char

[main loop]

i           Read a char
:0(?v       If we've hit EOF, go down a row
:@=1$-      Check (new char != previous char)
{+          Add to unequal pairs count
{1+         Increment length by 1
}}20.       Continue loop

[output]

~~          Pop last two chars (top one will be -1 for EOF)
:0=+        Add 1 to length if zero (to prevent division by zero errors)
,           Divide, giving chunkiness
n;          Output and halt

Invio precedente (37 + 3 = 40 byte)

l1)?v1n;
n,$&\l1-}0& \;
l2(?^$:@=&+&>

Questo programma restituisce la scorrevolezza di una stringa. L'immissione avviene tramite il -sflag, ad es

py -3 fish.py chunkiness.fish -s "Peanut Butter"

C #, 94 89 byte

Sotto 100 byte, quindi immagino che sia una qualche forma di vittoria in sé?

Questa è una definizione di funzione (consentita secondo le specifiche) che restituisce la scorrevolezza della stringa di input:

Func<string,float>(s=>s.Length>1?s.Zip(s.Skip(1),(a,b)=>a==b?1f:0).Sum()/(s.Length-1):1);

Abbastanza semplice, se la lunghezza è 0 o 1 restituisce 1, altrimenti confronta la stringa con se stessa meno il primo carattere, quindi restituisce il numero di coppie identiche diviso per il numero di coppie.

Modifica: sostituito sottostringa con Salta. Errore da principiante!

J, 14 13 byte

Calcola il grosso. Complimenti a J per aver definito 0 % 0uguale a 0.

(]+/%#)2~:/\]

Provalo online

Ecco una spiegazione:

   NB. sample input
   in =. 'sssmmsss'

   NB. all infixes of length 2
   2 ]\ in
ss
ss
sm
mm
ms
ss
ss

    NB. are the parts of the infix different?
    2 ~:/\ in
0 0 1 0 1 0 0

    NB. sum and item count of the previous result
    (+/ , #) 2 ~:/\ in
2 7

    NB. arithmetic mean: chunkiness
    (+/ % #) 2 ~:/\ in
0.285714

    NB. as a tacit verb
    (] +/ % #) 2 ~:/\ ]

    NB. 0 divided by 0 is 0 in J
    0 % 0
0

CJam, 23 byte

q_,Y<SS+@?2ew_::=:+\,d/

Spiegazione:

q                           e# read input
 _,                         e# its length
   Y<                       e# is less than 2?
     SS+                    e# then a smooth string
        @?                  e# otherwise the input
          2ew               e# pairs of consecutive characters
             _::=           e# map to 1 if equal, 0 if not
                 :+         e# sum (number of equal pairs)
                   \,       e# total number of pairs
                     d/     e# divide

Questo genera il rapporto di scorrevolezza.

CJam, 16 byte

1q2ew::=_:+\,d/*

Codice sorgente economico che calcola la scorrevolezza .

Per input di lunghezza 0 o 1, questo stampa il risultato corretto prima di uscire con un errore. Con l'interprete Java, l'output dell'errore va su STDERR ( come dovrebbe ).

Se provi il codice online , ignora tutto tranne l'ultima riga di output.

Come funziona

1q               e# Push a 1 and read from STDIN.
  2ew            e# Push the overlapping slices of length 2.
                 e# This will throw an error for strings of length 0 or 1,
                 e# so the stack (1) is printed and the program finishes.
     ::=         e# Twofold vectorized comparision.
        _:+      e# Push a copy and add the Booleans.
           \,    e# Swap with the original and compute its length.
             d/  e# Cast to double and divide.
               * e# Multiply with the 1 on the bottom of the stack.

Julia, 52 byte

Uniformità!

s->(n=length(s))<2?1:mean([s[i]==s[i+1]for i=1:n-1])

Ciò crea una funzione senza nome che accetta una stringa e restituisce un valore numerico.

Se la lunghezza dell'input è inferiore a 2, la levigatezza è 1, altrimenti calcoliamo la proporzione di caratteri adiacenti identici prendendo la media di una matrice di logici.

Nim, 105 96 91 byte

proc f(s):any=
 var a=0;for i,c in s[.. ^2]:a+=int(s[i+1]!=c)
 a.float/max(s.len-1,1).float

Cercando di imparare Nim. Questo calcola il grosso di una stringa.

^{( Se provo a leggere questo come Python, il rientro sembra tutto incasinato ... Ora sembra più simile a Ruby ...)}

Python 3, 63 byte

Questa è una funzione lambda anonima che accetta una stringa come argomento e restituisce la sua pesantezza.

lambda n:~-len(n)and sum(x!=y for x,y in zip(n,n[1:]))/~-len(n)

Per usarlo, dagli un nome e chiamalo.

f=lambda n:~-len(n)and sum(x!=y for x,y in zip(n,n[1:]))/~-len(n)
f("Peanut Butter") -> 0.08333333333333333
f("!")             -> 0
f("")              -> -0.0

Python 3, 52 byte

lambda s:sum(map(str.__ne__,s,s[1:]))/(len(s)-1or 1)

Questo calcola la chunkiness e produce output -0.0per la stringa vuota. Se non ti piacciono gli zero negativi puoi sempre risolverlo con un byte extra:

lambda s:sum(map(str.__ne__,s,s[1:]))/max(len(s)-1,1)

Haskell, 64 byte

f[]=1
f[_]=1
f x=sum[1|(a,b)<-zip=<<tail$x,a==b]/(sum(x>>[1])-1)

Produce fluidità. es. f "Peanut Butter"-> 8.333333333333333e-2.

Come funziona:

f[]=1                               -- special case: empty list
f[_]=1                              -- special case: one element list

f x=                                -- x has at least two elements
         (a,b)<-zip=<<tail$x        -- for every pair (a,b), drawn from zipping x with the tail of itself
                            ,a==b   -- where a equals b
      [1|                        ]  -- take a 1
   sum                              -- and sum it
              /                     -- divide  by
                   (x>>[1])         -- map each element of x to 1
               sum                  -- sum it
                           -1       -- and subtract 1

sum(x>>[1])è la lunghezza di x, ma poiché il sistema di tipo forte di Haskell richiede di alimentare frazionari /, non posso usare lengthquale restituisce numeri interi. La conversione di numeri interi in frazionari fromInteger$length xè troppo lunga.

JavaScript (ES6), 55 byte

Smoothness, 56 byte

f=x=>(z=x.match(/(.)(?=\1)/g))?z.length/--x.length:+!x[1]

Chunkiness, 55 byte

f=x=>(z=x.match(/(.)(?!\1)/g))&&--z.length/--x.length||0

dimostrazione

Calcola la scorrevolezza, poiché è quello che preferisco. Funziona solo in Firefox per ora, in quanto è ES6.

f=x=>(z=x.match(/(.)(?=\1)/g))?z.length/--x.length:+!x[1]

O.innerHTML += f('Peanut Butter') + '\n';
O.innerHTML += f('chUnky') + '\n';
O.innerHTML += f('sssmmsss') + '\n';
O.innerHTML += f('999') + '\n';
O.innerHTML += f('AA') + '\n';
O.innerHTML += f('Aa') + '\n';
O.innerHTML += f('!') + '\n';
O.innerHTML += f('') + '\n';

<pre id=O></pre>

KDB (Q), 30

Restituisce morbidezza.

{1^sum[x]%count x:1_(=':)(),x}

Spiegazione

                         (),x    / ensure input is always list
                x:1_(=':)        / check equalness to prev char and reassign to x
   sum[x]%count                  / sum equalness divide by count N-1
 1^                              / fill null with 1 since empty/single char will result in null
{                             }  / lamdba

Test

q){1^sum[x]%count x}1_(=':)(),x}"Peanut Butter"
0.08333333
q){1^sum[x]%count x:1_(=':)(),x}"sssmmsss"
0.7142857
q){1^sum[x]%count x:1_(=':)(),x}"Aa"
0f
q){1^sum[x]%count x:1_(=':)(),x}"aa"
1f
q){1^sum[x]%count x:1_(=':)(),x}"chUnky"
0f
q){1^sum[x]%count x:1_(=':)(),x}"!"
1f
q){1^sum[x]%count x:1_(=':)(),x}""
1f

Rubino , 69 66 byte

->s{(c=s.chars.each_cons(2).count{|x,y|x!=y}.to_f/~-s.size)>0?c:0}

Provalo online!

Rasato di pochi byte con commenti dall'IMP. Inoltre, con la prossima versione 2.7.0 di Ruby è possibile salvare alcuni byte sostituendoli |x,y|x!=ycon@1!=@2

Python 3, 69 byte

Nessuno ha ancora pubblicato una soluzione Python, quindi ecco un'implementazione abbastanza semplice di una funzione di "chunkiness". Cortocircuita su una stringa di lunghezza 1e stampa 0(che è un numero intero anziché un float ma sembra essere consentito in base alle regole).

Su una stringa vuota, viene emesso -0.0anziché 0.0. Probabilmente questo potrebbe essere considerato accettabile, come -0.0 == 0 == 0.0resi True.

def c(s):l=len(s)-1;return l and sum(s[i]!=s[i+1]for i in range(l))/l

Esempi:

>>> c(''); c('a'); c('aaa'); c("Peanut Butter")
-0.0
0
0.0
0.916666666667
>>> -0.0 == 0 == 0.0
True

(Python 3 viene utilizzato per la sua divisione float predefinita.)

C, 83 byte

float f(char*s){int a=0,b=0;if(*s)while(s[++a])b+=s[a]!=s[a-1];return--a?1.*b/a:b;}

Una funzione che restituisce il grosso .

Spiegazione

float f(char *s) {

Accetta una stringa C e restituisce un float (il doppio funzionerebbe ma è più caratteri).

int a=0, b=0;

Contatori: aper coppie totali, bper coppie non corrispondenti. L'uso intlimita la "lunghezza arbitraria" della stringa, ma questa è solo una piccola violazione dei requisiti e non ho intenzione di risolverlo.

if (*s)

Caso speciale la stringa vuota - lascia entrambi i contatori zero.

    while (s[++a])

Stringa non vuota: scorrere attraverso di essa con pre-incremento (quindi la prima volta nel ciclo s[a]sarà il secondo carattere. Se la stringa ha un solo carattere, il corpo del ciclo non verrà inserito e asarà 1.

        b += s[a]!=s[a-1];

Se il carattere corrente differisce dal precedente, incrementare b.

return --a ? 1.*b/a : b;
}

Dopo il ciclo, ci sono tre possibilità: 'a == 0, b == 0' per un input vuoto, 'a == 1, b == 0' per un input a carattere singolo o 'a> 1, b> = 0 'per l'immissione di più caratteri. Sottraiamo 1 da a(l' ?operatore è un punto di sequenza, quindi siamo al sicuro), e se è zero, abbiamo il secondo caso, quindi dovremmo restituire zero. Altrimenti, b/aè quello che vogliamo, ma dobbiamo prima promuovere bun tipo a virgola mobile o otterremo la divisione intera. Per una stringa vuota, finiremo con uno zero negativo, ma le regole non lo impediscono.

test:

#include <stdio.h>
int main(int argc, char **argv)
{
    while (*++argv)
        printf("%.6f %s\n", f(*argv), *argv);
}

Che dà:

./chunky 'Peanut Butter' chUnky sssmmsss 999 AA Aa '!' ''
0.916667 Peanut Butter
1.000000 chUnky
0.285714 sssmmsss
0.000000 999
0.000000 AA
1.000000 Aa
0.000000 !
-0.000000 

come richiesto.

Perl, 69

Funzione che restituisce fluidità :

sub f{($_)=@_;$s=s/(.)(?!\1)//sgr;chop;!$_||length($s)/length;}

Spiegazione

sub f {
    # read argument into $_
    ($_) = @_;

    # copy $_ to $s, removing any char not followed by itself
    # /s to handle newlines as all other characters
    $s = s/(.)(?!\1)//sgr;

     # reduce length by one (unless empty)
    chop;

    # $_ is empty (false) if length was 0 or 1
    # return 1 in that case, else number of pairs / new length
    !$_ || length($s)/length;
}

test

printf "%.6f %s\n", f($a=$_), $a foreach (@ARGV);

0.083333 Peanut Butter
0.000000 chUnky
0.714286 sssmmsss
1.000000 999
1.000000 AA
0.000000 Aa
1.000000 !
1.000000 

Mathematica, 73 72 byte

Questo non vince nulla per dimensioni, ma è semplice:

levigatezza

N@Count[Differences@#,_Plus]/(Length@#-1)&@StringSplit[#,""]&

In[177]:= N@Count[Differences@#,_Plus]/(Length@#-1)&@StringSplit[#,""] &@"sssmmsss"

Out[177]= 0.285714

GeL: 76 73 caratteri

Scorrevolezza.

@set{d;0}
?\P$1=@incr{d}
?=
\Z=@lua{c=@column -1\;return c<1and 1or $d/c}

Esecuzione di esempio:

bash-4.3$ for i in 'Peanut Butter' 'chUnky' 'sssmmsss' '999' 'AA' 'Aa' '!' ''; do
>     echo -n "$i -> "
>     echo -n "$i" | gel -f smooth.gel
>     echo
> done
Peanut Butter -> 0.083333333333333
chUnky -> 0
sssmmsss -> 0.71428571428571
999 -> 1
AA -> 1
Aa -> 0
! -> 1
 -> 1

(GeL = attacchi Gema + Lua. Molto meglio, ma ancora lontani dalla vittoria.)

Gema: 123 120 caratteri

Scorrevolezza.

@set{d;0}
?\P$1=@incr{d}
?=
\Z=@subst{\?\*=\?.\*;@cmpn{@column;1;10;10;@fill-right{00000;@div{$d0000;@sub{@column;1}}}}}

Esecuzione di esempio:

bash-4.3$ for i in 'Peanut Butter' 'chUnky' 'sssmmsss' '999' 'AA' 'Aa' '!' ''; do
>     echo -n "$i -> "
>     echo -n "$i" | gema -f smooth.gema
>     echo
> done
Peanut Butter -> 0.0833
chUnky -> 0.0000
sssmmsss -> 0.7142
999 -> 1.0000
AA -> 1.0000
Aa -> 0.0000
! -> 1.0
 -> 1.0

(È stato più un esercizio per me stesso vedere quali sono le possibilità di risolverlo in una lingua senza supporto numerico in virgola mobile e supporto aritmetico generalmente doloroso. La seconda riga, in particolare la \Psequenza, è pura magia, l'ultima riga è vera tortura.)

Java 8, 84 82 byte

s->{float l=s.length()-1,S=s.split("(.)(?=\\1)").length-1;return l<1?1:S<1?0:S/l;}

Smoothness delle uscite.

Provalo online.

Spiegazione:

s->{                     // Method with String parameter and float return-type
  float l=s.length()-1,  //  Length of the input-String minus 1 (amount of pairs in total)
        S=s.split("(.)(?=\\1)").length-1;
                         //  Length of the input split by duplicated pairs (with lookahead)
  return l<1?            //  If the length of the input is either 0 or 1:
          1              //   Return 1
         :S<1?           //  Else-if `S` is -1 or 0:
          0              //   Return 0
         :               //  Else:
          S/l;}          //   Return duplicated pairs divided by the length-1

Cocco , 38 byte

s->sum(map((!=),s,s[1:]))/-~len(s[2:])

Provalo online!

Una porta Python 3 sarebbe 50 byte .

PowerShell, 55 byte

levigatezza

%{$s=$_;@([char[]]$s|?{$_-eq$a;$a=$_;$i++}).count/--$i}

Sembra un po 'sciocco ottenere una variabile in stdin e quindi dargli un identificatore, ma è più veloce che avere una funzione.

Python 3, 61 byte

calcola il grosso:

f=lambda s: sum(a!=b for a,b in zip(s,s[1:]))/max(len(s)-1,1)

K (22)

ottimizzato la soluzione Q di WooiKent:

{1^(+/x)%#x:1_=':(),x}

Rubino, 63 byte

Produce chunkiness.

f=->s{s.chars.each_cons(2).count{|x,y|x!=y}/[s.size-1.0,1].max}

Simile alla soluzione di @ daniero, ma leggermente accorciato dividendo direttamente per la lunghezza della stringa - 1 e quindi basandosi su .count per essere zero con stringhe di lunghezza 0 e 1 (.max assicura che non dividerò per 0 o -1).

Mathematica, 107 byte

Calcola il chunkiness prendendo metà della distanza di Levenshtein tra ogni digraph e il suo contrario.

f[s_]:=.5EditDistance@@{#,StringReverse@#}&/@StringCases[s,_~Repeated~{2},Overlaps->All]//Total@#/Length[#]&

Se preferisci una risposta razionale esatta, elimina .5e posiziona un /2prima dell'ultimo &senza penalità. Il programma stesso ha un grosso 103/106, o circa .972.