एक डायमंड टाइलिंग को स्केल करें

27

किसी भी नियमित षट्भुज को हीरे के साथ टाइल किया जा सकता है, उदाहरण के लिए:

   ______
  /_/_/\_\
 /_/\_\/\_\
/\_\/_/\/_/\
\/_/\_\/_/\/
 \_\/_/\_\/
  \_\_\/_/

हम ऊपर आकार के एक टाइलिंग पर विचार करेंगे 1(चूंकि हीरे की भुजाएं एक /या \एक से बनी होती हैं)। आकार का एक ही टाइलिंग 2जैसा दिखेगा:

      ____________ 
     /   /   /\   \  
    /___/___/  \___\ 
   /   /\   \  /\   \  
  /___/  \___\/  \___\ 
 /\   \  /   /\  /   /\  
/  \___\/___/  \/___/  \ 
\  /   /\   \  /   /\  /
 \/___/  \___\/___/  \/ 
  \   \  /   /\   \  /
   \___\/___/  \___\/ 
    \   \   \  /   /
     \___\___\/___/

आपका कार्य 1इनपुट के रूप में एक ASCII आर्ट टाइलिंग (आकार का ) प्राप्त करना है , साथ ही साथ एक सकारात्मक पूर्णांक N(दशमलव या यूनेरी में), वांछित आउटपुट के आकार को निर्दिष्ट करना है। फिर आपको उसी टाइलिंग के स्केल-अप संस्करण का उत्पादन करना चाहिए।

ध्यान दें कि हेक्सागोन किसी भी आकार और 1x1x1 (तीन हीरे युक्त) जितना छोटा हो सकता है।

हेक्सागोन आकार को संरेखित करने के लिए न तो इनपुट और न ही आउटपुट में कोई अनुगामी स्थान होना चाहिए, न ही अधिक अग्रणी स्थान। इनपुट और आउटपुट दोनों में वैकल्पिक रूप से एक एकल अनुगामी न्यूलाइन हो सकती है (यह पसंद इनपुट और आउटपुट के लिए समान नहीं होती है)।

आप STDIN (या निकटतम विकल्प), कमांड-लाइन तर्क या फ़ंक्शन तर्क के माध्यम से इनपुट ले रहे हैं और STDOUT (या निकटतम विकल्प), फ़ंक्शन रिटर्न मान या फ़ंक्शन (आउट) पैरामीटर के माध्यम से परिणाम लिख सकते हैं।

यह कोड गोल्फ है, इसलिए जीत में सबसे छोटा जवाब (बाइट्स में) है।

उदाहरण तिलिंग्स

यहाँ कुछ इनपुट झुकाव हैं जिन्हें आप अपने सबमिशन का परीक्षण करने के लिए उपयोग कर सकते हैं।

 __
/_/\
\_\/

  ____
 /_/\_\
/\_\/_/\
\/_/\_\/
 \_\/_/

   ______
  /_/_/\_\
 /_/\_\/\_\
/\_\/_/\/_/\
\/_/\_\/_/\/
 \_\/_/\_\/
  \_\_\/_/

    ________
   /_/\_\_\_\
  /\_\/\_\_\_\
 /\/_/\/_/_/\_\
/\/\_\/_/_/\/\_\ 
\/\/_/\_\_\/\/_/
 \/\_\/_/\_\/_/
  \/\_\_\/_/_/
   \/_/_/_/_/

निम्नलिखित स्निपेट आदानों के लिए इसी आउटपुट शामिल हैं N = 1के माध्यम से N = 6।

कोड स्निपेट दिखाएं

