Розглянемо рядок довжиною N, наприклад, Peanut Butterз N = 13. Зауважте, що в рядку є пари N-1 пар сусідніх символів. Бо Peanut Butterперша з 12 пар є Pe, друга - eaостання er.

Коли пари в основному різні символи, рядок має кучеряву якість, наприклад chUnky.
Коли ці пари здебільшого одного і того ж символу, струна має рівну якість, наприклад sssmmsss.

Визначте чіткість рядка до відношення кількості пар з двома різними символами до загальної кількості пар (N-1).

Визначте гладкість рядка як відношення кількості пар з двома однаковими символами до загальної кількості пар (N-1).

Наприклад, є Peanut Butterлише одна пара з однаковими символами ( tt), тому її гладкість становить 1/12 або 0,0833, а її чіткість - 11/12 або 0,9167.

Порожні рядки та рядки, що містять лише один символ, визначаються як 100% гладкі та 0% чіткі.

Виклик

Напишіть програму, яка приймає рядок довільної довжини і виводить або її коефіцієнт чіткості або плавності як значення з плаваючою комою.

• Візьміть вхід через stdin або командний рядок, або ви можете написати функцію, яка займає рядок.
• Ви можете припустити, що вхідний рядок містить лише символи ASCII для друку (а значить, однорядковий).
• Надрукуйте поплавок на stdout до 4 або більше знаків після коми, або ви можете повернути його, якщо ви написали функцію. Десяткові місця, які не містять жодної інформації, не потрібні, наприклад, 0це нормально замість 0.0000.
• Вибирайте смаку або гладкість, як вам зручніше. Просто не забудьте сказати, яку саме програму випускає.

Виграє найкоротший код у байтах.

Приклади

Peanut Butter→ Chunkiness: 0.91666666666Гладкість: 0.08333333333
chUnky→ Chunkiness: 1.0Гладкість: 0.0
sssmmsss→ Chunkiness: 0.28571428571Гладкість: 0.71428571428
999→ Chunkiness: 0.0Гладкість: 1.0
AA→ Chunkiness: 0.0Гладкість: 1.0
Aa→ Chunkiness: 1.0Гладкість: 0.0
!→ Chunkiness: 0.0Гладкість: 1.0
[порожній рядок] → Chunkiness: 0.0, Плавність:1.0

Питання про бонус: якому ви віддаєте перевагу , чіткі або гладкі струни ?

APL, 10 байт

Це зчитує вхід зі stdin та друкує чутливість до stdout. Алгоритм той самий, який використовується для рішення J.

(+/÷⍴)2≠/⍞

CJam, 19 байт

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

100% вибагливий вихідний код, що обчислює чутливість .

Спробуйте цю приємну користь в Інтернеті.

Як це працює

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.

Очевидно, що NaN округляється до 4 десяткових знаків - 0.

Pyth, 13 12 байт

csJnVztz|lJ1

Повністю кокетливий код обчислення чутливості.

