Compter la tour se déplace 1D

31

Étant donné une position avec une rangée de tours et / ou des espaces vides, affichez le nombre de mouvements de tour différents possibles. Une tour peut se déplacer vers la gauche ou la droite vers un espace vide, mais pas vers celui qui nécessite de passer sur une autre tour. Lorsqu'une tour se déplace, les autres tours restent en place.

Par exemple, à partir de cette position, 6 mouvements sont possibles:

.R..RRR.
  • La première tour (la plus à gauche) peut se déplacer de 1 espace vers la gauche, ou 1 ou 2 espaces vers la droite (3 mouvements)
  • La tour suivante ne peut se déplacer que de 1 ou 2 cases à gauche (2 mouvements)
  • La troisième tour ne peut pas bouger du tout car elle est coincée entre deux autres tours (0 mouvement)
  • La dernière tour ne peut se déplacer que de 1 case vers la droite (1 coup)

Notez qu'une position peut ne pas avoir de tour du tout, ou pas d'espace vide du tout.

Entrée: Une liste non vide (chaîne, tableau, etc.) de tours et d'espaces vides. Vous pouvez les représenter sous la forme True/ False, 1/ 0, 'R'/ '.'ou deux caractères codés sur un seul octet ou des chiffres à un chiffre de votre choix. C'est à vous de choisir celui qui signifie tour et celui qui signifie espace vide.

Sortie: Un entier non négatif. Les flotteurs entiers sont également très bien.

Cas de test

La sortie est le nombre à gauche.

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

Pour plus de cas de test, voici toutes les entrées jusqu'à la longueur 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
source

Réponses:

9

Rétine , 14 9 octets

w`_+R|R_+

Essayez-le en ligne! Le lien inclut des cas de test. Utilise l' _espace vide car c'est le caractère non regex le plus agréable. Fonctionne en comptant le nombre de sous-chaînes qui correspondent à un mouvement de tour valide. Une sous-chaîne est un mouvement de tour valide si elle contient au moins un _plus un simple Rau début ou à la fin.

— Neil
source
Oh, vous avez essentiellement compris comment faire ce que j'ai mentionné dans ma réponse. Je sais pourquoi je n'y ai pas pensé.
— mbomb007
9

Python 3 , 30 29 octets

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

Essayez-le en ligne!

-1 octet grâce à @JoKing

La fonction prend une chaîne d'octets Python en entrée. Chaque espace vide est codé sous forme de tabulation et chaque tour est codée sous forme d'octet b'\x00'ayant une valeur 0.

Le calcul équivaut à lambda s:(s+s).strip().count(b'\t')un nombre d'octets inférieur.

— Joel
source
6

JavaScript (ES6),  38  33 octets

5 octets enregistrés grâce à @JoKing

Prend l'entrée sous forme de chaîne. Attend un espace pour une case vide et tout autre personnage pour une tour.

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

Essayez-le en ligne!

Commenté

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 octets

7 octets enregistrés grâce à @Grimy

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

Essayez-le en ligne!

— Arnauld
source
1
La version Python devrait utiliser à la countplace de split( TIO )
— Grimmy
@Grimy Merci. :)
— Arnauld
4

Perl 6 , 16 octets

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

Essayez-le en ligne!

Une expression régulière qui correspond à toutes les instances exhaustives de tours suivies d'espaces ou d'espaces suivis d'une tour et renvoie le nombre de correspondances.

— Jo King
source
3

Rétine , 23 15 octets

Doublez le nombre d'espaces entre les tours, les lignes grep avec au moins une tour, puis comptez le nombre d'espaces.

R.+R
$0$0
G`R

Essayez-le en ligne!

Bien que le programme utilise des espaces au lieu de points, j'ai ajouté un code de préfixe afin que les cas de test fournis puissent être facilement collés et utilisés.

J'espérais pouvoir utiliser des correspondances qui se chevauchent (?<=R.*) | (?=.*R), mais les chevauchements ne sont pas aussi agressifs. Il faudrait compter toutes les façons possibles d'obtenir une correspondance afin de retourner le résultat correct avec cette méthode.

— mbomb007
source
1
Semble donner le mauvais résultat, .R.R.R.bien que changer la première ligne R.+Rpuisse aider?
— Neil
@Neil Fixed. Merci.
— mbomb007
2

Gelée , 6 octets

t1;ḟẠS

Essayez-le en ligne!

Un lien monadique prenant une liste de 0tour et 1d'espace et renvoyant un entier avec le nombre de coups. Le lien TIO prend la liste collée des cartes possibles donnée dans la question, convertit au bon format et sort ensuite les réponses calculées et correctes.

Explication

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

C (clang) , 57 octets

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

