Herausforderung

Bei einer ASCII-Kunstform müssen Sie herausfinden, ob die Form ein reguläres Sechseck ist oder nicht.

Sechsecke

Ein reguläres Sechseck wird nach zwei Regeln definiert:

• Es hat sechs Seiten
• Jede Seite hat die gleiche Anzahl von Zeichen

Die folgende Form ist beispielsweise regelmäßig, hat jedoch keine sechs Seiten und ist daher kein reguläres Sechseck :

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

In ähnlicher Weise hat die folgende Form sechs Seiten, hat jedoch Seiten unterschiedlicher Länge und ist daher kein reguläres Sechseck:

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

Die folgende Form hat jedoch sechs Seiten und alle Seiten haben die gleiche Anzahl von Zeichen, sodass es sich um ein reguläres Sechseck handelt:

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

Regeln

Die Ausgabe sollte ein wahrer oder falscher Wert sein (wahr, wenn die Form ein reguläres Sechseck ist, falsch, wenn nicht).

Die Formen enthalten immer nur druckbare ASCII-Zeichen.

Der Rand der Form wird niemals Leerzeichen enthalten. In diesem Fall können Sie Falschgeld zurückgeben.

Vor und / oder nach der Form können beliebig viele Leerzeichen eingefügt werden.

Möglicherweise sind nicht alle Winkel in der Form gleich. Die folgende Form ist eine gültige Eingabe:

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

Es wird ein falscher Wert zurückgegeben.

Alle Form-Eingaben erfolgen in einem durch Leerzeichen getrennten Raster. Die hexagonale Eingabe erfolgt in einem versetzten Raster (jede Zeile ist von der nächsten versetzt).

Beispiele

Wahrheit

Die folgenden Formen sollten wahrheitsgemäße Werte zurückgeben:

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

Das Folgende sollte falsche Werte zurückgeben

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

  *
 * *
* * *

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

Diese Form befindet sich nicht in einem durch Leerzeichen getrennten Raster und ist nicht versetzt.

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

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

Bei der Eingabe einzelner Zeichen kann Ihr Programm entweder "Wahr" oder "Falsch" ausgeben:

&

Gewinnen

Das kürzeste Programm in Bytes gewinnt.

R, 184 Bytes

Golf gespielt, könnte wahrscheinlich von ein paar Bytes golfen werden

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, sehr chaotisch, eher auf halbem Weg golfen

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
}

Da das Eingabeformat nicht angegeben ist, muss Input in einem R-Array-Format angegeben werden, das ungefähr so ​​aussieht.

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

Hier ist eine Generatorfunktion, die die Eingabe generiert. Der Generator generiert kein Objekt, das in die Hexagon-Check-Funktion eingespeist wird, sondern den Code, der das Array angibt (praktisch dasselbe). Dies sollte also nicht als Syntaxanalyse des Texts gelten. Denken Sie daran, dass ich keinen Text eingebe, sondern eine Array-Struktur.

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

Zum Beispiel wäre der generierte Code: 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 ))der identisch ist mitarray(c(" ", " ", "2", " ", " ", " ", "8", " ", "7", " ", "5", " ", "3", " ", "1", " ", "9", " ", "8", " ", "6", " ", "4", " ", "2", " ", "0", " ", "9", " ", "7", " ", "5", " ", "3", " ", "1", " ", "0", " ", " ", " ", "6", " ", " "), dim = c(5, 9))

Hoffentlich entspricht diese Eingabemethode den Regeln.

Hier sind die Testfälle

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

Eingabearrays generieren

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

Auf Sechseck prüfen

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)

Wobei \nein buchstäbliches Newline-Zeichen darstellt. 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 Bytes

Die richtige Sprache für den Job ... irgendwie.

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 ist eine Sprache aus der 2-D Pattern Matching Challenge. Es sollte bei dieser Aufgabe wirklich gut sein, aber leider haben alle Eckfälle den Code wirklich aufgebläht. Ich habe auch ein paar Dolmetscherfehler entdeckt. Trotzdem war es eine lustige Herausforderung.

mist die Hauptschlange, die alle anderen dazu aufruft, die eigentliche Arbeit zu erledigen. Es beginnt in der oberen rechten Ecke des Sechsecks und geht im Uhrzeigersinn. Nummerierte Gruppen werden verwendet, um sicherzustellen, dass alle diagonalen Seitenlängen gleich sind und die horizontale Seitenlänge mit der Höhe der gesamten Figur übereinstimmt. Ich könnte eine ausführlichere Erklärung schreiben, aber ich habe die letzten zwei Tage damit verbracht, mich mit Eckfällen zu befassen. Probieren Sie es einfach hier aus . : ^)

Perl, 127 125 124 121 Bytes

Beinhaltet +4 für -0p

Geben Sie eine Eingabe für STDIN ein

#!/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*$/