Учитывая позицию с рядом ладей и / или пустых мест, выведите, сколько возможных ходов ладьи. Ладья может двигаться влево или вправо в пустое пространство, но не в ту, которая требует прохода через другую ладью. Когда ладья движется, остальные ладьи остаются на месте.

Например, из этой позиции возможно 6 ходов :

.R..RRR.

• Первый (крайний левый) ладья может переместиться на 1 пробел влево или на 1 или 2 пробела вправо (3 хода)
• Следующая ладья может двигаться только на 1 или 2 пробела влево (2 хода)
• Третья ладья не может двигаться вообще, потому что она зажата между двумя другими ладьями (0 ходов)
• Последняя ладья может двигаться только на 1 пробел вправо (1 ход)

Обратите внимание, что позиция может вообще не иметь грачей или вообще не иметь пустых мест.

Входные данные: непустой список (строка, массив и т. Д.) Грачей и пустых пространств. Вы можете представить их как True/ False, 1/ 0, 'R'/ '.'или любые два последовательных отдельных однобайтовых символа или однозначные числа на ваш выбор. Вам решать, что означает ладью, а что означает пустое пространство.

Выход: неотрицательное целое число. Целые числа тоже хорошо.

Контрольные примеры

Выходной это число слева.

6 .R..RRR.
0 .
0 R
4 R..RR
3 ...R
8 ..R..R..
0 ......

Для большего количества тестовых случаев здесь представлены все входные данные длиной до 5.

0 .
0 R
0 ..
1 .R
1 R.
0 RR
0 ...
2 ..R
2 .R.
1 .RR
2 R..
2 R.R
1 RR.
0 RRR
0 ....
3 ...R
3 ..R.
2 ..RR
3 .R..
3 .R.R
2 .RR.
1 .RRR
3 R...
4 R..R
3 R.R.
2 R.RR
2 RR..
2 RR.R
1 RRR.
0 RRRR
0 .....
4 ....R
4 ...R.
3 ...RR
4 ..R..
4 ..R.R
3 ..RR.
2 ..RRR
4 .R...
5 .R..R
4 .R.R.
3 .R.RR
3 .RR..
3 .RR.R
2 .RRR.
1 .RRRR
4 R....
6 R...R
5 R..R.
4 R..RR
4 R.R..
4 R.R.R
3 R.RR.
2 R.RRR
3 RR...
4 RR..R
3 RR.R.
2 RR.RR
2 RRR..
2 RRR.R
1 RRRR.
0 RRRRR

Сетчатка , 14 9 байт

w`_+R|R_+

Попробуйте онлайн! Ссылка включает в себя тестовые случаи. Используется _для пустого пространства, так как это самый приятный персонаж без регулярных выражений. Работает путем подсчета количества подстрок, которые соответствуют действительному ходу ладьи. Подстрока является допустимым ходом ладьи, если она содержит хотя бы один _плюс один Rв начале или конце.

Python 3 , 30 29 байт

lambda s:sum((s+s).strip())/9

Попробуйте онлайн!

-1 байт благодаря @JoKing

Функция принимает байтовую строку Python в качестве входных данных. Каждое пустое пространство кодируется как вкладка, а каждая ладья кодируется как байт, b'\x00'имеющий значение 0.

Вычисление эквивалентно lambda s:(s+s).strip().count(b'\t')меньшему количеству байтов.

JavaScript (ES6),  38  33 байта

Сохранено 5 байт благодаря @JoKing

Принимает ввод в виде строки. Ожидается пробел для пустого квадрата и любой другой символ для ладьи.

s=>(s+s).trim().split` `.length-1

Попробуйте онлайн!

комментарии

s =>          // s = input, e.g. " R  RRR "
  (s + s)     // double -> " R  RRR  R  RRR "
  .trim()     // remove leading and trailing spaces -> "R  RRR  R  RRR"
  .split` `   // split on spaces -> [ 'R', '', 'RRR', '', 'R', '', 'RRR' ]
  .length - 1 // return the length - 1 -> 6

Python 2 ,  40  33 байта

Сохранено 7 байтов благодаря @Grimy

lambda s:(s+s).strip().count(' ')

Попробуйте онлайн!

Japt , 5 байт

²x èS

Попытайся

²x èS        Implicit input string of U
²            U + U
 x           Remove trailing and leading whitespace
   èS        Number of spaces

Perl 6 , 16 байт

{+m:ex/s+R|Rs+/}

Попробуйте онлайн!

Регулярное выражение, которое соответствует всем исчерпывающим случаям грачей, за которыми следуют пробелы или пробелы, за которыми следует ладья, и возвращает количество совпадений.

05AB1E , 5 байтов

«ðÚð¢

Попробуйте онлайн!

«       # concatenate the input with itself
 ðÚ     # remove leading and trailing spaces
   ð¢   # count spaces

Сетчатка , 23 15 байт

Удвойте количество пробелов между ладьями, добавьте в строки grep хотя бы одну ладью, затем посчитайте количество пробелов.

R.+R
$0$0
G`R
 

