বিভাজক স্কাইলাইন


46

যেকোন ধনাত্মক পূর্ণসংখ্যার জন্য k, d(k)বিভাজকের সংখ্যা বোঝাতে দিন k। উদাহরণস্বরূপ, d(6)হয় 4, কারণ 6রয়েছে 4ভাজক (যথা 1, 2, 3, 6)।

একটি ধনাত্মক পূর্ণসংখ্যা দেওয়া N, একটি নির্দিষ্ট অক্ষর, যেমন যে "বিল্ডিং" অনুভূমিক অবস্থানে অবস্থিত উচ্চতা ব্যবহার করে একটি "দিগন্ত" হওয়া ASCII শিল্প প্রদর্শন kহয় d(k)জন্য k = 1, ..., N। নীচে পরীক্ষার কেসগুলি দেখুন।

বিধি

  • কোনও অ-শ্বেতস্থান অক্ষর ধারাবাহিকভাবে ব্যবহার করা যেতে পারে, #পরীক্ষার ক্ষেত্রে যেমন দেখানো হয় তা অগত্যা ।
  • অ্যালগরিদম তাত্ত্বিকভাবে নির্বিচারে উচ্চতর জন্য কাজ করা উচিত N। অনুশীলনে, প্রোগ্রামটি সময়, মেমরি, ডেটা-টাইপ আকার বা স্ক্রিন আকারের দ্বারা সীমাবদ্ধ থাকলে তা গ্রহণযোগ্য।
  • অনুভূমিকভাবে বা উল্লম্বভাবে নেতৃত্বাধীন বা পিছনের স্থানগুলি বা নতুন লাইনের অনুমতি রয়েছে।
  • ইনপুট এবং আউটপুট যে কোনও যুক্তিসঙ্গত উপায়ে নেওয়া যেতে পারে ।
  • কোনও প্রোগ্রামিং ভাষায় প্রোগ্রাম বা ফাংশন অনুমোদিত । স্ট্যান্ডার্ড সমস্যা নিষিদ্ধ করা হয়।
  • বাইটস মধ্যে সংক্ষিপ্ত কোড।

পরীক্ষার মামলা

N = 10:

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

N = 50:

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

N = 200:

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

উত্তর:


12

জেলি , 9 বাইট

0পরিবর্তে ব্যবহার করে #

RÆD0ṁz⁶ṚY

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


2
5 মিনিট 10 সেকেন্ড :-)
লুইস মেন্ডো

13
আমি এর মধ্যে অন্য জিনিসগুলি পড়ছিলাম ... আমি পরের বারে আরও দ্রুত হব।
Leaky নুন


7

অক্টাভা, 41 40 32 বাইট

@ স্টেভিগ্রিফিনকে ধন্যবাদ 8 টি বাইট সংরক্ষণ

