Pertimbangkan string dengan panjang N, seperti Peanut Butterdengan N = 13. Perhatikan bahwa ada N-1 pasangan karakter yang berdekatan dalam string. Sebab Peanut Butter, yang pertama dari 12 pasangan adalah Pe, yang kedua adalah ea, yang terakhir adalah er.

Ketika pasangan sebagian besar karakter yang berbeda, string memiliki kualitas yang tebal, misalnya chUnky.
Ketika pasangan ini sebagian besar karakter yang sama, string memiliki kualitas yang halus, misalnya sssmmsss.

Tentukan chunkiness string menjadi rasio jumlah pasangan dengan dua karakter berbeda dengan jumlah total pasangan (N-1).

Tentukan kelancaran string menjadi rasio jumlah pasangan dengan dua karakter identik dengan jumlah total pasangan (N-1).

Misalnya, Peanut Butterhanya memiliki satu pasangan dengan karakter yang identik ( tt), sehingga kehalusannya adalah 1/12 atau 0,0833 dan chunkiness-nya adalah 11/12 atau 0,9167.

String kosong dan string dengan hanya satu karakter didefinisikan sebagai 100% halus dan chunky 0%.

Tantangan

Tulis program yang menggunakan string dengan panjang sewenang-wenang dan output baik rasio chunkiness atau smoothness sebagai nilai floating point.

• Ambil input melalui stdin atau baris perintah, atau Anda dapat menulis fungsi yang mengambil string.
• Anda dapat mengasumsikan string input hanya berisi karakter ASCII yang dapat dicetak (dan karenanya adalah satu-baris).
• Cetak pelampung ke stdout ke 4 atau lebih tempat desimal, atau Anda dapat memilih untuk mengembalikannya jika Anda menulis suatu fungsi. Tempat desimal yang tidak menyampaikan informasi tidak diperlukan, misalnya boleh 0saja 0.0000.
• Pilih chunkiness atau smoothness sesuai keinginan. Pastikan untuk mengatakan yang mana output program Anda.

Kode terpendek dalam byte menang.

Contohnya

Peanut Butter→ chunkiness: 0.91666666666, Smoothness: 0.08333333333
chUnky→ chunkiness: 1.0, Smoothness: 0.0
sssmmsss→ chunkiness: 0.28571428571, Smoothness: 0.71428571428
999→ chunkiness: 0.0, Smoothness: 1.0
AA→ chunkiness: 0.0, Smoothness: 1.0
Aa→ chunkiness: 1.0, Smoothness: 0.0
!→ chunkiness: 0.0, Smoothness: 1.0
[kosong string] → chunkiness: 0.0, Kelancaran:1.0

Pertanyaan bonus: Manakah yang Anda sukai , string chunky atau smooth ?

APL, 10 byte

Ini membaca input dari stdin dan mencetak chunkiness ke stdout. Algoritma ini sama dengan yang digunakan untuk solusi J.

(+/÷⍴)2≠/⍞

CJam, 19 byte

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

100% kode sumber chunky yang menghitung chunkiness .

Coba kebaikan besar online ini.

Bagaimana itu bekerja

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.

Jelas, NaN dibulatkan ke 4 tempat desimal adalah 0.

Pyth, 13 12 byte

csJnVztz|lJ1

Kode chunky sepenuhnya menghitung chunkiness.

