ASCII कला को तीसरे आयाम पर लाएं

Question

इस चुनौती में, आपको ASCII कला (जो आमतौर पर 2D होती है) को 3D में लाना होगा!

कैसे?

इस तरह,

X X DD 
 X  D D
X X DD 

सेवा...

  X X DD 
 X X DD D
X X DDDD 
 X XDDD
X X DD

तो फिर कैसे हम ऐसा करते हैं कि ?

आस्की कला को देखते हुए और N, इस Nबार दोहराएं ।

• हर चरित्र के लिए (हम इसे कॉल करेंगे A):
• आज्ञा देना Bचरित्र जो बिल्कुल 1 सही है और 1 ऊपर से हैA
• यदि Bकोई स्थान है या अपरिभाषित है:
• सेट Bकरने के लिए A।

चश्मा

• पहला इनपुट न्यूलाइन वर्णों के साथ एक स्ट्रिंग हो सकता है या 2D ASCII कला का प्रतिनिधित्व करने वाले तारों की एक सूची हो सकती है।
• आपको %END%इनपुट के अंत को टैग करने के लिए उपयोग करने की अनुमति है , लेकिन इसकी आवश्यकता नहीं है।
• दूसरा इनपुट होगा N। यह एक सकारात्मक पूर्णांक होगा।
• स्ट्रिंग्स की सभी लाइनें समान लंबाई की होंगी।

उदाहरण

इनपुट: ("###\n###",1)

आउटपुट:

 ###
####
###

नियम

बुनियादी कोड-गोल्फ नियम लागू होते हैं।

भी, यदि आपके कोई प्रश्न हैं, तो टिप्पणियों में पूछना सुनिश्चित करें!

Comments

आप स्पष्ट करना चाह सकते हैं कि "रिक्त" स्थान (U + 0020) या कुछ भी नहीं है।

— लीक नून

@ लीक यह अब तय है?

क्या अतिरिक्त व्हाट्सएप की अनुमति है?

— लीक

हां, उन्हें अनुमति है।

क्या मैं मान सकता हूं कि प्रत्येक पंक्ति की लंबाई समान होगी? (क्या मैं दायीं ओर रिक्त स्थान के साथ इनपुट को प्री-पैड कर सकता हूं?)

— लीक नून

Answer 1

पर्ल, 81 बाइट्स

75 बाइट्स कोड + 6 के लिए -i -n0।
ध्यान दें कि \eअक्षर ASCII हैं, \x1bलेकिन \eपरीक्षण में आसानी के लिए उपयोग किया जाता है।

कृपया ध्यान दें कि यह समाधान एएनएसआई से बचने के क्रम का उपयोग करता है और इसके लिए संगत टर्मिनल की आवश्यकता होती है, साथ ही -iआप जिस 'आयाम' की संख्या को पास करना चाहते हैं, उसके लिए कमांडलाइन तर्क का उपयोग करना चाहिए।

$n=s/^//mg-1;s/ /\e[1C/g;print(s/^/\e[${^I}C/grm."\e[${n}A"),--$^I for($_)x$^I

उपयोग:

लिनक्स संगत टर्मिनल में, PS1=यह सुनिश्चित करने के लिए कि आपकी प्रदर्शित छवि को ओवरराइट नहीं किया गया है , पहले चलाएं ।

perl -i10 -n0e '$n=s/^//mg-1;s/ /\e[1C/g;print(s/^/\e[${^I}C/grm."\e[${n}A"),--$^I for($_)x$^I' <<< ' 
ROFL:ROFL:ROFL:ROFL
         _^___
 L    __/   [] \    
LOL===__        \ 
 L      \________]
         I   I
        --------/
