introduction

Vous êtes assis avec votre collègue, en train de déjeuner et de vous vanter du dernier et soi-disant plus grand projet sur lequel vous avez travaillé. En tombant malade et fatigué de votre vitrine constante d'égoïsme, il / elle vous lance un défi juste pour que vous vous taisiez. Étant la personne égoïste et joyeuse que vous êtes, vous acceptez bien sûr (car vous devez accepter chaque défi). Le défi , comme il l'explique, est, étant donné l' entrée d'un bloc de texte contenant 1 ou plus de chaque caractère !@#$^&*, de sortir dans n'importe quel format raisonnable les coordonnées du ou des interrupteurs qui sont "activés".

Selon votre collègue, un interrupteur est un interrupteur $et un interrupteur est classé comme "on" si et seulement s'il satisfait au moins 1 des critères suivants:

1. Il est entouré de tous ^. Donc...

   ^^^
   ^$^
   ^^^
   

   résulte en un interrupteur "on".

2. Il est entouré de tous &. Donc...

   &&&
   &$&
   &&&
   

   résulte en un interrupteur "on".

3. Il est entièrement recouvert sur au moins deux côtés avec *. Par exemple,

   ***
   &$&
   ***
   

   entraîne un interrupteur "on", mais

   &*&
   &$&
   &*&
   

   non, puisque l'interrupteur n'est pas complètement couvert des deux côtés par l' *art.

4. Il y a au moins 1 !et / ou 1 @dans l'un des coins autour. Cela ne compte pas si aucun d'eux n'est dans un coin. Donc...

   !&&
   ^$@
   @&!
   

   se traduit par un interrupteur "on", car il y a au moins 1 !et / ou @au moins 1 des coins (dans le cas ci-dessus, il y a 2 !s valides et 1 valable @dans 3 coins). Et...

   &!&
   ^$@
   ^!&
   

   ne le fait pas , bien qu'il y ait 2 !s et 1 @, car aucun d'entre eux n'est dans aucun des coins.

5. 1 ou plus ne se# trouvent sur aucun côté autour du commutateur, à moins qu'au moins 1 entoure le commutateur. En d'autres termes, s'il y a au moins 1 présent d'un côté, il prévaut sur toutes les autres règles, sauf s'il y a aussi un présent. Donc:&#&

   #&*
   *$*
   !**
   

   résulte en un interrupteur "on", bien qu'un #existe, car il y a un &autour de l'interrupteur, et il suit au moins 1 des règles ci-dessus. Cependant, si le point d'exclamation n'était pas présent comme ceci:

   #&*
   *$*
   ***
   

   L'interrupteur serait désactivé, car il ne suit pas au moins l'une des règles ci-dessus. Par conséquent, même si un commutateur peut être entouré par un #et un &, il serait toujours désactivé à moins qu'il ne respecte une ou plusieurs de ces règles. De plus, il doit toujours y avoir un rapport> = 1: 1 entre &s et #s pour que le commutateur soit valide. Par exemple,

   #&!
   *$*
   **#
   

   serait toujours un commutateur invalide, même s'il suit 1 de ces règles, car il y a 2 #s, mais seulement 1 &, et donc pas un rapport> = 1: 1 entre &s et #s. Pour que cela soit valide, vous devez ajouter 1 ou plusieurs &s supplémentaires à n'importe quel bord afin d'équilibrer le nombre de #s et de &s, éventuellement comme ceci:

   #&!
   *$&
   &*#
   
   3:2 ratio between &s and #s
   

   Finalement...

   #^^
   ^$*
   @^!
   

   entraîne un interrupteur "off", bien qu'il suive 1 ou plusieurs des règles ci-dessus, car il en contient au moins 1 #, et aucun &s pour le surbalancer.

6. Les commutateurs valides seront uniquement à l' intérieur d' une entrée, et par conséquent, chaque valide $doit être complètement entouré par 8 des caractères valides. Par exemple, si l'entrée entière devait être:

   *$*
   !$!
   !!!
   

   le haut $n'est certainement pas un commutateur valide car le commutateur est sur un bord, et par conséquent le commutateur n'est pas complètement entouré de 8 caractères valides. Dans ce cas, le commutateur ne doit même pas être pris en compte. Cependant, le commutateur du milieu est complètement valide et, en fait, est "activé", car il remplit au moins l'une des exigences ci-dessus.

Pour démontrer, considérez ce bloc de caractères:

!@#^^$#!@
!@#$$*$&@
@$^!$!@&&

que nous pouvons étiqueter pour des coordonnées comme ça, en appelant l'axe vertical yet l'axe horizontal x:

y

3 !@#^^$#!@
2 !@#$$*$&@
1 @$^!$!@&&

  123456789 x

Les coordonnées doivent toujours être renvoyées dans un (x,y)format similaire à une grille de coordonnées bidimensionnelle. Maintenant, quels commutateurs sont allumés? Eh bien, trouvons-les d'abord tous. Nous pouvons déjà voir qu'il y en a 1 dans la rangée tout en haut et un autre tout en bas. Cependant, ce sont automatiquement des non-opérations, car ils ne sont pas complètement entourés de 8 caractères.

Vient ensuite celui de la ligne 2. Plus précisément, celui-ci:

#^^
#$$
^!$

Nous pouvons voir qu'il y a 3 $signes dans cela, mais nous voulons juste nous concentrer sur celui du milieu, et, comme vous pouvez probablement le voir, il est déjà invalide, car il a 2 #s autour sans aucun &s pour les équilibrer en dehors. De plus, cela ne respecte même aucune des règles, donc même s'il s'agissait d'un commutateur valide, il serait de toute façon "désactivé".

