introduzione

Stai seduto con il tuo collega, pranzi e ti vanti dell'ultimo e presumibilmente il più grande progetto a cui stai lavorando. Stanco e stanco della tua costante vetrina dell'egoismo, lui / lei ti dà una sfida proprio per farti tacere. Essendo la persona egoista e felice di essere, accetti ovviamente (perché devi accettare ogni sfida). La sfida , come spiega lui / lei, dato un input di un blocco di testo contenente 1 o più di ogni carattere in !@#$^&*, emette in qualsiasi formato ragionevole le coordinate degli switch che sono / sono "on".

Secondo il tuo collega, un interruttore è a $e un interruttore è classificato come "acceso" se e solo se soddisfa almeno 1 dei seguenti criteri:

È circondato da tutti ^. Così...
```
^^^
^$^
^^^
```
si traduce in un interruttore "on".
È circondato da tutti &. Così...
```
&&&
&$&
&&&
```
si traduce in un interruttore "on".
È completamente coperto da almeno due lati con *. Per esempio,
```
***
&$&
***
```
risulta in un interruttore "on", ma
```
&*&
&$&
&*&
```
no, poiché l'interruttore non è completamente coperto su due lati da *s.
C'è almeno 1 !e / o 1 @in uno degli angoli attorno ad esso. Questo non conta se uno di questi non è in un angolo. Così...
```
!&&
^$@
@&!
```
si traduce in un interruttore "on", poiché vi è almeno 1 !e / o @almeno 1 degli angoli (nel caso precedente, ci sono 2 se validi !e 1 valido @in 3 angoli). E...
```
&!&
^$@
^!&
```
fa non , anche se ci sono 2 !s e 1 @, dal momento che nessuno di loro sono in qualsiasi degli angoli.
1 o più non si# trovano su alcun lato attorno all'interruttore, a meno che almeno 1 circonda l'interruttore. In altre parole, se c'è almeno 1 presente su un lato, ignora tutte le altre regole, a meno che non ci sia anche un presente. Perciò:&#&
```
#&*
*$*
!**
```
si traduce in un interruttore "on", anche se #esiste, poiché esiste un &interruttore attorno allo switch e segue almeno 1 delle regole precedenti. Tuttavia, se il punto esclamativo non fosse presente in questo modo:
```
#&*
*$*
***
```
L'interruttore sarebbe disattivato, poiché non segue almeno una delle regole precedenti. Pertanto, anche se un interruttore può essere circondato da un #e un &, sarebbe comunque spento a meno che non segua una o più di queste regole. Inoltre, deve essere sempre presente un rapporto> = 1: 1 tra &s e #s affinché l'interruttore sia valido. Per esempio,
```
#&!
*$*
**#
```
sarebbe comunque uno switch non valido, sebbene segua 1 di queste regole, poiché ci sono 2 #s, ma solo 1 &, e quindi non un rapporto> = 1: 1 tra &s e #s. Per rendere questo valido, è necessario aggiungere 1 o più ulteriori &s per qualsiasi bordo in equilibrio ordine il numero di #s e &s fuori, forse in questo modo:
```
#&!
*$&
&*#

3:2 ratio between &s and #s
```
Infine...
```
#^^
^$*
@^!
```
si traduce in un interruttore "off", sebbene segua 1 o più delle regole di cui sopra, poiché contiene almeno 1 #attorno ad esso e non &è necessario bilanciare.
Gli interruttori validi saranno solo essere all'interno di un ingresso e, quindi, della durata $devono essere circondato completamente da qualsiasi 8 dei caratteri validi. Ad esempio, se l'intero input fosse:
```
*$*
!$!
!!!
```
la parte superiore $è sicuramente non un interruttore valido poiché l'interruttore è su un bordo, e quindi l'interruttore non è completamente circondato da 8 caratteri validi. In questo caso, l'interruttore non dovrebbe nemmeno essere considerato. Tuttavia, l'interruttore nel mezzo è completamente valido e, di fatto, è "acceso", poiché soddisfa almeno uno dei requisiti di cui sopra.

Per dimostrare, considera questo blocco di caratteri:

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

che possiamo etichettare per coordinate in questo modo, chiamando l'asse verticale ye l'asse orizzontale x:

y

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

  123456789 x

Le coordinate devono sempre essere restituite in un (x,y)formato simile a una griglia di coordinate bidimensionale. Ora, quali interruttori sono attivi? Bene, prima troviamoli tutti. Possiamo già vedere che ce n'è 1 nella riga in alto e un altro in fondo. Tuttavia, quelli sono automaticamente vietati, poiché non sono completamente circondati da 8 caratteri.