'

          ROFL:ROFL:ROFL:ROFL
         ROFL:ROFL:ROFL:ROFL
        ROFL:ROFL:ROFL:ROFL
       ROFL:ROFL:ROFL:ROFL\
      ROFL:ROFL:ROFL:ROFL\_]
     ROFL:ROFL:ROFL:ROFL\_]
    ROFL:ROFL:ROFL:ROFL\_]/
   ROFL:ROFL:ROFL:ROFL\_]/
  ROFL:ROFL:ROFL:ROFL\_]/
 ROFL:ROFL:ROFL:ROFL\_]/
   LOL==___^___]_\_\_]/
  LOL==__/ \_[]_\_\_]/
 LOL===__ \______\_]/
  L      \________]/
          I---I---/
         --------/

perl -i3 -n0e '$n=s/^//mg-1;s/ /\e[1C/g;print(s/^/\e[${^I}C/grm."\e[${n}A"),--$^I for($_)x$^I' <<< 'X X DD
 X  D D
X X DD
'
   X X DD
  X X DD D
 X X DDDD
  X XDDD
 X X DD

Answer 2

सीजेएम, 25 24 बाइट्स

{{' 1$f+La@+..{sS@er}}*}

एक अनाम ब्लॉक जो स्ट्रिंग की सूची और स्टैक पर पुनरावृत्ति की संख्या की अपेक्षा करता है, इसके बजाय स्ट्रिंग्स की एक नई सूची छोड़ देता है।

इसका परीक्षण यहां करें। (सुविधा के लिए STDIN से स्ट्रिंग को पढ़ने वाला एक परीक्षण आवरण शामिल है।)

व्याख्या

{       e# Repeat this block N times...
  '     e#   Push a space character.
  1$    e#   Copy the current grid.
  f+    e#   Prepend the space to each line of the grid.
  La    e#   Push [[]].
  @+    e#   Pull up the other copy of the grid and prepend the [].
        e#   We've now got two copies of the grid, one shifted right by
        e#   a cell and one shifted down by a cell. We now want to replace
        e#   spaces in the latter with the corresponding character in the
        e#   former.
  ..{   e#   For each pair of characters in corresponding positions...
    s   e#     Turn the character in the down-shifted grid into a string.
    S   e#     Push " ".
    @   e#     Pull up the character from the right-shifted grid.
    er  e#     Replace spaces with that character.
  }
}*

Comments

दस रोफ्लॉप्टर! goo.gl/PEK4iB

Sप्रारंभिक स्थान के लिए काम क्यों नहीं करता है? इसके अलावा, क्या इसे किसी फ़ंक्शन में चर (जो अधिलेखित हो सकता है) का उपयोग करने की अनुमति है?

— लुइस मेन्डो

@LuisMendo Sकाम नहीं करता है, क्योंकि तब fइसके बजाय उस स्ट्रिंग पर मैपिंग होगी। फ़ंक्शंस, मेरा मानना ​​है कि "सामान्य" भाषाओं में, ऐसे कई फ़ंक्शन सबमिशन भी हैं जो ग्लोबल्स पर भरोसा करते हैं जो कि इनवोकेशन के बीच छेड़छाड़ नहीं करते हैं।

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

धन्यवाद। मैं भूल गया कि CJam में एक चरित्र एक चरित्र स्ट्रिंग के समान नहीं है

— लुइस मेंडू

आप Convex का उपयोग करके एक बाइट को बचा सकते हैं क्योंकि इसमें दो-चार के बजाय एक-चार ट्रांसलेटर ऑपरेटर है: convex.tryitonline.net/… (बेशर्म प्लग)

— GamrCorps

Answer 3

एपीएल, 49 बाइट्स

{⎕UCS 32⌈{s+(s=0)×1⊖¯1⌽s←0⍪⍵,0}⍣⍺⊣(32∘≠×⊣)⎕UCS↑⍵}

इनपुट: चरित्र वैक्टर के वेक्टर। उदाहरण:

      2 {⎕UCS 32⌈{s+(s=0)×1⊖¯1⌽s←0⍪⍵,0}⍣⍺⊣(32∘≠×⊣)⎕UCS↑⍵} 'X X DD' ' X  D D' 'X X DD'
  X X DD 
 X X DD D
X X DDDD 
 X XDDD  
X X DD   

यह काम किस प्रकार करता है:

• ↑⍵ तर्क को वर्णों के मैट्रिक्स में बदल देता है
• ⎕UCS चार से पूर्णांक तक
• (32∘≠×⊣) शून्य के साथ रिक्त स्थान (32) स्थानापन्न करें
• ...⍣⍺⊣ लागू apply (बाएं तर्क) बाईं ओर कार्य करते समय
• s←0⍪⍵,0 शीर्ष पर और सही तर्क पर शून्य के साथ सीमा
• 1⊖¯1⌽ 1 ऊपर और 1 दाईं ओर घुमाएं
• s+(s=0)× मूल स्थानांतरित संस्करण के लिए लेकिन केवल मूल के शून्य के शीर्ष पर
• 32⌈ 32 में शून्य वापस लाता है
• ⎕UCS पूर्णांक से चार तक

Answer 4

MATL , 24 बाइट्स

:"ct32>*TTYatFTEqYSy~*+c

इनपुट प्रारूप है

2
{'X X DD', ' X  D D', 'X X DD'}

तो दूसरा उदाहरण है

1
{'###', '###'}

आउटपुट में अतिरिक्त व्हाट्सएप है, जिसे चुनौती द्वारा अनुमति दी गई है।

इसे ऑनलाइन आज़माएं!

---

यदि इनपुट के रूप में एक 2 डी चार सरणी स्वीकार्य है (मैंने ओपी को दो बार पूछा है ...), पहले cहटाया जा सकता है, इसलिए 23 बाइट्स :

:"t32>*TTYatFTEqYSy~*+c

इस मामले में इनपुट प्रारूप है (सभी तारों की लंबाई समान है, जिसमें रिक्त स्थान के साथ राइट-पेडिंग की आवश्यकता हो सकती है):

2
['X X DD '; ' X  D D'; 'X X DD ']

इसे ऑनलाइन आज़माएं!

---

व्याख्या

:        % Input number n implicitly. Generate [1 2 ... n]
"        % For loop: repeat n times
  c      %   Convert to char array. In the first iteration it inputs a cell array of
         %   strings implicitly and converts to a 2D char array, right-padding with
         %   spaces. In the next iterations it does nothing, as the top of the stack
         %   is already a 2D char array
  t32>*  %   Convert characters below 32 into 0
  TT     %   Push array [1 1]
  Ya     %   Pad the 2D char array with one zero in the two directions (up/down,
         %   left/right), on both sides
  t      %   Duplicate
  FTEq   %   Push array [-1 1]
  YS     %   Circularly shift the 2D char array one unit up and one unit right
  y      %   Push a copy of the non-shifted 2D array
  ~      %   Logical negate: nonzero entries become 0, zero entries become 1. This
         %   will be used as a mask for entries that need to be changed. Since the
         %   values at those entries are zero, we can simply add the new values. We do
         %   that by multiplying the mask by the shifted array and adding to the
         %   non-shifted array
  *      %   Multiply element-wise
  +      %   Add element-wise
  c      %   Convert the 2D array back to char
         % End for
         % Implicitly display

Answer 5

उत्तल , 23 बाइट्स

बाइट गिनती CP-1252 एन्कोडिंग मानती है।

{{' 1$f+La@+..{sS@Ë}}*}

एक अनाम ब्लॉक जो स्ट्रिंग की सूची और स्टैक पर पुनरावृत्ति की संख्या की अपेक्षा करता है, इसके बजाय स्ट्रिंग्स की एक नई सूची छोड़ देता है।

इसे ऑनलाइन आज़माएं!

यह कॉनवेक्स (जो कि सीजेएम पर आधारित है) पर मेरे सीजेएम उत्तर का एक सीधा पोर्ट है । अंतर केवल इतना है कि उत्तल Ëके erलिए उत्तल का उपयोग करता है , एक बाइट की बचत करता है। इसके बारे में मुझे बताने के लिए GamrCorps का धन्यवाद।

Answer 6

पायथ, 54 33 बाइट्स

ju+++dhG.bsmh|-d;;.t,Y+dNdtGGeG.*

परीक्षण सूट।

Comments

आपको दो की आवश्यकता क्यों है ;?

— वेन

@ यूएन प्रोग्रामिंग भाषाओं में ;सामान्य नहीं है ;।

— लीक नन

;एक चर है।

— लीक नन

;lambdas में आह पाइथ ओवरलोड्स ...

— वेन

@ven जब आप Pyth के साथ मिलता है, तो आप का प्रयोग करेंगे I, .?, V, F, ;, (स्पष्ट बयान) बहुत कम है, और वे द्वारा प्रतिस्थापित किया जाएगा ?, m, u, F, M, L, R, #, ...

— लीकी नून

Answer 7

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

f=(a,n)=>n?f((a=[``,...a].map(s=>[...s||` `])).map((b,i)=>i--&&b.map((c,j)=>a[i][++j]>' '?0:a[i][j]=c))&&a.map(b=>b.join``),n-1):a

स्वीकार करता है और स्ट्रिंग्स की एक सरणी देता है, आउटपुट के लिए एक अतिरिक्त पंक्ति तैयार करता है, यह सुनिश्चित करता है कि प्रत्येक पंक्ति में कम से कम एक स्थान हो, उन सभी को वर्णों में विभाजित करता है, हालांकि छोरों को पंक्ति के ऊपर वर्णों की प्रतिलिपि बनाने और दाईं ओर स्तंभ करने की कोशिश कर रहा है, फिर लूप को पूरा करने के लिए खुद को पुनरावर्ती कहता है।

Answer 8

पायथन 2, 116 बाइट्स

S=' '
def f(a,d):e=[S*len(`a`)];exec"a=[''.join(t[t[1]>S]for t in zip(S+x,y+S))for x,y in zip(a+e,e+a)];"*d;return a

मैं इसे जल्द ही गोल्फ करूंगा।

Comments

क्या आप सुनिश्चित हैं कि lambdaवह छोटा नहीं है?

— wizzwizz4

मुझे eवहां असाइनमेंट की जरूरत है । इसके अलावा, execएक बयान है, इसलिए यह एक मेमने में नहीं हो सकता।

— लिन

ठीक है। केवल निश्चित कर रहा था।

— wizzwizz4

Answer 9

रूबी, 95 बाइट्स

->a,n{n.downto(0){|i|f="<Esc>[1C"
$><<a.gsub(/^/,f*i).gsub(" ",f)+(i>0?"<Esc>[#{a.lines.size-1}A":"")}}

प्रत्येक <Esc>एक शाब्दिक ESC चरित्र ( 0x1b) है।

प्रयोग

लैम्बडा को एक वेरिएबल की तरह असाइन करें func।

art = <<END
X X DD
 X  D D
X X DD
END

func[art, 2]
# Prints:
#   X X DD
#  X X DD D
# X X DDDD
#  X XDDD
# X X DD

Ungolfed

->(art, num) {
  num.downto(0) do |i|
    forward = "\e[1C"
    $> << art.gsub(/^/, forward * i).gsub(" ", forward) +
            (i > 0 ? "\e[#{art.lines.size - 1}A" : "")
  end
}

forwardएस्केप अनुक्रम, \e[1C, कर्सर आगे (दाएं) 1 अंतरिक्ष और ले जाता है \e[<n>Aयह चाल ऊपर nलाइनों। मूल रूप से यह कोड क्या करता है, "लेयर्स" को आगे की ओर प्रिंट करें, स्पेस के साथ forwardअन्य लेयर्स को ओवरराइट करने से बचने के लिए सीक्वेंस के साथ स्पेस की जगह लें।

Comments

आपने गलती से गोल्फ संस्करण में f=पहले डाल दिया ->था। इसे -2 बाइट के लिए निकालें।

— 8 अक्टूबर को wizzwizz4