Попробуйте онлайн!

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

Я надеялся, что смогу использовать перекрывающиеся матчи (?<=R.*) | (?=.*R), но перекрытия не настолько агрессивны. Необходимо будет подсчитать все возможные способы получения соответствия, чтобы получить правильный результат с помощью этого метода.

Желе , 6 байт

t1;ḟẠS

Попробуйте онлайн!

Монадическая ссылка, берущая список 0для ладьи и 1для пробела и возвращающая целое число с количеством ходов. Ссылка TIO берет вставленный список возможных досок, приведенных в вопросе, преобразует в правильный формат и затем выводит рассчитанные и правильные ответы.

объяснение

t1     | Trim 1s from end
  ;    | Concatenate to input
   ḟẠ  | Filter out 1s if all input were 1s, otherwise filter out 0s
     S | Sum

Japt , 6 байт

Пробелы для пробелов, любой другой символ для ладьи.

²x ¸ÊÉ

Попытайся

Улитки, 7 байт

По крайней мере, это лучше, чем Retina :)

o
\.+\R

Попробуйте онлайн!

Желе , 5 байт

ḲẈ+ƝS

Попробуйте онлайн!

-1 спасибо Джонатану Аллану .

0представляет ладью, 1представляет пустое пространство.

Stax , 7 6 5 байт

àσQ█ε

Запустите и отладьте его

Используйте вкладку для пустого квадрата и любой другой символ для ладьи.

C (лязг) , 57 байт

i,r,o;g(*n,z){for(o=r=i=0;z--;i=-~i*!*n++)o+=*n?r=1,i:r;}

Попробуйте онлайн!

• Сохранено 1 благодаря @ceilingcat

Я понял, что это не работает для пустых списков .. Теперь это работает! Плюс сэкономил несколько байтов!

1 = ладья. 0 = пространство.

for (.. i + = n ++? - i: 1) // подсчитывает пробелы или сбрасывает дополнительные ходы => i = - ~ i ! * n ++ (@ceilingcat)

о + = * п г = 1, г:? г; // добавляет к выводу -i- (дополнительные ходы), когда ладья встречается, плюс устанавливает -r- (ладья встретилась), -i- будет очищен для предложения с приращением.

добавляет -r- для каждого пробела (ладья встречается гарантировано)

Haskell , 36 байт

f s=sum$snd.span(>0)=<<[s,reverse s]

Попробуйте онлайн!

Использует 1 для пустого пространства, 0 для ладьи. Подсчитывает количество единиц, которых нет в начальном блоке единиц, и добавляет это к результату для обратной строки.

Haskell , 33 байта

sum.(t.reverse<>t)
t=snd.span(>0)

Попробуйте онлайн!

Анонимная функция, которая принимает входные данные в виде списка 1s (пробелы) и 0s (грачи). Это обрезает пробелы в начале и конце списка, затем объединяет две версии списка и суммирует их.

При этом используется GHC 8.4.1 или более поздней версии, чтобы иметь доступ к <>оператору без его импорта.

Python 2 , 59 байт

def f(r):S=map(len,r.split('R'));return sum(S)*2-S[0]-S[-1]

Попробуйте онлайн!

Japt , 6 байт

²x ¸ÊÉ

Попробуйте онлайн

Wolfram Language (Mathematica) , 43 38 байт