Демонстрація. Тестовий джгут.

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 байт

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,x3дає підрядку рядка, що x1починається (на основі однієї) на число x2і закінчується на число x3, а потім seq(будує послідовність.

Дає значення плавності. AnsМінлива 0за замовчуванням, так що не потрібно Elseв Ifзаяві, або зберігати що - небудь , щоб Ansзаздалегідь.

Матлаб ( 37 36 байт)

Це можна зробити за допомогою наступної анонімної функції, яка повертає незграбність:

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

Коментарі:

• У старих версіях Matlab (наприклад, R2010b) вам потрібно +передати масив char xу подвійний масив:

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

  Але це не так у останніх версіях (тестованих у R2014b), які зберігають один байт. Дякуємо Йонасу за його коментар.

• Вираз з maxобробляє односимвольні та нульові випадки (для нарізності)

Приклад:

>> 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 байт

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

Ця програма повертає чіткість рядка.

Пояснення

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

Попереднє надсилання (37 + 3 = 40 байт)

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

Ця програма повертає гладкість рядка. Введення здійснюється через -sпрапор, наприклад

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

C #, 94 89 байт

Під 100 байтів, тож я гадаю, що це сама перемога перемоги?

Це визначення функції (дозволено відповідно до специфікації), яке повертає гладкість вхідного рядка:

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

Досить прямо, якщо довжина дорівнює 0 або 1, вона повертає 1, інакше вона порівнює рядок із собою за меншим першим символом, а потім повертає кількість однакових пар, поділене на кількість пар.

Редагувати - замінено підрядку на Пропустити. Помилка новачка!

J, 14 13 байт

Обчислює чутливість. Кудос до J для визначення 0 % 0рівності 0.

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

Спробуйте в Інтернеті

Ось пояснення:

   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 байти

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

Пояснення:

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

Це виводить коефіцієнт плавності.

CJam, 16 байт

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

Cheaty вихідний код, який обчислює плавність .

Для входів довжиною 0 або 1 це друкує правильний результат перед виходом із помилкою. З інтерпретатором Java вихід помилок переходить до STDERR ( як слід ).

Якщо спробувати код в Інтернеті , просто ігноруйте все, крім останнього рядка виводу.

Як це працює

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.

Юлія, 52 байти

Гладкість!

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

Це створює неназвану функцію, яка приймає рядок і повертає числове значення.

Якщо довжина вводу менше 2, гладкість дорівнює 1, інакше ми обчислюємо частку однакових суміжних символів, беручи середнє значення масиву логіки.

Нім, 105 96 91 байт

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

Намагаюся навчитися Німу. Це обчислює чутливість струни.

^{( Якщо я спробую прочитати це як Python, відступ виглядає все заплутаним ... Тепер це більше схоже на Ruby ...)}

Пітон 3, 63 байти

Це анонімна лямбда-функція, яка приймає рядок як аргумент і повертає її чутливість.

lambda n:~-len(n)and sum(x!=y for x,y in zip(n,n[1:]))/~-len(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 байти

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

Це обчислює чутливість і видає -0.0порожній рядок. Якщо вам не подобаються негативні нулі, ви завжди можете це виправити додатковим байтом:

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

Haskell, 64 байти

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

Виводить плавність. наприклад f "Peanut Butter"-> 8.333333333333333e-2.

Як це працює:

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, але оскільки система сильного типу Haskell вимагає подавати дроби до /, я не можу використовувати, lengthякі повертають цілі числа. Перетворення цілих чисел у дробові через fromInteger$length xзанадто довго.

JavaScript (ES6), 55 байт

Плавність, 56 байт

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

Чупливість, 55 байт

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

Демо

Розраховує гладкість, тому що саме я віддаю перевагу. Зараз у Firefox працює лише так, як це 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>

КДБ (Q), 30

Повертає гладкість.

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

Пояснення

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

Тест

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

Рубі , 69 66 байт

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

Спробуйте в Інтернеті!

Поголений з декількох байтів із коментарями від IMP. Крім того, в майбутній версії 2.7.0 з Ruby можна зберегти кілька байтів, замінивши |x,y|x!=yна@1!=@2

Python 3, 69 байт

Ще ніхто не опублікував рішення Python, тож ось досить реальна реалізація функції "чутливості". Це коротке замикання на струні завдовжки 1та відбитки0 (що є цілим числом, а не поплавком, але, здається, дозволено згідно з правилами).

У порожньому рядку він виводить, -0.0а не 0.0. Можливо, це може вважатися прийнятним як -0.0 == 0 == 0.0повернення True.

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

Приклади:

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

(Python 3 використовується для його плавного поділу за замовчуванням.)

C, 83 байти

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

Функція, що повертає незграбність .

Пояснення

float f(char *s) {

Прийміть рядок C і поверніть float (подвійний працював би, але це більше символів).

int a=0, b=0;

Лічильники - aдля загальних пар, bдля невідповідних пар. Використання intобмежує "довільну довжину" рядка, але це лише незначне порушення вимог, і я не збираюся це виправляти.

if (*s)

Особливий випадок порожній рядок - залиште обидва лічильники нульовими.

    while (s[++a])

Непорожній рядок - повторіть його з попереднім збільшенням (тому перший раз через цикл s[a]буде другим символом. Якщо рядок має лише один символ, тіло циклу не буде введено, іa буде 1.

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

Якщо поточний символ відрізняється від попереднього, приріст b.

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

Після циклу є три можливості: 'a == 0, b == 0' для порожнього вводу, 'a == 1, b == 0' для введення з одним символом або 'a> 1, b> = 0 'для введення багато символів. Ми віднімаємо 1 a( ?оператор - це точка послідовності, тому ми в безпеці), і якщо він дорівнює нулю, у нас є другий випадок, тому слід повернути нуль. Інакшеb/a це те, що ми хочемо, але ми повинні bспочатку перейти до типу з плаваючою комою, або ми отримаємо ціле ділення. Для порожнього рядка ми отримаємо від’ємний нуль, але правила цього не забороняють.

Тести:

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

Що дає:

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

по мірі необхідності.

Перл, 69

Функція повертає гладкість :

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

Пояснення

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

Тести

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 

Математика, 73 72 байти

Це не виграє нічого за розмір, але це просто:

Гладкість

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

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

Out[177]= 0.285714

GeL: 76 73 символів

Гладкість.

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

Проба зразка:

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. Набагато краще, але все ще далеко від перемоги.)

Гема: 123 120 символів

Гладкість.

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

Проба зразка:

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

(Більше було вправою для себе, щоб побачити, які шанси вирішити це мовою без підтримки числа з плаваючою комою та загалом болючої арифметичної підтримки. Другий рядок, особливо \Pпослідовність, є чистою магією; останній рядок - справжні тортури.)

Java 8, 84 82 байт

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

Виводить гладкість.

Спробуйте в Інтернеті.

Пояснення:

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

Кокос , 38 байт

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

Спробуйте в Інтернеті!

Порт Python 3 матиме 50 байт .

PowerShell, 55 байт

Гладкість

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

Здається трохи нерозумно отримати змінну в stdin, а потім дати їй ідентифікатор, але швидше, ніж функція.

Пітон 3, 61 байт

обчислити чутливість:

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

К (22)

налаштовано Q-рішення WooiKent:

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

Рубін, 63 байти

Виводить незграбність.

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

Подібно до рішення @ daniero, але трохи скорочене шляхом прямого поділу на довжину рядка - 1, а потім покладається на .count, що дорівнює нулю, з рядками довжини 0 та 1 (.max гарантує, що я не поділю на 0 або -1).

Математика, 107 байт

Обчислює чутливість, беручи половину відстані Левенштейна між кожним диграфом та його зворотною стороною.

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

Якщо ви віддаєте перевагу точній раціональній відповіді, видаліть .5і поставте /2перед останнім &без жодного штрафу. Сама програма має чутливість 103/106, або приблизно .972.