Essayez-le en ligne!

  • Enregistré 1 grâce à @ceilingcat

J'ai réalisé que cela ne fonctionnait pas pour les listes vides .. Maintenant ça marche! De plus, vous avez économisé quelques octets!

1 = tour. 0 = espace.

pour (.. i + = n ++? - i: 1) // compte les espaces ou réinitialise les mouvements supplémentaires => i = - ~ i ! * n ++ (@ceilingcat)

o + = * n? r = 1, i: r; // ajoute à la sortie -i- (déplacements supplémentaires) quand une tour est rencontrée plus définit -r- (tour rencontré), -i- sera effacé pour incrémenter la phrase.

ajoute -r- pour chaque espace (tour atteint garanti)

— AZTECCO
source
Roches? Vos roches bougent-elles?
— Mât
1
@Mast lol désolé! Modifié
— AZTECCO
2

Haskell , 36 octets

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

Essayez-le en ligne!

Utilise 1 pour l'espace vide, 0 pour la tour. Compte le nombre de 1 ne figurant pas dans un bloc initial de uns et l'ajoute au résultat pour la chaîne inversée.

— Xnor
source
2

Haskell , 33 octets

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

Essayez-le en ligne!

Fonction anonyme qui prend l'entrée comme une liste de 1 (espaces) et de 0 (tours). Cela coupe les espaces du début et de la fin de la liste, puis concatène les deux versions de la liste et les additionne.

Celui-ci utilise GHC 8.4.1 ou une version ultérieure pour avoir accès à l' <>opérateur sans l'importer.

— Jo King
source
1

Java 11, 35 32 octets

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

Port de la réponse Python 3 de @Joel .
-3 octets grâce à @Joel également.

Utilise NULL-bytes ( \0) pour Rooks et tabs ( \t) pour les espaces.

Essayez-le en ligne.

J'ai essayé d'utiliser s->(s+s).trim().chars().sum()/9au début en 31 octets, mais cela ne fonctionne pas parce que la fonction String#trimintégrée supprime non seulement les espaces / tabulations / sauts de ligne de début et de fin, mais également tous les autres octets qui sont plus petits ou égaux à U+0020(Unicode 32; un espace) , donc cela supprimera également les octets NULL ..
Merci à Joel de m'avoir recommandé le nouveau Java 11+ String#stripintégré (que j'ai oublié qu'ils ont ajouté) comme alternative. Celui-ci supprime également les portions de fin / début, mais dans ce cas, seuls les espaces blancs , de sorte que les octets NULL sont conservés.

Explication:

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
source
1
Java 11+ permet d'utiliser String.strip()pour supprimer uniquement les espaces blancs: 32 octets
— Joel
@Joel Ah, complètement oublié celui-là! Merci. :)
— Kevin Cruijssen
1

C , 183 156 151 137 137 96 91 octets

Merci à plafondcat pour 91 octets.

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 est une tour, tout le reste est un espace.

TIO

— Girobuz
source
Quelques choses - une fonction (au lieu d'un programme complet) est autorisée, vous pouvez compter sur un comportement indéfini (par exemple, la mise à zéro automatique) tant que votre programme fonctionne correctement sur au moins un compilateur, il est plus court à utiliser à la 82place ou 'R', il est plus court pour utiliser e+e*dque e*(1+d), e=0,d=1;else e++; can be changed to e = -1, d = 1; e ++; , and b [a] `et b[++a]peut être remplacé par *bet*++b
— ASCII uniquement
0

Pyth , 7 octets

/r6*2Qd

Essayez-le en ligne!

Prend une chaîne de Rpour les tours, (espace) pour les espaces vides

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

x86-64 - 26 octets

L'entrée est un tableau de 32 bits maximum et un entier représentant le nombre de carrés, 1 représentant la tour, 0 représentant le vide.

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

Copie les bits pour qu'ils soient ajoutés à gauche et supprime les bits de fin zéro. Obtient ensuite le nombre de bits zéro de tête et le soustrait du nombre total de bits zéro.

Code machine x86-64 - 22 octets - échecs de longueur régulière uniquement.

L'entrée est un entier de 32 bits avec l'octet de poids faible composé de 8 bits représentant les tours. 1 est une tour, 0 est vide.

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

Copie les bits dans l'octet significatif suivant et supprime les zéro bits de fin. Obtient ensuite le nombre de bits zéro de tête et le soustrait du nombre total de bits zéro.

— moi'
source
Donc, cela ne fonctionne que pour des lignes de longueur exactement 8? Si oui, cela semble un peu trop spécifique pour le défi.
— ar4093
On a supposé accidentellement qu'il s'agissait de rangs réguliers, fixés maintenant.
— moi le
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.