Rozważ ciąg długości N, taki jak Peanut ButterN = 13. Zauważ, że w ciągu znajduje się para N-1 sąsiadujących znaków. Bo Peanut Butterpierwsza z 12 par to Pedruga to eaostatniaer .

Gdy pary są w większości różnymi znakami, ciąg ma masywną jakość, np chUnky.
Gdy te pary są w większości tego samego znaku, łańcuch ma gładką jakość, npsssmmsss .

Zdefiniuj masywność łańcucha jako stosunek liczby par z dwoma różnymi znakami do łącznej liczby par (N-1).

Określ gładkość łańcucha jako stosunek liczby par o dwóch identycznych znakach do całkowitej liczby par (N-1).

Na przykład, Peanut Butterma tylko jedną parę z identycznymi znakami ( tt), więc jego gładkość wynosi 1/12 lub 0,0833, a jej bryła to 11/12 lub 0,9167.

Puste łańcuchy i łańcuchy zawierające tylko jeden znak są zdefiniowane jako 100% gładkie i 0% masywne.

Wyzwanie

Napisz program, który pobiera ciąg o dowolnej długości i wyświetla jako wynik zmiennoprzecinkowy albo jego kruchość, albo współczynnik gładkości.

• Weź dane wejściowe za pomocą stdin lub wiersza poleceń, albo możesz napisać funkcję, która pobiera ciąg.
• Możesz założyć, że ciąg wejściowy zawiera tylko drukowalne znaki ASCII (a zatem jest jednowierszowy).
• Wydrukuj zmiennoprzecinkowe na stdout do 4 lub więcej miejsc po przecinku, lub możesz zwrócić go, jeśli napisałeś funkcję. Miejsca dziesiętne, które nie przekazują żadnych informacji, nie są wymagane, np. 0Jest w porządku zamiast 0.0000.
• Wybierz masywność lub gładkość według własnego uznania. Pamiętaj tylko, aby powiedzieć, który program generuje.

Najkrótszy kod w bajtach wygrywa.

Przykłady

Peanut Butter→ Masywność:, 0.91666666666Gładkość: 0.08333333333
chUnky→ Masywność:, 1.0Gładkość: 0.0
sssmmsss→ Masywność:, 0.28571428571Gładkość:0.71428571428
999 → Chunkiness: 0.0, gładkość: 1.0
AA→ Chunkiness: 0.0, gładkość: 1.0
Aa→ Chunkiness: 1.0, gładkość: 0.0
!→ Chunkiness: 0.0, gładkość: 1.0
[pusty łańcuch] → Chunkiness: 0.0, Gładkość:1.0

Dodatkowe pytanie: które preferujesz , grube lub gładkie sznurki ?

APL, 10 bajtów

Odczytuje dane wejściowe ze standardowego wejścia i wypisuje masywność na standardowe wyjście. Algorytm jest taki sam, jak w przypadku rozwiązania J.

(+/÷⍴)2≠/⍞

CJam, 19 bajtów

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

100% masywny kod źródłowy, który oblicza masywność .

Wypróbuj tę masywną dobroć online.

Jak to działa

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.

Oczywiście NaN w zaokrągleniu do 4 miejsc po przecinku wynosi 0.

Pyth, 13 12 bajtów

csJnVztz|lJ1

W pełni masywny kod obliczający masywność.

