Desafío

Dada una forma de arte ASCII, debe averiguar si la forma es un hexágono regular o no.

Hexágonos

Un hexágono regular se define usando dos reglas:

• Tiene seis lados
• Cada lado tiene el mismo número de caracteres

Por ejemplo, la siguiente forma es regular pero no tiene seis lados y, por lo tanto, no es un hexágono regular :

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

De manera similar, la siguiente forma tiene seis lados pero tiene lados de diferentes longitudes y, por lo tanto, no es un hexágono regular :

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

Sin embargo, la siguiente forma tiene seis lados y todos los lados tienen el mismo número de caracteres, por lo que es un hexágono regular:

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

Reglas

La salida debe ser un valor verdadero o falso (verdadero si la forma es un hexágono regular, falso si no).

Las formas solo contendrán caracteres ASCII imprimibles.

El borde de la forma nunca contendrá espacios. Si lo hace, puede regresar falsey.

Puede haber cantidades arbitrarias de espacios en blanco antes y / o después de la forma.

Todos los ángulos en la forma pueden no ser iguales, por ejemplo, la siguiente forma es una entrada válida:

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

Devolverá un valor falsey.

Todas las entradas de forma estarán en una cuadrícula separada por espacios. La entrada hexagonal estará en una cuadrícula escalonada (cada línea está desplazada de la siguiente).

Ejemplos

Verdad

Las siguientes formas deberían devolver valores verdaderos:

 # _
+ + +
 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

Lo siguiente debería devolver valores falsey

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

  *
 * *
* * *

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

Esta forma no está en una cuadrícula separada por espacios y no está escalonada.

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

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

Para entradas de un solo carácter, su programa puede generar verdadero o falso:

&

Victorioso

El programa más corto en bytes gana.

R, 184 bytes

Golfed, probablemente podría ser golfed por unos pocos bytes

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))}

Sin golf, muy desordenado, más bien a medio 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
}

Dado que el formato de entrada no está especificado, la entrada debe especificarse en un formato de matriz R, con un aspecto similar a este.

         [,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"  " "  " " 

Aquí hay una función generadora que genera la entrada. El generador no genera un objeto que se alimenta a la función de verificación hexagonal, sino más bien el código que especifica la matriz (efectivamente, lo mismo). Por lo tanto, esto no debe contar como analizar el texto. Recuerde que no estoy ingresando texto, sino más bien una estructura de matriz.

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))))))
}

Por ejemplo, el código generado sería: 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 ))que es idéntico 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))

Esperemos que este método de entrada cumpla con las reglas.

Aquí están los casos de prueba.

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 ="   .....
  .......
.........
  .......
   ....."

Generar matrices de entrada

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

Prueba de hexágono

sapply(.Last.value , f)

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

JavaScript (ES6), 214 bytes

(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)

Donde \nrepresenta un carácter de nueva línea literal. Sin golf:

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 bytes

El idioma correcto para el trabajo ... más o menos.

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 es un lenguaje del desafío 2-D Pattern Matching . Debería ser realmente bueno en esta tarea, pero desafortunadamente todos los casos de esquina realmente hincharon el código. También encontré un par de errores de interpretación. Aún así, fue un desafío divertido.

mes la serpiente principal que llama a todos los demás para hacer el trabajo real. Coincide comenzando en la esquina superior derecha del hexágono y yendo en sentido horario. Los grupos numerados se usan para verificar que las longitudes laterales diagonales son todas iguales y que la longitud lateral horizontal coincide con la altura de toda la figura. Podría escribir una explicación más detallada, pero he pasado los últimos dos días lidiando con casos de esquina, así que pruébelo usted mismo aquí . : ^)

Perl, 127 125 124 121 bytes

Incluye +4 para -0p

Dar entrada sobre 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*$/