Demonstrasi. Uji harness.

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,x3memberikan substring string x1mulai (berbasis satu) pada angka x2dan berakhir pada angka x3, kemudian seq(membangun urutan.

Memberikan nilai kelancaran. The Ansvariabel 0secara default, jadi kita tidak perlu Elseke Ifpernyataan, atau ke toko apa pun untuk Ansterlebih dahulu.

Matlab ( 37 36 bytes)

Ini dapat dilakukan dengan fungsi anonim berikut, yang mengembalikan chunkiness:

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

Komentar:

• Dalam versi Matlab lama (seperti R2010b), Anda perlu +melemparkan array char xke array ganda:

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

  Tapi itu tidak terjadi di versi terbaru (diuji dalam R2014b), yang menghemat satu byte. Terima kasih kepada Jonas untuk komentarnya.

• Ekspresi dengan maxmenangani kasus satu karakter dan nol karakter (untuk chunkiness)

Contoh:

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

Program ini mengembalikan chunkiness string.

Penjelasan

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

Pengiriman sebelumnya (37 + 3 = 40 byte)

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

Program ini mengembalikan kelancaran sebuah string. Input melalui -sflag, mis

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

C #, 94 89 byte

Sub 100 byte, jadi saya kira itu beberapa bentuk kemenangan itu sendiri?

Ini adalah definisi fungsi (diizinkan sesuai spesifikasi) yang mengembalikan kelancaran string input:

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

Cukup mudah, jika panjangnya adalah 0 atau 1 maka akan mengembalikan 1, jika tidak maka string akan dibandingkan dengan karakter pertama, kemudian mengembalikan jumlah pasangan identik dibagi dengan jumlah pasangan.

Edit - diganti Substring dengan Lewati. Kesalahan pemula!

J, 14 13 byte

Menghitung tingkat chunkiness. Kudos to J untuk mendefinisikan 0 % 0sama dengan 0.

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

Cobalah online

Berikut ini penjelasannya:

   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/

Penjelasan:

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

Ini menghasilkan rasio kelancaran.

CJam, 16 byte

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

Kode sumber Cheaty yang menghitung kehalusan .

Untuk input dengan panjang 0 atau 1, ini mencetak hasil yang benar sebelum keluar dengan kesalahan. Dengan Java interpreter, output kesalahan menuju ke STDERR ( sebagaimana mestinya ).

Jika Anda mencoba kode online , abaikan saja semuanya kecuali baris terakhir dari output.

Bagaimana itu bekerja

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

Kelancaran!

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

Ini menciptakan fungsi tanpa nama yang menerima string dan mengembalikan nilai numerik.

Jika panjang input kurang dari 2, kelancarannya adalah 1, jika tidak kita menghitung proporsi karakter yang berdekatan yang identik dengan mengambil rata-rata dari array logis.

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

Mencoba mempelajari Nim. Ini menghitung chunkiness string.

^{( Jika saya mencoba membaca ini sebagai Python indentasi terlihat kacau ... Sekarang lebih mirip Ruby ...)}

Python 3, 63 Bytes

Ini adalah fungsi lambda anonim yang mengambil string sebagai argumen, dan mengembalikan chunkiness-nya.

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

Untuk menggunakannya, berikan nama dan panggil saja.

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)

Ini menghitung chunkiness, dan output -0.0untuk string kosong. Jika tidak suka nol negatif, Anda selalu dapat memperbaikinya dengan byte tambahan:

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)

Keluaran kelancaran. misalnya f "Peanut Butter"->8.333333333333333e-2 .

Bagaimana itu bekerja:

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])adalah panjang x, tetapi karena sistem tipe Haskell yang kuat mengharuskan untuk memberi makan fraksional /, saya tidak dapat menggunakan lengthyang mengembalikan bilangan bulat. Mengubah bilangan bulat menjadi pecahan melalui fromInteger$length xterlalu lama.

JavaScript (ES6), 55 byte

Kelancaran, 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

Demo

Menghitung kehalusan, karena itulah yang saya sukai. Hanya berfungsi di Firefox untuk saat ini, seperti 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

Mengembalikan kelancaran.

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

Penjelasan

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

Uji

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 byte

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

Cobalah online!

Dicukur beberapa byte dengan komentar dari IMP. Juga, dengan mendatang versi 2.7.0 dari Ruby itu mungkin untuk menghemat byte dengan mengganti |x,y|x!=ydengan@1!=@2

Python 3, 69 byte

Belum ada yang memposting solusi Python, jadi inilah implementasi fungsi "chunkiness" yang cukup mudah. Ini hubungan pendek pada string panjang 1, dan cetakan 0(yang merupakan bilangan bulat daripada pelampung tetapi tampaknya diizinkan sesuai dengan aturan).

