Contando Gemas

fundo

Minha caixa de jóias caiu! Existem muitas gemas de formas diferentes no chão. E sua tarefa é contar o número de um certo tipo de gema.

I / O

• Seu código deve receber duas entradas Se G, que pode ser uma string com novas linhas, uma matriz de linhas, uma matriz bidimensional de caracteres, um arquivo de texto ou em qualquer formato razoável (se houver, indique-o claramente).
• Estas duas cordas só irá conter !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~(a partir 0x21de 0x7Ena tabela ASCII), espaço e novas linhas (forma binária dependendo da sua plataforma).
• Em cada sequência, as linhas têm o mesmo comprimento.
• Sé a gema que queremos contar. Existem duas circunstâncias.
  1. Incluído e não contém nenhuma área fechada aninhada. (no exemplo 1/2)
  2. Não contém nenhuma área fechada. (no exemplo 3/4)
• Os espaços circundantes não são considerados parte da gema.
• G é a forma de gemas no chão.
• É aceitável que seu código exija entrada extra para especificar as dimensões SeG
• É aceitável que seu código aceite valores ASCII como entradas, em vez de caracteres próprios. Mas você não deve substituir caracteres por números inteiros mais simples (0,1,2,3). Seu programa deve ser capaz de processar caracteres ou valores ASCII.

Exemplo 1 (Caractere como entrada)

Entrada S:

+-+  
| +-+
| | |
| | |
| +-+
+-+  

Entrada G:

    +-+       +-+
    | +-+   +-+ |
    | | |   | | |
    | | |   | | |
    | +-+   +-+ |
    +-+       +-+
         +-+     
+---+    | +-+   
|   |    | | |   
|   |    | | |   
|   |    | +-++  
|   |    +-+| +-+
+---+       | | |
            | | |
  +-+       | +-+
  | +-+     +-+  
  | |-|          
  | |-|          
  | +-+          
  +-+            

Ouptut:

2

Exemplo 2 (valor ASCII como entrada)

Entrada S:

32 32 32 32 32 32 32 32
32 32 32 32 99 32 99 32
32 32 32 99 32 99 32 99
32 32 32 99 32 32 32 99
32 32 32 99 32 32 32 99
32 32 32 99 32 32 32 99
32 32 32 32 99 32 99 32
32 32 32 32 32 99 32 32
32 32 32 32 32 32 32 32

Entrada G:

32 99 32 99 32 99 32 99 32 32 99 32
99 32 99 32 99 32 99 32 99 99 32 99
99 32 32 32 99 32 32 32 99 32 32 99
99 99 32 32 99 32 32 32 99 32 32 99
99 32 32 32 99 32 32 32 99 32 32 99
32 99 32 99 32 99 32 99 99 32 99 32
32 32 99 32 32 32 99 32 32 99 32 32

Resultado:

1

Visualizado S(32 substituído por -):

-- -- -- -- -- -- -- --
-- -- -- -- 99 -- 99 --
-- -- -- 99 -- 99 -- 99
-- -- -- 99 -- -- -- 99
-- -- -- 99 -- -- -- 99
-- -- -- 99 -- -- -- 99
-- -- -- -- 99 -- 99 --
-- -- -- -- -- 99 -- --
-- -- -- -- -- -- -- --

Visualizado G:

-- 99 -- 99 -- 99 -- 99 -- -- 99 --
99 -- 99 -- 99 -- 99 -- 99 99 -- 99
99 -- -- -- 99 -- -- -- 99 -- -- 99
99 99 -- -- 99 -- -- -- 99 -- -- 99
99 -- -- -- 99 -- -- -- 99 -- -- 99
-- 99 -- 99 -- 99 -- 99 99 -- 99 --
-- -- 99 -- -- -- 99 -- -- 99 -- --

Exemplo 3 (Não incluído)

Graças a @ Draco18s

Entrada S

AB

Entrada G

AAB BA CAB

Resultado

2

Exemplo 4 (2D não incluído)

Entrada S

ABCD
  GE
   F

Entrada G

ABCD 
BGGED
CDEFE
    F

Resultado

1

Observações

• Apenas duas gemas de uma forma exata são consideradas iguais.
• A mesma forma em direções diferentes não é considerada a mesma.
• No entanto, conforme descrito no exemplo de E / S, é possível sobrepor. Sob tais circunstâncias, apenas os completos são contados.
• +, -e |no exemplo não tem significados especiais. Eles não indicam nenhum canto ou borda da forma.
• Você pode assumir que a entrada é sempre válida.
• Você pode assumir que duas gemas alvo nunca compartilham exatamente a mesma vantagem.
• As brechas padrão são proibidas.
• Este é um código de golfe, então o código mais curto vence!

C (gcc) , 303305 326 bytes

Todas as otimizações precisam ser desativadas e funcionam apenas no GCC de 32 bits.

#define r(z,k)for(z=0;z<k;z++)
#define c s[i][j]
x,y,o,p,t,i,j;char**s;h(i,j){!((i<0)+(j<0)+i/x+j/y+c-32)?h(i+1,j),h(i-1,j),h(i,j+1),h(i,j-1),c=0:0;}f(w,e,u,v,a,g)char**a,**g;x=w,y=e,s=a;r(o,x)h(o,0),h(o,y-1);r(p,y)h(0,p),h(x-1,p);w=0;r(o,u-x+1)r(p,v-y+1){t=1;r(i,x)r(j,y)t*=!(c*(c-g[i+o][j+p]));w+=t;}}

O código usa o floodfill para substituir os espaços ao redor \0e procura correspondências enquanto ignora \0.

ungolfed e macros calculadas (algumas letras são diferentes da versão golfed, mas a lógica permanece a mesma):

int x, y, o, p, c, d, t;
char **s, **g;
h(int i, int j) {                             // Floodfill function
    if(i<0 || j<0) return;                    // Boundary detection
    if(i>=x || j>=y) return;
    if(s[i][j] != ' ') return;                // Character detection

    s[i][j] = 0;                              // Replace it with \0
    h(i+1, j);
    h(i-1, j)
    h(i  , j+1);
    h(i  , j-1);
}
f(
    int w,    //1st dimension of S
    int e,    //2nd dimension of S
    int u,    //1st dimension of G
    int v     //2nd dimension of G
    char** i, //Input S
    char** j, //Input G
    );
{
    x=w,y=e,s=i,g=j;
    for(o=0; o<x; o++)                        // Replace all surrounding spaces using floodfill
    {
        h(o, 0);                               
        h(o, y-1);
    }
    for(p=0; p<y; p++)
    {
        h(0,   p);
        h(x-1, p);
    }
    w = 0;
    for(o=0; o<=u-x; o++)                     // Main O(w*e*u*v) matching process
        for(p=0; p<=v-y; p++) {
            t=1;
            for(c=0; c<x; c++)
                for(d=0; d<y; d++)
                if(s[c][d]*(s[c][d]-g[c+o][d+p]))
                    t=0;
            w+=t;
        }
}