Dada uma posição com uma fileira de torres e / ou espaços vazios, produza quantos movimentos diferentes de torres são possíveis. Uma torre pode se mover para a esquerda ou direita para um espaço vazio, mas não para uma que exija passar por outra torre. Quando uma torre se move, as outras torres permanecem no lugar.

Por exemplo, nesta posição, são possíveis 6 movimentos :

.R..RRR.

• A primeira torre (mais à esquerda) pode mover 1 espaço para a esquerda ou 1 ou 2 espaços para a direita (3 movimentos)
• A próxima torre só pode mover 1 ou 2 espaços para a esquerda (2 movimentos)
• A terceira torre não pode se mover porque está espremida entre outras duas (0 movimentos)
• A última torre só pode mover 1 espaço para a direita (1 movimento)

Observe que uma posição pode não ter torres ou espaços vazios.

Entrada: Uma lista não vazia (string, array, etc.) de torres e espaços vazios. Você pode representá-los como True/ False, 1/ 0, 'R'/ '.', ou quaisquer dois caracteres consistentes de byte distinto ou números de um dígito de sua escolha. Depende de você qual significa torre e qual significa espaço vazio.

Saída: Um número inteiro não negativo. Flutuadores de número inteiro também são bons.

Casos de teste

A saída é o número à esquerda.

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

Para mais casos de teste, aqui estão todas as entradas até o comprimento 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

Retina , 14 9 bytes

w`_+R|R_+

Experimente online! O link inclui casos de teste. Utiliza _para o espaço vazio, pois é o caractere não regular mais agradável. Funciona contando o número de substrings que correspondem a uma movimentação de Torre válida. Uma substring é uma movimentação de Torre válida se contiver pelo menos um _mais um Rno início ou no final.

Python 3 , 30 29 bytes

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

Experimente online!

-1 byte graças a @JoKing

A função usa uma string de bytes Python como entrada. Cada espaço vazio é codificado como uma guia e cada torre é codificada como um byte b'\x00'com valor 0.

O cálculo é equivalente a lambda s:(s+s).strip().count(b'\t')uma contagem de bytes mais baixa.

JavaScript (ES6),  38  33 bytes

Guardado 5 bytes graças a @JoKing

Recebe a entrada como uma sequência. Espera um espaço para um quadrado vazio e qualquer outro personagem para uma torre.

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

Experimente online!

Comentado

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 bytes

Guardado 7 bytes graças a @Grimy

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

Experimente online!

Japt , 5 bytes

²x èS

Tente

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

Perl 6 , 16 bytes

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

Experimente online!

Uma regex que corresponde a todas as instâncias exaustivas de torres seguidas por espaços ou espaços seguidos por uma torre e retorna o número de correspondências.

05AB1E , 5 bytes

«ðÚð¢

Experimente online!

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

Retina , 23 15 bytes

Dobre o número de espaços entre as torres, linhas grep com pelo menos uma torre e conte o número de espaços.

R.+R
$0$0
G`R
 

Experimente online!

Embora o programa use espaços em vez de pontos, eu adicionei o código do prefixo para que os casos de teste fornecidos possam ser facilmente colados e usados.

Eu esperava poder usar partidas sobrepostas (?<=R.*) | (?=.*R), mas as sobreposições não são tão agressivas. Seria necessário contar todas as maneiras possíveis de obter uma correspondência para retornar o resultado correto com esse método.

Gelatina , 6 bytes

t1;ḟẠS

Experimente online!

Um link monádico obtendo uma lista de 0para torre e 1espaço e retornando um número inteiro com o número de movimentos. O link TIO pega a lista colada de possíveis painéis fornecidos na pergunta, converte para o formato correto e depois gera as respostas calculadas e corretas.

Explicação

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

Japonês , 6 bytes

Espaços para espaços, qualquer outro personagem para gralhas.

²x ¸ÊÉ

Tente

Caracóis, 7 bytes

Pelo menos, bate Retina :)

o
\.+\R

Experimente online!

Gelatina , 5 bytes

ḲẈ+ƝS

Experimente online!

-1 graças a Jonathan Allan .

0representa uma torre, 1representa um espaço vazio.