Demonstracja. Uprząż testowa.

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 bajtów

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,x3podaje podłańcuch łańcucha x1rozpoczynający się (jeden) od liczby x2i kończący się na liczbiex3 , a następnie seq(buduje sekwencję.

Podaje wartość gładkości. AnsZmienna jest 0domyślnie, więc nie potrzebują Elsedo Ifrachunku lub zapisać do niczego Answcześniej.

Matlab ( 37 36 bajtów)

Można to zrobić za pomocą następującej anonimowej funkcji, która zwraca masę:

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

Komentarze:

• W starych wersjach Matlaba (takich jak R2010b) musisz +rzutować tablicę char xna podwójną tablicę:

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

  Ale nie jest tak w najnowszych wersjach (testowanych w R2014b), co oszczędza jeden bajt. Dzięki Jonasowi za komentarz.

• Wyrażenie z maxobsługuje przypadki jednoznakowe i zerowe (dla masowości)

Przykład:

>> 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 bajtów

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

Ten program zwraca masę łańcucha.

Wyjaśnienie

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

Poprzednie przesłanie (37 + 3 = 40 bajtów)

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

Ten program zwraca gładkość łańcucha. Wejście odbywa się za pomocą -sflagi, np

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

DO#, 94 89 bajtów

Pod 100 bajtów, więc myślę, że to jakaś forma zwycięstwa sama w sobie?

To jest definicja funkcji (dozwolona zgodnie ze specyfikacją), która zwraca gładkość łańcucha wejściowego:

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

Całkiem proste, jeśli długość wynosi 0 lub 1, zwraca 1, w przeciwnym razie porównuje ciąg do siebie mniejszego pierwszego znaku, a następnie zwraca liczbę identycznych par podzieloną przez liczbę par.

Edytuj - zastąpiono podciągiem Pomiń. Błąd nowicjusza!

J, 14 13 bajtów

Oblicza masę. Wyrazy uznania dla J za zdefiniowanie 0 % 0równe 0.

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

Wypróbuj online

Oto wyjaśnienie:

   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 bajty

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

Wyjaśnienie:

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

Daje to współczynnik gładkości.

CJam, 16 bajtów

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

Cheaty kod źródłowy, który oblicza gładkość .

Dla danych wejściowych o długości 0 lub 1, drukuje poprawny wynik przed wyjściem z błędem. W przypadku interpretera Java dane wyjściowe błędów są przekazywane do STDERR ( tak jak powinno) ).

Jeśli wypróbujesz kod online , po prostu zignoruj ​​wszystko oprócz ostatniego wiersza wyniku.

Jak to działa

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 bajty

Gładkość!

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

Tworzy to nienazwaną funkcję, która akceptuje ciąg znaków i zwraca wartość liczbową.

Jeśli długość danych wejściowych jest mniejsza niż 2, gładkość wynosi 1, w przeciwnym razie obliczamy proporcję identycznych sąsiednich znaków, przyjmując średnią z tablicy logicznej.

Nim, 105 96 91 bajtów

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

Próbuję nauczyć się Nima. Oblicza to wielkość łańcucha.

^{( Jeśli spróbuję odczytać to jako Python, wcięcie wygląda na pomieszane ... Teraz wygląda bardziej jak Ruby ...)}

Python 3, 63 bajtów

Jest to anonimowa funkcja lambda, która przyjmuje argument jako argument i zwraca jego masywność.

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

Aby go użyć, nadaj mu nazwę i zadzwoń.

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 bajty

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

Oblicza to masywność i wyniki -0.0 dla pustego ciągu. Jeśli nie lubisz ujemnych zer, zawsze możesz to naprawić za pomocą dodatkowego bajtu:

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

Haskell, 64 bajty

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

Wykazuje gładkość. na przykładf "Peanut Butter" ->8.333333333333333e-2 .

Jak to działa:

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])jest długością x, ale ponieważ system silnego typu Haskella wymaga karmienia ułamków zwykłych /, nie mogę użyć, lengthktóra zwraca liczby całkowite. Konwersja liczb całkowitych na ułamki zwykłe przez fromInteger$length xjest zdecydowanie za długa.

JavaScript (ES6), 55 bajtów

Gładkość, 56 bajtów

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

Masywność, 55 bajtów

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

Próbny

Oblicza gładkość, ponieważ wolę to. Na razie działa tylko w przeglądarce Firefox, ponieważ jest to 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

Zwraca gładkość.

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

Wyjaśnienie

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

Rubinowy , 69 66 bajtów

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

Wypróbuj online!

Ogolono kilka bajtów z komentarzami z IMP. Ponadto w nadchodzącej wersji 2.7.0 Ruby można zapisać niektóre bajty, zastępując |x,y|x!=yje@1!=@2

Python 3, 69 bajtów

Nikt jeszcze nie opublikował rozwiązania w języku Python, więc oto dość prosta implementacja funkcji „chunkiness”. To zwiera ciąg długości 1i drukuje0 (która jest liczbą całkowitą, a nie liczbą zmiennoprzecinkową, ale wydaje się, że jest dozwolona zgodnie z regułami).

