Considérons une chaîne de longueur N, comme Peanut Butteravec N = 13. Notez qu'il y a N-1 paires de caractères voisins dans la chaîne. Car Peanut Butter, la première des 12 paires est Pe, la seconde est ea, la dernière est er.

Lorsque les paires sont principalement des caractères différents, la chaîne a une qualité volumineuse, par exemple chUnky.
Lorsque ces paires sont principalement le même caractère, la chaîne a une qualité lisse, par exemple sssmmsss.

Définissez la grosseur d'une chaîne comme étant le rapport du nombre de paires avec deux caractères différents au nombre total de paires (N-1).

Définissez le lissage d'une chaîne comme étant le rapport du nombre de paires avec deux caractères identiques au nombre total de paires (N-1).

Par exemple, Peanut Buttern'a qu'une seule paire avec des caractères identiques ( tt), donc son lissage est 1/12 ou 0,0833 et son gros morceau est 11/12 ou 0,9167.

Les chaînes vides et les chaînes avec un seul caractère sont définies comme 100% lisses et 0% grosses.

Défi

Écrivez un programme qui accepte une chaîne de longueur arbitraire et génère son rapport de grosseur ou de lissage sous forme de valeur à virgule flottante.

• Prenez l'entrée via stdin ou la ligne de commande, ou vous pouvez écrire une fonction qui prend une chaîne.
• Vous pouvez supposer que la chaîne d'entrée ne contient que des caractères ASCII imprimables (et donc une seule ligne).
• Imprimez le flotteur à stdout à 4 décimales ou plus, ou vous pouvez choisir de le retourner si vous avez écrit une fonction. Les décimales qui ne transmettent aucune information ne sont pas nécessaires, par exemple, 0c'est bien au lieu de 0.0000.
• Choisissez la grosseur ou la douceur selon vos préférences. Assurez-vous simplement de dire lequel produit votre programme.

Le code le plus court en octets gagne.

Exemples

Peanut Butter→ chunkiness: 0.91666666666, Lissé: 0.08333333333
chUnky→ chunkiness: 1.0, Lissé: 0.0
sssmmsss→ chunkiness: 0.28571428571, Lissé: 0.71428571428
999→ chunkiness: 0.0, Lissé: 1.0
AA→ chunkiness: 0.0, Lissé: 1.0
Aa→ chunkiness: 1.0, Lissé: 0.0
!→ chunkiness: 0.0, Lissé: 1.0
[chaîne vide] → chunkiness: 0.0, Douceur:1.0

Question bonus: laquelle préférez-vous , des cordes grosses ou lisses ?

APL, 10 octets

Ceci lit l'entrée de stdin et imprime la grosseur à stdout. L'algorithme est le même que celui utilisé pour la solution J.

(+/÷⍴)2≠/⍞

CJam, 19 octets

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

Code source 100% volumineux qui calcule la grosseur .

Essayez ce gros morceau en ligne.

Comment ça marche

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.

De toute évidence, NaN arrondi à 4 décimales est égal à 0.

Pyth, 13 12 octets

csJnVztz|lJ1

Code entièrement volumineux calculant la grosseur.