Stax , 7 6 5 bytes

àσQ█ε

Execute e depure

Use a guia para quadrado vazio e qualquer outro caractere para torre.

C (clang) , 57 bytes

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

Experimente online!

• Guardado 1 graças a @ceilingcat

Percebi que não funcionava para listas vazias. Agora funciona! Além disso, salvou alguns bytes!

1 = torre. 0 = espaço.

for (.. i + = n ++? - i: 1) // conta espaços ou redefine movimentos extras => i = - ~ i ! * n ++ (@ceilingcat)

o + = * n? r = 1, i: r; // adiciona à saída -i- (movimentos extras) quando uma torre é alcançada mais os conjuntos -r- (torre alcançada), -i- serão limpos para aumentar a sentença.

adiciona -r- para cada espaço (a torre é garantida)

Haskell , 36 bytes

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

Experimente online!

Usa 1 para espaço vazio, 0 para torre. Conta o número de 1s que não estão no bloco inicial de unidades e adiciona isso ao resultado da sequência invertida.

Haskell , 33 bytes

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

Experimente online!

Função anônima que recebe entrada como uma lista de 1s (espaços) e 0s (torres). Isso apara os espaços desde o início e o final da lista, concatena as duas versões da lista e as soma.

Isso usa o GHC 8.4.1 ou posterior para ter acesso ao <>operador sem importá-lo.

Python 2 , 59 bytes

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

Experimente online!

Japonês , 6 bytes

²x ¸ÊÉ

Experimente online

Wolfram Language (Mathematica) , 43 38 bytes

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

Experimente online!

Solução Retina do Porto de Neil . Usa 1 para espaços e 0 para torres.

Haskell , 68 58 54 bytes

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

Experimente online!

Vermelho , 46 bytes

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

Experimente online!

Apenas uma porta vermelha das soluções JavaScript / Python da Arnauld . Ocupa um espaço como um quadrado vazio.

Java 11, 35 32 bytes

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

Porto de @ Joel Python 3 resposta 's .
-3 bytes também graças a @Joel .

Usa bytes nulos ( \0) para torres e tabulações ( \t) para espaços.

Experimente online.

Tentei usar s->(s+s).trim().chars().sum()/9inicialmente como 31 bytes, mas isso não funciona porque o String#trimbuiltin não apenas remove espaços / guias / linhas iniciais e finais, mas também todos os outros bytes menores ou iguais a U+0020(unicode 32; um espaço) , portanto, ele removerá os bytes nulos também.
Obrigado a Joel por me recomendar o novo Java 11+ String#stripbuiltin (que eu esqueci que eles adicionaram) como alternativa. Este também remove partes finais / iniciais, mas neste caso apenas espaços em branco , portanto os bytes nulos são retidos.

Explicação:

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 bytes

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

Experimente online!

C # (compilador interativo do Visual C #) , 27 bytes

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

Guardou um byte graças a @someone

Experimente online!

Stax , 7 6 bytes

-1 byte graças ao recursivo

╣ë|óêπ

Execute e depure

Befunge-98 (PyFunge) , 73 bytes

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

Experimente online!

C , 183 156 151 137 96 91 bytes

Obrigado ao ceilingcat por 91 bytes.

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 é uma torre, todo o resto é um espaço.

TIO

Pitão , 7 bytes

/r6*2Qd

Experimente online!

Utiliza uma sequência de Rpara gralhas, (espaço) para espaços vazios

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

x86-64 - 26 bytes

A entrada é uma matriz de até 32 bits e um número inteiro representando o número de quadrados, 1 representando a torre, 0 representando vazio.

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  

Copia os bits para que sejam adicionados à esquerda e remove os zero bits à direita. Em seguida, obtém o número de zero bits à esquerda e o subtrai do número total de zero bits.

Código da máquina x86-64 - 22 bytes - apenas nas classificações regulares de xadrez.

A entrada é um número inteiro de 32 bits com o byte menos significativo feito de 8 bits, representando as torres. 1 é uma torre, 0 está vazio.

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  

Copia os bits no próximo byte significativo e remove os zero bits à direita. Em seguida, obtém o número de zero bits à esquerda e o subtrai do número total de zero bits.