Vient ensuite un autre dans la rangée 2:

^^$
$$*
!$!

Encore une fois, concentrez-vous uniquement sur l'interrupteur au milieu. Ce commutateur est "on", car il a au moins 1 !dans au moins 1 coin. Les coordonnées de celui-ci sont (5,2).

Passons à autre chose, nous passons enfin au dernier interrupteur. Celui-ci est également dans la deuxième ligne et apparaît comme suit:

$#!
*$&
!@&

et, comme vous pouvez probablement le voir, celui-ci est également un interrupteur valide, bien qu'il y ait un #entourage, car il y a 2 autres &s pour contrebalancer le #. En plus de cela, il a également au moins 1 !dans au moins 1 des coins, et donc non seulement le commutateur est valide, mais il est également "on". Les coordonnées de ce commutateur sont (7,2).

Nous avons finalement atteint la fin et avons trouvé 2 interrupteurs "on" dans tout ce bloc de texte. Leurs coordonnées sont (5,2)et (7,2), ce qui est notre réponse finale, et quelle devrait être la sortie. Cependant, cette entrée était très simple. Les entrées peuvent devenir beaucoup plus grandes, car il n'y a pas de limite sur la taille du bloc de texte. Par exemple, l'entrée pourrait même être un 200x200bloc de texte aléatoire .

Contraintes

• Les échappatoires standard sont interdites.

• Il ne peut peut - être intégré pour cela, mais juste au cas où il est (à la recherche vous Mathematica), l'utilisation de Encastrements qui permettent de résoudre directement ce sont interdits.

Cas de test:

Donné au format string input -> [array output]:

@#$$&^!&!# 
@*&!!^$&^@
$!#*$@#@$!   ->  [[7,3],[9,2]]
*@^#*$@&*#

#^&!$!&$@@#&^^&*&*&&
!^#*#@&^#^*$&!$!*^$$
#^#*#$@$@*&^*#^!^@&* -> [[19,3],[15,3],[8,2]]
#$@$!#@$$^!#!@^@^^*#

@!@!^&*@*@
*$*^$!*&#$
@$^*@!&&&#
**$#@$@@#!  -> [[2,8],[5,8],[6,6],[9,3]]
##*&*#!^&^
$&^!#$&^&@
^^!#*#@#$*
$@@&#@^!!&
#@&#!$$^@$


!!@##!$^#!&!@$##$*$#
$^*^^&^!$&^!^^@^&!#!
@*#&@#&*$!&^&*!@*&** -> [[9,4],[9,3]]
^!!#&#&&&#*^#!^!^@!$
&$$^*$^$!#*&$&$#^^&$

Plus à venir bientôt

Notes complémentaires

• Vous pouvez supposer que l'entrée sera toujours sous la forme d'un bloc complet (c'est-à-dire un rectangle ou un carré)
• Il n'y aura jamais d'autre caractère dans l'entrée que ceux dans !@#$^&*.

Rappelez-vous, c'est un code-golf donc le code le plus court gagne!

Haskell, 304 octets

import Data.List
s!c=sum[1|a<-s,a==c]
f t|Just w<-elemIndex '\n't,h<-t!'\n'=[c|c<-mapM(\a->[2..a-1])[w,h],s<-[(\[x,y]->t!!((h-y-1)*(w+1)+x))<$>mapM(\a->[a-2..a])c],s!!4=='$',foldr1(-)((s!)<$>"#&")<1,or$("@!"/="@!"\\map(s!!)[0,2..8]):zipWith(\c i->all(==c)$(s!!)<$>[0..8]\\(4:i))"^&**"[[],[],[1,7],[3,5]]]

Ceci définit la fonction fqui exécute la tâche donnée.

JavaScript (ES6), 363 339 312 309 298 octets

Il s'agit d'une fonction prenant l'entrée sous forme de chaîne et renvoyant une liste de coordonnées. Il est divisé en 2 parties principales: une transformation des commutateurs en une paire de coordonnées et ses personnages environnants, et un contrôle `` est-il allumé '' basé sur les règles du défi sur les personnages environnants.

a=>[...a].map((z,p,m)=>(y-=z==B,z)=='$'&&(r=m[p-n-2]+m[p-n]+m[p+n]+m[p+n+2]+m[p-n-1]+m[p-1]+m[p+1]+m[p+n+1],r=r[L]<9?r:'')[T]`&`[L]>=r[T]`#`[L]&&(/(\^|&){8}|\*{4}(.\*\*.|\*..\*)/.exec(r)||/!|@/.exec(r.substr(0,4)))&&[1+(p-(w-y))%n,y],y=w=a[T='split'](B='\n')[L='length'],n=a.search(B)).filter(e=>e)

Python 2 , 299 297 279 275 261 259 octets

m=input()
R=range
h=len(m)
for y in R(h-2):
 for x in R(len(m[0])-2):
	a=''.join(m[y+o][x:x+3]for o in R(3))
	if(a.count('&')>=a.count('#'))*(a[:4]+a[5:]in('^'*8,'&'*8)or'*'*6in(a[:3]+a[6:],a[::3]+a[2::3])or'!'in a[::2]or'@'in a[::2])*a[4]=='$':print x+2,h+~y

Essayez-le en ligne!

Prend l'entrée comme une liste de chaînes

Imprime la sortie sous la forme d'une paire de coordonnées x, y sur chaque ligne