শয়তানের সিঁড়ি আঁকুন


46

শয়তান এর সিঁড়ি একটি ফ্র্যাক্টাল মত ক্যান্টর সেট এর সাথে সম্পর্কিত ফাংশন।

এখানে চিত্র বর্ণনা লিখুন

আপনার কাজটি এই মজাদার ফাংশনটির অনুলিপি করা - এএসসিআইআই আর্টে!

ইনপুট

একটি একক পূর্ণসংখ্যা n >= 0, আউটপুটটির আকার নির্দেশ করে। এসটিডিআইএন, ফাংশন আর্গুমেন্ট বা কমান্ড-লাইন আর্গুমেন্টের মাধ্যমে ইনপুট দেওয়া যেতে পারে।

আউটপুট

আকারে শয়তানের সিঁড়ির ASCII- শিল্প উপস্থাপনাটি nহয় স্ট্রিং হিসাবে ফিরে আসে বা STDOUT এ মুদ্রিত হয়। প্রতিটি সারির শেষে স্থানগুলি ট্রেলিং ঠিক আছে তবে শীর্ষস্থানীয় স্থানগুলি নেই। আপনি allyচ্ছিকভাবে একটি একক পেছনের নতুন লাইন মুদ্রণ করতে পারেন।

আকারের জন্য 0, আউটপুটটি কেবল:

x

(আপনি যদি চান তবে স্থানের পরিবর্তে অন্য কোনও মুদ্রণযোগ্য ASCII অক্ষর ব্যবহার করতে পারেন x))

আকারের জন্য n > 0, আমরা:

  • আকারের আউটপুট নিন n-1এবং তিনটি ফ্যাক্টর দ্বারা প্রতিটি সারিতে প্রসারিত করুন
  • একক xএর সারিগুলির মধ্যে রাইফেল
  • সারিগুলি ডানদিকে সরান যাতে xপ্রতিটি কলামে ঠিক এক থাকে এবং xসারিগুলির সাথে হ্রাসের সাথে প্রথমটির অবস্থান ন্যূনতম হয়

উদাহরণস্বরূপ, এর আউটপুট n = 1হল:

    x
 xxx
x

এর জন্য আউটপুট পেতে n = 2, আমরা তিনটি ফ্যাক্টর দ্বারা প্রতিটি সারি প্রসারিত:

            xxx
   xxxxxxxxx
xxx

একক সারি সারিগুলির মধ্যে রাইফেল x:

x
            xxx
x
   xxxxxxxxx
x
xxx
x

ডানদিকে শিফট করুন:

                  x
               xxx
              x
     xxxxxxxxx
    x
 xxx
x

অন্য একটি উদাহরণ হিসাবে, এখানে হয় n = 3

স্কোরিং

এটি কোড-গল্ফ, সুতরাং কয়েকটি বাইটে সমাধান জিততে পারে।

উত্তর:


7

পাইথ, 30

jb_u+G+*leGd*HNu+N+^3hTNUQ]1]k

এটি এমন একটি প্রোগ্রাম যা এসটিডিএন থেকে ইনপুট নেয় এবং ক্যান্টর সেটটি সন্ধান করার জন্য গ্রিসির পদ্ধতি ব্যবহার করে। বক্রটি প্রদর্শন করতে "চরিত্রটি ব্যবহার করে।

এটি এখানে অনলাইনে চেষ্টা করুন।

ব্যাখ্যা:

আমি কোডটি দুটি অংশে ব্যাখ্যা করব, প্রথমে ক্যান্টর সেট প্রজন্ম:

u+N+^3hTNUQ]1
u        UQ]1         : reduce( ... , over range(input), starting with [1])
 +N                   : lambda N,T: N + ...
   +^3hTN             : 3 ** (T+1) + N   (int + list in pyth is interpreted as [int] + list)

এবং আউটপুট বিন্যাস:

jb_u+G+*leGd*HN    ]k
jb_                    : "\n".join(reversed(...)
   u               ]k  : reduce(lambda G,H: ... , over cantor set, starting with [""])
    +G+*leGd           : G + len(G[-1]) * " " + ...
            *HN        : H * '"'

লক্ষ্য করুন যে পাইথ এন = '' 'তে ডিফল্টরূপে।


32

জে ( 73 68 58 41 39 39 35 34 টি অক্ষর)

কিছু সময়ের জন্য সমস্যাটি সম্পর্কে চিন্তাভাবনা করার পরে, আমি শয়তানের সিঁড়ি ধরণের উত্পন্ন করার জন্য সম্পূর্ণ ভিন্ন উপায় খুঁজে পেয়েছি। এটির ব্যাখ্যা সহ পুরানো উত্তরটি সরানো হয়েছে, আপনি কীভাবে এটির উত্তর দেওয়ার জন্য এই উত্তরটির সংশোধনগুলি দেখতে পারেন।

এই উত্তরটি শয়তানের সিঁড়িটিকে উপস্থাপন করে একটি ফাঁকা এবং তীক্ষ্ণ ধরণের অ্যারে দেয় returns

