Sfida

Data una forma d'arte ASCII, devi scoprire se la forma è un esagono regolare o meno.

esagoni

Un esagono regolare viene definito usando due regole:

• Ha sei lati
• Ogni lato ha un uguale numero di personaggi

Ad esempio, la seguente forma è regolare ma non ha sei lati e quindi non è un esagono regolare :

B a a h
s a i d
y o u r
g a o t

Allo stesso modo, la seguente forma ha sei lati ma ha lati di lunghezze diverse e quindi non è un esagono regolare :

  * *
 * * *
* * * *
 * * *
  * *

Tuttavia, la forma seguente ha sei lati e tutti i lati hanno lo stesso numero di caratteri, quindi è un esagono regolare:

  T h e
 h e x a
g o n s a
 r e c o
  m i n

Regole

L'output dovrebbe essere un valore di verità o falsità (verità se la forma è un esagono regolare, falsa in caso contrario).

Le forme conterranno sempre e solo caratteri ASCII stampabili.

Il bordo della forma non conterrà mai spazi. In tal caso, puoi restituire falsey.

Possono esserci quantità arbitrarie di spazi bianchi prima e / o dopo la forma.

Tutti gli angoli nella forma potrebbero non essere uguali, ad esempio, la seguente forma è un input valido:

  . . .
   . . .
. . . . .
 . . . .
  . . .

Restituirà un valore di falso.

Tutti gli input di forma saranno su una griglia separata da spazio. L'input esagonale sarà su una griglia sfalsata (ogni linea è sfalsata dalla successiva).

Esempi

Truthy

Le seguenti forme dovrebbero restituire valori veritieri:

 # _
+ + +
 9 :

  5 6 7
 8 9 0 1
2 3 4 5 6
 7 8 9 0
  1 2 3

    t h i s
   i       s
  a         h
 e           x
  a         g
   o       n
    ! ! ! !

    5 6 7
   8 9 0 1
  2 3 4 5 6
   7 8 9 0
    1 2 3

Falsey

Quanto segue dovrebbe restituire valori falsi

r e c t a
n g l e s

  h e l l o
 w o r l d s
t h i s i s b
 e t a d e c
  a y n o w

  *
 * *
* * *

  .....
 .......
.........
 .......
  .....

Questa forma non è su una griglia separata da spazio e non è sfalsata.

   * * * *
  ---------
 * * * * * *
-------------
 * * * * * *
  ---------
   * * * *

5 6 7
8 9 0 1
2 3 4 5 6
7 8 9 0
1 2 3

Per i caratteri a carattere singolo, il tuo programma può generare verità o falsa:

&

vincente

Vince il programma più breve in byte.

R, 184 byte

Golfizzato, potrebbe probabilmente essere golfato da pochi byte

function(m){e=min;f=max;l=length;v=which(m!=" ",T);a=v[,1];n=l(v[a==1,2]);u=(v[a==e(a),2]);all(u==v[a==f(a),2])&all(c(e(d<-v[a==ceiling(f(v[,1])/2),2]),f(d))==c(u[1]-n+1,u[l(u)]+n-1))}

Ungolfed, molto disordinato, più come a metà campo da golf

f=function(m) {
  v = which(m!=" ",T)
  a = v[,1]
  n = length(v[a==1,2])
  u=(v[a==min(a),2])
  c1 = all(u==v[a==max(a),2])
  d = v[a==ceiling(max(v[,1])/2),2]
  c2 = all(c(min(d), max(d))==c(u[1]-n+1,u[length(u)]+n-1))
  c1 & c2
}

Poiché il formato di input non è specificato, Input deve essere specificato in un formato di array R, simile a questo.

         [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9]
[1,] " "  " "  "5"  " "  "6"  " "  "7"  " "  " " 
[2,] " "  "8"  " "  "9"  " "  "0"  " "  "1"  " " 
[3,] "2"  " "  "3"  " "  "4"  " "  "5"  " "  "6" 
[4,] " "  "7"  " "  "8"  " "  "9"  " "  "0"  " " 
[5,] " "  " "  "1"  " "  "2"  " "  "3"  " "  " " 

Ecco una funzione del generatore che genera l'ingresso. Il generatore non genera un oggetto che viene immesso nella funzione di controllo esagonale, ma piuttosto il codice che specifica l'array (effettivamente la stessa cosa). Quindi questo non dovrebbe essere considerato come analisi del testo. Ricorda che non sto inserendo testo, ma piuttosto una struttura a matrice.

generate = function(x) {
  s = strsplit(strsplit(x, "\n")[[1]], "")
  m = max(sapply(s, length))
  dput(do.call(rbind, lapply(s, function(x) c(x, rep(" ", m-length(x))))))
}