Count[Subsequences@#,{0,1..}|{1..,0}]&

Попробуйте онлайн!

Порт сетчатки Нейла . Использует 1 для пробелов и 0 для грачей.

Haskell , 68 58 54 байта

(n#y)(a:x)|a<1=n+(0#1)x|m<-n+1=y+(m#y)x
(_#_)x=0
f=0#0

Попробуйте онлайн!

Красный , 46 байт

func[s][length? next split trim append s s sp]

Попробуйте онлайн!

Просто красный порт решений Arnauld для JavaScript / Python . Занимает пространство как пустой квадрат.

Java 11, 35 32 байта

s->(s+s).strip().chars().sum()/9

Порт @Joel 's Python 3 ответа .
-3 байта также благодаря @Joel .

Использует NULL-bytes ( \0) для Rooks и tabs ( \t) для пробелов.

Попробуйте онлайн.

Я попытался использовать s->(s+s).trim().chars().sum()/9сначала как 31-байтовый код, но это не работает, потому что String#trimвстроенная функция не только удаляет начальные и конечные пробелы / табуляции / новые строки, но также и все другие байты, которые меньше или равны U+0020(Unicode 32; пробел) поэтому он также удалит NULL-байты.
Спасибо Джоэлу за то, что он порекомендовал мне новую String#stripвстроенную версию Java 11+ (которую я забыл добавить) в качестве альтернативы. Этот также удаляет завершающие / ведущие части, но в этом случае только пробелы , поэтому байты NULL сохраняются.

Объяснение:

s->                              // Method with String as parameter & integer return-type
  (s+s)                          //  Concatenate the input to itself
       .strip()                  //  Then trim all leading and trailing tabs
               .chars().sum()    //  Sum the unicode values of the remaining characters
                             /9  //  And divide it by 9 to get the amount of remaining tabs

Perl 5 -MList::Util=sum -pF/R/ , 40 байт

$\=2*sum map$_=y///c,@F}{$\-="@F"+$F[-1]

Попробуйте онлайн!

C # (интерактивный компилятор Visual C #) , 27 байт

x=>(x+x).Trim().Sum(d=>d)/9

Сохраненный байт благодаря @someone

Попробуйте онлайн!

Stax , 7 6 байт

-1 байт благодаря рекурсивному

╣ë|óêπ

Запустите и отладьте его

Befunge-98 (PyFunge) , 73 байта

#;ep10fp#;>#v~:'.-#v_$1+0k
v0+ge0*gf0$_v#!-R':<
>ep20fp   v >0fg1-*0eg+.@

Попробуйте онлайн!

C , 183 156 151 137 96 91 байт

Благодаря потолку Cat за 91 байт.

c,e;char*z,b[9];main(d){for(gets(z=b);e=*z>81?c-=e*~!d,d=0:e+1,*++z;);printf("%i",d?:c+e);}

R - ладья, все остальное - пробел.

TIO

Pyth , 7 байт

/r6*2Qd

Попробуйте онлайн!

Принимает строку Rдля грача, (пробел) для пустого пространства

/     d  # Count spaces in
 r6      #  Strip spaces from
   *2Q   #   2 * input() (= concatenation)

x86-64 - 26 байт

Входные данные представляют собой массив длиной до 32 бит и целое число, представляющее количество квадратов, 1 представляет собой ладью, 0 - пустой.

C4 E2 69 F7 C1       shlx        eax,ecx,edx
0B C1                or          eax,ecx  
F3 0F BC C8          tzcnt       ecx,eax  
D3 E8                shr         eax,cl  
F3 0F BD C8          lzcnt       ecx,eax  
F7 D0                not         eax  
F3 0F B8 C0          popcnt      eax,eax  
2B C1                sub         eax,ecx  
C3                   ret  

Копирует биты так, чтобы он был добавлен слева от него, и удаляет завершающие нулевые биты. Затем получает количество начальных нулевых битов и вычитает его из общего числа нулевых битов.

Машинный код x86-64 - 22 байта - только шахматные ряды обычной длины.

Входные данные представляют собой 32-разрядное целое число с наименее значимым байтом из 8 битов, представляющих грачи. 1 - ладья, 0 - пусто.

8A E9                mov         ch,cl  
91                   xchg        eax,ecx
F3 0F BC C8          tzcnt       ecx,eax
D3 E8                shr         eax,cl 
F3 0F BD C8          lzcnt       ecx,eax
F7 D0                not         eax  
F3 0F B8 C0          popcnt      eax,eax
2B C1                sub         eax,ecx
C3                   ret  

Копирует биты в следующий значащий байт и удаляет завершающие нулевые биты. Затем получает количество начальных нулевых битов и вычитает его из общего числа нулевых битов.