Peanut ButterN = 13 gibi N uzunluklu bir dize düşünün . Dizede N-1 komşu karakter çiftlerinin bulunduğuna dikkat edin. Çünkü Peanut Butter, 12 çiftin ilki Pe, ikincisi, easonuncusu er.

Çiftler çoğunlukla farklı karakterler olduğunda, dize tıknaz bir kaliteye sahiptir, örn chUnky.
Bu çiftler çoğunlukla aynı karakter olduğunda, dize yumuşak bir kaliteye sahiptir, örneğinsssmmsss .

Tıknazlığı tanımlaBir dize iki farklı karakterli çift sayısının toplam çift sayısına oranı olarak (N-1).

Pürüzsüzlüğü tanımlayınBir dize , iki aynı karaktere sahip çift sayısının toplam çift sayısına (N-1) oranı olarak .

Örneğin, Peanut Butteraynı karaktere ( tt) sahip yalnızca bir çift vardır , bu nedenle pürüzsüzlüğü 1/12 veya 0.0833 ve yığınlığı 11/12 veya 0.9167'dir.

Boş dizeler ve yalnızca bir karakter içeren dizeler% 100 düzgün ve% 0 tıknaz olarak tanımlanır.

Meydan okuma

İsteğe bağlı bir uzunlukta bir dizi olan ve yığınsallık veya pürüzsüzlük oranını kayan nokta değeri olarak veren bir program yazın.

• Stdin veya komut satırı üzerinden giriş yapın, aksi halde dize alan bir fonksiyon yazabilirsiniz.
• Giriş dizesinin yalnızca yazdırılabilir ASCII karakterleri içerdiğini (ve dolayısıyla tek satırlık olduğunu) kabul edebilirsiniz.
• Şamandırayı stdout'a 4 veya daha fazla ondalık basamağa yazdırın veya işlev yazdıysanız döndürmeyi seçebilirsiniz. Hiçbir bilgi iletmeyen ondalık basamaklara gerek yoktur, örneğin 0bunun yerine iyi 0.0000.
• Tercih ettiğiniz gibi öbek veya pürüzsüzlük seçin. Sadece programınızın çıktılarını söylediğinizden emin olun.

Bayt cinsinden en kısa kod kazanır.

Örnekler

Peanut Butter→ bodurluk: 0.91666666666, Pürüzsüzlük: 0.08333333333
chUnkybodurluk →: 1.0, Pürüzsüzlük: 0.0
sssmmsssbodurluk →: 0.28571428571, Pürüzsüzlük: 0.71428571428
999bodurluk →: 0.0, Pürüzsüzlük: 1.0
AAbodurluk →: 0.0, Pürüzsüzlük: 1.0
Aabodurluk →: 1.0, Pürüzsüzlük: 0.0
!bodurluk →: 0.0, Pürüzsüzlük: 1.0
bodurluk → [boş dize]: 0.0, Pürüzsüzlük:1.0

Bonus soru: Hangisini tercih edersin , tıknaz mı yoksa düzgün dizeler mi?

APL, 10 bayt

Bu stdin'den girdi okur ve tıknazlığı stdout'a yazdırır. Algoritma, J çözümü için kullanılanla aynıdır.

(+/÷⍴)2≠/⍞

CJam, 19 bayt

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

Hesaplar% 100 bodur kaynak kodu bodurluk .

Çevrimiçi olarak bu tıknaz iyiliği deneyin.

Nasıl çalışır

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.

Açıkçası, 4 ondalık basamağa yuvarlanmış NaN 0'dır.

Pyth, 13 12 bayt

csJnVztz|lJ1

Tamamen tıknaz kod öbek hesaplama.

