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 :

    t h i s
   i       s
  a         h
 e           x
  a         g
   o       n
    ! ! ! !

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.

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

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.

code-golf ascii-art hexagonal-grid Beta Decay
la source

4

Mathematica one liner entrant.

ThreeFx

1

Je pense que vous voudrez peut-être ajouter deux cas de test: un sans espaces de tête, par exemple: 5 6 7\n8 9 0 1\n2 3 4 5 6\n7 8 9 0\n1 2 3et un avec un espace supplémentaire en tête pour l'une des lignes: ss5 6 7\nss8 9 0 1\n2 3 4 5 6\ns7 8 9 0\nss1 2 3(les espaces de tête sont remplacés par spour le rendre un peu plus clair dans cette forme non formatée) . Tous les 10 de vos cas de test valident correctement avec mon code actuellement, mais ces deux cas échoueraient avec l'approche que j'ai utilisée.

Kevin Cruijssen

L'exemple avec les périodes est-il nécessairement falsey? La période manquante est un espace qui est l'un des personnages valides pouvant constituer l'hexagone,

Ton Hospel

1

@TonHospel Je pense que l'idée est que le contour est un hexagone régulier ininterrompu.

Martin Ender

Tous les angles de la forme peuvent ne pas être égaux par exemple, la forme suivante est une entrée valide: ce phrasé semble trompeur. Nous détectons sûrement des hexagones réguliers? Voulez-vous dire que les symboles n'ont pas nécessairement une symétrie angulaire?

Lynn

2

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

Vlo
la source

@DLosc Vous n'avez pas défini la fonction de génération. Essayez ce lien: goo.gl/9MtCLg Vous pouvez également vérifier avec une entrée manuelle comme

f(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, j'ai raté cette partie. Merci.

DLosc

1

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

Neil
la source

J'ai trouvé un bug: entrée " x\n g g\ng g g\n g g" devrait donner false, mais donne true.

DLosc

@DLosc Je suppose que c'est deux espaces avant la x ?

Neil

@DLosc Je pense que je l'ai réparé maintenant, ça m'a coûté 30 octets ...

Neil

1

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

DLosc
la source

1

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

Ton Hospel
la source

Hexagolf: Validagons