Torre de contagem move 1D

31

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
code-golf  counting  chess 
— xnor
fonte

Respostas:

9

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.

— Neil
fonte
Ah, você basicamente descobriu como fazer o que eu mencionei na minha resposta. Não sei por que não pensei nisso.
— mbomb007 02/09
9

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.

— Joel
fonte
6

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!

— Arnauld
fonte
1
A versão Python deve usar em countvez de split( TIO )
— Grimmy
@ Grimy Obrigado. :)
— Arnauld em
4

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.

— Brincadeira
fonte
3

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.

— mbomb007
fonte
1
Parece dar o resultado errado, .R.R.R.embora a alteração da primeira linha R.+Rpossa ajudar?
— Neil
@Neil Fixed. Obrigado.
— mbomb007 4/09
2

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
— Nick Kennedy
fonte
2

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)

— AZTECCO
fonte
Rocks? Suas pedras se movem?
— Mastro
1
@Mast lol sorry! Editado
— AZTECCO 04/09
2

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.

— xnor
fonte
2

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.

— Brincadeira
fonte
1

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
— Kevin Cruijssen
fonte
1
O Java 11+ permite usar String.strip()para remover apenas os espaços em branco: 32 bytes
— Joel
@ Joel Ah, esqueci completamente esse! Obrigado. :)
— Kevin Cruijssen em
1

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

— girobuz
fonte
Algumas coisas - uma função (em vez de um programa completo) é permitida, você pode confiar em um comportamento indefinido (por exemplo, zerar automaticamente), desde que seu programa funcione corretamente em pelo menos um compilador, seja mais curto para usar 82ou 'R'mais curto para use e+e*dthan e*(1+d), e=0,d=1;else e++; can be changed to e = -1, d = 1; e ++; , and b [a] `e b[++a]pode ser substituído por *be*++b
— somente ASCII
0

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)
— ar4093
fonte
0

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.

— mim'
fonte
Então isso só funciona para linhas com exatamente o comprimento 8? Se sim, isso parece um pouco específico demais para o desafio.
— ar4093 11/09
Acidentalmente assumiram que eram fileiras regulares de torres, consertadas agora.
— me
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.