Questa sfida è ispirata da un'immagine che si aggira spesso su Facebook simile a questa . Tranne il nostro quadrato di base sarà più simile a questo:

┌─┬───┬─┐
├─┼─┬─┼─┤
├─┼─┴─┼─┤
├─┼─┬─┼─┤
└─┴─┴─┴─┘

Il quadrato è composto da un n x mquadrato 1x1, devi contare quanti quadrati secondari (1x1, 2x2, 3x3, 4x4, 5x5, ecc.) Possono adattarsi all'interno di quel quadrato. I quadrati possono mancare alcune linee della griglia (come nell'esempio sopra) o essere completi come nell'esempio qui sotto. Ciò significa che una ripartizione matematica non è possibile (per quanto ne so).

ingressi:

• La quantità di linee ( n) di input per costruire il quadrato;
• Un quadrato composto dai seguenti caratteri: ─ ┐ ┌ └ ┴ ┘ ┬ ├ ┤ ┼ |attraverso le nlinee di input.

Produzione:

• La quantità di quadrati di qualsiasi dimensione che possono rientrare nel quadrato di input (qui vogliamo solo un singolo numero, non un numero per ogni dimensione).

Criterio vincente:

Vince la risposta più piccola (numero di byte).

Casi test:

Nel:

5
┌─┬─┬─┬─┐
├─┼─┼─┼─┤
├─┼─┼─┼─┤
├─┼─┼─┼─┤
└─┴─┴─┴─┘

Fuori: 30

Nel:

3
┌─┬─┐
├─┼─┤
└─┴─┘

Fuori: 5

Nel:

5
┌─┬─┐
├─┴─┤
├───┤
├─┬─┤
└─┴─┘

Fuori: 7

Nel:

4
┌─┬─┬─┬─┬─┬─┐
├─┼─┼─┼─┼─┼─┤
├─┼─┼─┼─┼─┼─┤
└─┴─┴─┴─┴─┴─┘

Fuori: 32

Nel:

2
┌─┐
└─┘

Fuori: 1

Nel:

4
┌─┬─┬─┬─┬─┬─┐
├─┴─┼─┼─┼─┴─┤
├─┬─┼─┼─┼─┬─┤
└─┴─┴─┴─┴─┴─┘

Fuori: 22

JavaScript (ES6), 292 byte 306 325

Modifica Ho fatto il conteggio dei byte completamente sbagliato, corretto ora grazie a http://bytesizematters.com/ corretto per l'ultima volta spero grazie a Cᴏɴᴏʀ O'Bʀɪᴇɴ vedi https://goo.gl/LSHC1U (e 1 byte in meno usando un valore letterale newline invece di '\ n')

(h,z)=>(o=>{r=p=>" ),┌(─┐┬'└│├┘┴┤┼".search(z[p]);for(q=s=0;++s<o/2&s<h;)for(y=0;y<(h-s)*o;y+=o)for(x=0;x<o-s*2;q+=!n,x+=2)for(n=i=0,t=x,u=y;i<=s;t+=2,u+=o,i++)n|=i<s&(!(r(t+y)&r(t+y+s*o)&1)|!(r(x+u)&r(x+u+s*2)&2))|i>0&(!(r(t+y)&r(t+y+s*o)&4)|!(r(x+u)&r(x+u+s*2)&8))})(-~z.search`
`)|q

Più di quanto mi aspettassi (probabilmente è possibile eliminare qualche byte in più)

Tutti i quadrati possibili vengono controllati e contati.

La rfunzione mappa ogni carattere su una bitmap che ha

• 1: centro della linea orizzontale a destra
• 2: linea verticale dal centro verso il basso
• 4: linea orizzontale al centro a sinistra
• 8: linea verticale dal centro verso l'alto

Un quadrato di qualsiasi dimensione deve avere

• 4 in tutte le celle tranne la prima nella riga superiore e inferiore
• 1 in tutte le celle tranne l'ultima nella riga superiore e inferiore
• 8 in tutte le celle tranne la prima nella colonna più a sinistra e più a destra
• 2 in tutte le celle tranne l'ultima nella colonna più a sinistra e più a destra

Test

f=(h,z)=>(o=>{r=p=>" ),┌(─┐┬'└│├┘┴┤┼".search(z[p]);k=(p,d,m)=>r(p)&r(p+s*d)&m;for(q=s=0;++s<o/2&s<h;)for(y=0;y<(h-s)*o;y+=o)for(x=0;x<o-s*2;q+=!n,x+=2)for(n=i=0,t=x,u=y;i<=s;t+=2,u+=o,i++)n=n|i<s&(!k(t+y,o,1)|!k(x+u,2,2))|i>0&(!k(t+y,o,4)|!k(x+u,2,8));})(-~z.search`
`)|q

console.log=(...x)=>O.textContent+=x+'\n'

// Less golfed

Uf=(h,z)=>{
  o=-~z.search`\n`;
  w=o/2;
  r=p=>" ),┌(─┐┬'└│├┘┴┤┼".search(z[p]);
  k=(p,d,m)=>r(p)&r(p+s*d)&m;
  for(q=s=0;++s<w&s<h;)
    for(y=0;y<(h-s)*o;y+=o)
      for(x=0;x<(w-s)*2;q+=!n,x+=2)
        for(n=i=0,t=x,u=y;i<=s;t+=2,u+=o,i++)
          n|=i<s&(!k(t+y,o,1)|!k(x+u,2,2))
          |i>0&(!k(t+y,o,4)|!k(x+u,2,8));
  return q
}

;[[5,`┌─┬───┬─┐
├─┼─┬─┼─┤
├─┼─┴─┼─┤
├─┼─┬─┼─┤
└─┴─┴─┴─┘`,20]
,[5,`┌─┬─┬─┬─┐
├─┼─┼─┼─┤
├─┼─┼─┼─┤
├─┼─┼─┼─┤
└─┴─┴─┴─┘`,30]
,[3,`┌─┬─┐
├─┼─┤
└─┴─┘`,5]
,[5,`┌─┬─┐
├─┴─┤
├───┤
├─┬─┤
└─┴─┘`,7]
,[4,`┌─┬─┬─┬─┬─┬─┐
├─┼─┼─┼─┼─┼─┤
├─┼─┼─┼─┼─┼─┤
└─┴─┴─┴─┴─┴─┘`,32]
,[2,`┌─┐
└─┘`,1]
,[4,`┌─┬─┬─┬─┬─┬─┐
├─┴─┼─┼─┼─┴─┤
├─┬─┼─┼─┼─┬─┤
└─┴─┴─┴─┴─┴─┘`,22],
,[6,`┌─┬─────┐
├─┼─┬─┐ │
│ ├─┼─┼─┤
│ └─┼─┼─┤
│   └─┼─┤
└─────┴─┘`,12],  
,[6,`┌─┬─┬─┬─┐
├─┴─┼─┼─┤
│   └─┼─┤
├─┬─┬─┼─┤
├─┼─┼─┼─┤
└─┴─┴─┴─┘`,23]]  
.forEach(t=>{
  var r=t[0],a=t[1],k=t[2],x=f(r,a)
  console.log(x==k?'OK '+x:'KO '+x+' Expected '+k,'\n'+a)
})

<pre id=O></pre>