计数车移动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 
— 异或
source

Answers:

9

视网膜，14 9字节

w`_+R|R_+

在线尝试！链接包括测试用例。用途_为空的空间，因为它是最愉快的非正则表达式字符。通过计算与有效的Rook移动相对应的子字符串数来工作。如果子字符串在开头或结尾处至少包含一个_加单个R，则它是有效的Rook移动。

— 尼尔
source
哦，您基本上想出了我在回答中提到的方法。Idk为什么我没有想到这一点。
— 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')具有较低字节数的情况。

— 乔尔
source
6

JavaScript（ES6）， 38  33字节

@JoKing节省了5个字节

将输入作为字符串。期望有一个空格来表示一个空的正方形，并且希望其他任何字符都可以成为一个rook。

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个字节

@Grimy节省了7个字节

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

在线尝试！

— Arnauld
source
1
在Python版本应该使用count，而不是split（TIO）
— Grimmy
@肮脏的谢谢你。:)
— Arnauld
4

Perl 6、16个字节

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

在线尝试！

一个正则表达式，用于匹配所有白名单中所有无用的实例，后跟空格，或者用空格和白名单，然后返回匹配数。

— 乔·金
source
3

视网膜，23 15字节

将白名单之间的空格数量加倍，grep行至少要包含一个白名单，然后计算空格数量。

R.+R
$0$0
G`R

在线尝试！

尽管该程序使用空格而不是句点，但我添加了前缀代码，以便可以轻松粘贴和使用所提供的测试用例。

我希望可以使用与重叠的匹配项(?<=R.*) | (?=.*R)，但重叠并不是那么积极。为了使用该方法返回正确的结果，将需要计算所有可能的匹配方式。

— mbomb007
source
1
似乎给出错误的结果，.R.R.R.尽管将第一行更改为R.+R可能会有所帮助？
— 尼尔
@Neil固定。谢谢。
— mbomb007
2

果冻，6个字节

t1;ḟẠS

在线尝试！

一个单子链接，该列表0获取for和ro的列表，1并返回一个带有移动数的整数。TIO链接获取问题中给出的可能板的粘贴列表，转换为正确的格式，然后输出计算出的正确答案。

说明

t1     | Trim 1s from end
  ;    | Concatenate to input
   ḟẠ  | Filter out 1s if all input were 1s, otherwise filter out 0s
     S | Sum
— 尼克·肯尼迪
source
2

C（clang），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）

o + = * n？r = 1，i：r; //当遇到白痴加上设置-r-（白痴满足）时，将添加到输出-i-（额外移动），将清除-i-以增加句子。

为每个空格添加-r-（保证满足新希望）

— 阿兹特克
source
石头吗 你的石头移动了吗？
— 桅杆
1
@桅杆大声笑对不起！编辑
— AZTECCO
2

Haskell，36个字节

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

在线尝试！

使用1表示空白，使用0表示空白。计算不在初始的1中的1的数目，并将其添加到反向字符串的结果中。

— 异或
source
2

Haskell，33个字节

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

在线尝试！

将输入作为1（空格）和0（rook）列表的匿名函数。这将从列表的开头和结尾开始修剪空格，然后将列表的两个版本连接起来并求和。

这将使用GHC 8.4.1或更高版本来访问<>操作员而不导入它。

— 乔·金
source
1

Java 11，35 32字节

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

@Joel的Python 3答案端口。
-3个字节也要 @Joel。

使用\0Rook和制表符（）的NULL字节（）\t使用空格使用）。

在线尝试。

我s->(s+s).trim().chars().sum()/9最初尝试使用31个字节，但此方法不起作用，因为String#trim内置函数不仅删除了开头和结尾的空格/制表符/换行符，而且还删除了所有其他小于或等于U+0020（unicode 32；空格）的字节，因此它也将删除NULL字节。.
感谢Joel向我推荐新的Java 11+ String#strip内置插件（我忘了他们添加了）作为替代。这个也删除尾部/前导部分，但是在这种情况下，仅保留空白，因此保留了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
— 凯文·克鲁伊森
source
1
Java 11+允许String.strip()仅使用空格：32个字节
— Joel
@Joel Ah，完全忘记了那个！谢谢。：）
— 凯文·克鲁伊森
1

Ç，183个 156 151 137 96 91字节

感谢ceilingcat的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是一个白痴，其他所有东西都是一个空间。

蒂奥

— 吉罗布兹
source
一些事情-允许一个函数（而不是一个完整的程序），只要您的程序在至少一个编译器上正确运行，您就可以依赖未定义的行为（例如，自动清零），使用82或的时间较短，而使用'R'的时间较短。使用e+e*dthan e*(1+d)，e=0,d=1;else e++; can be changed to e = -1，d = 1; e ++; , and b [a]`，并且b[++a]可以替换为*b和*++b
— 仅限ASCII
0

Pyth，7个字节

/r6*2Qd

在线尝试！

接受一串Rfor rook，（空格）代表空白

/     d  # Count spaces in
 r6      #  Strip spaces from
   *2Q   #   2 * input() (= concatenation)
— ar4093
source
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位整数，其最低有效字节由代表rook的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

将这些位复制到下一个有效字节，然后删除尾随的零位。然后获取前导零位的数量，并将其从零位的总数中减去。

— 我'
source
因此，这仅适用于长度恰好为8的行？如果是的话，那么挑战似乎太具体了。
— ar4093
意外地认为他们是常规的车队，现在已经解决了。
— 我
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.