@(N)" #"(sort(~mod(k=1:N,k'))+1)

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

পূর্ববর্তী উত্তর:

@(N)" #"(sort(~bsxfun(@mod,k=1:N,k')+1))

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

@(N)" #"(sort(ismember((k=1:N)./k',k))+1)

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

ব্যাখ্যা:

N=5;
d = (1:N)./(1:N)'    %divide each of numbers from 1 to N by 1 to N 
                     %a [N by N] matrix created
d =

   1.00   2.00   3.00   4.00   5.00
   0.50   1.00   1.50   2.00   2.50
   0.33   0.66   1.00   1.33   1.66
   0.25   0.50   0.75   1.00   1.25
   0.20   0.40   0.60   0.80   1.00

m = ismember(d,1:N)      %find divisors of each number
m =

  1  1  1  1  1
  0  1  0  1  0
  0  0  1  0  0
  0  0  0  1  0
  0  0  0  0  1

idx = sort(m)                  %sort the matrix

idx =

  0  0  0  0  0
  0  0  0  0  0
  0  0  0  1  0
  0  1  1  1  1
  1  1  1  1  1

" #"(idx+1)     %replace 0 and 1 with ' ' and '#' respectively


   #
 ####
#####

1
খুব সুন্দর পদ্ধতির!
লুইস মেন্ডো

2
অক্টাভা সিঙ্গেলটন সম্প্রসারণ নিখুঁতভাবে সম্পাদন করে, তাই @(N)" #"(sort(~mod(k=1:N,k')+1))আপনাকে কয়েকটি বাইট সাশ্রয় করে :) আপনি শীর্ষস্থানীয় নিউলাইনগুলি একটি গোষ্ঠী পান তবে, এই বিষয়ে নিয়মগুলি কী তা আমি নিশ্চিত নই।
স্টিভি গ্রিফিন

1
একই bytecount (32): @(N)['',35*sort(~mod(k=1:N,k'))]
স্টিভি গ্রিফিন

@ স্টেভিগ্রিফিন ধন্যবাদ! আমি এই বৈশিষ্ট্য সম্পর্কে সচেতন ছিলাম না। কি mod(1:N,(1:N).') ম্যাটল্যাব গ্রহণযোগ্য?
rahnema1

2
আমি মনে করি এটি R2016b হিসাবে সম্ভব , তবে দুর্ভাগ্যক্রমে আমি নিজে এটি পরীক্ষা করতে পারি না, যেহেতু আমার কাছে তা নেই।
স্টিভি গ্রিফিন

6

হাস্কেল , 71 বাইট

fনেয় Intএবং ফেরত দেয় a String

f m|l<-[1..m]=unlines[[last$' ':drop(m-i)['#'|0<-mod n<$>l]|n<-l]|i<-l]

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

  • mহয় Nওপি এর (Haskell, ভেরিয়েবল ছোট হাতের অক্ষরে ইন করতে হবে।)
  • l=[1..m]সমস্ত সারি, কলাম এবং সম্ভাব্য বিভাজকগুলির মাধ্যমে পুনরাবৃত্তি করার জন্য নেস্টেড তালিকা বোঝার ক্ষেত্রে সংক্ষিপ্তসারটি ব্যবহৃত হয়। এর অর্থ হোয়াইটস্পেসে ভরা কিছু অতিরিক্ত প্রাথমিক সারি।
  • nকলামটি (এছাড়াও সংখ্যাটি পরীক্ষিত), iসারি।
  • ['#'|0<-mod n<$>l]'#'বিভাজকের সংখ্যা সহ দৈর্ঘ্যের অক্ষরের একটি তালিকা n

6

অক্টাভা, 61 বাইট

for i=1:input(''),p(1:nnz(~rem(i,1:i)),i)=35;end,[flip(p),'']

ব্যাখ্যা:

for i=1:input('')         % Loop, for i from 1 to the input value
 p(1:nnz(~rem(i,1:i)),i)=35;end,[flip(p),'']   
% Breakdown:
         ~rem(i,1:i)      % Return true if the remainder of i divided by any of the values
                          % in the vector 1 - i
     nnz(~rem(i,1:i))     % Check how many of them are non-zero
 p(1:nnz(~rem(i,1:i)),i)=35;end   % Assign the value 35 (ASCII for #) to rows 1
                                  % to the number of divisors of i, in column i
end,              % End loop
[flip(p),'']      % Flip the matrix, and concatenate it with the empty string

আমি কয়েকটি বিষয় হাইলাইট করতে চাই

  • লুপের মধ্যে সরাসরি ইনপুট নেয়
    • কোনও ভেরিয়েবলকে ইনপুট মান বরাদ্দ করে না
  • কোনও অ্যারে শুরু করে না
    • এটি ফ্লাইতে তৈরি করে, প্রয়োজনীয় হিসাবে কলাম এবং সারি যুক্ত করে
  • স্বয়ংক্রিয়ভাবে ASCII- মান 0 সাদা স্থানের (ASCII-32) কাস্ট করে

লুপের ভিতরে কী ঘটে (ধরুন ইনপুট 6)

p =  35
p =
   35   35
    0   35
p =
   35   35   35
    0   35   35
p =
   35   35   35   35
    0   35   35   35
    0    0    0   35
p =
   35   35   35   35   35
    0   35   35   35   35
    0    0    0   35    0
p =
   35   35   35   35   35   35
    0   35   35   35   35   35
    0    0    0   35    0   35
    0    0    0    0    0   35

  1. একক 35 হিসাবে শুরু
  2. 2 টি বিভাজনকারীদের জন্য জায়গা তৈরি করতে একটি কলাম এবং একটি সারি প্রসারিত
  3. 3 (মাত্র দুটি বিভাজক) এর জন্য জায়গা তৈরি করতে একটি কলাম প্রসারিত করা হয়
  4. 3 টি বিভাজক ( 1,2,4) এর জন্য জায়গা তৈরি করতে একটি কলাম এবং একটি সারি প্রসারিত
  5. একটি কলাম প্রসারিত, 5 জন্য জায়গা করতে
  6. 4 টি বিভাজক ( 1,2,3,6) এর জন্য জায়গা তৈরি করতে একটি কলাম এবং এক সারি প্রসারিত

অবশেষে আমরা এটা টুসকি, এবং একটি স্ট্রিং এটি পরিবর্তন করে, পরোক্ষভাবে পরিবর্তন 0করতে 32:

warning: implicit conversion from numeric to char
ans =
     #
   # #
 #####
######


5

এপিএল (ডায়ালগ) , 19 বাইট

⊖⍉↑'#'⍴¨⍨+⌿0=∘.|⍨⍳⎕

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

 মূল্যায়ন ইনপুট ( এন ) পান

 1 ... এন

∘.|⍨ 1 ... N উভয় উল্লম্ব এবং অনুভূমিক অক্ষ হিসাবে বিভাজন বাকী টেবিল

0= যেখানে শূন্যের সমান (যেমন এটি ভাগ হয়)

+⌿ কলামগুলি যোগ করুন (অর্থাত প্রতিটি সংখ্যার জন্য বিভাজকের গণনা দেয়)

'#'⍴¨⍨ হ্যাশ অক্ষরটি পুনরায় আকার দেওয়ার জন্য প্রতিটি সংখ্যা ব্যবহার করুন (স্ট্রিংয়ের তালিকা দেয়)

 মিশ্রণ (সারি সারণিতে স্ট্রিংগুলির তালিকা)

 TRANSPOSE

 উল্টে উল্টানো


5

গণিত, 59 57 বাইট

Rotate[Grid@Map[X~Table~#&,0~DivisorSigma~Range@#],Pi/2]&

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


পিপিসিজিতে উত্তর দেওয়ার জন্য স্বাগতম, সহকর্মী লেগো মিনিফিগ :-)
লুইস মেন্ডো

1
এখন আর ফিরে নেই ...
লুইস মেন্ডো

স্বাগত! আরও একটি ম্যাথমেটিকা ​​গল্ফার দেখে ভাল লাগল। এই উত্তরটি সম্পূর্ণরূপে বৈধ নয় কারণ আপনি স্নিপেটে ইনপুটটিকে হার্ডকড করেছেন। উত্তরের পূর্ণ প্রোগ্রাম বা কলযোগ্য ফাংশন (যা নামবিহীন হতে পারে) হওয়া দরকার। তাই এই প্রতিস্থাপন কোন খরচ সংশোধন করা যেতে পারে 50সঙ্গে #এবং সংযোজন &। আপনি ইনফিক্স স্বরলিপি সহ কিছু বাইটগুলিও সংরক্ষণ করতে পারেন: X~Table~#&এবং0~DivisorSigma~Range@#
মার্টিন ইন্ডার

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

আমি অনেক ভেবে দেখলাম. এটি গাল মন্তব্যে আরও জিহ্বা ছিল। বিভ্রান্তির জন্য দুঃখিত.
ইয়ান মিলার

5

সি #, 333 281 বাইট

using System.Linq;using C=System.Console;class P{static void Main(){var n=int.Parse(C.ReadLine());var v=new int[n];for(var k=2;k<=n;k++)for(var i=1;i<k;i++)if(k%i==0)v[k-1]++;for(var i=0;i<v.Length;i++)for(var u=v.Max()-v[i];u<v.Max();u++){C.SetCursorPosition(i,u);C.Write("#");}}}

লাইন বিরতি সহ:

using System.Linq;
using C = System.Console;

class P
{
    static void Main()
    {
        var n = int.Parse(C.ReadLine());
        var v = new int[n];
        for (var k = 2; k <= n; k++)
            for (var i = 1; i < k; i++)
                if (k % i == 0)
                    v[k - 1]++;
        for (var i = 0; i < v.Length; i++)
            for (var u = v.Max() - v[i]; u < v.Max(); u++)
            {
                C.SetCursorPosition(i, u);
                C.Write("#");
            }
    }
}

যদিও আমি নিশ্চিত যে এটিও সম্ভব সংক্ষিপ্ত, তবুও আমি আশা করি আমরা একসাথে আরও একটি ছোট সমাধান অর্জন করব;)

রাজনাগুলের সাহায্যে 52 বাইট সংরক্ষণ করা হয়েছে


1
আপনি যদি তালিকার পরিবর্তে কোনও আন্ত-অ্যারে ব্যবহার করেন তবে আপনি- usingস্টেটমেন্ট থেকে প্রচুর বাইট সংরক্ষণ করতে পারেন ।
রাজনগুল

@ রজনগুল এটি আপডেট করেছে।
মেটালাকন

২২২ বাইট: using System.Linq;using C=System.Console;n=>{var v=new int[n];for(var k=1,i;++k<=n;)for(i=1;i<k;)if(k%i++==0)v[k-1]++;for(var i=0,u;i<v.Length;i++)for(u=v.Max()-v[i];u<v.Max();){C.SetCursorPosition(i, u++);C.Write("#");}};একটিতে সংকলন করুন Action, বর্ধিত স্থানগুলি এবং অন্যান্য কয়েকটি ছোট ছোট টুইটগুলি সরান। আমি এটি পরীক্ষা করিনি তবে এটি কাজ করা উচিত।
TheLethalCoder

@TheLethalCoder আমি এটি পরীক্ষা করব / আগামীকাল আমার উত্তর আপডেট করব।
মেটাকলন

5

গণিত, 99 বাইট

{T=DivisorSigma[0,Range@#];Row[Column/@Table[Join[Table[,Max[T]-T[[i]]],$~Table~T[[i]]],{i,1,#}]]}&

এন = 50 এর জন্য

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


কোড চালানোর জন্য কি এই সমস্ত স্পেসগুলি (এবং নিউলাইনগুলি) প্রয়োজনীয়? আমি নিজে কখনও ম্যাথমেটিকাকে প্রোগ্রামিং করি নি, তবে বেশিরভাগ ভাষায় আপনি প্রায় সমস্ত জায়গাগুলি সরিয়ে ফেলতে পারেন।
কেভিন ক্রুইজসেন

এটি আমার প্রথম গল্ফ টিপসের জন্য ধন্যবাদ
J42161217

2
কোনও সমস্যা নেই, এবং পিপিসিজিতে আপনাকে স্বাগতম! আপনি এখনো থাকে, তাহলে আপনি পেতে পারে মধ্যে golfing <সমস্ত ভাষা> জন্য টিপস এবং ম্যাথামেটিকাল মধ্যে golfing জন্য টিপস আকর্ষণীয় মাধ্যমে পড়তে। :) উপভোগকর তোমার থাকা.
কেভিন ক্রুইজসেন

বাইরের কোঁকড়া ধনুর্বন্ধনীগুলি আউটপুট প্রদর্শিত না হওয়া থেকে বৃত্তাকার বন্ধনীগুলিতে পরিবর্তন করা যেতে পারে এবং আপনি 2 বাইট সংরক্ষণ করতে কিছু ইনফিক্স / প্রিফিক্স সিনট্যাক্স ব্যবহার করতে পারেন:(T=0~DivisorSigma~Range@#;Row[Column/@Table[Join[Table[,Max@T-T[[i]]],$~Table~T[[i]]],{i,1,#}]])&
নম্বরমানিয়াক

5

কাঠকয়লা , 23 22 20 বাইট

F…·¹N«Jι⁰Fι¿¬﹪ι⁺κ¹↑#

এটি অনলাইন চেষ্টা করুন! লিঙ্কটি কোডটির ভার্জোজ সংস্করণ। সম্পাদনা: লুপিং দ্বারা সংরক্ষিত 1 বাইট kথেকে 0থেকে i-1এবং যোগ 1লুপ ভিতরে। ভেরিয়েবলের ইনপুটটি না সঞ্চয় করে আরও দুটি বাইট সংরক্ষণ করা হয়েছে। ব্যাখ্যা:

F…·¹N       for (i : InclusiveRange(1, InputNumber()))
«           {
 Jι⁰         JumpTo(i, 0);
 Fι          for (k : Range(i))
  ¿¬﹪ι⁺κ¹     if (!(i % (k + 1)))
   ↑#          Print(:Up, "#");
            }

সম্পাদনা করুন: এই 18-বাইট "ওয়ান-লাইনার" (লিঙ্কটি কোডের ভার্বোজ সংস্করণে) প্রশ্ন জমা দেওয়ার সময় চারকোলের সংস্করণটির সাথে কাজ করবে না: অনলাইনে চেষ্টা করে দেখুন!

↑E…·¹N⪫Eι⎇﹪ι⁺¹λω#ω


3

05 এ বি 1 ই , 12 বাইট

কোড:

LÑ€g'#×.BøR»

ব্যাখ্যা:

L             # Create the range 1 .. input
 Ñ            # Get the list of divisors of each
  €g          # Get the length of each element
    '#        # Push a hash tag character
      ×       # String multiply
       .B     # Squarify, make them all of equal length by adding spaces
         ø    # Transpose
          R   # Reverse the array
           »  # Join by newlines

05AB1E এনকোডিং ব্যবহার করে । এটি অনলাইন চেষ্টা করুন!


আপনি কি ζপরিবর্তে ব্যবহার করতে পারবেন না .Bø? এছাড়াও, চরিত্রটি থাকতে হবে না#
অলিভার নি

ζতখন আর ছিল না।
ম্যাজিক অক্টোপাস আরন

3

পাইথন 2 , 101 বাইট

N=input();r=range
for i in r(N,0,-1):print''.join('# '[i>sum(x%-~p<1for p in r(x))]for x in r(1,1+N))

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

এটি উল্লম্বভাবে শীর্ষস্থানীয় সাদা স্থান তৈরি করে (প্রচুর পরিমাণে)। এটি মোট Nলাইন মুদ্রণ করে, যার বেশিরভাগ অংশই সাধারণত ফাঁকা থাকবে।


3

জাপট , 34 33 16 14 বাইট

17 বাইট সংরক্ষিত হয়েছে @ ইথ প্রডাকশনগুলির জন্য ধন্যবাদ

õ@'#pXâ l÷z w

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


আপনি কেবল zõ_â lã'#pX÷z w
প্যাডিংটি

স্ট্রিংগুলি স্বয়ংক্রিয়ভাবে প্যাড করে জানতেন না। ধন্যবাদ!
লুক

2

জে , 28 বাইট

[:|:&.|.[('#',@$~1+_&q:)@-i.

একটি monadic ক্রিয়া সংজ্ঞা দেয়। এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

[:|:&.|.[('#',@$~1+_&q:)@-i.  Input is y.
                          i.  Range from 0 to y-1
        [                -    subtracted from y (gives range from y to 1).
         (             )@     For each of the numbers:
                   _&q:         Compute exponents in prime decomposition,
                 1+             add 1 to each,
          '#'  $~               make char matrix of #s with those dimensions,
             ,@                 and flatten into a string.
                              The resulting 2D char matrix is padded with spaces.
[:|:&.|.                      Reverse, transpose, reverse again.



2

এলিস , 33 বাইট

I.!.t&w?t!aot&wh.Bdt.?-ex' +o&;k@

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

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

/
ki@/.!.t&w?t!aot&wh.Bdt.?-ex' +o&;

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

আউটপুটে নন-হোয়াইটস্পেস অক্ষর !

দ্রষ্টব্য যে সমাধানটি এক টন শীর্ষস্থানীয় শ্বেতস্পেসকেও মুদ্রণ করে (এটি সর্বদা একটি খালি লাইন দিয়ে শুরু হয় এবং তারপরে একটি NxNগ্রিড প্রিন্ট করে তাই বৃহত্তর জন্য N, প্রথম সারির আগে অনেকগুলি ফাঁকা স্থান থাকবে !))

ব্যাখ্যা

আমি নির্মাণটির &w...kআগে ব্যবহার এবং ব্যাখ্যা করেছি (উদাহরণস্বরূপ এখানে )। এটি একটি ঝরঝরে ছোট্ট আইডিয়োম যা পূর্ণসংখ্যা n টিপ দেয় এবং তারপরে এন + 1 বার একটি কোড চালায় (ফলস্বরূপ, এটি সাধারণত t&w...kলুপ এন বার চালানোর জন্য ব্যবহৃত হয় , tইনপুট মান হ্রাস করার সাথে ) ment এটি রিটার্ন অ্যাড্রেস স্ট্যাক (আরএএস) দিয়ে কাজ করে করা হয় । wবর্তমান আইপি ঠিকানাটি আরএএস-তে চাপ দেয় এবং আমরা যদি এটির সাথে পুনরাবৃত্তি করি &তবে ঠিকানাটি এন বারে ধাক্কা দেয় । kআরএএস থেকে একটি ঠিকানা পপ করে এবং সেখানে ফিরে আসে। যদি আরএএস ফাঁকা থাকে তবে এটি কিছুই করে না এবং লুপটি বেরিয়ে আসে।

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

সুতরাং এই নির্মাণ:

&wX&wYk

একটি কাজের নেস্টেড লুপ যা XYYYXYYYXYYY...( Yপ্রতিটি পুনরাবৃত্তিতে কয়েকটি সংখ্যার জন্য ) চালায় । এটি বেশ ঝরঝরে যে আমরা উভয় লুপগুলিকে একটি একক দিয়ে শেষ করতে পারি k, কারণ এটি প্রতিটি সময় অভ্যন্তরীণ ঠিকানাগুলি হ্রাস করার পরে আরএএস থেকে একটি বহিরাগত ঠিকানা গ্রহণ করবে।

এই আইডিয়ামটি প্রোগ্রামটিতে আউটপুট গ্রিডের উপর লুপ চালাতে ব্যবহৃত হয়।

I         Read a character and push its code point as input N.
.!        Store a copy on the tape.
.         Make another copy.
t&w       Run this outer loop N times. This loops over the lines of the
          output, so the current iteration corresponds to a divisor count
          no more than i (i counting down from N).
  ?t!       Decrement the value on the tape. That means we'll actually have
            i-1 on the tape during the iteration.
  ao        Print a linefeed. Doing this now leads to the weird leading linefeed, 
            but it's necessary for the &w...&w...k pattern.
  t&w       Remember that we still have a copy of N on the stack. We'll also
            ensure that this is the case after each loop iteration. So this
            also runs the inner loop N times. This iterates over the columns
            of the output grid so it's j that goes from 1 to N and corresponds
            to the number whose divisors we want to visualise.
              At this point the stack will always be empty. However, operating
              on an empty stack works with implicit zeros at the bottom of
              the stack. We'll use the top zero to keep track of j.
    h         Increment j.
    .B        Duplicate j and push all of its divisors.
    dt        Push the stack depth minus 1, i.e. the divisor count of j.
    .         Duplicate the divisor count.
    ?-        Retrieve i-1 from the tape and subtract it. So we're computing
              d(j)-i+1. We want to output a non-whitespace character iff this
              value is positive (i.e. if i is no greater than d(j)).
    ex        Extract the most significant bit of this value. This is 1 for
              all positive values and 0 for non-positive ones. It's the shortest
              way (I believe) to determine if a value is positive.
    ' +       Add this to the code point of a space. This gives a 33, or '!',
              if the cell is part of the skyline.
    o         Output the character.
    &;        We still have all the divisors and the divisor count on the stack.
              We pop the divisor count to discard that many values (i.e. to
              get rid of the divisors again).
k         Return to the appropriate loop beginning to run the continue the
          nested loop.
@         Terminate the program.

1
কোন একক লাইনের সাথে প্রথম এলিস প্রোগ্রাম? :-)
লুইস মেন্ডো

1
@ লুইসমেন্দো না, আমি মনে করি লিও কয়েকটি কার্ডিনাল-কেবল প্রোগ্রাম লিখেছেন (এবং সম্ভবত আমারও আছে ... উদাহরণস্বরূপ কুইন এবং হ্যালো, ওয়ার্ল্ড)। সম্ভবত সবচেয়ে বিস্তৃত একক-লাইন প্রোগ্রাম। :)
মার্টিন এন্ডার

হুম, আমার সমাধান "টোন শীর্ষস্থানীয় হোয়াইটস্পেস" ট্রিক দিয়ে কিছু বাইট সংরক্ষণ করতে পারে
কুইন্টোপিয়া

2

আসলে , 25 বাইট

R♂÷♂l;M' *╗⌠'#*╜@+⌡M┬♂ΣRi

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

প্রচুর শীর্ষস্থানীয় নিউলাইনগুলি সহ 22-বাইট সংস্করণ

;╗R⌠÷l'#*╜' *@+⌡M┬♂ΣRi

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


ঠিক আছে, গিথুব এর রিডমে আপডেট করা উচিত ÷ l স্ট্যান্ডার্ড বিভাজক গণনা ক্রিয়াকলাপ হিসাবে অন্তর্ভুক্ত ...
কুইন্টোপিয়া

2

আর, 83 82 বাইট

-1 বাইট ধন্যবাদ মিকিটি কে

N=scan();m=matrix('#',N,N);for(i in 1:N)m[i,1:sum(i%%1:N>0)]=' ';write(m,'',N,,'')

স্টিডিনের Nকাছ থেকে পড়ে।

N=scan()                        # read N
m=matrix('#',N,N)               # make an NxN matrix of '#' characters
for(i in 1:N)                   # for each integer in the range
    m[i,1:sum(i%%1:N!=0)]=' '   # set the first n-d(n) columns of row i to ' '
write(m,'',N,,'')               # print to console with appropriate formatting

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


1
!=0হতে পারে>0
মিকিটি


1

স্পেসবিএএস - 149 বাইট

1 INPUT n: DIM h(n)
2 FOR i=1 TO n
3 FOR j=1 TO i
4 h(i)+=(i MOD j=0)
5 NEXT j
6 NEXT i
7 FOR i=1 TO n
8 FOR j=51-h(i) TO 50
9  ?AT j,i;"#"
10 NEXT j
11 NEXT i

একটি অ্যারে বিভাজকের সংখ্যা ট্র্যাক করে রাখে, তারপরে স্ক্রিনের অবস্থান 50 এ অক্ষরের সঠিক সংখ্যাটি মুদ্রণ করে।

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


1

পিএইচপি, 99 বাইট

for(;$d<$k?:$k++<$argn+$d=$n=0;)$k%++$d?:$r[--$n]=str_pad($r[$n],$k).H;ksort($r);echo join("
",$r);

একটি শীর্ষস্থানীয় স্থান মুদ্রণ; পাইপ হিসাবে চালান php -nr '<code>'বা এটি অনলাইনে চেষ্টা করুন

ভাঙ্গন

for(;$d<$k?:                    # inner: loop $d from 1 to $k
    $k++<$argn+$d=$n=0;)        # outer: loop $k from 1 to $argn, reset $d and $n
    $k%++$d?:                       # if $d divides $k
        $r[--$n]=str_pad($r[$n],$k).H;  # add one store to building $k
ksort($r);echo join("\n",$r);   # reverse and print resulting array

1

পাওয়ারশেল, 101 বাইট

((($d=1.."$args"|%{($x=$_)-(1..$_|?{$x%$_}).Count})|sort)[-1])..1|%{$l=$_;-join($d|%{' #'[$_-ge$l]})}

কম গল্ফ পরীক্ষা স্ক্রিপ্ট:

$f = {

$d=1.."$args"|%{
    ($x=$_)-(1..$_|?{$x%$_}).Count
}                                     # $d is the Divisor count array
$maxHeight=($d|sort)[-1]
$maxHeight..1|%{
    $l=$_
    -join($d|%{' #'[$_-ge$l]})
}

}

@(
    ,(10, 
    "     # # #",
    "   # # ###",
    " #########",
    "##########")

    ,(50, 
    "                                               #  ",
    "                                   #           #  ",
    "                       #     #     #   # #     #  ",
    "                       #     #     #   # #     #  ",
    "           #     # #   #   # # #   #   # # ##  # #",
    "           #   # # #   #   # # #   #   # # ##  # #",
    "     # # # # ### # ### # ### # ##### ### # ### # #",
    "   # # ### # ### # ### ##### # ##### ### # ### ###",
    " #################################################",
    "##################################################")

    ,(200,
    "                                                                                                                                                                                   #                    ",
    "                                                                                                                                                                                   #                    ",
    "                                                                                                                       #                                               #           #                    ",
    "                                                                                                                       #                       #                       #           #                    ",
    "                                                                                                                       #                       #                       #           #           #        ",
    "                                                                                                                       #                       #                       #           #           #        ",
    "                                                           #           #           #     #     #           #           #     #     #       #   #     #     #   #       #           #           #     # #",
    "                                                           #           #           #     #     #           #           #     #     #       #   #     #     #   #       #           #           #     # #",
    "                                               #           #           #       #   #     #     #           #   #       #     #     #       #   #     #     #   # #     #       #   #           #     # #",
    "                                   #           #           #           #       #   #     #     #   #       #   #       #     #     #       #   #     #     #   # #     #       #   #           #   # # #",
    "                       #     #     #   # #     #     # #   #     #   # #     # #   #   # #     #   # # ##  # # # #     #     # # # #  ## # #   #     # # # #   # #  #  # #   # #   # # # #  ## #  ## # #",
    "                       #     #     #   # #     #     # #   #   # #   # #     # #   #   # #     #   # # ##  # # # #     #     # # # #  ## # #   #     # # # #   # #  #  # #   # #   # # # #  ## #  ## # #",
    "           #     # #   #   # # #   #   # # ##  # # # # #   #  ## # # # #  ## # #   #   # # #   # ### # ##  # # # # ##  #   # # # # #  ## # #   #  ## # ### #   # # ##  # ### ###   # # # # ### #  ## # #",
    "           #   # # #   #   # # #   #   # # ##  # # # # #   #  ## # # # #  ## # ##  #   # # #   # ### # ##  # # # # ##  #   # # # # #  ## # #   #  ## # ### #   # # ##  # ### ###   # # # # ### #  ## # #",
    "     # # # # ### # ### # ### # ##### ### # ### # ### ##### # ##### ### # ##### ### ##### ####### ### # ### # ### ####### ##### ### ##### # ######### # ##### ##### ### # ### ##### # ######### # ### # #",
    "   # # ### # ### # ### ##### # ##### ### # ### ##### ##### # ##### ### # ##### ### ##### ####### ### # ### # ### ############# ### ##### # ######### # ##### ##### ### ##### ##### # ######### # ### # #",
    " #######################################################################################################################################################################################################",
    "########################################################################################################################################################################################################")


) | % {
    $n,$expected = $_
    $result = &$f $n
    "$result"-eq"$expected"
    #$result    # uncomment this to enjoy the view of the Divisor skyline
}

আউটপুট:

True
True
True


1

ওল্ফ্রাম ভাষা (গণিত) , 46 44 বাইট a

Grid[PadLeft[0Divisors@Range@#-" "]+" "]&

এটি অনলাইন চেষ্টা করুন! তবে সম্ভবত এটি অনলাইন চেষ্টা করুন! গ্রিডের পরিবর্তে কলামফর্ম সহ , যেহেতু টিআইওতেGrid কাজ করে না। ম্যাথমেটিকায় এটি আরও ভাল দেখাচ্ছে:

গণিতের আউটপুট

একটি তৃতীয় গণিত সমাধান ... Divisors@Range@#আমরা চাইলে বিভাজনগুলি সন্ধান করি এবং তারপরে আমরা প্রতিটি বিভাজককে সমান করে গুণ করে 0এবং বিয়োগ " "করি -" "

PadLeftবামদিকে শূন্য যুক্ত করে, পাশের একটি স্কাইলাইন তৈরি করে, যার ওরিয়েন্টেশনটি আমরা = দিয়ে ঠিক করি \[Transpose]। সবশেষে, " "সমস্ত কিছু যুক্ত করা সমস্ত প্রবেশকে হয় হয় 0বা হয় " "

বিকল্প হিসাবে, 59-বাইট ""<>Riffle[PadLeft["X"-" "+0Divisors@Range@#]+" ","\n"]&স্ট্রিং আউটপুট উত্পাদন করে।


1

++ , 58 বাইট যুক্ত করুন

D,g,@,FL1+
D,k,@~,J
L,R€gd"#"€*$dbM€_32C€*z£+bUBcB]bR€kbUn

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

কিভাবে এটা কাজ করে

gkgx1nd(x)k

A=[d(1),d(2),d(3),...,d(n)]#Amax(A)Aপ্রতিটি উপাদানটির জন্য এই সংখ্যাটি ফাঁকা করার আগে এবং বারবার হ্যাশগুলিতে ফাঁকাগুলি সংযুক্ত করার আগে এই সর্বোচ্চটি থেকে। এর পরে, আমরা নতুন লাইনে প্রতিটি লাইনে যোগদানের আগে, সারিগুলি স্থানান্তর এবং বিপরীত করি। অবশেষে, আমরা আকাশরেখা আউটপুট।

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