Introducción

Estás sentado con tu compañero de trabajo, almorzando y presumiendo sobre el último y supuestamente el mejor proyecto en el que has estado trabajando. Cansado y cansado de su constante muestra de egoísmo, él / ella le ofrece un desafío para que se calle. Siendo la persona egoísta y feliz que eres, por supuesto que aceptas (porque debes aceptar todos y cada uno de los desafíos). El desafío , tal como lo explica, es que, dada la entrada de un bloque de texto que contiene 1 o más de cada carácter !@#$^&*, las coordenadas de los interruptores que están / están "en" emiten en cualquier formato razonable.

Según su compañero de trabajo, un interruptor es un $, y un interruptor se clasifica como "encendido" si y solo si cumple al menos 1 de los siguientes criterios:

1. Está rodeado de todos ^. Entonces...

   ^^^
   ^$^
   ^^^
   

   da como resultado un interruptor "encendido".

2. Está rodeado de todos &. Entonces...

   &&&
   &$&
   &&&
   

   da como resultado un interruptor "encendido".

3. Está completamente cubierto en al menos dos lados con *. Por ejemplo,

   ***
   &$&
   ***
   

   da como resultado un interruptor "encendido", pero

   &*&
   &$&
   &*&
   

   no lo hace, ya que el interruptor no está completamente cubierto en ninguno de los dos lados por *s.

4. Hay al menos 1 !y / o 1 @en cualquiera de las esquinas a su alrededor. Esto no cuenta si alguno de estos no está en una esquina. Entonces...

   !&&
   ^$@
   @&!
   

   da como resultado un interruptor "encendido", ya que hay al menos 1 !y / o @al menos 1 de las esquinas (en el caso anterior, hay 2 !sy válidos @en 3 esquinas). Y...

   &!&
   ^$@
   ^!&
   

   Cómo no , aunque hay 2 !s y 1 @, ya que ninguno de ellos se encuentra en ninguna de las esquinas.

5. 1 o más no# están en ningún lado alrededor del interruptor, a menos que al menos 1 rodee el interruptor. En otras palabras, si hay al menos 1 presente en un lado, anula todas las demás reglas, a menos que también haya un presente. Por lo tanto:&#&

   #&*
   *$*
   !**
   

   da como resultado un interruptor "encendido", aunque #existe, ya que hay un &interruptor alrededor del interruptor y sigue al menos 1 de las reglas anteriores. Sin embargo, si el signo de exclamación no estuviera presente así:

   #&*
   *$*
   ***
   

   El interruptor estaría apagado, ya que no sigue al menos una de las reglas anteriores. Por lo tanto, a pesar de que un interruptor puede estar rodeado por a #y a &, aún estaría apagado a menos que siga una o más de estas reglas. Además, siempre debe haber una relación> = 1: 1 entre &sy #s para que el cambio sea válido. Por ejemplo,

   #&!
   *$*
   **#
   

   seguiría siendo un cambio no válido, aunque sigue 1 de estas reglas, ya que hay 2 #s, pero solo 1 &, y por lo tanto no una relación> = 1: 1 entre &sy #s. Para que esto sea válido, debe agregar 1 o más &s adicionales a cualquier borde para equilibrar el número de #sys &, posiblemente así:

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

   Finalmente...

   #^^
   ^$*
   @^!
   

   da como resultado un interruptor de "apagado", aunque sigue 1 o más de las reglas anteriores, ya que contiene al menos 1 #a su alrededor, y no se &puede equilibrar.

6. Los conmutadores válidos solo estarán dentro de una entrada y, por lo tanto, cada válido $debe estar rodeado completamente por cualquiera de los 8 caracteres válidos. Por ejemplo, si la entrada completa fuera:

   *$*
   !$!
   !!!
   

   la parte superior $definitivamente no es un interruptor válido ya que el interruptor está en un borde y, por lo tanto, el interruptor no está completamente rodeado por 8 caracteres válidos. En este caso, el cambio ni siquiera debería considerarse. Sin embargo, el interruptor en el medio es completamente válido y, de hecho, está "activado", ya que cumple al menos uno de los requisitos anteriores.

Para demostrarlo, considere este bloque de caracteres:

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

que podemos etiquetar para coordenadas así, llamando al eje vertical yy al eje horizontal x:

y

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

  123456789 x

Las coordenadas siempre deben devolverse en un (x,y)formato, similar a una cuadrícula de coordenadas bidimensional. Ahora, ¿qué interruptores están encendidos? Bueno, primero vamos a encontrarlos a todos. Ya podemos ver que hay 1 en la fila superior y otro en la parte inferior. Sin embargo, esos son automáticamente no-ops, ya que no están completamente rodeados por 8 caracteres.

Luego viene el de la fila 2. Específicamente, este:

#^^
#$$
^!$

Podemos ver que hay 3 $signos en esto, pero solo queremos centrarnos en el que está en el medio, y, como puede ver, ya no es válido, ya que tiene 2 #s alrededor sin &s para equilibrarlos. fuera. Además, esto ni siquiera sigue ninguna de las reglas, por lo que incluso si fuera un cambio válido, estaría "apagado" de todos modos.

Luego viene otro en la fila 2:

^^$
$$*
!$!

Nuevamente, solo concéntrate en el interruptor en el medio. Este interruptor está "activado", ya que tiene al menos 1 !en al menos 1 esquina. Las coordenadas de este son (5,2).

Continuando, finalmente pasamos al último interruptor. Este también está en la segunda fila y aparece así:

$#!
*$&
!@&

y, como probablemente pueda ver, este también es un interruptor válido, aunque lo #rodea, ya que hay otros 2 &s para compensar el #. Además de eso, también tiene al menos 1 !en al menos 1 de las esquinas, y por lo tanto no solo es válido el interruptor, sino que también está "activado". Las coordenadas de este interruptor son (7,2).

Finalmente hemos llegado al final, y hemos encontrado 2 interruptores "en" en todo ese bloque en el texto. Sus coordenadas son (5,2)y (7,2), que es nuestra respuesta final, y cuál debería ser la salida. Sin embargo, esta entrada fue muy simple. Las entradas pueden ser mucho más grandes, ya que no hay límite en cuanto al tamaño del bloque de texto. Por ejemplo, la entrada podría incluso ser un 200x200bloque de texto aleatorio .

Contracciones

• Las lagunas estándar están prohibidas.

• No puede posiblemente ser un built-in para esto, pero por si acaso hay (mirarte Mathematica), se prohíbe el uso de muebles empotrados que resuelven directamente esto.

Casos de prueba:

Dado en el formato 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]]
^!!#&#&&&#*^#!^!^@!$
&$$^*$^$!#*&$&$#^^&$

Más muy pronto

Notas adicionales

• Puede suponer que la entrada siempre tendrá la forma de un bloque completo (es decir, un rectángulo o un cuadrado)
• No habrá nunca más ser cualquier otro personaje de la entrada que los de !@#$^&*.

Recuerde, este es un código de golf, por lo que gana el código más corto.

Haskell, 304 bytes

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]]]

Esto define la función fque realiza la tarea dada.

JavaScript (ES6), 363 339 312 309 298 bytes

Esta es una función que toma la entrada como una cadena y devuelve una lista de coordenadas. Se divide en 2 partes principales: una transformación de interruptores en un par de coordenadas y sus caracteres circundantes, y un control de 'está listo' basado en las reglas del desafío en los personajes circundantes.

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 bytes

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

Pruébalo en línea!

Toma la entrada como una lista de cadenas

Imprime la salida como un par de coordenadas x, y en cada línea