चुनौती

ASCII कला आकृति को देखते हुए, आपको यह पता लगाना चाहिए कि आकार एक नियमित षट्भुज है या नहीं।

hexagons

एक नियमित षट्भुज को दो नियमों का उपयोग करके परिभाषित किया गया है:

इसकी छह भुजाएँ हैं
प्रत्येक पक्ष में समान वर्ण हैं

उदाहरण के लिए, निम्नलिखित आकृति नियमित है, लेकिन इसके छह पहलू नहीं हैं और इसलिए यह एक नियमित षट्भुज नहीं है :

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

इसी तरह, निम्नलिखित आकार में छह पक्ष होते हैं, लेकिन विभिन्न लंबाई के पक्ष होते हैं और इसलिए एक नियमित षट्भुज नहीं होता है :

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

हालाँकि, निम्नलिखित आकार में छह पक्ष होते हैं और सभी पक्षों में समान वर्ण होते हैं, इसलिए यह एक नियमित षट्भुज है:

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

नियम

आउटपुट एक सत्य या एक गलत मूल्य होना चाहिए (सत्य यदि आकार एक नियमित षट्भुज है, तो गलत नहीं है)।

आकृतियों में केवल मुद्रण योग्य ASCII वर्ण होंगे।

आकार की सीमा में रिक्त स्थान कभी नहीं होंगे। यदि ऐसा होता है, तो आप झूठी वापसी कर सकते हैं।

आकृति से पहले और / या बाद में व्हाट्सएप की मनमानी मात्रा हो सकती है।

आकार में सभी कोण उदाहरण के लिए समान नहीं हो सकते हैं, निम्न आकृति वैध इनपुट है:

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

यह एक गलत मूल्य लौटाएगा।

सभी आकृति इनपुट अंतरिक्ष से अलग ग्रिड पर होंगे। हेक्सागोनल इनपुट एक कंपित ग्रिड पर होगा (प्रत्येक पंक्ति अगले से ऑफसेट है)।

उदाहरण

Truthy

निम्नलिखित आकृतियों को सत्य मान लौटाना चाहिए:

 # _
+ + +
 9 :

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

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

  *
 * *
* * *

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

यह आकार अंतरिक्ष से अलग ग्रिड पर नहीं है और कंपित नहीं है।

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

एकल वर्ण इनपुट के लिए, आपका प्रोग्राम सत्य या गलत हो सकता है:

जीतना

बाइट्स में सबसे छोटा कार्यक्रम जीतता है।

code-golf ascii-art hexagonal-grid

— बीटा डिके
स्रोत

4

गणितज्ञ एक लाइनर इनकमिंग।

— थ्री एफएक्स

1

मुझे लगता है कि आप दो परीक्षण मामलों को जोड़ना चाहते हैं: उदाहरण के लिए अग्रणी रिक्त स्थान के बिना, 5 6 7\n8 9 0 1\n2 3 4 5 6\n7 8 9 0\n1 2 3एक : और एक अतिरिक्त पंक्ति के साथ एक अग्रणी स्थान के लिए: ss5 6 7\nss8 9 0 1\n2 3 4 5 6\ns7 8 9 0\nss1 2 3(अग्रणी रिक्त स्थान sइस असंक्रमित रूप में थोड़ा और स्पष्ट करने के लिए बदल दिए जाते हैं ) । आपके सभी 10 परीक्षण मामले मेरे कोड के साथ वर्तमान में सही रूप से मान्य हैं, लेकिन ये दो मामले मेरे द्वारा उपयोग किए गए दृष्टिकोण से विफल होंगे।

— केविन क्रूज़सेन

क्या पीरियड्स का उदाहरण जरूरी है? मिसिंग पीरियड एक ऐसा स्थान है, जो कि वैध पात्रों में से एक है जो षट्भुज को बना सकता है,

— टन हास्पेल

1

@ टॉन्होस्पेल मुझे लगता है कि विचार यह है कि रूपरेखा एक नियमित नियमित षट्भुज है।

— मार्टिन एंडर