Pada string kosong, ini menghasilkan -0.0bukan 0.0. Bisa dibilang ini bisa dianggap dapat diterima, sebagai -0.0 == 0 == 0.0pengembalian True.

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

Contoh:

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

(Python 3 digunakan untuk divisi float default-nya.)

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

Fungsi mengembalikan chunkiness .

Penjelasan

float f(char *s) {

Terima string C, dan kembalikan float (dobel akan bekerja tetapi lebih banyak karakter)

int a=0, b=0;

Penghitung - auntuk pasangan total, buntuk pasangan yang tidak cocok. Menggunakan intbatas "panjang sewenang-wenang" dari string, tapi itu hanya pelanggaran kecil terhadap persyaratan dan saya tidak akan memperbaikinya.

if (*s)

Kasus khusus string kosong - biarkan kedua counter nol.

    while (s[++a])

Non-empty string - iterate through it dengan pre-increment (jadi pertama kali melalui loop, s[a]akan menjadi karakter kedua. Jika string hanya memiliki satu karakter, badan loop tidak akan dimasukkan, dan aakan menjadi 1.

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

Jika karakter saat ini berbeda dari sebelumnya, kenaikan b.

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

Setelah perulangan, ada tiga kemungkinan: 'a == 0, b == 0' untuk input kosong, 'a == 1, b == 0' untuk input karakter tunggal atau 'a> 1, b> = 0 'untuk input multi-karakter. Kami mengurangi 1 dari a( ?operator adalah titik urutan, jadi kami aman), dan jika nol, kami memiliki huruf kedua, jadi harus mengembalikan nol. Kalau tidak, b/aitulah yang kita inginkan, tetapi kita harus mempromosikan bke tipe floating-point terlebih dahulu atau kita akan mendapatkan divisi integer. Untuk string kosong, kita akan berakhir dengan nol negatif, tetapi aturan tidak melarangnya.

Tes:

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

Pemberian yang mana:

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

seperti yang dipersyaratkan.

Perl, 69

Fungsi mengembalikan kelancaran :

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

Penjelasan

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

Tes

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

Ini tidak memenangkan apa pun untuk ukuran, tetapi langsung:

Kelancaran

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

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

Out[177]= 0.285714

GeL: 76 73 karakter

Kelancaran.

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

Contoh dijalankan:

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 binding. Jauh lebih baik, tapi masih jauh dari kemenangan.)

Gema: 123 120 karakter

Kelancaran.

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

Contoh dijalankan:

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

(Apakah lebih merupakan latihan bagi diri saya untuk melihat apa peluang untuk menyelesaikannya dalam bahasa tanpa dukungan angka floating point dan dukungan aritmatika yang umumnya menyakitkan. Baris ke-2, terutama \Purutannya, adalah sihir murni, baris terakhir adalah siksaan nyata.)

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

Keluaran Kelancaran.

Cobalah online.

Penjelasan:

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

Kelapa , 38 byte

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

Cobalah online!

Port Python 3 akan menjadi 50 byte .

PowerShell, 55 byte

Kelancaran

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

Tampaknya sedikit konyol untuk mendapatkan variabel di stdin dan kemudian memberikannya pengenal, tetapi lebih cepat daripada memiliki fungsi.

Python 3, 61 Bytes

hitung chunkiness:

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

K (22)

solusi Q tweak WooiKent:

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

Ruby, 63 Bytes

Keluaran chunkiness.

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

Mirip dengan solusi @ daniero, tetapi sedikit dipersingkat dengan langsung membagi dengan panjang string - 1 dan kemudian mengandalkan .count menjadi nol dengan panjang 0 & 1 string (.max memastikan saya tidak akan membagi dengan 0 atau -1).

Mathematica, 107 byte

Menghitung kekonyolan dengan mengambil setengah dari jarak Levenshtein antara setiap digraf dan kebalikannya.

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

Jika Anda lebih suka jawaban rasional yang tepat, hapus .5dan tempatkan /2sebelum yang terakhir &tanpa penalti. Program itu sendiri memiliki chunkiness 103/106, atau sekitar 0,972.