Hexagolf: Validagons


13

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.


44
Mathematica one liner entrante.
ThreeFx

1
Creo que es posible que desee agregar dos casos de prueba: uno sin espacios iniciales, por ejemplo: 5 6 7\n8 9 0 1\n2 3 4 5 6\n7 8 9 0\n1 2 3y otro con un espacio adicional que conduzca a una de las filas: ss5 6 7\nss8 9 0 1\n2 3 4 5 6\ns7 8 9 0\nss1 2 3(los espacios iniciales se reemplazan por spara que quede un poco más claro en esta forma sin formato) . Los 10 casos de prueba se están validando correctamente con mi código actualmente, pero estos dos casos fallarían con el enfoque que utilicé.
Kevin Cruijssen

¿Es el ejemplo con los períodos necesariamente falsey? El período que falta es un espacio que es uno de los caracteres válidos que pueden formar el hexágono,
Ton Hospel

1
@TonHospel Creo que la idea es que el esquema es un hexágono regular ininterrumpido.
Martin Ender

Todos los ángulos en la forma pueden no ser iguales, por ejemplo, la siguiente forma es una entrada válida: esta frase parece engañosa. ¿Seguramente estamos detectando hexágonos regulares? ¿Quieres decir que los símbolos no tienen necesariamente simetría angular?
Lynn

Respuestas:


2

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 

@DLosc No tenía la función de generación definida. Pruebe este enlace: goo.gl/9MtCLg También puede verificar con una entrada manual comof(array(c(" ", " ", "2", " ", " ", " ", "8", " ", "7", " ", "5", " ", "3", " ", "1", " ", "9", " ", "8", " ", "6", " ", "4", " ", "2", " ", "0", " ", "9", " ", "7", " ", "5", " ", "3", " ", "1", " ", "0", " ", " ", " ", "6", " ", " "), dim = c(5, 9)))
Vlo

Ah, me perdí esa parte. Gracias.
DLosc

1

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

Encontré un error: la entrada " x\n g g\ng g g\n g g"debería dar falso, pero da verdadero.
DLosc

@DLosc Supongo que hay dos espacios antes del x?
Neil

@DLosc Creo que ya lo solucioné, aunque me costó 30 bytes ...
Neil

1

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í . : ^)


1

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*$/
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.