Рассмотрим строку длиной 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% короткие.

Вызов

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

• Возьмите ввод через стандартный ввод или командную строку, или вы можете написать функцию, которая принимает строку.
• Можно предположить, что входная строка содержит только печатаемые символы ASCII (и, следовательно, является однострочной).
• Выведите число с плавающей запятой на стандартный вывод в 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 байт

Это читает входные данные из стандартного ввода и печатает блок в стандартный вывод. Алгоритм тот же, что и для решения 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, поэтому нам не нужен оператор Elseto Ifили что-то сохранять Ansзаранее.

Matlab ( 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/*

Обманочный исходный код, который вычисляет гладкость .

Для входов длины 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 ...)}

Python 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 Руби , что можно сэкономить несколько байт, заменив |x,y|x!=yс@1!=@2

Python 3, 69 байт

Никто еще не опубликовал решение Python, так что вот довольно простая реализация функции «chunkiness». Он закорачивает строку длины 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 и верните число с плавающей запятой (двойной будет работать, но больше символов).

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 

как требуется.

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

Mathematica, 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 bindings. Намного лучше, но все еще далеко от победы.)

Гема: 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

(Для меня это было больше упражнение, чтобы увидеть, каковы шансы решить его на языке без поддержки чисел с плавающей запятой и, как правило, болезненной арифметической поддержки. 2-я строка, особенно \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 и затем дать ей идентификатор, но это быстрее, чем иметь функцию.

Python 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).

Mathematica, 107 байт

Вычисляет размерность, беря половину расстояния Левенштейна между каждым орграфом и его оборотом.

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

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