Inspirado tangencialmente pela abertura do livro What-If.
A entrada é um retângulo de espaços como uma string, lista de strings, etc., com objetos feitos de #
dentro:
########
# #
########
### ####
### ####
###
Os objetos sempre serão retângulos sem interseção, sem toque. Um objeto flexível é definido como um objeto que não é preenchido com #
s no meio e é apenas uma borda; um objeto rígido é aquele que é preenchido. Um objeto com largura ou altura <=2
é considerado rígido. Todos os objetos são rígidos ou flexíveis.
Se houver mais objetos rígidos na entrada, saída "Hard"
, se mais suave, saída "Soft"
, se forem iguais, saída "Equal"
.
Isso é código-golfe , então o código mais curto em bytes vence!
Casos de teste
Esses casos não são entradas completas, mas como cada objeto deve ser caracterizado. A entrada real será como a arte ASCII no topo da questão.
Difícil
#
####
##
##
##########
##########
##########
Suave
###
# #
###
###################
# #
# #
# #
###################
####
# #
# #
# #
# #
# #
# #
# #
####
Casos de teste reais
########
# #
########
### ####
### ####
###
Hard
###
###
###
###################
# #
# #
# #
###################
Equal
######
# #
######
###
## # # #
###
########
# #
########
Soft
fonte
Respostas:
MATL ,
105104585049 bytesObrigado a @ Neil por uma sugestão que me permitiu remover 46 bytes!
Entrada é uma matriz de caracteres 2D, com linhas separadas por
;
. O exemplo do desafio éAqui está outro exemplo:
Isso corresponde a
e assim deve dar
'Equal'
.Como um terceiro exemplo, correspondente a
'Soft'
,isso é,
Experimente online!
Explicação
Isso usa convolução 2D para detectar formas. A entrada é convertida em uma matriz 2D com
1
indicação#
e-1
espaço; e é preenchido com uma moldura de-1
valores. Isso garante que as formas na borda do campo original também sejam detectadas.Um objeto macio é detectado pela máscara
que corresponde ao canto superior esquerdo do objeto com um ponto interior vazio. Observe que a convolução inverte a máscara, portanto é definida como
[-1 1; 1 1]
no código. O número S de posições nas quais a convolução4
é igual é o número total de objetos flexíveis.Um objeto (macio ou rígido) é detectado pela máscara
que corresponde ao canto superior esquerdo do objeto, juntamente com alguns pontos exteriores vazios. Essa máscara é a versão negada da anterior, portanto, o resultado da convolução anterior pode ser reutilizado. Especificamente, o número T de posições em que esse resultado é igual
-4
é é o número total de objetos.O número H de objectos duros é T - S . A cadeia de saída é determinada pelo sinal de S - H = 2 * S - T .
fonte
JavaScript (ES6),
123121118 bytesEconomizou 2 bytes graças a @ edc65!
Recebe entrada como uma cadeia de linhas multilinha preenchida com espaços para formar uma grade.
Explicação / Teste
Muito perto do comprimento do MATL!Basicamente, ele procura a linha superior de#
s de cada objeto e, se o comprimento da linha superior for menor que 2 ou os 2 primeiros caracteres abaixo da linha superior forem iguais, é difícil, caso contrário é suave.fonte
###
retornaEqual
.~g.search(/$/m)
é um pouco mais legível do que~g.search`\n`||-1
.||-1
-me a corrigi-lo, mas sua sugestão me fez perceber que adicionar|$
ao regex economizaria 2 bytes de qualquer maneira. Obrigado!n=l=...
n>l?...:n<l?...:...
Geléia,
5049464338343332 bytesExperimente online! ou verifique todos os casos de teste .
fundo
Existem 16 padrões 2 × 2 diferentes de blocos e espaços:
Destes, como dois objetos nunca se tocam,
nunca ocorrerá na entrada, deixando-nos com 14 padrões possíveis.
Atribuindo
um valor de 0 e
#
um valor de 1 , podemos codificar um padrão 2 × 2como 2 (2a + c) + (2b + d) = 4a + 2b + 2c + d , deixando os seguintes valores para os 14 padrões.
Para padrões parciais 2 × 1 , 1 × 2 ou 1 × 1 na borda inferior e / ou direita, nós os trataremos como se estivessem preenchidos com espaços, codificando-os como 4a + 2b , 4a + 2c e 4a , respectivamente .
Dessa forma, cada objeto (macio ou rígido) terá exatamente um padrão 4 (seu canto inferior direito); cada objeto macio terá exatamente dois padrões 7 (seu canto inferior esquerdo e seu canto superior direito).
Assim, subtrair a quantidade de 4 padrões do número de 7 padrões encontrados na entrada produzirá (s + h) - 2s = h - s: = d , em que h e s são a quantidade de objetos rígidos e flexíveis que eles formam.
Imprimimos Hard se d> 0 , Soft se d <0 e Igual se d = 0 .
Como funciona
fonte
Julia,
999593 bytes!
espera uma matriz Char bidimensional como argumento. Experimente online!Como funciona
Isso usa quase exatamente a mesma idéia da minha resposta Jelly , com uma melhoria:
Em vez de contar a quantidade de 4 e 7 , removemos todos os outros números e subtraímos 5,5 para mapear (4, 7) para (-1,5, 1,5) . Dessa forma, o sinal da soma das diferenças resultantes determina a saída correta.
fonte
TSQL,
328249 bytesDeclarando variáveis e dados de teste:
Código:
Código desinflado:
Explicação:
O script está varrendo o texto para o padrão:
Cada um desses é o começo de uma caixa
Para essas posições, o script está verificando o padrão, não precisa verificar o primeiro x:
Quando isso existe, é um objeto flexível, caso contrário, é um objeto rígido.
fonte