Défi

Étant donné une forme d'art ASCII, vous devez savoir si la forme est un hexagone régulier ou non.

Hexagones

Un hexagone régulier est défini selon deux règles:

• Il a six côtés
• Chaque côté a un nombre égal de caractères

Par exemple, la forme suivante est régulière mais elle n'a pas six côtés et n'est donc pas un hexagone régulier :

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

De même, la forme suivante a six côtés mais a des côtés de longueurs différentes et n'est donc pas un hexagone régulier :

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

Cependant, la forme suivante a six côtés et tous les côtés ont le même nombre de caractères, il s'agit donc d'un hexagone normal:

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

Règles

La sortie doit être une valeur true ou falsey (true si la forme est un hexagone régulier, falsey sinon).

Les formes ne contiendront que des caractères ASCII imprimables.

La bordure de la forme ne contiendra jamais d'espace. Si c'est le cas, vous pouvez retourner falsey.

Il peut y avoir des quantités arbitraires d'espaces avant et / ou après la forme.

Tous les angles de la forme peuvent ne pas être égaux par exemple, la forme suivante est une entrée valide:

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

Il renverra une valeur de falsey.

Toutes les entrées de forme seront sur une grille séparée par des espaces. L'entrée hexagonale sera sur une grille décalée (chaque ligne est décalée de la suivante).

Exemples

Truthy

Les formes suivantes doivent renvoyer des valeurs véridiques:

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

Les éléments suivants doivent renvoyer les valeurs de 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

  *
 * *
* * *

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

Cette forme n'est pas sur une grille séparée par des espaces et n'est pas décalée.

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

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

Pour les entrées à un seul caractère, votre programme peut produire soit true soit falsey:

&

Gagnant

Le programme le plus court en octets gagne.

R, 184 octets

Golfé, pourrait probablement être joué par quelques octets

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

Non golfé, très en désordre, plus comme à mi-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
}

Étant donné que le format d'entrée n'est pas spécifié, l'entrée doit être spécifiée dans un format de tableau R, ressemblant à ceci.

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

Voici une fonction de générateur qui génère l'entrée. Le générateur ne génère pas un objet qui est introduit dans la fonction de vérification hexagonale, mais plutôt le code spécifiant le tableau (en fait la même chose). Cela ne doit donc pas compter comme une analyse du texte. N'oubliez pas que je ne saisis pas de texte, mais plutôt une structure de tableau.

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

Par exemple, le code généré serait: 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 ))qui est identique à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))

Espérons que cette méthode de saisie soit conforme aux règles.

Voici les cas de test

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

Générer des tableaux d'entrée

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

Test d'hexagone

sapply(.Last.value , f)

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

JavaScript (ES6), 214 octets

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

Où \nreprésente un caractère de nouvelle ligne littéral. Non 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 octets

La bonne langue pour le travail ... en quelque sorte.

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 est un langage de correspondance de motifs 2D défi de . Il devrait être vraiment bon dans cette tâche, mais malheureusement, tous les cas d'angle ont vraiment gonflé le code. J'ai également découvert quelques bogues d'interprète. C'était quand même un défi amusant.

mest le serpent principal qui appelle tous les autres pour faire le travail. Cela correspond à partir du coin supérieur droit de l'hexagone et dans le sens horaire. Les groupes numérotés sont utilisés pour vérifier que les longueurs des côtés diagonaux sont toutes égales et que la longueur du côté horizontal correspond à la hauteur de la figure entière. Je pourrais écrire une explication plus détaillée, mais j'ai passé les deux derniers jours à traiter des cas d'angle, alors essayez-le par vous-même ici . : ^)

Perl, 127 125 124 121 octets

Comprend +4 pour -0p

Donnez votre avis sur 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*$/