Na pusty ciąg wyświetla dane wyjściowe -0.0zamiast 0.0. Prawdopodobnie można to uznać za akceptowalne, jako -0.0 == 0 == 0.0zwroty True.

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

Przykłady:

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

(Python 3 jest używany jako domyślny podział zmiennoprzecinkowy).

C, 83 bajty

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

Funkcja powraca masę .

Wyjaśnienie

float f(char *s) {

Zaakceptuj ciąg C i zwróć liczbę zmiennoprzecinkową (podwójne działałoby, ale jest więcej znaków).

int a=0, b=0;

Liczniki - adla par całkowitych, bdla par niepasujących. Użycie intogranicza „dowolną długość” łańcucha, ale to tylko niewielkie naruszenie wymagań i nie zamierzam tego naprawiać.

if (*s)

Przypadek specjalny pusty ciąg - pozostaw oba liczniki zerowe.

    while (s[++a])

Niepuste ciąg - iteruj go z przyrostem wstępnym (więc po raz pierwszy przez pętlę s[a]będzie drugim znakiem. Jeśli ciąg ma tylko jeden znak, treść pętli nie zostanie wprowadzona i abędzie wynosić 1.

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

Jeśli obecny znak różni się od poprzedniego, zwiększaj b.

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

Po pętli istnieją trzy możliwości: „a == 0, b == 0” dla pustych danych wejściowych, „a == 1, b == 0” dla danych jednoznakowych lub „a> 1, b> = 0 'dla wprowadzania wielu znaków. Odejmujemy 1 od a( ?operator jest punktem sekwencyjnym, więc jesteśmy bezpieczni), a jeśli jest zero, mamy drugi przypadek, więc powinien zwrócić zero. W przeciwnym razie b/ajest to, czego chcemy, ale najpierw musimy awansować bdo typu zmiennoprzecinkowego , w przeciwnym razie uzyskamy podział na liczby całkowite. W przypadku pustego ciągu otrzymamy ujemne zero, ale reguły tego nie zabraniają.

Testy:

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

Co daje:

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

jako wymagane.

Perl, 69

Funkcja zwracająca gładkość :

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

Wyjaśnienie

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

Testy

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 bajty

To nie wygrywa nic ze względu na rozmiar, ale jest proste:

Gładkość

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

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

Out[177]= 0.285714

GeL: 76 73 znaków

Gładkość.

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

Przykładowy przebieg:

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 = wiązania Gema + Lua. Znacznie lepiej, ale wciąż daleko od zwycięstwa.)

Gema: 123 120 znaków

Gładkość.

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

Przykładowy przebieg:

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

(To było dla mnie więcej ćwiczenia, aby zobaczyć, jakie są szanse na rozwiązanie go w języku bez obsługi liczb zmiennoprzecinkowych i ogólnie bolesnego wsparcia arytmetycznego. Druga linia, szczególnie \Psekwencja, to czysta magia, ostatnia linia to prawdziwa tortura.)

Java 8, 84 82 bajtów

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

Wykazuje gładkość.

Wypróbuj online.

Wyjaśnienie:

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

Kokos , 38 bajtów

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

Wypróbuj online!

Port Python 3 miałby 50 bajtów .

PowerShell, 55 bajtów

Gładkość

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

Trochę głupie wydaje się uzyskanie zmiennej stdin, a następnie nadanie jej identyfikatora, ale jest to szybsze niż posiadanie funkcji.

Python 3, 61 bajtów

obliczyć masę:

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

K (22)

poprawione rozwiązanie Q WooiKent:

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

Ruby, 63 bajtów

Wytwarza chunkiness.

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

Podobne do rozwiązania @ daniero, ale nieznacznie skrócone przez bezpośrednie podzielenie przez długość łańcucha - 1, a następnie poleganie na .count równym zero przy łańcuchach długości 0 i 1 (.max zapewnia, że ​​nie podzielę przez 0 lub -1).

Mathematica, 107 bajtów

Oblicza masywność, przyjmując połowę odległości Levenshteina między każdym wykresem a jego odwrotnością.

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

Jeśli wolisz dokładną racjonalną odpowiedź, usuń .5i umieść /2przed ostatnią &bez kary. Sam program ma masywność 103/106, czyli około 0,972.