Meydan okuma

Bir ASCII sanat şekli verildiğinde, şeklin normal bir altıgen olup olmadığını öğrenmelisiniz.

altıgenler

Normal bir altıgen iki kural kullanılarak tanımlanır:

• Altı tarafı var
• Her bir tarafın eşit sayıda karakteri vardır

Örneğin, aşağıdaki şekil normaldir, ancak altı tarafı yoktur ve normal bir altıgen değildir :

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

Benzer şekilde, aşağıdaki şeklin altı tarafı vardır, ancak farklı uzunluklarda kenarları vardır ve bu nedenle normal bir altıgen değildir :

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

Bununla birlikte, aşağıdaki şeklin altı yüzü vardır ve tüm kenarların aynı sayıda karakteri vardır, bu yüzden normal bir altıgendir:

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

kurallar

Çıktı bir doğruluk ya da bir falsey değeri olmalıdır (şekil düzenli bir altıgen ise doğrudur, değilse falsey).

Şekiller yalnızca yazdırılabilir ASCII karakterleri içerecektir.

Şeklin kenarlığı asla boşluk içermez. Varsa, falsey geri dönebilirsiniz.

Şekilden önce ve / veya sonra keyfi miktarda boşluk olabilir.

Şekildeki tüm açılar örneğin eşit olmayabilir, aşağıdaki şekil geçerli giriştir:

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

Bir falsey değeri döndürür.

Tüm şekil girişleri boşlukla ayrılmış ızgarada olacaktır. Altıgen giriş aşamalı bir ızgarada olacaktır (her satır bir sonrakinden ofsetlenir).

Örnekler

Doğru

Aşağıdaki şekiller doğruluk değerleri döndürmelidir:

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

Aşağıdakiler falsey değerlerini döndürmelidir

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

  *
 * *
* * *

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

Bu şekil, boşlukla ayrılmış bir ızgarada değildir ve kademeli değildir.

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

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

Tek karakter girişleri için programınız doğruluk veya falsey çıktısı verebilir:

&

Kazanan

Bayt cinsinden en kısa program kazanır.

R, 184 bayt

Golf, muhtemelen birkaç bayt tarafından golf olabilir

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, çok dağınık, yarı golf gibi

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
}

Girdi biçimi belirtilmediğinden, Girdi'nin R dizisi biçiminde belirtilmesi gerekir, böyle bir şeye bakar.

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

İşte girdiyi üreten bir jeneratör işlevi. Jeneratör, altıgen kontrol fonksiyonuna beslenen bir nesne oluşturmaz, aksine diziyi belirten kodu (etkili bir şekilde aynı şey) oluşturur. Yani bu metni ayrıştırmak olarak sayılmamalıdır. Metin girmiyorum, daha ziyade bir dizi yapısı olduğumu unutmayın.

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

Örneğin, üretilen kod olacaktır: 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 ))özdeş olanarray(c(" ", " ", "2", " ", " ", " ", "8", " ", "7", " ", "5", " ", "3", " ", "1", " ", "9", " ", "8", " ", "6", " ", "4", " ", "2", " ", "0", " ", "9", " ", "7", " ", "5", " ", "3", " ", "1", " ", "0", " ", " ", " ", "6", " ", " "), dim = c(5, 9))

Umarım bu giriş yöntemi kurallara uygundur.

İşte test senaryoları

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

Girdi dizileri oluşturma

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

Altıgen için test

sapply(.Last.value , f)

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

JavaScript (ES6), 214 bayt

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

Burada \ngerçek bir satırsonu karakterini temsil eder. 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 bayt

İş için doğru dil ... biraz.

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 Boyutlu Kalıp Eşleştirme zorluğunun bir dilidir . Bu görevde gerçekten iyi olmalı, ancak ne yazık ki tüm köşe vakaları kodu gerçekten şişirdi. Ayrıca birkaç tercüman hatası da buldum. Yine de eğlenceli bir mücadeleydi.

mdiğerlerini gerçek işi yapmaya çağıran ana yılan. Altıgenin sağ üst köşesinden başlayıp saat yönünde gidiyor. Numaralandırılmış gruplar, çapraz kenar uzunluklarının hepsinin eşit olduğunu ve yatay kenar uzunluğunun tüm şeklin yüksekliğiyle eşleştiğini doğrulamak için kullanılır. Daha ayrıntılı bir açıklama yazabilirdim, ancak son iki günü köşe davalarıyla uğraşarak geçirdim, bu yüzden burada kendiniz deneyin . : ^)

Perl, 127 125 124 121 bayt

İçin +4 içerir -0p

STDIN'e giriş verin

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