Quais interruptores estão ativados?

12

Introdução

Você está sentado com seu colega de trabalho, almoçando e se gabando com ele sobre o mais recente e supostamente maior projeto em que você está trabalhando. Ficando doente e cansado de sua constante demonstração de egoísmo, ele / ela oferece um desafio para você calar a boca. Sendo a pessoa egoísta e feliz que dá sorte, é claro que você aceita (porque deve aceitar cada desafio). O desafio , como ele / ela explica, é dada uma entrada de um bloco de texto contendo 1 ou mais caracteres de cada !@#$^&*, gerando , em qualquer formato razoável, as coordenadas dos comutadores que estão / estão "ativados".

De acordo com seu colega de trabalho, uma opção é ae $uma opção é classificada como "ativada" se, e somente se, atender a pelo menos um dos seguintes critérios:

  1. Está cercado por todos ^. Então...

    ^^^
^$^
^^^

    resulta em um interruptor "on".

  2. Está cercado por todos &. Então...

    &&&
&$&
&&&

    resulta em um interruptor "on".

  3. É completamente coberto em pelo menos dois lados com *. Por exemplo,

    ***
&$&
***

    resulta em um interruptor "on", mas 

    &*&
&$&
&*&

    não, uma vez que o interruptor não é completamente coberto por nenhum dos dois lados por *s.

  4. Há pelo menos 1 !e / ou 1 @em qualquer um dos cantos ao redor. Isso não conta se um deles não estiver em um canto. Então...

    !&&
^$@
@&!

    resulta em um interruptor "ligado", pois há pelo menos 1 !e / ou @em pelo menos 1 dos cantos (no caso acima, existem 2 se !1 válido @em 3 cantos). E...

    &!&
^$@
^!&

    faz não , apesar de existirem 2 !s e um @, uma vez que nenhum deles está em qualquer dos cantos.

  5. 1 ou mais não# estão de nenhum lado ao redor do comutador, a menos que pelo menos 1 envolva o comutador. Em outras palavras, se houver pelo menos um presente de um lado, ele substituirá todas as outras regras, a menos que haja também um presente. Portanto:&#&

    #&*
*$*
!**

    resulta em um comutador "ligado", embora #exista um , pois existe um &ao redor do comutador e segue pelo menos uma das regras acima. No entanto, se o ponto de exclamação não estivesse presente da seguinte forma:

    #&*
*$*
***

    O interruptor estaria desligado, pois não segue pelo menos uma das regras acima. Portanto, mesmo que um switch pode ser rodeado por um #e um &, ele ainda estaria fora, a menos que se segue uma ou mais dessas regras. Além disso, deve sempre ser a> = 1: 1 entre &s e #s para o interruptor para ser válido. Por exemplo,

    #&!
*$*
**#

    ainda seria um interruptor inválido, embora segue-se uma dessas regras, uma vez que existem 2 #s, mas apenas 1 &, e, portanto, não a> = 1: 1 entre &s e #s. Para tornar isso válido, você deve adicionar 1 ou mais &s adicionais a qualquer borda para equilibrar o número de se #es &, possivelmente da seguinte maneira:

    #&!
*$&
&*#

3:2 ratio between &s and #s

    Finalmente...

    #^^
^$*
@^!

    resulta em um interruptor "desligado", embora siga uma ou mais das regras acima, pois contém pelo menos 1 #ao seu redor e não há &s para desequilibrá-lo.

  6. Os interruptores válidos irá única estar dentro de uma entrada, e, portanto, uma validade $tem de ser rodeado completamente por qualquer oito dos caracteres válidos. Por exemplo, se toda a entrada fosse:

    *$*
!$!
!!!

    $definitivamente, a parte superior não é uma opção válida, pois a chave está em uma extremidade e, portanto, a chave não é completamente cercada por 8 caracteres válidos. Nesse caso, a opção nem deve ser considerada. No entanto, a opção no meio é completamente válida e, de fato, está "ativada", pois atende a pelo menos um dos requisitos acima.

Para demonstrar, considere este bloco de caracteres:

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

que podemos rotular para coordenadas como essa, chamando o eixo vertical ye o eixo horizontal x:

y

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

  123456789 x

