एफिल टॉवर्स: "ए" से एक बड़ा "ए" बनाएं

20

एक फ़ंक्शन बनाएं जो कई लाइनों को दिया गया है n, एक बनाता है bigA।

  • क्षैतिज पट्टी bigAमध्य पंक्ति या दो के निचले भाग में होनी चाहिए, यदि nवह समान हो तो भी
  • आउटपुट के लिए एक मोनोस्पेस फ़ॉन्ट मान लें

आउटपुट लाइनों को तोड़ने के लिए स्पष्ट लाइनब्रेक के साथ एक स्ट्रिंग (या समान, उदाहरण के लिए वर्ण सरणी) होना चाहिए, और बाएं-गद्दी के लिए सही व्हाट्सएप के साथ (आप 4 रिक्त स्थान होने के लिए \ t मान सकते हैं)। दाईं ओर कोई भी व्हाट्सएप हो सकता है।

उदाहरण

एन = 1

A

n = 2

 A
AAA

n = 3

  A
 AAA
A   A

n = 4

   A
  A A
 AAAAA
A     A

n = 5

    A
   A A
  AAAAA
 A     A
A       A

यह छोटे "एच" के "एच" से प्रेरित है

code-golf  ascii-art 
— बड
स्रोत
क्या मैं दाईं ओर व्हॉट्सएप जोड़ सकता हूं? इसके अलावा, अनुगामी न्यूलाइन की अनुमति है?
— बब्बलर
@ बब्बलर, दाईं ओर का कोई भी व्हाट्सएप ठीक है, हालांकि कोई नई रेखा नहीं है
— बुड
क्या हमें स्ट्रिंग्स के बजाय 2 डी चरित्र सरणियों को वापस करने की अनुमति है? (संकेत: यह आमतौर पर किसी भी प्रकार के आउटपुट की अनुमति देने की सिफारिश की जाती है)
— ओलिवियर ग्रैगोइरे
1
@ ओलिवियरग्रॉइयर श्योर, जब तक लाइनों के लिए एक स्पष्ट विराम है (उदाहरण के लिए "\ n" तत्व, नेस्टेड एरेज़)
— बुड
1
@ टोनहॉस्पेल, नहीं, जो वास्तव में इस के अंतर को पराजित करता है
— बुड

जवाबों:

12

05AB1E , 13 बाइट्स

कोड:

Ð;î¹)'A1376SΛ

05AB1E एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

Ð                  # Triplicate the input.
 ;î                # Compute ceiling(n / 2).
   ¹               # Push the first input again.
    )              # Wrap into an array. For input 7, this would result in:
                     [7, 7, 4, 7].
     'A            # Push the character 'A'
       1376S       # Push the array [1, 3, 7, 6]. These are the directions of the canvas.
                     This essentially translates to [↗, ↘, ↖, ←].
            Λ      # Write to canvas using the previous three parameters.

कैनवास

मुझे शायद कैनवास को थोड़ा और अधिक (और अन्य कार्यों के लिए) दस्तावेज़ करना चाहिए, लेकिन यह मूल रूप से इसे तैयार करता है। दिए गए प्रकारों के आधार पर कैनवास में अलग-अलग 'मोड' होते हैं। कैनवास कमांड के तीन पैरामीटर हैं: <लंबाई> <string> <दिशा> ।

चूंकि लंबाई और दिशा पैरामीटर सूचियां हैं, इसलिए यह निष्पादित किए जाने वाले निर्देशों का एक सेट बनाने के लिए इन सूचियों को 'ज़िप' करता है। स्ट्रिंग पैरामीटर सिर्फ अक्षर A है , इसलिए यह सभी निर्देशों द्वारा उपयोग किया जाने वाला भरण वर्ण है। निर्देश के निम्नलिखित सेट के रूप में कैनवास इसकी व्याख्या करता है (इनपुट 7 के लिए):

  • लम्बाई की एक लाइन खींचें 7 तार के साथ एक दिशा में ↗
  • लम्बाई की एक लाइन खींचें 7 तार के साथ एक दिशा में ↘
  • लम्बाई की एक लाइन खींचें 4 तार के साथ एक दिशा में ↖
  • लम्बाई की एक लाइन खींचें 7 तार के साथ एक दिशा में ←

निर्देशों का निम्नलिखित तरीके से अनुवाद किया गया है:

7   0   1
  ↖ ↑ ↗
6 ← X → 2
  ↙ ↓ ↘