' #'{~1(]|.@=@#~[:,3^q:)2}.@i.@^>:

উত্তরটি এর দুটি অংশে স্পষ্ট স্বরলিপিতে বিভক্ত হয়েছে:

f =: 3 : '|. = (, 3 ^ 1 q: y) # y'
g =: 3 : '(f }. i. 2 ^ >: y) { '' #'''

ব্যাখ্যা

পদ্ধতিটি কিছুটা আলাদা, সুতরাং অবলোকন করুন এবং অবাক হন।

  1. >: 3 - তিনটি বর্ধিত, অর্থাৎ,

    4
    
  2. 2 ^ >: 3 - তিনটি বাড়ানো তিনটি শক্তি, যা,

    16
    
  3. i. 2 ^ >: 3- প্রথম 2 ^ >: 3পূর্ণসংখ্যা, যা,

    0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
    
  4. }. i. 2 ^ 4- প্রথম 2 ^ >: 3পূর্ণসংখ্যা, শিরশ্ছেদ করা, অর্থাৎ,

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
    

    এই ক্রমটি কল করি s; আমরা fএখন প্রবেশ ।

  5. 1 q: s- প্রতিটি আইটেমের প্রধান পচনে 2 এর এক্সটেন্ডার s। সাধারণভাবে, প্রধান পঁচনের x q: yপ্রথম xপ্রাইমগুলির জন্য এক্সটেনারগুলির একটি সারণী উত্পন্ন করে y। এই ফলন:

    0
    1
    0
    2
    0
    1
    0
    3
    0
    1
    0
    2
    0
    1
    0
    
  6. 3 ^ 1 q: s - এই অভিজাতদের শক্তি তিনটি, অর্থাৎ,

     1
     3
     1
     9
     1
     3
     1
    27
     1
     3
     1
     9
     1
     3
     1
    
  7. , 3 ^ 1 q: s- ফলশ্রুতি (যেটি, এর কাঠামোর সাথে যুক্তিটি ভেক্টরটিতে ধসে পড়ে) result এটি প্রয়োজন কারণ q:একটি অযাচিত ট্রেইলিং অক্ষটি পরিচয় করিয়ে দেয়। এই ফলন

     1 3 1 9 1 3 1 27 1 3 1 9 1 3 1
    
  8. (, 3 ^ 1 q: s) # s- sপ্রতিফলিত প্রতিটি আইটেম প্রায়শই আগের ফলাফলের সম্পর্কিত আইটেম হিসাবে প্রায়শই প্রতিলিপি করা হয়,

    1 2 2 2 3 4 4 4 4 4 4 4 4 4 5 6 6 6 7 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 9 10 10 10 11 12 12 12 12 12 12 12 12 12 13 14 14 14 15
    
  9. = (, 3 ^ 1 q: s) # s - পূর্ববর্তী ফলাফলের স্ব শ্রেণিবদ্ধকরণ, এটি হ'ল একটি ম্যাট্রিক্স যেখানে প্রতিটি সারি আর্গুমেন্টের একটি অনন্য আইটেমকে উপস্থাপন করে, প্রতিটি কলাম আর্গুমেন্টের সম্পর্কিত আইটেমকে উপস্থাপন করে এবং প্রতিটি ঘর সারি এবং কলামের আইটেম সমান কিনা তা উপস্থাপন করে, এটাই,

    1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
    0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
    0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
    0 0 0 0 0 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
    0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
    0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
    0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
    0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
    0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
    0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
    0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0
    0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 0 0 0 0 0
    0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0
    0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0
    0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
    
  10. |. = (, 3 ^ 1 q: s) # s - পূর্ববর্তী ফলাফলটি উল্লম্ব অক্ষের সাথে উল্টে গেল।

  11. (|. = (, 3 ^ 1 q: s) # s) { ' #'- পূর্ববর্তী ফলাফলের আইটেমগুলি অ্যারেতে সূচক হিসাবে ব্যবহৃত হয় ' #', তাই 0দ্বারা প্রতিস্থাপিত হয়  এবং 1প্রতিস্থাপিত হয় #, অর্থাৎ,

                                                                    #
                                                                 ### 
                                                                #    
                                                       #########     
                                                      #              
                                                   ###               
                                                  #                  
                       ###########################                   
                      #                                              
                   ###                                               
                  #                                                  
         #########                                                   
        #                                                            
     ###                                                             
    #      
    

    ফলাফল আমরা চাই।


1 টি বাইট সংরক্ষণের (,],~3^#@~.)@]পরিবর্তে পাওয়ার লুপের ভিতরে (1,[:,1,"0~3*])। এবং যদি আপনি !আউটপুট চর হিসাবে ঠিক থাকেন u:32+পরিবর্তে ' #'{~অন্য একটি সংরক্ষণ করে।
এলোমেলো

#\ এর পরিবর্তে i.@#এবং আপনি এপিএলকে ছাড়িয়ে যাবেন! :)
এলোমেলো

আপনার দ্বিতীয় সমাধানটি কাজ করে না কারণ একটি ক্যাপের প্রয়োজন হবে, তবে আমি এপিএলকে হারাতে আরও একটি উপায় পেয়েছি।
FUZxxl

নতুন আউটপুট সিঁড়ি হয় n-1না n
এলোমেলো

@ আরন্দোমরা আহ ... এতো খারাপ। এটি স্থিরযোগ্য কিনা তা আমাকে দেখতে দিন।
FUZxxl

26

হেক্সাগনি , 217 বাইট

এটি ছিল অত্যন্ত মজা। এই চ্যালেঞ্জ পোস্ট করার জন্য আপনাকে ধন্যবাদ।

সম্পূর্ণ প্রকাশ: এই চ্যালেঞ্জটি পোস্ট করার সময় ভাষা (হেক্সাগনি) উপস্থিত ছিল না। তবে, আমি এটি আবিষ্কার করি নি, এবং ভাষা এই চ্যালেঞ্জের জন্য ডিজাইন করা হয়নি (বা অন্য কোনও নির্দিষ্ট চ্যালেঞ্জ)।

){_2"_{\"{{""}"{'2//_.\><*\"\/_><[\]/3\'\_;|#__/(\2\'3_'}(#:|{$#{>_\//(#={/;01*&"\\_|[##={|}$_#></)]$_##|){*_.>.(/?#//~-="{}<_"=#/\}.>"%<.{#{x\"<#_/=&{./1#_#>__<_'\/"#|@_|/{=/'|\"".{/>}]#]>(_<\'{\&#|>=&{{(\=/\{*'"]<$_

ষড়ভুজযুক্ত আউট:

        ) { _ 2 " _ { \ "
       { { " " } " { ' 2 /
      / _ . \ > < * \ " \ /
     _ > < [ \ ] / 3 \ ' \ _
    ; | # _ _ / ( \ 2 \ ' 3 _
   ' } ( # : | { $ # { > _ \ /
  / ( # = { / ; 0 1 * & " \ \ _
 | [ # # = { | } $ _ # > < / ) ]
$ _ # # | ) { * _ . > . ( / ? # /
 / ~ - = " { } < _ " = # / \ } .
  > " % < . { # { x \ " < # _ /
   = & { . / 1 # _ # > _ _ < _
    ' \ / " # | @ _ | / { = /
     ' | \ " " . { / > } ] #
      ] > ( _ < \ ' { \ & #
       | > = & { { ( \ = /
        \ { * ' " ] < $ _

প্রোগ্রামটি আসলে #নির্দেশনাটি ব্যবহার করে না , তাই কোষগুলি প্রকৃতপক্ষে অব্যবহৃত রয়েছে তা দেখানোর জন্য আমি সেই চরিত্রটি ব্যবহার করেছি।

এই প্রোগ্রাম কিভাবে কাজ করে? যা নির্ভর করে. আপনি কি সংক্ষিপ্ত সংস্করণ চান, না দীর্ঘ?

সংক্ষিপ্ত ব্যাখ্যা

নিম্নলিখিত ব্যাখ্যায় "লাইন" এবং "বিভাগ" দ্বারা আমি কী বোঝাতে চাইছি তা বোঝানোর জন্য, উদ্দেশ্যযুক্ত আউটপুটটির এই বিচ্ছেদ বিবেচনা করুন:

segments →
 │   │ │         │ │   │x   lines
─┼───┼─┼─────────┼─┼───┼─     ↓
 │   │ │         │ │xxx│
─┼───┼─┼─────────┼─┼───┘
 │   │ │         │x│
─┼───┼─┼─────────┼─┘
 │   │ │xxxxxxxxx│
─┼───┼─┼─────────┘
 │   │x│
─┼───┼─┘
 │xxx│
─┼───┘
x│

এটি ব্যাখ্যা করার সাথে, প্রোগ্রামটি নিম্নলিখিত সিউডোকোডের সাথে মিলে যায়:

n = get integer from stdin

# Calculate the number of lines we need to output.
line = pow(2, n+1)

while line > 0:
    line = line - 1

    # For all segments except the last, the character to use is spaces.
    ch = ' ' (space, ASCII 32)

    # The number of segments in each line is
    # equal to the line number, counting down.
    seg = line

    while seg > 0:
        seg = seg - 1

        # For the last segment, use x’s.
        if seg = 0:
            ch = 'x' (ASCII 120)

        # Calculate the actual segment number, where the leftmost is 1
        n = line - seg

        # Output the segment
        i = pow(3, number of times n can be divided by 2)
        i times: output ch

    output '\n' (newline, ASCII 10)

end program

দীর্ঘ ব্যাখ্যা

দয়া করে এই রঙ-কোডেড কোড পাথ চিত্রটি দেখুন।

কার্যকর করার পথ

এক্সিকিউশনটি উপরের বাম কোণে শুরু হয়। নির্দেশের ক্রম){2'"''3''"2}?)"{ মোটামুটি সংশ্লেষিত পথ অনুসরণ করে (প্লাস কয়েকটি রিডানড্যান্ট বাতিল, যেমন ইত্যাদি) কার্যকর করা হয়। আমরা ক্রিমসনে হাইলাইট করা নির্দেশ পয়েন্টার # 0 দিয়ে শুরু করি। অর্ধেক পথ ধরে, আমরা উপরের ডানদিকের কোণে শুরু করে বন সবুজ রঙে আঁকা # 1 এ চলেছি। আইপি # 2 কর্নফ্লাওয়ার নীল (মাঝের ডানদিকে) থেকে শুরু হলে মেমরির বিন্যাসটি হ'ল:

স্মৃতি বিন্যাস

পুরো প্রোগ্রাম জুড়ে, প্রান্তগুলি 2a লেবেলযুক্ত এবং 2 বি সর্বদা মান থাকবে 2(আমরা তাদের 2ⁿ⁺¹ গণনা করতে এবং যথাক্রমে 2 দ্বারা বিভক্ত করতে ব্যবহার করি) এবং 3 লেবেলযুক্ত প্রান্তটি সর্বদা থাকবে 3(আমরা এটি 3ⁱ গণনা করতে ব্যবহার করি)।

কর্নফ্লাওয়ার নীল রঙে হাইলাইট করা আমাদের প্রথম লুপটি প্রবেশ করার সাথে সাথে আমরা ব্যবসায় পেতে পারি। এই লুপটি (}*{=&}{=2ⁿ⁺¹ মান গণনা করার জন্য নির্দেশাবলী কার্যকর করে ⁿ⁺¹ যখন লুপটি প্রস্থান করে, স্যাডল ব্রাউন পাথটি নেওয়া হয়, যা আমাদের নির্দেশ পয়েন্টার # 3 এ নিয়ে যায়। এই আইপিটি নীচে প্রান্তে কেবল গোল্ডেনরোড হলুদে ছড়িয়ে পড়ে এবং শীঘ্রই আইপি # 4 এ নিয়ন্ত্রণ অতিক্রম করে।

Fuchsia পথ নির্দেশ করে কিভাবে আইপি # 4, নীচে বাঁদিকের শুরু, দ্রুতগতিতে হ্রাস আয় লাইন , সেট CH করার 32(স্থান চরিত্র) এবং seg (এর নতুন মান) এর লাইন । এটি প্রাথমিকভাবে হ্রাসের কারণে যা আমরা আসলে 2ⁿ⁺¹ − 1 দিয়ে শুরু করি এবং অবশেষে মান 0 দিয়ে একটি শেষ পুনরাবৃত্তিটি অনুভব করি We আমরা তারপরে প্রথম নেস্টেড লুপটি প্রবেশ করি ।

আমরা শাখাবিন্যাস নীল, যেখানে, একটি সংক্ষিপ্ত হ্রাস পর আমাদের মনোযোগ ঘুরিয়ে seg , আমরা দেখতে CH আপডেট xশুধুমাত্র যদি seg এখন শূন্য। পরে, এন লাইন সেট করা আছে - সেগমেন্টের প্রকৃত সংখ্যাটি নির্ধারণ করতে সেগ করুন Im তাত্ক্ষণিকভাবে আমরা এবার অন্য লুপটি প্রবেশ করলাম, এবার টমেটোর ন্যায্য রঙে।

এখানে, আমরা নির্ধারণ করেছি যে কতবার n (বর্তমান বিভাগের সংখ্যা) 2 দ্বারা বিভক্ত করা যেতে পারে যতক্ষণ মডুলো শূন্য দেয় ততক্ষণ আমরা i বৃদ্ধি করব এবং n কে 2 দিয়ে ভাগ করব যখন আমরা সন্তুষ্ট হই তখন n আর এভাবে বিভাজ্য হয় না , আমরা স্লেট ধূসরতে শাখা করি, যার দুটি লুপ থাকে: প্রথমে এটি আমরা যে হিসাব করেছিলাম তার শক্তিতে 3 উত্থাপন করে এবং তারপরে এটি বহুবার ছাড়িয়ে যায়। লক্ষ্য করুন যে এই লুপগুলির প্রথমটিতে একটি রয়েছে[নির্দেশনা, যা আইপি # 3 এ নিয়ন্ত্রণ নিয়ন্ত্রণ করে - এটি কেবলমাত্র নীচের প্রান্তে কেবল শিশুর পদক্ষেপ নিয়েছিল। লুপের বডি (3 দিয়ে গুণমান এবং হ্রাস) একটি নিঃসঙ্গ আইপি # 3 দ্বারা নির্বাহ করা হয়, কোডের নীচের প্রান্তটি সহ একটি অন্তহীন গা dark় জলপাই সবুজ চক্রে বন্দী। একইভাবে, এই স্লেট ধূসর লুপগুলির দ্বিতীয়টিতে একটি ]নির্দেশ রয়েছে , যা আইপি # 5 কে আউটপুট সিএইচ এবং হ্রাসকে সক্রিয় করে , এখানে গা dark় ভারতীয় লাল দেখায়। উভয় ক্ষেত্রেই, দাসত্বের মধ্যে আটকে থাকা সেই নির্দেশিকা পয়েন্টারগুলি বাধ্যতামূলকভাবে এক সময়ে একটি পুনরাবৃত্তি সম্পাদন করে এবং আইপি # 4 এ নিয়ন্ত্রণ ফিরিয়ে দেয়, কেবলমাত্র তাদের পরিষেবাটি পুনরায় আহ্বানের জন্য এই মুহুর্তটিকে বিড করার জন্য। স্লেট ধূসর, ইতিমধ্যে, এর ফুচিয়া এবং নীল ভাইদের সাথে আবার যোগদান করে।

সেগ যখন অনিবার্যভাবে শূন্যে পৌঁছেছে, নীল লুপটি লন সবুজ পথে বেরিয়ে আসে, যা কেবল নতুন লাইন চরিত্রটিকে আউটপুট করে এবং লাইন লুপটি অবিরত করার জন্য অবিলম্বে ফুশিয়ায় ফিরে যায় । লাইন লুপের চূড়ান্ত পুনরাবৃত্তির বাইরে চূড়ান্ত প্রোগ্রামের সমাপ্তির সংক্ষিপ্ত সাবলীল ইবোনের পথ রয়েছে।


8
এখন এটি কেবল সাদামাটা পুরানো ins
FUZxxl

21

পাইথন 2, 78

L=[1]
i=3
exec"L+=[i]+L;i*=3;"*input()
while L:x=L.pop();print' '*sum(L)+'x'*x

তালিকাটি দিয়ে শুরু করে L=[1], আমরা এটিকে সদৃশ করি এবং মাঝের দিকে 3 এর পরবর্তী শক্তি সন্নিবেশ করি, যার ফলস্বরূপ [1, 3, 1]nশয়তানের সিঁড়ির জন্য আমাদের সারির দৈর্ঘ্য দিতে বারবার এটি পুনরাবৃত্তি হয়েছে। তারপরে আমরা প্রতিটি সারি ফাঁকা জায়গায় মুদ্রণ করি।


20

এপিএল, 38

⊖↑'x'/⍨¨D,⍨¨0,¯1↓-+\D←{1,⍨∊1,⍪3×⍵}⍣⎕,1

উদাহরণ:

      ⊖↑'x'/⍨¨D,⍨¨0,¯1↓-+\D←{1,⍨∊1,⍪3×⍵}⍣⎕,1
⎕:
      2
                  x
               xxx 
              x    
     xxxxxxxxx     
    x              
 xxx               
x   

ব্যাখ্যা:

⊖↑'x'/⍨¨D,⍨¨0,¯1↓-+\D←{1,⍨∊1,⍪3×⍵}⍣⎕,1

                                     ⎕       ⍝ read a number from the keyboard
                       {           }⍣ ,1      ⍝ apply this function N times to [1]
                               3×⍵           ⍝ multiply each value by 3
                           ∊1,⍪               ⍝ add an 1 in front of each value
                        1,⍨                  ⍝ add an 1 to the end
                     D←                      ⍝ store values in D (lengths of rows)
                   +\                        ⍝ get running sum of D
                  -                          ⍝ negate (negative values on / give spaces)
             0,¯1↓                           ⍝ remove last item and add a 0 to the beginning
                                             ⍝ (each row needs offset of total length of preceding rows)   
         D,⍨¨                                ⍝ join each offset with each row length
   'x'/⍨¨                                    ⍝ get the right number of x-es and spaces for each row
 ↑                                           ⍝ make a matrix out of the rows
⊖                                            ⍝ mirror horizontally 

এটি একটি দুর্দান্ত সমাধান।
FUZxxl

20
আমি পছন্দ করি যে কোডটির ব্যাখ্যাটি একটি ডেভিলের সিঁড়ির মতো দেখাচ্ছে।
অ্যালেক্স এ।

আমি একটি আরও সংক্ষিপ্ত এপিএল সমাধান পেয়েছি।
FUZxxl

14

জিএনইউ সেড, 142

সবচেয়ে সংক্ষিপ্ত উত্তর নয়, তবে এর খারাপ !:

s/$/:/
:l
s/x/xxx/g
s/:/:x:/g
tb
:b
s/^1//
tl
s/:x/X/g
s/^/:/
:m
s/.*:([Xx]+)Xx*:$/&\1:/
tm
:n
s/([ :])[Xx](x*Xx*)/\1 \2/g
tn
s/:/\n/g
s/X/x/g

যেহেতু এটি সেড (কোনও স্থানীয় গাণিতিক নয়), "আউটপুটটির আকার নির্দেশ করে" একটি একক পূর্ণসংখ্যা n> = 0 বিধিটি দিয়ে আমি স্বাধীনতা নিচ্ছি । এই ক্ষেত্রে ইনপুট পূর্ণসংখ্যার অবশ্যই একটি স্ট্রিং হওয়া উচিত 1, যার দৈর্ঘ্য n। আমি মনে করি এটি আউটপুটটির আকারকে "ইঙ্গিত" করছে, যদিও এটি সরাসরি n এর সমকালের সমান নয়। সুতরাং এন = 2 এর জন্য, ইনপুট স্ট্রিংটি হবে 11:

$ echo 11 | sed -rf devils-staircase.sed

                  x
               xxx
              x
     xxxxxxxxx
    x
 xxx
x

$ 

এটি ও (সি এন ) এর ঘনঘন সময় জটিলতার সাথে সম্পূর্ণ হয়ে দেখা দেয় , যেখানে সি প্রায় 17 n


বিকল্পভাবে যদি প্রয়োজন হয় যে n সংখ্যার ঠিক প্রবেশ করানো হয় তবে আমরা এটি করতে পারি:

সেড, 274 বাইট

s/[0-9]/<&/g
s/9/8Z/g
s/8/7Z/g
s/7/6Z/g
s/6/5Z/g
s/5/4Z/g
s/4/3Z/g
s/3/2Z/g
s/2/1Z/g
s/1/Z/g
s/0//g
:t
s/Z</<ZZZZZZZZZZ/g
tt
s/<//g
s/$/:/
:l
s/x/xxx/g
s/:/:x:/g
tb
:b
s/^Z//
tl
s/:x/X/g
s/^/:/
:m
s/.*:([Xx]+)Xx*:$/&\1:/
tm
:n
s/([ :])[Xx](x*Xx*)/\1 \2/g
tn
s/:/\n/g
s/X/x/g

আউটপুট:

$ echo 2 | sed -rf devils-staircase.sed

                  x
               xxx
              x
     xxxxxxxxx
    x
 xxx
x

$ 

7
এটা সত্যিই দুর্দান্ত।
FUZxxl

8

পাইথন 2, 81

def f(n,i=1,s=0):
 if i<2<<n:q=3**len(bin(i&-i))/27;f(n,i+1,s+q);print' '*s+'x'*q

প্রোগ্রাম সংস্করণ (88)

def f(n,s=0):
 if n:q=3**len(bin(n&-n))/27;f(n-1,s+q);print' '*s+'x'*q
f((2<<input())-1)

n1 ম-সূচকযুক্ত সারিতে x এর সংখ্যা 3 এর পাওয়ার (প্রথম সেট বিটের ইনডেক্স, nএলএসবি থেকে শুরু করে) to


8

পাইথন 2, 74

def f(n,s=0):
 if~n:B=3**n;A=s+B-2**n;f(n-1,A+B);print' '*A+'x'*B;f(n-1,s)

একটি পুনরাবৃত্তি পদ্ধতির। আকার- $ n $ শয়তানের সিঁড়িটি তিন ভাগে বিভক্ত

  • বাম রিকার্সিভ শাখা, আকারের সিঁড়ি n-1, যার দৈর্ঘ্য3**n - 2**n
  • xদৈর্ঘ্যের 'এর কেন্দ্র লাইন3**n
  • ডান রিকার্সিভ শাখা, আকারের একটি সিঁড়ি n-1, যার দৈর্ঘ্য3**n - 2**n

নোট তিনটি অংশ মোট দৈর্ঘ্য যে 3*(3**n) - 2*(2**n)বা3**(n+1) - 2**(n+1) যা, যা আবেশকে নিশ্চিত করে।

Alচ্ছিক চলক sবর্তমান প্রিন্টগুলির অফসেট সংরক্ষণ করে যা আমরা মুদ্রণ করছি। আমরা প্রথমে বৃহত্তর অফসেট সহ বাম শাখায় পুনরাবৃত্তি করি, তারপরে কেন্দ্র লাইনটি মুদ্রণ করি, তারপরে বর্তমান অফসেটে ডান শাখাটি করব।


6

সিজেম, 36 35 33 বাইট

এখানে আরেকটি সিজেএম পদ্ধতির ব্যবস্থা রয়েছে (আমি অপ্টিমাইজারের কোডটির দিকে নজর দিইনি, সুতরাং আসলে এটির চেয়ে আলাদা কিনা তা আমি জানি না):

L0sl~{{3*0s}%0s\+}*{1$,S*\+}%W%N*

এটি 0কার্ভের জন্য ব্যবহার করে। বিকল্পভাবে, (grc এর কৌশল ব্যবহার করে)

LLl~){3\#a1$++}/{1$,S*\'x*+}%W%N*

যা ব্যবহার করে x

এটি এখানে পরীক্ষা করুন।

ব্যাখ্যা

প্রাথমিক ধারণাটি হ'ল প্রথমে সারিগুলির সাথে একটি অ্যারে গঠন করা

["0" "000" "0" "000000000" "0" "000" "0"]

এবং তারপরে এই তালিকার মধ্য দিয়ে যাওয়ার জন্য, সঠিক পরিমাণে জায়গাগুলির প্রিপেন্ডিং।

L0sl~{{3*0s}%0s\+}*{1$,S*\+}%W%N*
L                                 "Push an empty string for later.";
 0s                               "Push the array containing '0. This is the base case.";
   l~                             "Read and evaluate input.";
     {           }*               "Repeat the block that many times.";
      {    }%                     "Map this block onto the array.";
       3*                         "Triple the current string.";
         0s                       "Push a new zero string.";
             0s\+                 "Prepend another zero string.";
                   {       }%     "Map this block onto the result.";
                    1$            "Copy the last line.";
                      ,S*         "Get its length and make a string with that many spaces.";
                         \+       "Prepend the spaces to the current row.";
                             W%   "Reverse the rows.";
                               N* "Join them with newlines.";

অন্যান্য সংস্করণ একইভাবে কাজ করে তবে লম্বা অ্যারে তৈরি করে

[1 3 1 9 1 3 1]

এবং তারপরে xচূড়ান্ত মানচিত্রে এর স্ট্রিংগুলিতে পরিণত হয় ।


6

ডায়ালগ এপিএল, 34 টি অক্ষর

Grc দ্বারা পদ্ধতির ব্যবহার সিঁড়ি আঁকুন (ডোমিনো) অক্ষর সহ এবং স্টিডিন থেকে ইনপুট নেয়। এই সমাধান অনুমান ⎕IO←0

' ⌹'[(∪∘.=⊖){⍵/⍳≢⍵}⊃(⊢,,)/3*⌽⍳1+⎕]
  • - স্টিডিনের কাছ থেকে ইনপুট নিন।
  • ⌽⍳1+⎕- সংখ্যার ক্রম নীচে থেকে 0 এ। (উদাঃ 3 2 1 0)
  • 3*⌽⍳1+⎕- এর শক্তি তিনটি (উদাঃ 27 9 3 1)
  • (⊢,,)/3*⌽⍳1+⎕- পূর্ববর্তী ফলাফলটি ডান দিক থেকে ভাঁজ ফাংশন দ্বারা ভাঁজ হয়েছিল ⊢,,যা ডিফএন সমান যা {⍵,⍺,⍵}জিআরসি এর পদ্ধতির অনুসারে শয়তানের সিঁড়ির ধাপ দৈর্ঘ্য দেয়।
  • {⍵/⍳≢⍵}⊃(⊢,,)/3*⌽⍳1+⎕ পদক্ষেপের দৈর্ঘ্য ধাপে রূপান্তরিত।
  • (∪∘.=⊖){⍵/⍳≢⍵}⊃(⊢,,)/3*⌽⍳1+⎕ যে স্ব-শ্রেণিবদ্ধ, আমার হিসাবে জে সমাধান হিসাবে । লক্ষ্য করুন যে ইতিমধ্যে ফলাফল সঠিকভাবে flips।
  • ' ⌹'[(∪∘.=⊖){⍵/⍳≢⍵}⊃(⊢,,)/3*⌽⍳1+⎕] নম্বর ফাঁকা এবং ডোমিনোস দ্বারা প্রতিস্থাপিত।

4

রুবি, 99

আমার অন্য জনের একটি আলাদা উত্তর, FUZxxl এর উত্তরে অনুপ্রাণিত

FUZxxl নোট করে যে x এর সংখ্যার সাথে সূচক 2 এর কারণগুলির সংখ্যার সাথে মিল রয়েছে। উদাহরণস্বরূপ এন = 2 এর জন্য আমাদের নিম্নোক্ত কার্যকারিতা রয়েছে:

1 =1
2 =1 * 2
3 =3
4 =1 * 2 * 2
5 =5
6 =3 * 2
7 =7

আমি 2 এর এই শক্তিগুলি আহরণের একটি আরও সহজ সরল উপায় ব্যবহার করি: i=m&-mযা ক্রম ফল দেয় 1 2 1 4 1 2 1etc. এটি নিম্নলিখিত হিসাবে কাজ করে:

m-1mএর সবচেয়ে গুরুত্বপূর্ণ বিটগুলির মতো একই , তবে সর্বনিম্ন উল্লেখযোগ্য 1 এর বিট শূন্য হয়ে যায় এবং ডানদিকে সমস্ত শূন্যগুলি 1 এর হয়ে যায়।

আসল সহ এটি করতে সক্ষম হতে এবং আমাদের বিটগুলি ফ্লিপ করতে হবে। এটি করার বিভিন্ন উপায় রয়েছে। একটি উপায় এটি থেকে বিয়োগ করা হয় -1

সামগ্রিক সূত্রটি তখন m& (-1 -(m-1)) যা সরল করেm&(-m)

উদাহরণ:

          100   01100100
100-1=     99   01100011
-1-99=   -100   10011100
100&-100=   4   00000100

এখানে কোডটি রয়েছে: নিউলাইনগুলি গণনা করা হয়, ইনডেন্টগুলি অপ্রয়োজনীয় এবং তাই আমার অন্যান্য উত্তর হিসাবে এটি গণনা করা হয় না। বেস 2 থেকে বেইস 3 তে আনাড়ি রূপান্তরিত হওয়ার কারণে এটি আমার অন্যান্য উত্তরের চেয়ে কিছুটা লম্বা 1 2 1 4 1 2 1 etc: 1 3 1 9 1 3 1 etc(তা এড়ানোর কোনও উপায় আছে Math::কি?)

def s(n)
  a=[]
  t=0
  1.upto(2*2**n-1){|m|i=3**Math::log(m&-m,2)
    a.unshift" "*t+"x"*i 
    t+=i}
  puts a
end

3

রুবি, 140 99

আমার দ্বিতীয় রুবি কোড এবং ভাষাটির ক্ষেত্রে আমার প্রথম অনর্থক ব্যবহার। পরামর্শগুলি সর্বাধিক স্বাগত। বাইট গণনাটি ইনডেন্টগুলির জন্য শীর্ষস্থানীয় স্পেসগুলি বাদ দেয় তবে এতে নিউলাইনগুলি অন্তর্ভুক্ত থাকে (মনে হয় বেশিরভাগ নিউলাইনগুলি মুছে ফেলা যায় না যদি না তারা কমপক্ষে কোনও স্থান প্রতিস্থাপন না করে।)

ইনপুট ফাংশন কল দ্বারা হয়। আউটপুট স্ট্রিংগুলির একটি অ্যারে, যা রুবি সহজেই স্ট্যান্ডআউটে একটি একক সহ একটি নতুন লাইন-বিচ্ছিন্ন তালিকা হিসাবে ডাম্পস করে puts

অ্যালগরিদমটি কেবল new iteration= previous iteration+ extra row of n**3 x's+ previous iteration। তবে কেবলমাত্র আউটপুট ডানদিকে শীর্ষস্থানগুলি পাওয়ার জন্য কোডের প্রচুর পরিমাণ রয়েছে code

def s(n)
  a=["x"]
  1.upto(n){|m|t=" "*a[0].length
    a=a.map{|i|t+" "*3**m+i}+[t+"x"*3**m]+a}
  puts a
end

সম্পাদনা করুন: রুবি, 97

এটি aউপরে বর্ণিত পদ্ধতিতে অ্যারেতে প্রয়োজনীয় x এর সমস্ত সংখ্যার একটি সংখ্যাযুক্ত টেবিল তৈরির অনুরূপ তবে ভিন্ন পদ্ধতির ব্যবহার করে তবে তারপরে স্ট্রিংগুলির একটি টেবিল তৈরি করে। স্ট্রিংয়ের টেবিলটি বিদ্যমান অ্যারেতে প্রিপেন্ড করতে cবরং অদ্ভুতভাবে নামকরণ unshiftপদ্ধতিটি ব্যবহার করে অ্যারে পিছনে দিকে নির্মিত হয় ।

বর্তমানে এই পদ্ধতিটি আরও ভাল দেখাচ্ছে - তবে কেবল 2 বাইট দ্বারা :-)

def s(n)
  a=c=[]
  (n+1).times{|m|a=a+[3**m]+a}
  t=0
  a.each{|i|c.unshift" "*t+"x"*i
    t+=i}
  puts c
end

1
আপনি প্রতিস্থাপন করতে পারেন for m in(0..n-1)do ... endসঙ্গে n.times{|m|...}
ওমর

@ ওমর ধন্যবাদ, আমি আগামীকাল চেষ্টা করব। অবিচ্ছিন্ন সিনট্যাক্স ত্রুটির কারণে এটি চালাতে কতটা প্রচেষ্টা নিয়েছে তা আপনি বিশ্বাস করবেন না। আমি কীভাবে এর জন্য পুনরাবৃত্ত পরিবর্তনশীল অ্যাক্সেস করতে পারি তা জানতাম না n.timesএবং আমি অবশ্যই এটি মনে রাখব। এটি একটি endখুব দূর করে! তবে এই উপলক্ষে আমি ভাবছিলাম যে for m in (1..n)ভাল হতে পারে কিনা , এড়াতে (m+1)। লেখার কি আরও ছোট উপায় আছে?
স্তর নদী সেন্ট

1
forমূলত এটি দীর্ঘ কারণ আপনি ব্যবহার করতে বাধ্য হন end(আপনি doএকটি নতুন লাইনের সাথে বা এর সাথে প্রতিস্থাপন করতে পারেন ;)। জন্য 1..nআপনি ব্যবহার করতে পারেন 1.upto(n){|m|...}। আমি চেহারাটি পছন্দ করি (1..n).each{|i|...}তবে এটি ব্যবহারের চেয়ে কিছুটা দীর্ঘ upto। এবং নোট করুন যে কল করে পুনরুক্তি করা eachবা uptoকেবল সংক্ষিপ্ত নয়, এটি আরও মূর্খ রুবি বিবেচনা করে।
ওমর

@ আবার ধন্যবাদ, 1.upto(n)এটি! এটির সাথে এবং কয়েকটি অযথা বন্ধনী বন্ধ হয়ে গেছে, আমি ইতিমধ্যে 120 এর নিচে নেমে এসেছি I আমি মনে করি 100 এর নীচে সম্ভব, আমি পরে সংশোধিত কোড পোস্ট করব।
স্তর নদী সেন্ট

3

হাস্কেল, 99 টি অক্ষর

d=q.((iterate((1:).(>>=(:[1]).(*3)))[1])!!)
q[]=[];q(a:r)=sum r&' '++a&'x'++'\n':q r
(&)=replicate

ফাংশনটি হ'ল d:

λ: putStr $ d 3
                                                                x
                                                             xxx
                                                            x
                                                   xxxxxxxxx
                                                  x
                                               xxx
                                              x
                   xxxxxxxxxxxxxxxxxxxxxxxxxxx
                  x
               xxx
              x
     xxxxxxxxx
    x
 xxx
x

এই সব বন্ধনী! আসলে কি কম দিয়ে ঘুরে দেখার কোনও উপায় নেই?
FUZxxl

আপনি খালি তালিকার ক্ষেত্রে সমীকরণগুলি অদলবদল করে qএবং একটি বাইট হারাতে পারেন q x=x। এছাড়াও, মনে হচ্ছে চারপাশে প্রথম বন্ধনীগুলি iterate...[1]অপ্রয়োজনীয়।
জাগারব

3

পিএইচপি - 137 বাইট

function f($n){for($a=[];$i<=$n;array_push($a,3**$i++,...$a))$r=str_repeat;foreach($a as$v){$o=$r(' ',$s).$r(x,$v)."
$o";$s+=$v;}echo$o;}

আমি এখানে গ্রিকের মতো একই কৌশল ব্যবহার করছি । নিখরচায় সংস্করণটি এখানে:

function staircase($n)
{
    $lengthsList = [];
    for ($i = 0; $i <= $n; ++$i) {
        array_push($lengthsList, 3 ** $i, ...$lengthsList);
    }

    $output = '';
    $cumulatedLength = 0;
    foreach ($lengthsList as $length)
    {
        $output = str_repeat(' ', $cumulatedLength) . str_repeat('x', $length) . "\n" . $output;
        $cumulatedLength += $length;
    }

    echo $output;
}

3**$i-> পিএইচপি 5.6 এর মত অনুভব করে। আপনি এটি নির্দিষ্ট করা উচিত। এটি পিএইচপি-র প্রায় প্রতিটি ইনস্টলেশনের সাথে বেমানান। আপনাকে কয়েকটি বাইট সংরক্ষণ করতে আপনার শুরু হওয়া উচিত $r=str_repeat;এবং যেখানে আপনার সেই ফাংশন রয়েছে সেখানে $rআপনি দুটি বাইট সংরক্ষণ করে প্রতিস্থাপন করতে পারেন । এছাড়াও, $r('x',$v)হতে পারে $r(x,$v)এবং এটি সূক্ষ্মভাবে কাজ করবে (লক্ষ্য করুন যে আমি ইতিমধ্যে ভেরিয়েবলের সাথে ফাংশনটির নামটি প্রতিস্থাপন করেছি)। এছাড়াও, আমি বিশ্বাস করি যে আপনাকে অন্য একটি বাইট সংরক্ষণ করার জন্য আবারও ++$i<=$nলেখা যেতে পারে $n>++$i
ইসমাইল মিগুয়েল

এখানে আপনার সামান্য শীতল কৌশল সহ আপনার ফাংশনটি এখানে রয়েছে: function f($n){$r=str_repeat;$a=[1];while($n>++$i)$a=array_merge($a,[3**$i],$a);foreach($a as$v){$o=$r(' ',$s).$r(x,$v)."\r$o";$s+=$v;}echo$o;}(সেই কুৎসিত নতুন লাইনের পরিবর্তে, আমি এর \rভিতরে ভেরিয়েবলের সাথে ডাবল-কোটড স্ট্রিংয়ের মধ্যে পলায়ন ক্রমটি যুক্ত করেছি $oThus সুতরাং "\r$o"এটির মতো একই বাইট-কাউন্ট রয়েছে ''.$o, নিউলাইনটি সর্বশেষ একটিতে বাদ পড়ে এবং একই ফলাফল উত্পন্ন করে
ইসমাইল মিগুয়েল

আসলে, সঠিকভাবে কাজ করার জন্য এই হ্রাসের শর্তটি whileহতে হবে $n>$i++
ইসমাইল মিগুয়েল

@ ইসমাইল মিগুয়েল পিএইচপি 5.6 পিএইচপি এর শেষ সংস্করণ, আমাকে আরও কিছু বলতে হবে না। যদি প্রায় প্রত্যেকেই একটি পুরানো সংস্করণ ব্যবহার করে এবং সংখ্যাগরিষ্ঠ কোনও অপ্রচলিত ব্যবহার করে তবে এটি আমার দোষ নয়। $r=str_repeatকৌতুক জন্য ধন্যবাদ । আমি কেবল $r='str_repeat';এমনই ভাবছিলাম যা কোন বাইট সংরক্ষণ করছিল না। অপরিবর্তিত ধ্রুবকটিও একটি ভাল কৌশল, ভাল কাজ;)। একটি নিউলাইন হ'ল লেখার চেয়ে এক বাইট ছোট \n, তাই আমি এটি রেখে দিয়েছি, তবে এর সাথে সংক্ষেপণ এড়াতে আমি ডাবল উদ্ধৃতি ব্যবহার করেছি $0। আবার ধন্যবাদ !
ব্ল্যাকহোল

এটি কেবল আপনার ভাল লাগবে। আমি যদি সচেতন না 3 ** $iথাকি তবে আমি বলব যে আপনার কাছে একটি ভয়ানক বাক্য গঠন রয়েছে। আপনি যে সংশোধন ঠিকানা করতে পারেন। আমি এই সম্পর্কে কেবল বলছি এবং তা নয় [1]কারণ এটি পিএইচপি 5.4 থেকে এসেছে, যা বেশ 'পুরানো'। 1 বছর আগে, আমি আপনাকে এটি নির্দিষ্ট করতে বলব। আজ, আমি আপনাকে কেবল এটি নির্দিষ্ট করতে (খুব স্বল্প লাইনে) নির্দিষ্ট করতে বলি। কোড সম্পর্কে বলতে গিয়ে, আপনার সাথে এখনও ++$i<=$nপ্রতিস্থাপন করা যেতে পারে $n>$i++। এটি পরীক্ষা করার জন্য আমাকে আপনার সমস্ত কোড পিএইচপি 5.3 এ রূপান্তর করতে হয়েছিল। যা বেদনাদায়ক ছিল। তবে আমি দেখতে পেয়েছি আপনি এখন পর্যন্ত 7 বাইট খেয়েছেন।
ইসমাইল মিগুয়েল

3

সি, 165

#define W while
f(n){int i=n+1,j=1<<i,k=1,l,r,s,t;W(i--)k*=3;l=k-j;W(--j){r=j,s=1;W(!(r%2))r/=2,s*=3;l-=s;t=l;W(t--)putchar(32);W(++t<s)putchar(88);putchar('\n');}}

এখানে একই কোডটি আনপ্যাক এবং সামান্য পরিষ্কার করা হয়েছে:

int f(int n) {
    int i=n+1, j=1<<i, k=1;
    while (i--) k*=3;
    int l=k-j;
    while (--j) {
        int r=j,s=1;
        while (!(r%2))
            r/=2, s*=3;
        l-=s;
        int t=l;
        while (t--) putchar(' ');
        while (++t<s) putchar('X');
        putchar('\n');
    }
}

এটি FUZxxl এর সমস্যার সমাধান হিসাবে, সারিগুলির জন্য নিখুঁত ফর্মের পরিবর্তে একটি স্পষ্টত ব্যবহারের একই ধারণাটির ভিত্তিতে। J এর ঘোষণাপত্র এটি 2 ^ (n + 1) এ সেট করে এবং প্রথম যখন লুপের গণনাগুলি কে = 3 ^ (এন + 1); তারপরে l = 3 ^ (n + 1) -2 ^ (n + 1) সিঁড়ির মোট প্রস্থ (এটি প্রমাণ করা খুব কঠিন নয়)। এরপরে আমরা 1 থেকে 2 all (n + 1) -1 পর্যন্ত সমস্ত সংখ্যার মধ্য দিয়ে যাই; প্রত্যেকের জন্য, যদি এটি 2 (exactly n) দ্বারা বিভাজ্য হয় তবে আমরা s = 3 ^ n 'এক্স এর প্রিন্ট করার পরিকল্পনা করব। আমরা সঠিক স্থান থেকে শুরু করব তা নিশ্চিত করার জন্য l সামঞ্জস্য করা হয়েছে: আমরা l স্পেস এবং এর এক্স লিখি, তারপরে একটি নতুন লাইন।


যখন ডাব্লু টু; সংজ্ঞায়িত করুন এবং কিছু অক্ষর সংরক্ষণ করতে ইন্টিট বাদ দিন।
FUZxxl

এছাড়াও কিছু সাশ্রয়ের জন্য t = l- = গুলি।
FUZxxl

@ ফুজএক্সএক্সএক্সএলএল আমি উভয়ের চেষ্টা করেছিলাম, তবে সি এখনও ফাংশনগুলিতে অন্তর্নিহিত ধরণের অনুমতি দেয় যদিও এটি তাদেরকে 'ক্লাসিক' পতাকা (কমপক্ষে জিসিসিতে) দিয়েও পরিবর্তনশীল ঘোষণাপত্রের অনুমতি দেয় না। এবং আমি # ডিফাইন ডাব্লু চেষ্টা করেছিলাম এবং যখন এটি এর যত্ন নেবে বলে মনে হয় না, যদিও আমি সংজ্ঞায় পিছলে যেতে পারি।
স্টিভেন স্টাডনিকি

এইচএম ... আমি মনে করি আপনি কেবল বৈশ্বিক ভেরিয়েবলের প্রকারটি বাদ দিতে পারেন। এটি আপনাকে খুব একটা এনে দেয় না। আপনি (*p)()=putchar;কল putcharহিসাবে শুরুতে যোগ করার চেষ্টা করতে পারেন p। আমি মনে করি এটি কাজ করা উচিত।
FUZxxl

2

সিজেম, 46 43 41 39 36 35 বাইট

L0ri),(a*+_W%(;+{3\#'x*+_,S*}%$1>N*

এখনই আলাদা পদ্ধতি ব্যবহার করে আপডেট করুন


পুরানো পদ্ধতির:

]ri){3f*_,)"x"a*\]z:+}*_s,f{1$,U+:U-S*\N}

বেশ নির্বোধ এবং দীর্ঘ, তবে কিছু শুরু করার জন্য।

আমি এটি গল্ফ একবার ব্যাখ্যা যোগ করবে।

এটি এখানে অনলাইনে চেষ্টা করুন


কিছু কাজ প্রয়োজন বলে মনে হচ্ছে। N = 4, 5, 17- এর জন্য সঠিকভাবে কাজ করে নি the এন = 17 এর সাহায্যে এটি স্ক্রিনে কোড ফেলে দেয় এবং নীচে এক্স এর সাথে পূরণ করে।
ডেভিডসি

1
4 ডেভিডকার্যাহার 4, 5 এর জন্য আমি মনে করি এটি কেবল লাইন মোড়ানো। আপনি যদি কোনও রেখা মোড়ানো না করে কোনও পাঠ্য সম্পাদককে আউটপুট অনুলিপি করেন তবে তা আমার কাছে ঠিক আছে বলে মনে হচ্ছে।
Sp3000

ঠিক আছে. আমি জানি জানি।
ডেভিডসি

2

জাভা, 271 269 ​​বাইট

গ্রিসের পদ্ধতি ব্যবহার করে।

import java.util.*;String a(int a){List<Integer>b=new ArrayList<>();int c=-1,d=1;for(;c++<a;b.add(d),b.addAll(b),b.remove(b.size()-1),d*=3);String f="";for(;b.size()>0;f+="\n"){d=b.remove(b.size()-1);for(int g:b)for(c=0;c<g;c++)f+=' ';for(c=0;c<d;c++)f+='x';}return f;}

ইন্ডেন্টযুক্ত:

import java.util.*;
String a(int a){
    List<Integer>b=new ArrayList<>();
    int c=-1,d=1;
    for(;c++<a;b.add(d),b.addAll(b),b.remove(b.size()-1),d*=3);
    String f="";
    for(;b.size()>0;f+="\n"){
        d=b.remove(b.size()-1);
        for(int g:b)
            for(c=0;c<g;c++)
                f+=' ';
        for(c=0;c<d;c++)
            f+='x';
    }
    return f;
}

কোন পরামর্শ স্বাগত।

2 বাইট mbomb007 ধন্যবাদ


আপনি 2 বাইট সংরক্ষণের b.size()>0পরিবর্তে ব্যবহার করতে পারেন !b.isEmpty()
mbomb007

1

পার্ল, 62

#!perl -p
eval's/x+/$&$&$&
x/g,s/\d*/x
/;'x++$_;s/x+/$"x$'=~y!x!!.$&/ge

প্রথমে অগ্রণী স্থানগুলি অগ্রণী স্থান ছাড়াই গণনা করে। তারপরে xবাকী স্ট্রিংয়ের অক্ষরের সংখ্যা অনুযায়ী প্রতিটি লাইনের আগে এগুলি যুক্ত করুন ।


1

জাভাস্ক্রিপ্ট (ES6) 104 106 118

সম্পাদনা করুন (অন্যান্য অনেক উত্তর মত) রিকার্সিভ ফাংশন, প্রতিটি লাইন জন্য '*' তালিকাটি iteratively এই প্রাপ্ত হয় সরানো হয়েছে, বিট এবং 3 এর ক্ষমতা তুচ্ছ
লুপ ভিতরে, একটি একাধিক লাইন স্ট্রিং নিচ থেকে buuilt, একটি চলমান গণনা পালন প্রতিটি লাইনে যোগ করার জন্য শীর্ষস্থানীয় স্পেস of

F=n=>{
  for(i=a=s='';++i<2<<n;a=s+'*'.repeat(t)+'\n'+a,s+=' '.repeat(t))
    for(t=u=1;~i&u;u*=2)t*=3;
  return a
}

প্রথমে সরানোর চেষ্টা করুন

রিকার্সিভ আর ফাংশন প্রতিটি লাইনের জন্য '*' সংখ্যা সহ একটি অ্যারে তৈরি করে। উদাহরণস্বরূপ আর (২) হ'ল [1, 3, 1, 9, 1, 3, 1]
এই অ্যারেটি প্রতিটি লাইনে যোগ করার জন্য শীর্ষস্থানীয় স্থানগুলির একটি চলমান গণনা রেখে নিচ থেকে একাধিক স্ট্রিং তৈরি করতে স্ক্যান করা হয়

F=n=>
(R=n=>[1].concat(...n?R(n-1).map(n=>[n*3,1]):[]))(n)
.map(n=>a=' '.repeat(s,s-=-n)+'*'.repeat(n)+'\n'+a,a=s='')
&&a 

টেস্ট সালে ফায়ারফক্স / ফায়ারবাগ কনসোলটি

F(3)

আউটপুট

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

1

আর - 111 টি অক্ষর

সরলভাবে বাস্তবায়ন, পুনরাবৃত্তভাবে অ্যারে তৈরি করা এবং এটি ধীরে ধীরে ধ্বংস করা।

n=scan()
a=1
if(n)for(x in 1:n)a=c(a,3^x,a)
for(A in a){cat(rep(' ',sum(a)-A),rep('x',A),'\n',sep='');a=a[-1]}

ব্যবহার:

> source('devil.r')
1: 2
2: 
Read 1 item
                  x
               xxx
              x
     xxxxxxxxx
    x
 xxx
x

ভাল পয়েন্ট, আমার কোডটি পরিবর্তন করেছে যাতে এটি nকমান্ড লাইন থেকে আর্গুমেন্ট গ্রহণ করে
koekenbakker

1
আপনি STDIN থেকে পড়ে 8 বাইট সংরক্ষণ করুন save n=scan()
অ্যালেক্স এ।

xএটি কার্সর হিসাবে ব্যবহার করার জন্য আপনাকে ঘোষণা করার দরকার নেই, আপনার প্রয়োজনও নেই if(n)। এছাড়াও, লাইন ব্রেকগুলি এমন একটি চরিত্র হিসাবে আমার মনে হয় count
freekvd

ধন্যবাদ, আপনি ঠিক বলেছেন xif(n)তবে সম্পর্কে নিশ্চিত না । আমি মামলাটি মোকাবেলায় সেই অংশটি যুক্ত করেছি n=0if(n)তারপর ফেরৎ Fতাই একটি একক ফেরৎ x। আমি যদি এটি অপসারণ করি n=0তবে অযাচিত ফলাফল দেয়। এখানে নতুন, তাই লাইন ব্রেক সম্পর্কে জানতাম না। এখন অন্তর্ভুক্ত!
koekenbakker

আপনি যদি এটিতে a=0লুপ সেট এবং শুরু করেন তবে x in 0:nএটি n = 0 এর জন্যও কাজ করে। তারপরে আপনি বাদ দিতে পারেন if(n)
freekvd

0

রুবি, 93

f=->n{s,p,k=[1],1;n.times{s=s+[p=p*3]+s};k=s.dup;k.each{m=s.pop;puts' '*s.reduce(0,:+)+?x*m}}

এটি গ্রিসির মতো একই পদ্ধতির ব্যবহার করে।

আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.