As coordenadas sempre devem ser retornadas em um (x,y)formato semelhante a uma grade de coordenadas bidimensional. Agora, quais interruptores estão ativados? Bem, vamos primeiro encontrar todos eles. Já podemos ver que há um na linha superior e outro na parte inferior. No entanto, essas são automaticamente não-ops, pois não são completamente cercadas por 8 caracteres.

Em seguida, vem o da linha 2. Especificamente, este:

#^^
#$$
^!$

Podemos ver que há três $sinais nisso, mas queremos apenas focar no que está no meio e, como você provavelmente pode ver, ele já é inválido, pois possui 2 #s ao redor, sem &s para equilibrá-los. Fora. Além disso, isso nem segue nenhuma das regras; portanto, mesmo que fosse uma opção válida, ela estaria "desativada" de qualquer maneira.

Em seguida, vem outro na linha 2:

^^$
$$*
!$!

Novamente, concentre-se apenas no interruptor no meio. Essa opção está "ativada", pois possui pelo menos 1 !em pelo menos 1 canto. As coordenadas deste são (5,2).

Continuando, finalmente passamos para o último interruptor. Este também está na segunda linha e aparece assim:

$#!
*$&
!@&

e, como você provavelmente pode ver, esse também é um comutador válido, embora exista um #ambiente ao seu redor, pois existem outros 2 &s para desequilibrar o #. Além disso, ele também possui pelo menos 1 !em pelo menos 1 dos cantos e, portanto, não apenas o switch é válido, mas também está "ativado". As coordenadas dessa opção são (7,2).

Finalmente chegamos ao fim e encontramos 2 opções "ativadas" naquele bloco inteiro de texto. Suas coordenadas são (5,2)e (7,2), qual é a nossa resposta final e qual deve ser o resultado. No entanto, essa entrada foi muito simples. As entradas podem ficar muito maiores, pois não há limite para o tamanho do bloco de texto. Por exemplo, a entrada pode até ser um 200x200bloco de texto aleatório .

Restrições

  • As brechas padrão são proibidas.

  • Não pode , eventualmente, ser um built-in para isso, mas apenas no caso de haver é (olhando para você Mathematica), o uso de built-ins que resolver diretamente esta são proibidos.

Casos de teste:

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

Mais em breve

Notas Adicionais

  • Você pode assumir que a entrada sempre estará na forma de um bloco completo (ou seja, um retângulo ou quadrado)
  • Não vai não ser qualquer outro personagem na entrada do que aqueles em !@#$^&*.

Lembre-se, este é um código de golfe, portanto o código mais curto vence!

code-golf string R. Kap
fonte
12
Parece um pouco longo e arbitrário.
orlp
@orlp É para isso que estou indo. É um desafio de qualquer maneira. Por que você diz que é arbitrário?
R. Kap
6
@ R.Kap Não há justificativa para nenhuma das regras; eles parecem feitos para adicionar complexidade sem motivo.
Fund Monica's Lawsuit
6
@QPaysTaxes Que justificação isso precisa? Estes são feitos para o bem do desafio. Ele é um desafio, e um desafio pode ser literalmente qualquer coisa . Tudo o que realmente precisa é de um conjunto de regras, uma entrada e o resultado da saída com base nessas regras.
R. Kap
1
Não estou dizendo que concordo, estou explicando por que parece arbitrário. Tome o meu desafio mais popular como exemplo: se você retirou todo o contexto e apenas disse: "Você recebe um conjunto de strings. Com base na indentação, agrupe-os, embaralhe os grupos, depois embaralhe os grupos interiores, mas mantenha os membros de grupos interiores no fundo, se existirem ", isso não faria muito sentido. No entanto, por ter contexto, todas essas regras e restrições estranhas pelo menos fingem fazer sentido.
Fund Monica's Lawsuit

Respostas:

2

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

Isso define a função fque executa a tarefa especificada.

faubi
fonte
2

JavaScript (ES6), 363 339 312 309 298 bytes

Esta é uma função que recebe a entrada como uma sequência e retorna uma lista de coordenadas. Ele é dividido em duas partes principais: uma transformação de interruptores em um par de coordenadas e seus personagens circundantes, e uma verificação de 'está pronto' com base nas regras do desafio para os personagens 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)
XavCo7
fonte
2

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

Experimente online!

Recebe entrada como uma lista de strings

Imprime a saída como um par de coordenadas x, y em cada linha

TFeld
fonte