code-golf  ascii-art  tiling 
— मार्टिन एंडर
स्रोत
20
मुझे लगता है कि आप अब हीरे में रुचि रखते हैं कि आपको अपने उपयोगकर्ता नाम के आगे एक मिल गया है।
— user12205
3
@ace: आप जानते हैं कि वे क्या कहते हैं: हीरे एक मॉडरेटर के सबसे अच्छे दोस्त हैं।
— एलेक्स ए
मुझे लगता है कि मुझे उत्तर पता है, लेकिन मुझे आशा है कि मैं गलत हूं: खाली लाइनों को अग्रणी स्थान के रूप में गिना जाएगा, जिसे आपने अवैध घोषित किया था? मेरे प्रारंभिक समाधान में N-1खाली लाइनें हैं। :(
— रेटो कोराडी
@RetoKoradi वास्तव में, कोई नई कहानी नहीं। माफ़ कीजिये।
— मार्टिन एंडर
1
मुझे लगा। मेरे बारे में 10 बाइट्स। जब मैं पहली बार समस्या को पहचानता था तो उतना बुरा नहीं था।
— रेटो कोराडी

जवाबों:

8

CJam, 85 79 76 72 बाइट्स

li:Tlf*NqN/T,f{ff{"_/"2$#_1<@+*~ST*@t}:+z{S+e`);e~{"_ "/"__"*W%}T2**N}/}

आकार पहली पंक्ति पर होना चाहिए। और हीरा पीछा करता है।

बहुत अच्छी तरह से गोल्फ नहीं हुआ ... और आधे अक्षर विवरण से आए।

स्पष्टीकरण (पिछले संस्करण का)

li:T            e# Read the size and save to T.
qN/             e# Read and split to lines.
\,fm*           e# Convert each character X to [X 0] [X 1]... [X T(]
{~              e# For each [X I] in each line:
    ST*         e# T spaces.
    \           e# I.
    "_\\"3$#    e# If X is '_, '\ or '/, return Y = 0, 1, -1 respectively.
    _W>@+       e# If it was '_ or '\, increase I by one.
    *(          e# I * Y - 1.
    @t          e# Set the character at that position to X.
}f%
:z:+            e# Make the returned lists from each iteration across T lines.
{S+e`);e~N+}%   e# Boring details to remove trailing spaces and append a newline.
T(>(\s          e# Boring details to extract the first line and only work on others.
{_{"_ "/"__"*W%}2*_@=!}g
                e# Boring details to make underlines expand left and right.
— jimmy23013
स्रोत
10

अजगर 2, 164

def g(s,n,j=1):
 for W in s.split("\n"):exec"O=p='';d=0\nfor c in W:q=' _'[j*'_'in p+c];e=[n-j,j-1][c=='/'];O+=q*(e+d)+[c,q][c>'^'];p=c;d=n+~e\nprint O;j-=1;"*j;j=n

परीक्षण मामलों पर आउटपुट।

तो, यहाँ क्या हो रहा है?

मुख्य विचार यह है कि मूल में प्रत्येक वर्ण n*nब्लॉक में आता है। उदाहरण के लिए, n = 4 के लिए, /बन सकता है

   /
  /
 /
/___

मूल चरित्र प्रत्येक पंक्ति में एक बार दिखाई देता है, और दोनों ओर पैडिंग होती है। यहाँ, यह बाईं तरफ, और और _सही पर। केवल नीचे की पंक्ति को गद्देदार किया जा सकता है '_'; बाकी हमेशा है ' '।

मुख्य कठिनाई यह है कि दाईं ओर पैडिंग आगामी प्रतीक पर निर्भर कर सकती है। विशेष रूप से, '/ 'से अलग-अलग पैडिंग है '/_', इसलिए हमें कुछ लुक-फॉरवर्ड की आवश्यकता होगी। इसके अलावा, रिक्त स्थान से बचने के लिए, हमें ध्यान देना होगा कि हम अंतिम प्रतीक पर हैं और दाईं ओर गद्दी लगाने से बचते हैं।

हम वर्तमान चरित्र के बाईं ओर केवल पैडिंग करके इन दोनों मुद्दों को दूर करते हैं। जब हम ऐसा करते हैं, तो हम वर्तमान पैडिंग सिंबल का उपयोग करके पिछले चरित्र से राइट-पेडिंग भी करते हैं। इसलिए, हम पिछले चार्ट से राइट-पेडिंग, वर्तमान चार्ट से ले-पेडिंग प्रिंट करते हैं, फिर वर्तमान चार्ट। हम "कर्ज" की राशि भी जमा करते हैं, अगले चार्ट के लिए भुगतान करना होगा।

अब कोड पर चलते हैं।

def g(s,n,j=1):
    for W in s.split("\n"):
        while j:
            O=p='';d=0
            for c in W:
                q=' _'[j*'_'in p+c]
                e=[n-j,j-1][c=='/']
                O+=q*(e+d)+[c,q][c>'^']
                p=c
                d=n+~e
            print O;j-=1;
        j=n

इनपुट स्ट्रिंग है sऔर स्केल-फैक्टर है n। हम nप्रत्येक इनपुट लाइन के लिए लाइन-बाय-लाइन, प्रिंटिंग लाइनों को Wअनुक्रमित प्रतियों के साथ जाते हैं j=n,n-1,...,2,1। पहली पंक्ति को केवल एक बार कॉपी किया जाता है, जिसे हम j1 को इनिशियलाइज़ करके प्राप्त करते हैं लेकिन इसे nप्रत्येक लूप में बदलते हैं ।

हम इनपुट लाइन के माध्यम से पुनरावृत्ति करते हैं, प्रिंट करने के लिए लाइन को जमा करते हैं O। सबसे पहले, हम उपयुक्त पैडिंग कैरेक्टर का पता लगाते हैं q, जो कि एक अंडरस्कोर है यदि हम बॉटम लाइन पर हैं और या तो वर्तमान या पिछला कैरेक्टर एक अंडरस्कोर है, और अन्यथा एक स्पेस है।

फिर, हम बाईं ओर ( e) रखने के लिए पैडिंग की मात्रा तय करते हैं । इसके लिए /, यह j-1(लाइन-कॉपी संख्या घटने के साथ घट रही है), और इसके लिए पूरक n-jहै \। हम अन्य पात्रों के साथ भी वैसा ही व्यवहार करते हैं। उदाहरण के लिए, हालांकि _ऐसा लगता है कि यह nअंडरस्कोर की एक पंक्ति देता है , यह वास्तव में एक एकल अंडरस्कोर देता है, बाएं और दाएं पर अंडरस्कोर द्वारा गद्देदार। यह अक्षम लगता है, लेकिन यह हमारे साथ काम करता है की सुविधा देता है _और में के रूप में ही ढांचे /और \, बात नहीं है "केंद्रीय" अंडरस्कोर की स्थिति इसलिए हम इसे और गांठ के साथ \; यह विकल्प विशेष आवरण के बिना शीर्ष पंक्ति को भी काम करता है।

अगला, हम आउटपुट स्ट्रिंग में जोड़ते हैं। हमने पैडिंग सिंबल q, और वर्तमान पैडिंग राशि का पता लगा लिया है e, लेकिन हमें dपिछले सिंबल से पैडिंग ऋण को याद रखना होगा । तो, हम जोड़ते हैं q*(e+d)। फिर, हम वर्तमान प्रतीक को जोड़ते हैं c, सिवाय इसके कि हमें एक गैर-नीचे पंक्ति में अंडरस्कोर से बचने की आवश्यकता है, जिसे हम अंडरस्कोर को पैडिंग प्रतीक में परिवर्तित करके ठीक करते हैं।

अंत में, हम पैडिंग ऋण राशि को रिकॉर्ड करते हैं, जो n+~dवर्तमान लेफ्ट-पेडिंग राशि का पूरक है। हम वर्तमान प्रतीक को भी रिकॉर्ड करते हैं p, ताकि हम बाद में जान सकें कि क्या पिछला प्रतीक था _।

— XNOR
स्रोत
3

जावास्क्रिप्ट ( ईएस 6 ) 274 281 289 338

// GOLFED
F=(b,n)=>{
b=b[R='replace'](/ |_/g,c=>c[T='repeat'](n))[R](/_(?=[\\\/])/g,'_'[T](n))[R](/\/\\/g,`/${'  '[T](n-1)}\\`)
.split('\n');
for(i=l=b.length*n-n+1;--i;)
b[i]=i%n?b[i+1][R](/_/g,' ')[R](/\/ ?/g,' /')[R](/ \\(.)?/g,'\\$1$1')
:' '[T](i>l/2?n-1:0)+b[i/n];
return b.join('\n')}


// UNGOLFED
U=(b,n)=>{
  b=b
  .replace(/ |_/g,c=>c.repeat(n))
  .replace(/_(?=[\/\\])/g,'_'.repeat(n))
  .replace(/\/\\/g,`/${'  '.repeat(n-1)}\\`)
  .split('\n');
  for(i=l=b.length*n-n+1;--i;)
  {
    if(i%n)
     b[i]=b[i+1]
     .replace(/_/g,' ')
     .replace(/\/ ?/g,' /')
     .replace(/ \\/g,'\\ ').replace(/ +$/,'')
     .replace(/ \\(.)?/g,'\\$1$1')
    else {
      b[i]=b[i/n]
      if(i>l/2)b[i]=' '.repeat(n-1)+b[i];
    }
  }
  return b.join('\n')
}

//TEST

test=[
' __\n/_/\\\n\\_\\/',
'  ____\n /_/\\_\\\n/\\_\\/_/\\\n\\/_/\\_\\/\n \\_\\/_/',
'   ______\n  /_/_/\\_\\\n /_/\\_\\/\\_\\\n/\\_\\/_/\\/_/\\\n\\/_/\\_\\/_/\\/\n \\_\\/_/\\_\\/\n  \\_\\_\\/_/',
'    ________\n   /_/\\_\\_\\_\\\n  /\\_\\/\\_\\_\\_\\\n /\\/_/\\/_/_/\\_\\\n/\\/\\_\\/_/_/\\/\\_\\\n\\/\\/_/\\_\\_\\/\\/_/\n \\/\\_\\/_/\\_\\/_/\n  \\/\\_\\_\\/_/_/\n   \\/_/_/_/_/'
]

test.forEach(t=>{
  var row = '<td>'+t+'<td>'
  for(rr=2;rr<5;rr++)
    row += '<td>'+F(t,rr)+'</td>'
  OUT.innerHTML += '<tr>'+row+'</tr>'
})
td {
  font-family: monospace;
  white-space: pre;
}
(better full page)
<table id=OUT></table>
स्निपेट का विस्तार करें

— edc65
स्रोत
3

अजगर 2, 217 211 195 194 190

b,f,s='\/ '
R=str.replace
def m(g,n,z=1):
 for d in g.split('\n'):
    for i in range(z):a=z+~i;print[i,a][d[-1]>f]*s+R(R(R(R(d,s,s*n),'_','_ '[i<z-1]*(z+n-1)),f+b,f+s*2*i+b),b+f,b+s*2*a+f);z=n

Sp3000 के लिए 6 बाइट्स धन्यवाद।

mपहले तर्क को एक स्ट्रिंग के रूप में हीरा होने के साथ कॉल करें , और दूसरा तर्क पुनरावृत्ति संख्या है।

यह एक 3-चरण स्ट्रिंग प्रतिस्थापन अनुक्रम पर आधारित है:

  • सबसे पहले, लाइन के आधार पर, 2n-1 रिक्त स्थान या अंडरस्कोर के साथ अंडरस्कोर को बदलें।
  • दूसरा, की जगह /\के साथ / \हस्तक्षेप स्थानों की संख्या लाइनों पर 2 2 * (n-1) के लिए से जाने के साथ,।
  • तीसरा, लाइनों के साथ 2 * (n-1) से 2 पर जाने वाले हस्तक्षेप स्थानों की संख्या के साथ प्रतिस्थापित \/करें \ /।

फिर, प्रमुख रिक्त स्थान को सही तरीके से प्राप्त करने के लिए, और पहली पंक्ति को सही प्राप्त करने के लिए विभिन्न प्रकार की मैकिंग है।

ध्यान दें कि कार्यक्रम की अंतिम पंक्ति एक टैब होनी चाहिए, न कि 4 रिक्त स्थान। मार्कडाउन टैब का समर्थन नहीं करता है।

— isaacg
स्रोत
दो गोल्फ: (i+(n-i+~i)*(d[-1]>f)) --> [i,n+~i][d[-1]>f]और आप केवल '_'एक बार उपयोग करते हैं , इसलिए आप एक बाइट को परिभाषित करते हैं।
— Sp3000
3

पायथन, 272 238 228 243 बाइट्स

अद्यतित संस्करण, एक स्ट्रिंग अनुक्रम के बजाय इनपुट के रूप में एकल स्ट्रिंग लेता है। इसके अलावा पहले वाले संस्करण में मौजूद व्हाट्सएप को भी हटा दिया गया था। दुर्भाग्य से ये परिवर्तन आकार में वृद्धि करते हैं।

s,u,f,b=' _/\\'
r=str.replace
def d(t,n,j=1):
 for p in t.split('\n'):
  for k in range(n-j,n):m,v=n+~k,'_ '[k<n-1];print r(r(r(r(r(r(r(r(p,f+u,'(_'),u+b,'_)'),s,s*n),u,v*n),f,s*m+f+s*k),'(',v*m+f+v*k),b,s*k+b+s*m),')',v*k+b+v*m).rstrip();j=n

व्हाट्सएप के साथ संस्करण, और पठनीयता के लिए छोटी इकाइयों में टूटे हुए बयान:

s, u, f, b = ' ', '_', '/', '\\'
def d(t, n):
    j = n - 1
    for p in t:
        for k in range(j, n):
            m, v = n - 1 - k, '_ '[k < n - 1]
            q = p[:-1]
            q = q.replace(f + u, '(_')
            q = q.replace(u + b, '_)')
            q = q.replace(s, s * n)
            q = q.replace(u, v * n)
            q = q.replace(f, s * m + f + s * k)
            q = q.replace('(', v * m + f + v * k)
            q = q.replace(b, s * k + b + s * m)
            q = q.replace(')', v * k + b + v * m)
            print q
            j = 0

यहाँ मूल दृष्टिकोण है:

  1. इनपुट में सभी लाइनों पर लूप।
  2. प्रत्येक पंक्ति के लिए, आउटपुट आकार पर लूप N, प्रत्येक लूप पुनरावृत्ति में आउटपुट लाइन बनाते हैं। पहली पंक्ति के लिए एक विशेष मामला है, जहां केवल अंतिम आउटपुट लाइन उत्पन्न होती है, आउटपुट की शुरुआत में खाली लाइनों को उत्पन्न करने से बचने के लिए।
  3. प्रत्येक वर्ण को वर्णों द्वारा पंक्ति में बदलें N, जहाँ:
    • प्रत्येक स्थान को Nरिक्त स्थान द्वारा प्रतिस्थापित किया जाता है।
    • प्रत्येक अंडरस्कोर को Nपहले N -1लूप पुनरावृत्तियों के लिए रिक्त स्थान द्वारा प्रतिस्थापित किया जाता है , और Nअंतिम लूप पुनरावृत्ति के लिए अंडरस्कोर।
    • स्लैश और बैकस्लैश N - 1रिक्त स्थान या अंडरस्कोर के साथ गद्देदार होते हैं ।

यहां सबसे मुश्किल हिस्सा यह है कि स्लैश / बैकस्लैश के लिए पैडिंग, अगले (स्लैश के लिए) या पिछले (बैकस्लैश के लिए) इनपुट चरित्र के आधार पर रिक्त स्थान या अंडरस्कोर का उपयोग करता है। यह स्ट्रिंग प्रतिस्थापन रणनीति के साथ अच्छी तरह से फिट नहीं लगता था।

मैंने इसे हल करने के लिए यह किया है कि मैं पहले कुछ दो चरित्र संयोजनों को अलग-अलग पात्रों के साथ बदल देता हूं, ताकि वास्तविक प्रतिस्थापन के दौरान मैं उनसे अलग तरह से व्यवहार कर सकूं। उदाहरण के लिए, /_द्वारा प्रतिस्थापित किया जाता है (_। इसके बाद, (प्रभावी रूप से "अंडरस्कोर के बाद स्लैश" है, जिसे तब तदनुसार प्रतिस्थापित किया जा सकता है।

फ़ंक्शन के परीक्षण के लिए उपयोग किया जाने वाला मुख्य कार्यक्रम:

import sys
import Golf

n = int(sys.argv[1])
t = ''.join(sys.stdin).rstrip()

Golf.d(t, n)
— रेटो कोराडी
स्रोत
1
n-1-kहैn+~k
— पुनरावर्ती
पूर्ण प्रकटीकरण के हित में: मैंने अभी पाया कि मेरा समाधान कुछ अनुगामी रिक्त स्थान पैदा करता है। चूंकि आउटपुट परिभाषा में इसकी अनुमति नहीं है, इसलिए यह आवश्यकताओं को पूरा नहीं करता है। सबसे खराब स्थिति में, मुझे .rstrip()9 और पात्रों के लिए जोड़ना होगा । मुझे उम्मीद है कि मैं बेहतर कर सकता हूं, और 5 पात्रों को काटने का एक तरीका भी पाया।
— रेटो कोराडी
ऐसा लगता है कि आपके इनपुट प्रारूप की अनुमति नहीं है। sys.stdinएक स्वीकार्य इनपुट पैरामीटर नहीं है - आपको स्ट्रिंग को हेरफेर करने की आवश्यकता है।
— isaacg
वैसे आप उपयोग कर सकते हैं sys.stdinऔर int(sys.argv[1])आप उन्हें मुफ्त में प्राप्त करने की उम्मीद नहीं कर सकते हैं क्योंकि उन्हें चर के रूप में पारित किया जा सकता है (यदि यह उचित खेल था, तो आप उपनामों को rangeबदलने और बदलने की अपेक्षा भी कर सकते हैं `और जो कुछ भी आपको पूर्वनिर्धारित करने की आवश्यकता है) ।
— मार्टिन एंडर
@ मार्टिनबटनर यह कहता है कि मैं इनपुट को एक फ़ंक्शन तर्क के रूप में ले सकता हूं। क्या यह नहीं है कि मैं यहाँ क्या कर रहा हूँ? मैं फ़ंक्शन तर्क को किसी भी तरह स्ट्रिंग की सूची में बदलने जा रहा था। क्या वह ठीक होगा? यह बहुत अलग नहीं है, क्योंकि दोनों stdinऔर तार की एक सूची स्ट्रिंग अनुक्रम हैं।
— रेटो कोराडी
1

पर्ल, 132

#!perl -p
INIT{$f=pop}s!.!$&x$f!ge;s! $!! while s!\\+\K\\|/(/)! $1!;
for$x(2..m!/!*$f){print y!_! !r;s!\\.?! \\!g;s!./(.)?!/$1$1!g;s!_ !__!g}

संयुक्त STDIN और ARGV इनपुट। उदाहरण:

$ perl ~/hex.pl <~/hex.txt 3
         __________________
        /     /     /\     \
       /     /     /  \     \
      /_____/_____/    \_____\
     /     /\     \    /\     \
    /     /  \     \  /  \     \
   /_____/    \_____\/    \_____\
  /\     \    /     /\    /     /\
 /  \     \  /     /  \  /     /  \
/    \_____\/_____/    \/_____/    \
\    /     /\     \    /     /\    /
 \  /     /  \     \  /     /  \  /
  \/_____/    \_____\/_____/    \/
   \     \    /     /\     \    /
    \     \  /     /  \     \  /
     \_____\/_____/    \_____\/
      \     \     \    /     /
       \     \     \  /     /
        \_____\_____\/_____/
— nutki
स्रोत
1

रूबी 236 237

->i,z{i.split(?\n).map{|l|z.times.map{|y|l.size.times.map{|i|z.times.map{|x|c=l[i]
z<y+2&&(l[i-1..i]=='_\\'||l[i..i+1]=='/_')&&o=?_
(c<?!||(x==y&&c==?\\)||(z==y+1&&c>?^)||(x+y+1==z&&c==?/))&&o=c
o||' '}.join}.join.rstrip}-['']}.join ?\n}

ऑनलाइन टेस्ट: http://ideone.com/e6XakQ

यह गोल्फिंग से पहले का कोड है:

-> diamond, zoom {
  diamond.split(?\n).map do |l|
    zoom.times.map do |y|
      l.size.times.map do |i|
        zoom.times.map do |x|
          out_char = crt_char = l[i]

          out_char = ' '

          # _ has to be continued under / or \
          if zoom == y+1 && l[i-1..i]=='_\\'
            out_char = ?_
          end
          if zoom == y+1 && l[i..i+1]=='/_'
            out_char = ?_
          end

          # logic to "zoom" \, / and _ characters 
          out_char = crt_char if crt_char == ' '
          out_char = crt_char if x==y && crt_char == ?\\  
          out_char = crt_char if zoom==y+1 && crt_char == ?_
          out_char = crt_char if x+y+1==zoom && crt_char == ?/

          out_char
        end.join
      end.join.rstrip
    end - ['']
  end.join ?\n
}
— क्रिस्टियन लुपस्कू
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.