Gösteri. Test kablo demeti.

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 bayt

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,x3dizgenin alt dizesini x1sayı x2ile başlayan (bir temelli) ve sayı ile biten x3sonra seq(bir dizi oluşturur.

Pürüzsüzlük değeri verir. AnsDeğişkendir 0biz gerek kalmaz, varsayılan olarak Elsekarşı Ifaçıklamada, veya mağaza şey Ansönceden.

Matlab ( 37 36 bayt)

Bu, ötelemeyi döndüren aşağıdaki adsız işlevle yapılabilir:

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

Yorumlar:

• Eski Matlab sürümlerinde (örneğin R2010b) +char dizisini xçift ​​diziye dönüştürmeniz gerekir:

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

  Ancak bu, bir bayttan tasarruf sağlayan son sürümlerde (R2014b'de test edilmiştir) geçerli değildir. Jonas'a yaptığı yorum için teşekkür ederim.

• İle ifade maxkolları (bodurluk için) bir karakter ve sıfır karakter vakaları

Örnek:

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

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

Bu program bir dize yığınını döndürür.

açıklama

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

Önceki gönderim (37 + 3 = 40 bayt)

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

Bu program bir dizenin düzgünlüğünü döndürür. Girdi -sbayrakla yapılır, örneğin

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

C #, 94 89 bayt

Sub 100 bayt, sanırım bu kendi içinde bir çeşit zafer.

Bu, giriş dizesinin düzgünlüğünü döndüren bir fonksiyon tanımıdır (spesifikasyona göre izin verilir) :

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

Oldukça basit, eğer uzunluk 0 veya 1 ise, 1 döndürür, aksi takdirde dizgiyi ilk karakterden daha az olan karakterle karşılaştırır, ardından çift sayısına bölünen özdeş çiftlerin sayısını döndürür.

Düzen - Atla ile değiştirilen Substring. Acemi hatası!

J 14 13 bayt

Tıknazlığı hesaplar. 0 % 00'a eşit olduğunu tanımlamak için J için Kudos .

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

Çevrimiçi deneyin

İşte bir açıklama:

   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 bayt

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

Açıklama:

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

Bu, pürüzsüzlük oranını verir.

CJam, 16 bayt

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

Hile kaynak kodunu hesaplar düzgünlük .

0 veya 1 uzunluktaki girişlerde bu, bir hatayla çıkmadan önce doğru sonucu yazdırır. Java yorumlayıcısı ile hata çıktısı STDERR’e ( olması gerektiği gibi ).

Eğer sen kodu çevrimiçi denerseniz son çıktı satırından başka her şeyi görmezden gelin.

Nasıl çalışır

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 bayt

Pürüzsüzlük!

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

Bu, bir dizgeyi kabul eden ve sayısal bir değer döndüren adsız bir işlev yaratır.

Girişin uzunluğu 2'den azsa, pürüzsüzlük 1'dir, aksi takdirde aynı mantıksal karakterlerin oranını bir mantıksal dizinin ortalamasını alarak hesaplarız.

Nim, 105 96 91 bayt

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

Nim'i öğrenmeye çalışıyorum. Bu bir dize yığınlığını hesaplar.

^{( Bunu Python olarak okumaya çalışırsam, girintiler tamamen berbat görünüyor ... Şimdi daha çok Ruby'ye benziyor ...)}

Python 3, 63 Bayt

Bu, argüman olarak bir dize alan ve chunkiness değerini döndüren adsız bir lambda işlevidir.

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

Kullanmak için bir isim verin ve arayın.

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 bayt

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

Bu tıknazlığı hesaplar ve -0.0boş dize için çıktılar . Negatif sıfırları beğenmiyorsanız, bunu her zaman ekstra bir baytla düzeltebilirsiniz:

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

Haskell, 64 bayt

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

Pürüzsüzlük verir. örneğin f "Peanut Butter"-> 8.333333333333333e-2.

Nasıl çalışır:

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])x uzunluğudur, ancak Haskell'in güçlü tip sistemi kesirsel beslemek istediğinden /, lengthtamsayıları döndüren kullanamıyorum . Tamsayıları kesirlere çevirmek fromInteger$length xçok uzun.

JavaScript (ES6), 55 bayt

Pürüzsüzlük, 56 bayt

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

Tıknaz, 55 bayt

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

gösteri

Pürüzsüzlüğü hesaplar, istediğim şey bu. Firefox'ta yalnızca ES6 olduğu gibi çalışır.

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

Düzgünlüğü döndürür.

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

açıklama

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

Ölçek

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

Ruby , 69 66 bayt

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

Çevrimiçi deneyin!

IMP'den gelen yorumlar ile birkaç bayt Tıraş. Ayrıca, Ruby'nin yaklaşmakta olan 2.7.0 sürümü |x,y|x!=yile değiştirerek bazı baytları kaydetmek mümkündür.@1!=@2

Python 3, 69 bayt

Henüz hiç kimse bir Python çözümü yayınlamamıştır, bu yüzden işte "chunkiness" işlevinin oldukça basit bir uygulaması. Bir dizi uzunlukta kısa devre yapar 1ve yazdırır0 (bu, yüzdürme yerine bir tam sayıdır ancak kurallara göre izin veriliyor gibi görünmektedir).

Boş bir dizgede bunun -0.0yerine çıktı verir 0.0. Muhtemelen bu, -0.0 == 0 == 0.0geri dönüş olarak kabul edilebilir olarak kabul edilebilir True.

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

Örnekler:

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

(Python 3, varsayılan şamandıra bölümü için kullanılır.)

C, 83 bayt

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

Tıknazlığı döndüren bir işlev .

açıklama

float f(char *s) {

Bir C stringini kabul edin ve bir float döndürün (double işe yarar ancak daha fazla karakter olur).

int a=0, b=0;

Sayaçlar - a toplam çiftler için, beşleşmeyen çiftler için. intSınırları kullanarak dizginin "keyfi uzunluğu", ancak bu sadece gereksinimlerin küçük bir ihlalidir ve düzeltmeyeceğim.

if (*s)

Özel durum boş dize - her iki sayacı da sıfır bırakın.

    while (s[++a])

Boş olmayan dize - ön artışla tekrarlayın (bu nedenle ilk kez döngüde s[a] ikinci karakter olur. Dizede yalnızca bir karakter varsa, döngü gövdesi girilmez ve a1 olur.

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

Geçerli karakter öncekinden farklıysa, artış b .

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

Döngüden sonra, üç olasılık vardır: boş bir giriş için 'a == 0, b == 0', tek karakterli giriş için 'a == 1, b == 0' veya 'a> 1, b> Çok karakterli giriş için = 0 '. 1'den a(? operatör bir sıralama noktasıdır, bu yüzden güvendeyiz) ve eğer sıfırsa, ikinci durum bizde, sıfıra dönmelidir. Aksi taktirde b/aistediğimiz budur, ancak teşvik etmeliyizb önce bir kayan nokta türüne yoksa tam sayıdaki bölümü alırız. Boş bir dize için, negatif bir sıfırla sonuçlanır, ancak kurallar buna izin vermez.

Testler:

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

Hangi verir:

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

gereğince, gerektiği gibi.

Perl, 69

İşlev dönüş düzgünlüğü :

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

açıklama

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

Testler

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 bayt

Bu, beden için hiçbir şey kazanmaz, ancak basit:

Pürüzsüzlük

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

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

Out[177]= 0.285714

Jel: 76 73 karakter

Pürüzsüzlük.

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

Örnek çalışma:

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 = Gema + Lua ciltleri. Çok daha iyi, ama yine de kazanmaktan uzak.)

Gema: 123 120 karakter

Pürüzsüzlük.

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

Örnek çalışma:

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

(Kayan nokta sayısı desteği ve genel olarak acı verici aritmetik destek olmadan bir dilde çözme şansının ne olduğunu görmek benim için daha fazla bir egzersiz oldu \P.

Java 8, 84 82 bayt

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

Pürüzsüzlük verir.

Çevrimiçi deneyin.

Açıklama:

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

Hindistan Cevizi , 38 bayt

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

Çevrimiçi deneyin!

Bir Python 3 portu 50 bayt olacaktır .

PowerShell, 55 bayt

Pürüzsüzlük

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

Stdin'deki bir değişkeni elde etmek için biraz aptalca görünüyor ve sonra ona bir tanımlayıcı veriyor, ancak bir işleve sahip olmaktan daha hızlı.

Python 3, 61 Bayt

tıknazlığı hesaplar:

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

K (22)

WooiKent'in Q çözümünü değiştirdi:

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

Ruby, 63 Bayt

Tıknazlık verir.

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

@ Daniero'nun çözümüne benzer, ancak doğrudan dize uzunluğu - 1'e bölerek ve daha sonra 0 ve 1 dizeleriyle sıfır olmasına güvenerek biraz kısaltır (.max, 0 veya -1 ile bölmememizi sağlar).

Mathematica, 107 bayt

Her digraph ve ters arasındaki Levenshtein mesafesinin yarısını alarak tıknazlığı hesaplar.

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

Kesin bir rasyonel cevap tercih ederseniz, ceza almak için sonuncusundan önce .5bir tane silin ve yerleştirin . Programın kendisi 103/106 veya yaklaşık .972 oranında bir yığınlığa sahiptir./2&