Manifestation. Harnais de test.

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 octets

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,x3donne la sous-chaîne de la chaîne x1commençant (une base) au numéro x2et se terminant au numéro x3, puis seq(construit une séquence.

Donne la valeur de lissage. La Ansvariable est 0par défaut, nous n'avons donc pas besoin d'un Elseà l' Ifinstruction, ni de stocker quoi que ce soit à l' Ansavance.

Matlab ( 37 36 octets)

Cela peut être fait avec la fonction anonyme suivante, qui retourne le gros morceau:

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

Commentaires:

• Dans les anciennes versions de Matlab (telles que R2010b), vous devez convertir +le tableau char xen un tableau double:

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

  Mais ce n'est pas le cas dans les versions récentes (testées dans R2014b), qui économisent un octet. Merci à Jonas pour son commentaire.

• L'expression avec maxgère les cas à un caractère et à zéro caractère (pour le gros morceau)

Exemple:

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

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

Ce programme renvoie la grosseur d'une chaîne.

Explication

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

Soumission précédente (37 + 3 = 40 octets)

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

Ce programme renvoie la fluidité d'une chaîne. L'entrée se fait via le-s drapeau, par ex.

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

C #, 94 89 octets

Sous 100 octets, donc je suppose que c'est une forme de victoire en soi?

Il s'agit d'une définition de fonction (autorisée selon la spécification) qui renvoie la fluidité de la chaîne d'entrée:

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

Assez simple, si la longueur est 0 ou 1, elle renvoie 1, sinon elle compare la chaîne à elle-même moins le premier caractère, puis renvoie le nombre de paires identiques divisé par le nombre de paires.

Modifier - remplacement de la sous-chaîne par Skip. Erreur de débutant!

J, 14 13 octets

Calcule la grosseur. Félicitations à J pour avoir défini 0 % 0une valeur égale à 0.

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

Essayez-le en ligne

Voici une explication:

   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 octets

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

Explication:

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

Cela génère le taux de lissage.

CJam, 16 octets

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

Code source astucieux qui calcule la fluidité .

Pour les entrées de longueur 0 ou 1, cela imprime le résultat correct avant de quitter avec une erreur. Avec l'interpréteur Java, la sortie d'erreur va à STDERR ( comme il se doit ).

Si vous essayez le code en ligne , ignorez tout, sauf la dernière ligne de sortie.

Comment ça marche

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 octets

Douceur!

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

Cela crée une fonction sans nom qui accepte une chaîne et renvoie une valeur numérique.

Si la longueur de l'entrée est inférieure à 2, la régularité est 1, sinon nous calculons la proportion de caractères adjacents identiques en prenant la moyenne d'un tableau de logiques.

Nim, 105 96 91 octets

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

Essayer d'apprendre Nim. Cela calcule la grosseur d'une chaîne.

^{( Si j'essaie de lire ceci en Python, l'indentation semble tout foiré ... Maintenant, cela ressemble plus à Ruby ...)}

Python 3, 63 octets

Il s'agit d'une fonction lambda anonyme qui prend une chaîne comme argument et renvoie sa grosseur.

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

Pour l'utiliser, donnez-lui un nom et appelez-le.

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 octets

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

Cela calcule la grosseur et affiche -0.0la chaîne vide. Si vous n'aimez pas les zéros négatifs, vous pouvez toujours corriger cela avec un octet supplémentaire:

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

Haskell, 64 octets

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

Produit une douceur. par exemple f "Peanut Butter"-> 8.333333333333333e-2.

Comment ça marche:

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])est la longueur de x, mais comme le système de type fort de Haskell nécessite de fournir des fractions /, je ne peux pas utiliser celui lengthqui renvoie des entiers. La conversion d'entiers en fractionnaires via fromInteger$length xest beaucoup trop longue.

JavaScript (ES6), 55 octets

Douceur, 56 octets

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

Chunkiness, 55 octets

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

Démo

Calcule la douceur, car c'est ce que je préfère. Fonctionne uniquement dans Firefox pour l'instant, car il s'agit de 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

Renvoie la douceur.

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

Explication

                         (),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

Tester

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

Rubis , 69 66 octets

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

Essayez-le en ligne!

Rasé de quelques octets avec les commentaires de IMP. De plus, avec la prochaine version 2.7.0 de Ruby, il est possible d'économiser quelques octets en remplaçant |x,y|x!=ypar@1!=@2

Python 3, 69 octets

