Wyzwanie

Biorąc pod uwagę kształt artystyczny ASCII, musisz dowiedzieć się, czy jest to zwykły sześciokąt, czy nie.

Sześciokąty

Zwykły sześciokąt jest definiowany przy użyciu dwóch reguł:

• Ma sześć stron
• Każda strona ma taką samą liczbę znaków

Na przykład poniższy kształt jest regularny, ale nie ma sześciu boków, a zatem nie jest zwykłym sześciokątem :

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

Podobnie poniższy kształt ma sześć boków, ale ma boki o różnych długościach, a zatem nie jest regularnym sześciokątem:

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

Jednak następujący kształt ma sześć boków, a wszystkie boki mają tę samą liczbę znaków, więc jest to zwykły sześciokąt:

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

Zasady

Dane wyjściowe powinny mieć wartość true lub falsey (prawda, jeśli kształt jest regularnym sześciokątem, falsey, jeśli nie).

Kształty zawsze będą zawierały tylko znaki ASCII do wydruku.

Granica kształtu nigdy nie będzie zawierać spacji. Jeśli tak, możesz zwrócić falsey.

Mogą występować dowolne ilości białych znaków przed i / lub po kształcie.

Wszystkie kąty w kształcie mogą nie być równe, na przykład poprawny jest następujący kształt:

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

Zwróci wartość falsey.

Wszystkie dane wejściowe kształtu będą na siatce oddzielonej spacjami. Sześciokątne dane wejściowe będą rozmieszczone naprzemiennie (każda linia jest odsunięta od następnej).

Przykłady

Prawda

Następujące kształty powinny zwracać prawdziwe wartości:

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

Poniższe powinny zwrócić wartości 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

  *
 * *
* * *

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

Ten kształt nie znajduje się na siatce oddzielonej przestrzenią i nie jest przesunięty.

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

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

W przypadku wprowadzania pojedynczych znaków twój program może wypisywać prawdę lub falsey:

&

Zwycięski

Najkrótszy program w bajtach wygrywa.

R 184 bajty

Grał w golfa, prawdopodobnie mógłby być golfowany o kilka bajtów

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

Bez golfa, bardzo niechlujny, bardziej jak golf w połowie drogi

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
}

Ponieważ format wejściowy jest nieokreślony, dane wejściowe należy określić w formacie tablicy R, wyglądając mniej więcej tak.

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

Oto funkcja generatora, która generuje dane wejściowe. Generator nie generuje obiektu, który jest wprowadzany do funkcji sprawdzania sześciokąta, ale kod określający tablicę (właściwie to samo). Dlatego nie powinno to być liczone jako parsowanie tekstu. Pamiętaj, że nie wprowadzam tekstu, a raczej strukturę tablic.

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

Na przykład wygenerowany kod to: 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 ))identyczny zarray(c(" ", " ", "2", " ", " ", " ", "8", " ", "7", " ", "5", " ", "3", " ", "1", " ", "9", " ", "8", " ", "6", " ", "4", " ", "2", " ", "0", " ", "9", " ", "7", " ", "5", " ", "3", " ", "1", " ", "0", " ", " ", " ", "6", " ", " "), dim = c(5, 9))

Mam nadzieję, że ta metoda wprowadzania danych jest zgodna z zasadami.

Oto przypadki testowe

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

Generuj tablice wejściowe

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

Test na sześciokąt

sapply(.Last.value , f)

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

JavaScript (ES6), 214 bajtów

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

Gdzie \nreprezentuje dosłowny znak nowej linii. Nie golfowany:

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 bajtów

Właściwy język do pracy ... w pewnym sensie.

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 to język z wyzwania 2-D Pattern Matching . Powinno być naprawdę dobre w tym zadaniu, ale niestety wszystkie narożne przypadki naprawdę nadęły kod. Odkryłem też kilka błędów tłumacza. To było jednak zabawne wyzwanie.

mjest głównym wężem, który wzywa wszystkich pozostałych do wykonania rzeczywistej pracy. Dopasowuje się, zaczynając od prawego górnego rogu sześciokąta i idąc zgodnie z ruchem wskazówek zegara. Grupy numerowane służą do sprawdzenia, czy wszystkie długości boków po przekątnej są równe i czy długość boku poziomego odpowiada wysokości całej figury. Mógłbym napisać bardziej szczegółowe wyjaśnienie, ale ostatnie dwa dni spędziłem na zajmowaniu się przypadkami narożnymi, więc po prostu wypróbuj je tutaj . : ^)

Perl, 127 125 124 121 bajtów

Obejmuje +4 za -0p

Podaj dane na 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*$/