5   4   3

यदि कुछ भी आउटपुट नहीं किया गया है, तो 05AB1E कैनवास परिणाम को स्वचालित रूप से आउटपुट करता है।

— अदनान
स्रोत
1
कैनवास स्पष्टीकरण के लिए बहुत बहुत धन्यवाद, यह एक शानदार विशेषता है :-)
— कलाडो
टीआईएल
— ट्रिपलेट
@ thecoder16 चौगुनी, पंचक, ..., अवनति
— मैजिक ऑक्टोपस Urn
वाह। मुझे गैर-संदिग्ध होने का संदेह था, लेकिन यह मौजूद है जैसा कि बाकी सभी करते हैं। बेशक हमारे पास अंग्रेजी में ऐसे बेकार शब्द हैं xD
— Quintec
1
@KevinCruijssen अरे, सभी देर से जवाब के लिए माफी, यह मेरे लिए अविश्वसनीय रूप से व्यस्त है पिछले कुछ हफ़्ते (मैं केवल 72 घंटे की 8 घंटे की नींद पाने में कामयाब रहा) तो मुझे नहीं लगता कि मैं ऐसा करने में सक्षम हूं अभी कुछ भी हो, लेकिन अगर आप चाहें तो इसे टिप पेज पर जोड़ने के लिए स्वतंत्र महसूस करें।
— अदनान
6

चारकोल , 17 15 बाइट्स

ＮθＰ×θAＭ⊘θ↗Ｐ^×θA

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

Ｎθ

इनपुट n।

Ｐ×θA

बड़े की क्षैतिज पट्टी प्रिंट करें A। (सम संख्याओं के लिए, n+1वें दाईं ओर को ओवरलैप करता है।)

Ｍ⊘θ↗

बड़े के शीर्ष पर ले जाएँ A।

Ｐ^×θA

बड़े के दोनों तरफ प्रिंट करें A।

— नील
स्रोत
4

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

lambda n:'\n'.join(' '*(n+~i)+('A'+' A'[i==n/2]*n*2)[:i*2]+'A'for i in range(n))

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

वांछित आउटपुट को बाएं व्हाट्सएप, लेफ्ट Aप्लस मिडिल व्हाट्सएप या Aएस और राइट में विभाजित करें A। एक निश्चित स्ट्रिंग पर स्लाइसिंग का उपयोग करके मध्य भाग की गणना करें। यह पहली पंक्ति उत्पन्न करने के लिए उसी तरह का उपयोग करने की अनुमति देता है।

— bubbler
स्रोत
4

स्टैक्स , 15 बाइट्स

┴3╬*ôP^x'┌_╓J²♫

इसे चलाएं और डीबग करें

अनपैक्ड, अनगुल्फेड और टिप्पणी की गई, कार्यक्रम इस तरह दिखता है।

m       map over [1 .. input] using rest of the program, output each result
'A      "A" literal
xhi=    is the iteration index equal to (integer) half the input?
65*     multiply by 65 (character code of "A")
]i*     repeat that character (" " or  "A") i times
+       concat to initial "A"
x)      left pad to the original input
|p      palindromize (concatenate the reverse minus the last character)

इसको चलाओ

— पुनरावर्ती
स्रोत
4

पायथन 3.6 , 79 बाइट्स या 73 बाइट्स

पत्र के क्षैतिज भागों को संरेखित करने के लिए f- स्ट्रिंग्स का उपयोग करना : 

lambda n:'\n'.join(f"{'A'+' A'[i==n//2]*2*i:>{n+i}}"[:-1]+'A'for i in range(n))

साथ \bएक को हटाने के लिए प्रयोग किया जाता Aहै (संभवतः धोखाधड़ी):

lambda n:'\n'.join(f"{'A'+' A'[i==n//2]*2*i:>{n+i}}\bA"for i in range(n))
— राडेक
स्रोत
3

जे , 65 बाइट्स