Ad esempio, il codice generato sarebbe: structure(c(" ", " ", "2", " ", " ", " ", "8", " ", "7", " ", "5", " ", "3", " ", "1", " ", "9", " ", "8", " ", "6", " ", "4", " ", "2", " ", "0", " ", "9", " ", "7", " ", "5", " ", "3", " ", "1", " ", "0", " ", " ", " ", "6", " ", " "), .Dim = c(5L, 9L ))che è identico aarray(c(" ", " ", "2", " ", " ", " ", "8", " ", "7", " ", "5", " ", "3", " ", "1", " ", "9", " ", "8", " ", "6", " ", "4", " ", "2", " ", "0", " ", "9", " ", "7", " ", "5", " ", "3", " ", "1", " ", "0", " ", " ", " ", "6", " ", " "), dim = c(5, 9))

Speriamo che questo metodo di input sia conforme alle regole.

Ecco i casi di test

x1 = 
"  5 6 7
 8 9 0 1
2 3 4 5 6
 7 8 9 0
  1 2 3"

x2 =
" # _
+ + +
 9 :"

x3 = 
"    t h i s
   i       s
  a         h
 e           x
  a         g
   o       n
    ! ! ! !"

x4 ="    5 6 7
   8 9 0 1
  2 3 4 5 6
   7 8 9 0
    1 2 3"

x5 = "r e c t a
n g l e s"

x6 = "  h e l l o
  w o r l d s
t h i s i s b
 e t a d e c
  a y n o w"

x7 ="  *
 * *
* * *"

x8 ="   .....
  .......
.........
  .......
   ....."

Genera array di input

sapply(mget(paste("x", 1:8, sep = "")), generate)

Test per esagono

sapply(.Last.value , f)

   x1    x2    x3    x4    x5    x6    x7    x8 
 TRUE  TRUE  TRUE  TRUE FALSE FALSE FALSE FALSE 

JavaScript (ES6), 214 byte

(s,a=s.split`\n`,n=a[l=a.length>>1].match(r=/(?=\S).*\S/),i=n.index)=>!/\S(  )*\S/.test(s)&&!a.some((s,j)=>(m=r.exec(s))&&(k=m.index)<i+(j<l?j=l-j:j-=l)|k+(m=m[0].length)+j>i+n[0].length|k+i+j&1|j%l<1&m+j+j!=l*4+1)

Dove \nrappresenta un carattere letterale newline. Ungolfed:

function validhex(s) {
    if (/S(  )*/S/.test(s)) return false;
    var a = s.split("\n");
    var l = Math.floor(a.length / 2);
    var n = a[l].match(/(?=\S).*\S/);
    for (var j = -l; j <= l; j++) {
        var m = a[j+l].match(/(?=\S).*\S/);
        if (!m) continue;
        if (m.index < n.index + Math.abs(j)) return false;
        if (m.index + m[0].length + Math.abs(j) > n.index + n[0].length) return false;
        if ((m.index + n.index + j) % 2) return false;
        if (j % l) continue;
        if (m[0].length != l * 4 + 1 - 2 * Math.abs(j)) return false;
    }
    return true;
}

SnakeEx , 200 byte

La lingua giusta per il lavoro ... in un certo senso.

m:{v<>}{r<RF>2P}{r<R>2P}{h<RF>1P}{w<>}{l<RF>2P}{l<R>2P}{h<.>1}
w:{u<>P}{v<>}
v:{e<L>}{u<R>1}
u:.*{e<>}
e:.$
r:[^ ]+
h:([^ ] )+
l:({c<.>}[^ ])+{c<.>}
c:{b<B>}(. )+{x<>LP}{s<>}
b:.{s<>}
s:[^\!-\~]*$
x:.

SnakeEx è un linguaggio della sfida 2-D Pattern Matching . Dovrebbe essere davvero bravo in questo compito, ma sfortunatamente tutti i casi angolari hanno davvero gonfiato il codice. Ho anche scoperto un paio di bug di interprete. Comunque, è stata una sfida divertente.

mè il serpente principale che chiama tutti gli altri a fare il vero lavoro. Corrisponde a partire dall'angolo in alto a destra dell'esagono e procede in senso orario. I gruppi numerati vengono utilizzati per verificare che le lunghezze del lato diagonale siano tutte uguali e che la lunghezza del lato orizzontale corrisponda all'altezza dell'intera figura. Potrei scrivere una spiegazione più dettagliata, ma ho passato gli ultimi due giorni a trattare casi angolari, quindi provalo qui da solo . : ^)

Perl, 127 125 124 121 byte

Include +4 per -0p

Dare input su STDIN

#!/usr/bin/perl -0p
/ *(.*\S)/;$a=join'\S *
\1',map$"x(abs).'\S '.(/$n/?'\S ':'. ')x(2*$n-1-abs),-($n=$1=~y/ //)..$n;$_=/^$`( *)$a\S\s*$/