Segue quello nella riga 2. In particolare, questo:

#^^
#$$
^!$

Possiamo vedere che ci sono 3 $segni in questo, ma vogliamo solo focalizzarci su quello nel mezzo e, come probabilmente vedrai, è già invalido, dal momento che ha 2 #s attorno ad esso senza &s per bilanciarli su. Inoltre, questo non segue nemmeno nessuna delle regole, quindi anche se fosse un passaggio valido, sarebbe comunque "spento".

Segue un altro nella riga 2:

^^$
$$*
!$!

Ancora una volta, concentrati solo sull'interruttore nel mezzo. Questo interruttore è "acceso", poiché ha almeno 1 !in almeno 1 angolo. Le coordinate di questo sono (5,2).

Andando avanti, finalmente passiamo all'ultimo interruttore. Anche questo è nella seconda riga e appare così:

$#!
*$&
!@&

e, come probabilmente vedrai, anche questo è un interruttore valido, sebbene ci sia un #ambiente circostante, poiché ci sono altre 2 &s per bilanciare #. Oltre a ciò, ha anche almeno 1 !in almeno 1 degli angoli, e quindi non solo è valido l'interruttore, ma è anche "acceso". Le coordinate di questo interruttore sono (7,2).

Abbiamo finalmente raggiunto la fine e abbiamo trovato 2 interruttori "on" in tutto il blocco del testo. Le loro coordinate sono (5,2)e (7,2), che è la nostra risposta finale, e quale dovrebbe essere l'output. Tuttavia, questo input è stato molto semplice. Gli input possono diventare molto più grandi, in quanto non c'è limite alla dimensione del blocco di testo. Ad esempio, l'input potrebbe persino essere un 200x200blocco di testo randomizzato .

contraints

Sono vietate le scappatoie standard.
Non ci può forse essere un built-in per questo, ma solo nel caso ci sia (guardando a voi Mathematica), l'uso di built-in che risolvono direttamente questo sono vietate.

Casi test:

Dato nel 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]]
^!!#&#&&&#*^#!^!^@!$
&$$^*$^$!#*&$&$#^^&$

Maggiori informazioni tra breve

Note aggiuntive

Si può presumere che l'input sarà sempre nella forma di un blocco completo (cioè un rettangolo o un quadrato)
Non ci sarà mai nessun altro personaggio nell'input oltre a quelli in !@#$^&*.

Ricorda, questo è un code-golf quindi vince il codice più corto!

code-golf string

— R. Kap
fonte

Sembra un po 'lungo e arbitrario.

— orlp,

@orlp Questo è quello che sto cercando. È comunque una sfida. Perché dici che è arbitrario però?

— R. Kap,

@ R.Kap Non c'è giustificazione per nessuna delle regole; sembrano inventati per aggiungere complessità senza motivo.

— Fondi Monica's Lawsuit,

@QPaysTaxes Di quale giustificazione necessita? Questi sono compensati per il bene della sfida. Si tratta di una sfida, e una sfida può essere letteralmente qualsiasi cosa . Tutto ciò di cui ha davvero bisogno è un insieme di regole, un input e ciò che l'output dovrebbe essere basato su tali regole.

— R. Kap

Non sto dicendo che sono d'accordo, sto spiegando perché sembra arbitrario. Prendi la mia sfida più popolare come esempio: se hai rimosso tutto il contesto e hai appena detto: "Ti viene data una serie di stringhe. Basandoti sul rientro, raggruppali, mescola i gruppi, quindi mescola i gruppi interni, ma mantieni i membri di gruppi interni in fondo se esistono ", non avrebbe molto senso. Tuttavia, poiché ha un contesto, tutte quelle strane regole e restrizioni fingono almeno di avere un senso.

— Finanzi la causa di Monica il

Haskell, 304 byte

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

Questo definisce la funzione fche esegue l'attività specificata.

— faubi
fonte

JavaScript (ES6), 363 339 312 309 298 byte

Questa è una funzione che accetta l'input come stringa e restituisce un elenco di coordinate. È diviso in 2 parti principali: una trasformazione di interruttori in una coppia di coordinate e i suoi personaggi circostanti, e un controllo "is it on" basato sulle regole della sfida sui personaggi circostanti.

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)

— XavCo7
fonte

Python 2 , 299 297 279 275 261 259 byte

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

Provalo online!

Accetta input come un elenco di stringhe

Stampa l'output come una coppia di coordinate x, y su ciascuna riga

— TFeld
fonte

Quali interruttori sono attivi?