f=:3 :''' A''{~1(([:(<@;]+i.@+:)<.@-:)y)}([:(}:@|."1,.])=/~@i.)y'

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

इसे लगभग घटाया जा सकता है। बस क्रिया को शांत करके 12 बाइट्स, लेकिन मुझे इसे करने में समस्या है।

स्पष्टीकरण:

3 : '...' एक स्पष्ट एक-लाइनर क्रिया को दर्शाता है

y तर्क है

=/~@i. तर्क के आकार के साथ एक पहचान मैट्रिक्स बनाता है

    =/~@i. 4
1 0 0 0
0 1 0 0
0 0 1 0
0 0 0 1

([:(}:@|."1,.]) गिराए गए प्रत्येक पंक्ति के अंतिम तत्वों के साथ आईने की प्रतिलिपि के साथ पहचान मैट्रिक्स को प्रस्तुत करता है।

    ]a =. ([:(}:@|."1,.])=/~@i.) 4
0 0 0 1 0 0 0
0 0 1 0 1 0 0
0 1 0 0 0 1 0
1 0 0 0 0 0 1

1(...)}(...) इसके दायें तर्क में 1 स्थिति में परिवर्तन होता है, जिसे बाईं ओर चुना जाता है

([:(<@;]+i.@+:)<.@-:) - निम्नलिखित को चुनकर तैयार करता है:

               <.@-: - halves the argument and finds the floor (finds the row number)
    <@;              - box the row, followed by a list of columns:  
        ]+i.@+:      - a list form the argumnt to the doubled row number

    ([:(<@;]+i.@+:)<.@-:) 4
┌───────────┐
│┌─┬───────┐│
││2│2 3 4 5││
│└─┴───────┘│
└───────────┘

    1(([:(<@;]+i.@+:)<.@-:) 4)}a
0 0 0 1 0 0 0
0 0 1 0 1 0 0
0 1 1 1 1 1 0
1 0 0 0 0 0 1

' A'{~ 0 और 'A' के स्थानों में एक स्थान प्रदान करता है जहाँ 1 है

    ' A'{~1(([:(<@;]+i.@+:)<.@-:) 4)}a
   A   
  A A  
 AAAAA 
A     A
— गैलेन इवानोव
स्रोत
2

SOGL V0.12 , 12 बाइट्स

 A*:╚╥≤.»I:ž

यह कोशिश करो!

स्पष्टीकरण:

 A*           repeat "A" input times
   :          duplicate it
    ╚         create a "/" diagonal of one of the copies of As
     ╥        palindromize it horizontally
      ≤       get the other copy of the "A"s on top
       .»I:   push floor(input/2)+1 twice
           ž  and at those coordinates in the palindromized diagonals place in the row of As
— dzaima
स्रोत
2

जाप -R , 20 19 बाइट्स

Çç" A"gZ¶Uz¹i'A êÃû

कोशिश करो

व्याख्या

                        :Implicit input of integer U
Ç                       :Create the range [0,U) and pass each Z through a function
         Uz             :  Floor divide U by 2
       Z¶               :  Test for equality with Z (true=1, false=0)
  " A"g                 :  Get the character in the string " A" at that index
 ç                      :  Repeat Z times
           ¹            :  (Closes a few nested methods)
            i'A         :  Prepend an "A"
                ê       :  Palindromise
                 Ã      :End function
                  û     :Centre pad each element to the length of the longest element
                        :Implicitly join with newlines and output

विकल्प

(इस उम्मीद में कि इससे मुझे कुछ बचत करने में मदद मिल सकती है!)

Æ'AúXÄ" A"gX¶Uz¹êÃû
— झबरा
स्रोत
1
एक अन्य वैकल्पिक जो बाइट अधिक लंबा है:ç h'AUz)¬íp ®i'A êÃû
— ETHproductions
@ETHproductions के p साथ बदलें ²और यह भी 19 बाइट्स है।
— शैगी
+1 मेरी राक्षसी से बेहतर है ।
— ओलिवर
1

जेली , 23 20 19 18 बाइट्स

=þ`o\L‘HĊƲ¦UŒBị⁾A

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

=þ` आकार का एक पहचान मैट्रिक्स बनाता है n ।

L‘HĊƲ¦उस पंक्ति को बाहर निकालने और लगाने के साथ क्षैतिज पट्टी की पंक्ति सूचकांक पाता हैo\ करने के है जो बार बनाता है।

Uप्रत्येक पंक्ति को उलट देता है ताकि हमारे पास "A" न हो और ŒB(palindromize; वेक्टरकृत) "A" के दूसरे भाग को बनाता है।

ị⁾A(फॉर्मेटिंग में ट्रिम हो रहे 0स्पेस के साथ ) स्पेस को 1एस और एस के साथ बदल देता है A।

— dylnan
स्रोत
1

टी-एसक्यूएल , 182 177 बाइट्स

DECLARE @n INT=5DECLARE @ INT=0a:DECLARE @s VARCHAR(9)=STR(POWER(10,@),@n)PRINT REPLACE(REPLACE(@s+REVERSE(LEFT(@s,@n-1)),'1','A'),'0',IIF(@=@n/2,'A',' '))SET @+=1IF @<@n GOTO a

पहला संस्करण (182 बाइट्स के साथ):

DECLARE @n INT=5DECLARE @ INT=0WHILE @<@n BEGIN DECLARE @s VARCHAR(9)=STR(POWER(10,@),@n)PRINT REPLACE(REPLACE(@s+REVERSE(LEFT(@s,@n-1)),'1','A'),'0',IIF(@=@n/2,'A',' '))SET @+=1 END

उपरोक्त संस्करण @ n = 9 तक काम करता है।

यहाँ एक और संस्करण है, जो @ n = 23 तक काम करता है, लेकिन इसमें 2 अतिरिक्त बाइट्स हैं:

DECLARE @n INT=5DECLARE @ INT=0WHILE @<@n BEGIN DECLARE @s VARCHAR(23)=STR(POWER(10.,@),@n)PRINT REPLACE(REPLACE(@s+REVERSE(LEFT(@s,@n-1)),'1','A'),'0',IIF(@=@n/2,'A',' '))SET @+=1 END

Ungolfed:

DECLARE @n INT=5

DECLARE @i INT=0
WHILE @i<@n BEGIN
    DECLARE @s VARCHAR(9)=STR(POWER(10,@i),@n)
    PRINT REPLACE(REPLACE(@s+REVERSE(LEFT(@s,@n-1)),'1','A'),'0',IIF(@i=@n/2,'A',' '))
    SET @i+=1
END
— रज़वान सोकोल
स्रोत
1

हास्केल , 98 97 95 बाइट्स और 109 बाइट्स

दो बहुत अलग दृष्टिकोण। पहला (95 बाइट्स):

c!n=([1..n]>>c)++"A"
f n=unlines[" "!(n-x)++drop 3([" "!(abs$n`div`2-x+1)!!0]!(2*x))|x<-[1..n]]

और दूसरा (109 बाइट्स):

m True='A'
m _=' '
g n=unlines[[m(abs(n-j)==l||l==q&&elem j[q+1..q+n])|j<-[1..2*n]]|l<-[0..n-1],q<-[n`div`2]]

उन्हें यहाँ की कोशिश करो! ; यहाँ संशोधित संस्करण की कोशिश करो!

यहाँ तीसरे संस्करण की कोशिश करो!

— राडेक
स्रोत
PPCG में आपका स्वागत है! आप infix ऑपरेटर के रूप में परिभाषितl करके अपने पहले दृष्टिकोण पर एक बाइट बचा सकते हैं ।
— लैकोनी
m True='A'एक छोटा हो गया m b|b='A'।
— लैकोनी
यह पता चला कि दो बाइट्स को भी बचाया जा सकता है। धन्यवाद! :)
— राडेक
1

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

तार की सूची स्वीकार्य परिणाम है, जैसा कि @Budd टिप्पणियों में कहा गया है।

lambda n:['%*sA\n'%(n+i,('A'+i*2*' A'[i==n/2])[:-1])for i in range(n)]

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

का उपयोग करते हुए लगातार धोखेबाज़ समाधान \b। यह TIO में कायरता दिखता है, कंसोल में यह काम करता है। 

lambda n:['%*s\bA\n'%(n+i,'A'+i*2*' A'[i==n/2])for i in range(n)]

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

— मृत पोसुम
स्रोत
0

जावास्क्रिप्ट, 124 बाइट्स

एक काफी भोली समाधान, ने इसे js कौशल का अभ्यास करने के लिए एक शॉट दिया।

for(i=-1,p=" ".repeat(n-1)+"A ";++i<n;console.log(i-~~(n/2)?p:p.slice(0,i)+"A".repeat(n)),p=p.slice(1,n)+" "+p.slice(n-1)){}

पैक नहीं किया गया

for(
 //create the first line
 i=-1, p=" ".repeat(n-1)+"A "; 
 ++i<n;
 console.log( 
 //if we are not at the bar
      i-~~(n/2)?
 //otherwise, use the modified previous line
      p
 //slice the start of the previous line and add As
      :p.slice(0,i)+"A".repeat(n)), 
 //add a space in between the previous line and remove padding on each side
 p=p.slice(1,n)+" "+p.slice(n-1)){}
— बड
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.