आकार में सभी कोण उदाहरण के लिए समान नहीं हो सकते हैं, निम्न आकृति मान्य इनपुट है: यह वाक्यांश भ्रामक लगता है। निश्चित रूप से हम नियमित हेक्सागोन्स का पता लगा रहे हैं? क्या आपको यह लिखने का मतलब है कि प्रतीकों में कोणीय समरूपता नहीं है?

— लिन

2

आर, 184 बाइट्स

गोल्फ, शायद कुछ बाइट्स द्वारा गोल्फ हो सकता है

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

अधकचरा, बहुत गन्दा, आधे रास्ते की तरह गोल्फ

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
}

चूंकि इनपुट प्रारूप अनिर्दिष्ट है, इसलिए इनपुट को आर सरणी प्रारूप में निर्दिष्ट करने की आवश्यकता है, जो कुछ इस तरह दिखता है।

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

यहां एक जनरेटर फ़ंक्शन है जो इनपुट उत्पन्न करता है। जनरेटर एक ऐसी वस्तु उत्पन्न नहीं करता है जो षट्भुज चेक फ़ंक्शन में खिलाया जाता है, बल्कि कोड को निर्दिष्ट सरणी (प्रभावी रूप से एक ही बात) को निर्दिष्ट करता है। तो यह पाठ पार्सिंग के रूप में नहीं गिना जाना चाहिए। याद रखें कि मैं पाठ इनपुट नहीं कर रहा हूँ, बल्कि एक सरणी संरचना।

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

उदाहरण के लिए, उत्पन्न कोड होगा: 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 ))जो समान है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))

उम्मीद है कि यह इनपुट विधि नियमों के अनुपालन में है।

यहाँ परीक्षण के मामले हैं

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

इनपुट सरणियाँ उत्पन्न करें

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

हेक्सागोन के लिए टेस्ट

sapply(.Last.value , f)

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

— VLO
स्रोत

@DLosc आपके पास परिभाषित फ़ंक्शन नहीं है। इस लिंक को आज़माएं: goo.gl/9MtCLg आप मैन्युअल इनपुट के साथ भी देख सकते हैं जैसे

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

आह, मुझे वह हिस्सा याद आ गया। धन्यवाद।

— १

1

जावास्क्रिप्ट (ईएस 6), 214 बाइट्स

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

जहां \nएक शाब्दिक न्यूलाइन चरित्र का प्रतिनिधित्व करता है। 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;
}

— नील
स्रोत

मुझे एक बग मिला: इनपुट " x\n g g\ng g g\n g g"गलत देना चाहिए, लेकिन सच है।

— DLosc

@ क्या मुझे लगता है कि यह दो स्थानों से पहले है x?

— नील

@ मुझे लगता है कि मैंने इसे अभी तय कर लिया है, हालांकि मेरी लागत 30 बाइट है ...

— नील

1

स्नेकएक्स। , 200 बाइट्स

नौकरी के लिए सही भाषा ... तरह।

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-D पैटर्न मिलान चुनौती से एक भाषा है । इस कार्य में वास्तव में अच्छा होना चाहिए, लेकिन दुर्भाग्य से सभी कोने के मामलों ने वास्तव में कोड को फूला दिया। मैंने दुभाषिए कीड़ों के एक जोड़े को भी बदल दिया। फिर भी, यह एक मजेदार चुनौती थी।

mमुख्य साँप है जो वास्तविक काम करने के लिए अन्य सभी को बुलाता है। यह षट्भुज के शीर्ष दाएं कोने पर शुरू होता है और दक्षिणावर्त जाता है। गिने हुए समूहों का उपयोग यह सत्यापित करने के लिए किया जाता है कि विकर्ण पक्ष की लंबाई सभी समान है और क्षैतिज पक्ष की लंबाई पूरे आंकड़े की ऊंचाई से मेल खाती है। मैं और अधिक विस्तृत विवरण लिख सकता था, लेकिन मैंने पिछले दो दिन कोने के मामलों से निपटने में बिताए हैं, इसलिए बस यहां अपने लिए प्रयास करें । : ^)

— DLosc
स्रोत

1

पर्ल, 127 125 124 121 बाइट्स

के लिए +4 शामिल है -0p

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

— टन हास्पेल
स्रोत

हेक्सागोल्फ: वैलीडैगन