Personne n'a encore publié de solution Python, alors voici une implémentation assez simple d'une fonction "chunkiness". Il court-circuite sur une chaîne de longueur 1et imprime0 (qui est un entier plutôt qu'un flottant mais semble être autorisé selon les règles).

Sur une chaîne vide, il génère -0.0 plutôt que 0.0. On peut dire que cela pourrait être considéré comme acceptable, en tant que -0.0 == 0 == 0.0retour True.

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

Exemples:

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

(Python 3 est utilisé pour sa division flottante par défaut.)

C, 83 octets

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;}

Une fonction de retour rend les gros morceaux .

Explication

float f(char *s) {

Acceptez une chaîne C et renvoyez un flottant (le double fonctionnerait mais est plus de caractères).

int a=0, b=0;

Compteurs - apour les paires totales, bpour les paires qui ne correspondent pas. L'utilisation intlimite la «longueur arbitraire» de la chaîne, mais ce n'est qu'une violation mineure des exigences et je ne vais pas la corriger.

if (*s)

Cas particulier de la chaîne vide - laissez les deux compteurs à zéro.

    while (s[++a])

Chaîne non vide - parcourez-la avec pré-incrémentation (donc la première fois dans la boucle, s[a]sera le deuxième caractère. Si la chaîne n'a qu'un seul caractère, le corps de la boucle ne sera pas entré et asera 1.

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

Si le caractère actuel diffère du précédent, incrémentez b.

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

Après la boucle, il y a trois possibilités: 'a == 0, b == 0' pour une entrée vide, 'a == 1, b == 0' pour une entrée à un seul caractère ou 'a> 1, b> = 0 'pour une entrée à plusieurs caractères. Nous soustrayons 1 de a(l' ?opérateur est un point de séquence, donc nous sommes sûrs), et si c'est zéro, nous avons le deuxième cas, donc nous devrions retourner zéro. Sinon, b/ac'est ce que nous voulons, mais nous devons bd'abord passer à un type à virgule flottante ou nous obtiendrons une division entière. Pour une chaîne vide, nous finirons avec un zéro négatif, mais les règles ne l'interdisent pas.

Tests:

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

Qui donne:

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

comme demandé.

Perl, 69

Fonction retournant la douceur :

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

Explication

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;
}

Les tests

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 octets

Cela ne gagne rien pour la taille, mais c'est simple:

Douceur

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

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

Out[177]= 0.285714

GeL: 76 73 caractères

Douceur.

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

Exemple d'exécution:

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 = fixations Gema + Lua. Beaucoup mieux, mais encore loin de gagner.)

Gema: 123 120 caractères

Douceur.

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

Exemple d'exécution:

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

(C'était plus un exercice pour moi de voir quelles sont les chances de le résoudre dans une langue sans support de nombres à virgule flottante et support arithmétique généralement douloureux. La 2e ligne, en particulier la \Pséquence, est de la magie pure, la dernière ligne est une véritable torture.)

Java 8, 84 82 octets

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

Rend la douceur.

Essayez-le en ligne.

Explication:

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

Noix de coco , 38 octets

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

Essayez-le en ligne!

Un port Python 3 serait de 50 octets .

PowerShell, 55 octets

Douceur

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

Semble un peu idiot pour obtenir une variable dans stdin puis lui donner un identifiant, mais c'est plus rapide que d'avoir une fonction.

Python 3, 61 octets

calculer la grosseur:

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

K (22)

peaufiné la solution Q de WooiKent:

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

Rubis, 63 octets

Génère de la grosseur.

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

Semblable à la solution de @ daniero, mais légèrement raccourci en divisant directement par la longueur de la chaîne - 1, puis en s'appuyant sur .count pour être nul avec les chaînes de longueur 0 et 1 (le .max garantit que je ne diviserai pas par 0 ou -1).

Mathematica, 107 octets

Calcule la grosseur en prenant la moitié de la distance de Levenshtein entre chaque digraphe et son inverse.

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

Si vous préférez une réponse rationnelle exacte, supprimez .5et placez un /2avant le dernier &sans pénalité. Le programme lui-même a une grosseur 103/106, soit environ 0,972.