Вызов

Учитывая художественную форму ASCII, вы должны выяснить, является ли форма правильным шестиугольником или нет.

Шестигранники

Правильный шестиугольник определяется по двум правилам:

• Имеет шесть сторон
• Каждая сторона имеет одинаковое количество символов

Например, следующая форма является правильной, но не имеет шести сторон и поэтому не является правильным шестиугольником :

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

Аналогично, следующая форма имеет шесть сторон, но имеет стороны разной длины и поэтому не является правильным шестиугольником:

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

Однако следующая форма имеет шесть сторон, и все стороны имеют одинаковое количество символов, поэтому это обычный шестиугольник:

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

правила

Вывод должен быть истинным или ложным значением (правдивым, если форма представляет собой правильный шестиугольник, ложным, если нет).

Формы будут содержать только печатные символы ASCII.

Граница фигуры никогда не будет содержать пробелов. Если это произойдет, вы можете вернуть фальси.

Может быть произвольное количество пробелов до и / или после фигуры.

Все углы в форме могут быть не равны, например, следующая форма является допустимым вводом:

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

Это возвратит фальшивое значение.

Все входные данные формы будут находиться в сетке, разделенной пробелами. Гексагональный вход будет находиться в шахматном порядке (каждая строка смещена относительно следующей).

Примеры

Truthy

Следующие формы должны возвращать истинные значения:

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

Следующее должно возвращать значения 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

  *
 * *
* * *

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

Эта форма не находится на сетке, разделенной пробелами, и не находится в шахматном порядке.

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

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

Для односимвольных вводов ваша программа может выводить truey или falsey:

&

выигрыш

Самая короткая программа в байтах побеждает.

R 184 байта

Гольф, вероятно, может быть в гольф на несколько байтов

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, очень грязный, больше похоже на полпути

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
}

Поскольку формат ввода не указан, Input необходимо указывать в формате R-массива, примерно так.

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

Вот функция генератора, которая генерирует ввод. Генератор генерирует не объект, который подается в функцию проверки шестиугольника, а код, определяющий массив (фактически то же самое). Так что это не должно рассматриваться как разбор текста. Помните, что я не вводю текст, а скорее структуру массива.

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

Например, сгенерированный код будет: 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 ))который идентичен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))

Надеемся, что этот метод ввода соответствует правилам.

Вот тестовые случаи

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

Генерация входных массивов

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

Тест на шестиугольник

sapply(.Last.value , f)

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

JavaScript (ES6), 214 байт

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

Где \nпредставляет буквальный символ новой строки. 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 байт

Правильный язык для работы ... вроде.

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 - это язык из задачи 2-D Pattern Matching . Это должно быть действительно хорошо в этой задаче, но, к сожалению, все угловые случаи действительно раздутый код. Я также обнаружил пару ошибок переводчика. Тем не менее, это было забавное испытание.

mэто главная змея, которая призывает всех остальных выполнять реальную работу. Это соответствует началу в верхнем правом углу шестиугольника и по часовой стрелке. Нумерованные группы используются для проверки того, что все стороны диагональной стороны равны и что длина горизонтальной стороны соответствует высоте всей фигуры. Я мог бы написать более подробное объяснение, но я провел последние два дня, занимаясь угловыми делами, так что попробуйте сами здесь . : ^)

Perl, 127 125 124 121 байт

Включает +4 для -0p

Внести вклад в 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*$/