Считать ладьи ходы 1D

31

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

Например, из этой позиции возможно 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
code-golf  counting  chess 
— XNOR
источник

Ответы:

9

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

w`_+R|R_+

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

— Нил
источник
О, вы в основном разобрались, как сделать то, что я упомянул в своем ответе. Иди, почему я не думал об этом.
— mbomb007
9

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')меньшему количеству байтов.

— Joel
источник
6

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

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

— Arnauld
источник
1
Версия Python должна использовать countвместо split( TIO )
— Grimmy
@ Грими Спасибо. :)
— Арно
4

Perl 6 , 16 байт

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

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

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

— Джо Кинг
источник
3

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

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

R.+R
$0$0
G`R

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

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

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

— mbomb007
источник
1
Кажется, дает неправильный результат, .R.R.R.хотя R.+Rможет помочь изменение первой строки ?
— Нил
@Neil Исправлено. Спасибо.
— mbomb007
2

Желе , 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
— Ник Кеннеди
источник
2

Желе , 5 байт

ḲẈ+ƝS

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

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

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

— Эрик Outgolfer
источник
1
Если вы используете пробел для ладьи и еще один пробел Ẉдля получения пяти:ḲẈ+ƝS
— Джонатан Аллан
@JonathanAllan LOL не думал об этом. А до этого я экспериментировал, Ẉно ṣ0вместо этого использовал ...
— Эрик Аутгольфер
2

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- для каждого пробела (ладья встречается гарантировано)

— AZTECCO
источник
Горные породы? Ваши камни движутся?
— Мачта
1
@ Простите, извините! Отредактировано
— AZTECCO
2

Haskell , 36 байт

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

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

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

— XNOR
источник
2

Haskell , 33 байта

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

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

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

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

— Джо Кинг
источник
1

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
— Кевин Круйссен
источник
1
Java 11+ позволяет использовать String.strip()для удаления только пробелы: 32 байта
— Джоэл
@ Джоэл Ах, совсем забыл об этом! Спасибо. :)
— Кевин Круйссен
1

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

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

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

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

— Воплощение невежества
источник
1
Afaik вы можете использовать вкладки, чтобы сохранить байт (более короткий код), но я нахожусь на телефоне.
— мое местоимение monicareinstate
1

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

— girobuz
источник
Несколько вещей - функция (вместо полной программы) разрешена, вы можете положиться на неопределенное поведение (например, автоматическое обнуление), если ваша программа работает корректно хотя бы на одном компиляторе, она короче, чтобы использовать 82вместо 'R'нее, или короче, чтобы используйте e+e*dчем e*(1+d), e=0,d=1;else e++; can be changed to е = -1, д = 1; е ++; , and b [a] `и b[++a]может быть заменен на *bи*++b
— только ASCII
0

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

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

— меня'
источник
Так что это работает только для строк ровно 8? Если да, то это кажется слишком конкретным для вызова.
— ar4093
Случайно предположил, что они были регулярными рядами ладьи, исправленными теперь.
— я "
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.