বিকল্প প্যাটার্ন

16

এখন মুছে ফেলা স্ট্যাকওভারফ্লো প্রশ্নে, কেউ নিম্নলিখিত পোস্ট করেছেন:

একটি প্রোগ্রাম বা ফাংশনে পর্যায়ক্রমে নিদর্শন প্রিন্ট করতে লিখুন *এবং #একটি প্রদত্ত পূর্ণসংখ্যা উপর ভিত্তি করে n। কিছু উদাহরণ:

ইনপুট: n=1
আউটপুট:

*

ইনপুট n=5
আউটপুট:

*####
###**
***##
###**
*####

ইনপুট: n=8
আউটপুট:

*#######
######**
***#####
####****
****####
#####***
**######
#######*

যেহেতু এটি দেখতে বেশ দুর্দান্ত কোড-গল্ফিং চ্যালেঞ্জের মতো দেখাচ্ছে, এটি এখানে।

এই নিদর্শনগুলি কীভাবে তৈরি হয়?

প্রথম লাইনটি একক দিয়ে শুরু হয় *, তারপরে n-1পিছনের পরিমাণ #।
দ্বিতীয় লাইনে তখন দুটি থাকে *, এর n-2পরিমাণের পরিমাণ থাকে #।
তৃতীয় লাইনটি তিনটি দিয়ে শুরু হয় *, তারপরে n-3চলার পরিমাণটি #।
প্রভৃতি

একবার আমরা মাঝখানে পৌঁছে গেছি ( n/2), আমরা আবার পরিমাণ গণনা করি *, যা উপরের উদাহরণগুলিতে দেখা যায়।

দ্রষ্টব্য যে বিজোড় ইনপুট সংখ্যার জন্য বিপরীত জোড়া লাইনগুলি (সুতরাং প্রথম এবং শেষ; দ্বিতীয় এবং শেষের পরবর্তী; ইত্যাদি) হুবহু এক। ইন n=5উদাহরণস্বরূপ প্রথম এবং শেষ লাইন আছে *####; দ্বিতীয় এবং শেষ লাইন পরের হয় ###**।
এমনকি ইনপুট সংখ্যার জন্য তবে উল্টানো জোড়া লাইনগুলি বিপরীত হয়। ইন n=8উদাহরণস্বরূপ প্রথম এবং শেষ লাইন আছে *#######এবং #######*; দ্বিতীয় এবং শেষ লাইনগুলির পরবর্তী ######**এবং **######হ'ল প্রভৃতি

চ্যালেঞ্জ নিয়ম:

  • আপনি যে কোনো দুটি স্বতন্ত্র ব্যবহার করতে পারেন মুদ্রণযোগ্য পরিবর্তে অক্ষর *এবং #। আপনি ব্যবহার করতে পারেন Aএবং B; 3এবং 7; <এবং >; ইত্যাদি দয়া করে আপনার উত্তরগুলিতে কী ব্যবহার করেছেন তা উল্লেখ করুন।
  • আপনি ধরে নিতে পারেন nএকটি ইতিবাচক পূর্ণসংখ্যা হবে ( >= 1)
  • আপনাকে STDOUT এ মুদ্রণের পরিবর্তে প্রতিটি লাইনের জন্য স্ট্রিংগুলির একটি তালিকা / অ্যারে বা অক্ষরের 2D ম্যাট্রিক্স আউটপুট দেওয়ার অনুমতি দেওয়া হয়।

সাধারণ নিয়ম:

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

পরীক্ষার কেস (প্রথম n=1মাধ্যমে n=10)

*

*#
#*

*##
#**
*##

*###
##**
**##
###*

*####
###**
***##
###**
*####

*#####
####**
***###
###***
**####
#####*

*######
#####**
***####
###****
***####
#####**
*######

*#######
######**
***#####
####****
****####
#####***
**######
#######*

*########
#######**
***######
#####****
*****####
#####****
***######
#######**
*########

*#########
########**
***#######
######****
*****#####
#####*****
****######
#######***
**########
#########*
code-golf  string  ascii-art 
— কেভিন ক্রুইজসেন
সূত্র
" আপনি * এবং # এর পরিবর্তে যে কোনও দুটি স্বতন্ত্র অক্ষর ব্যবহার করতে পারেন " "- সেগুলি কি মুদ্রণযোগ্য হতে হবে? আমরা কি NUL এবং SOH (ASCII কোড 0 এবং 1) ব্যবহার করতে পারি?
— এনজিএন
@ngn দুঃখিত, কেবল মুদ্রণযোগ্য অক্ষর। চ্যালেঞ্জের বিবরণে স্পষ্ট করে দেবে।
— কেভিন ক্রুইজসেন

উত্তর:

17

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

lambda n:["%*s"%(i%2*2*n-n,"x"*min(i+1,n-i))for i in range(n)]

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

ব্যবহারসমূহ x এবং স্থান।

সারিগুলি এইভাবে গণনা করা হয়:

"%-5s" % "x"      == "x    "
"%5s"  % "xx"     == "   xx"
"%-5s" % "xxx"    == "xxx  "
"%5s"  % "xx"     == "   xx"
"%-5s" % "x"      == "x    "

এবং %*sমধ্যে নির্বাচন করতে নির্দিষ্টকরণ ব্যবহার করে ।n-n

— লিন
সূত্র
6

এমএটিএল, 34 31 18 বাইট

:t!>tPY|!"@X@oQ&P!

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

* * এর জন্য 0 এবং # এর জন্য 1 ব্যবহার করে। লিনের জেলি উত্তরের উপর ভিত্তি করে ।

পুরানো উত্তর, 31 বাইট:

2/tk:wXk:Ph"X@ot~XHh@Gy-hHQ&PY"

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

* * এর জন্য 1 এবং # এর জন্য 0 ব্যবহার করে। 

         % implicit input, say 5
2/       % divide input number by 2 [2.5]
tk       % make a copy and floor that [2.5, 2]
:        % create range 1 to the floored value [2.5, [1, 2]]
wXk      % bring out the division result and this time ceil it
         %  [[1, 2], 3]
:        % create range 1 to that [[1, 2], [1, 2, 3]]
Ph       % flip the last array and concatenate horizontally 
         %  [[1, 2, 3, 2, 1]]
"        % loop through the array
  X@o    % Is the current loop index odd? 1 for odd, 0 for even
  t~     % duplicate and logical negate that
  XH     % copy that value to clipboard H
  h      % and concatenate the values ([1 0] on odd iterations, [0 1] on even) 
  @      % push current value from array (say 2, then stack is [[0 1], 2)
  G      % push input again
  y-     % subtract current array value from input [[0 1], 2, 3]
  h      % concatenate those two [[0 1], [2, 3]]
  H      % get the stored value from clipboard H (1 for even iterations, 0 for odd) 
  Q      % increment that
  &P     % flip the array in that dimension: in even iterations, this flips
         %   across columns and hence inverts the two values. [[0 1], [3, 2]]
         %   in odd iterations, it's a no-op
  Y"     % run-length decoding - repeat the element from first array the number of times
         %  specified in the second array
         % implicit loop end, implicit output
— সূন্দর - মনিকা পুনরায় স্থাপন করুন
সূত্র
6

এপিএল (ডায়ালগ ক্লাসিক) , 18 বাইট

⎕a[↑⊢∘⌽\(⊂>⊢⌊⌽)⍳⎕]

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

ABপরিবর্তে আউটপুট*#

⎕ মূল্যায়ন ইনপুট n

⍳⎕ ভেক্টর 0 1 ... n-1

⊢⌊⌽মিনিট ( ⌊) নিজের ( ⊢) এবং তাদের বিপরীতে ( ⌽) - ট্রেন দেখুন see

⊂>⊢⌊⌽⍳সম্পূর্ণরূপে ভেক্টরটি এর ⊂প্রতিটিটির চেয়ে কম কোথায় ⊢⌊⌽- বুলিয়ান (0/1) ভেক্টরের একটি ভেক্টরকে ফেরত দিন

⊢∘⌽\ প্রতিটি অন্যান্য ভেক্টর বিপরীত

↑ একটি ম্যাট্রিক্স মধ্যে মিশ্রিত

⎕aবড় হাতের ইংরেজি বর্ণমালা, 'AB...Z'

⎕a[ ]0 1সঙ্গে প্রতিস্থাপন'A' 'B'

— ngn
সূত্র
কৌতূহল এর বাইরে. শূন্যস্থান ছাড়াই 0 ও 1 এর ম্যাট্রিক্স আউটপুট করা কত বাইট হতে পারে? আমি অভিমানী করছি ⎕a[...}তাদের রূপান্তর Aএবং Bস্পেস ছাড়া তাদের পালন তুলনায় খাটো 0এবং 1বিবেচনা আপনি যে ব্যবহার করেছি স্পেস ছাড়া, কিন্তু জানতে আগ্রহী হলে বাইটে অনেক পার্থক্য আছে যদি আপনি তাদের যেমন রাখা 0এবং 1।
— কেভিন ক্রুইজসেন
1
@ কেভিন ক্রুইজসেন যতদূর আমি গল্ফ করতে পারি, একই দৈর্ঘ্য হবে - হয় ⎕d[... ]বা ⊃¨⍕¨... পরবর্তী প্রকাশে ⍕¨"প্রতিটি ফর্ম্যাট" - এটি প্রতিটি সংখ্যাকে একটি নেস্টেড চর ভেক্টর হিসাবে রূপান্তরিত করে , সুতরাং আমাদের প্রথম "প্রতিটি প্রয়োজন" "( ⊃¨) কেবল চর স্কেলারগুলি পেতে (এবং তাই মুদ্রণের সময় কোনও সাদা জায়গা নেই)।
— ngn
5

কাঠকয়লা , 21 বাইট

≔⮌…⁰ＮθＥθ⭆蛧⟦μλ⟧κ⌊⟦κι

এটি অনলাইন চেষ্টা করুন! ব্যবহার 0এবং 1। লিঙ্কটি কোডটির ভার্জোজ ভার্সন এবং এতে অন্তর্ভুক্ত §*#যা আউটপুটটি *এবং #প্রশ্নের মধ্যে অনুবাদ করে । ব্যাখ্যা:

    Ｎ                   Input number
  …⁰                    Range from 0
 ⮌                      Reversed
≔    θ                  Assign to `q`
      Ｅθ                Map over reversed range
        ⭆θ              Map over reversed range and join
           §⟦μλ⟧κ       Alternate between range and reversed range column
                 ⌊⟦κι   Minimum of range and reversed range row
          ›             Greater
                        Implicitly print each row on its own line
— নিল
সূত্র
5

জেলি ,  12  15 বাইট

+3 ফিক্সিং n=1এজ-কেস বাগ :(

R«Ṛ$‘r⁸ṬUÐe0YE?

একটি পূর্ণসংখ্যা গ্রহণকারী একটি পূর্ণাঙ্গ প্রোগ্রাম যা ওপিতে সংজ্ঞায়িত হিসাবে যথাক্রমে 0এবং এর 1জন্য *এবং আউটপুট প্রিন্ট করে #।

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

কিভাবে?

R«Ṛ$‘r⁸ṬUÐe0YE? - Main Link: integer, n
R               - range -> [1,2,3,4,...,n]
   $            - last two links as a monad:
  Ṛ             -   reverse -> [n,...,4,3,2,1]
 «              -   minimum (vectorises) -> [1,2,3,4,...,4,3,2,1]
    ‘           - increment (vectorises) -> [2,3,4,5,...,5,4,3,2]
      ⁸         - chain's left argument, n
     r          - inclusive range (vectorises) -> [[2,3,...,n],[3,4,...n],[4,5,...n],[5,...n],...,[5,...n],[4,5,...n],[3,4,...n],[2,3,...,n]]
       Ṭ        - untruth (vectorises) -> [[0,1,1,...,1],[0,0,1,1,...,1],[0,0,0,1,...,1],[0,0,0,0,1,...,1],...,[0,0,0,0,1,...,1],[0,0,0,1,...,1],[0,0,1,1,...,1],[0,1,1,...,1]]
         Ðe     - apply to entries with even indices:
        U       -   upend              -> [[0,1,1,...,1],[1,1,...,1],[0,0,0,1,...,1],[1,...,1,0,0,0,0],...]
              ? - if...
             E  - ...condition: all equal? (only true when n=1, where we have [1,1])
           0    - ...then: zero
            Y   - ...else: join with newline characters
                - implicit print
— জোনাথন অ্যালান
সূত্র
দেখে মনে হচ্ছে এটি হুবহু আমার অ্যালগরিদম তবে ভিন্ন রূপায়ণ যা 1 এস এর পরিবর্তে 0 এর ফলাফল এবং বিপরীত।
— এরিক আউটগল্ফার
হ্যাঁ কার্যকরভাবে একই জিনিস ... এবং আমি আমার করা ফিক্সটি দেখানোর জন্য আমার পোস্টটি আপডেট করি নি।
— জনাথন অ্যালান
4

জাভা 10, 145 বাইট

n->{var r=new char[n][n];for(int j=0,k;j<n;++j)for(k=0;k<n;)r[j][k]=k++<(j<n/2?j%2<1?j+1:n+~j:j%2>0?j:n-j)?j%2<1?'*':'#':j%2>0?'*':'#';return r;}

সমস্ত তিনকাগুলি এটিকে কিছুটা অগোছালো করে তোলে তবে এটি ঠিকঠাক কাজ করে। আমি নেস্টেড লুপ এবং অন্যান্য বিভিন্ন জিনিস চ্যাপ্টা করার চেষ্টা করেছি, তবে তারা কেবল বাইটের গণনা বাড়িয়েছে। এটি এখানে অনলাইনে চেষ্টা করুন ।

Ungolfed:

n -> { // lambda taking an integer as output and returning a char[][]
    var r = new char[n][n]; // the output array; we make use of Java 10's var here (replace with char[][] for another 4 bytes to make this work in Java 8)
    for(int j = 0, k; j < n; ++j) // iterate over the lines
        for(k = 0; k < n; )       // iterate over the j'th line
            r[j][k] = // set the current character
                      k++ < // determine if we're in the first or second portion of the line:
                            (j < n/2 ? // for the first half of the output:
                                 j%2 < 1  // on even lines ...
                                 ? j + 1  // ... print the first symbol j+1 times ...
                                 : n + ~j // ... on odd lines, print it n-j-1 times.
                             : j%2 > 0 ?  // for the second half of the output, on odd lines ...
                                 j :      // ... print the first symbol j times ...
                                 n - j)   // ... on even lines, print it n-j times.
                      ? j%2 < 1 ? '*' : '#'  // for the first part of the line, use '*' on even lines, '#' otherwise
                      : j%2 > 0 ? '*' : '#'; // for the second part of the line, use '*' on odd lines, '#' otherwise
    return r; // return the completed array
}

জাভা 8 11, 179 127 বাইট

n->{String r="",a,b;for(int j=0;j<n;b="#".repeat(j<n/2?n+~j:j),r+=(j++%2<1?a+b:b+a)+"\n")a="*".repeat(j<n/2?j+1:n-j);return r;}

এটি এখানে অনলাইনে চেষ্টা করে দেখুন (টিআইওর কাছে এখনও জাভা 11 নেই, সুতরাং এটি একটি কাস্টম পদ্ধতি ব্যবহার করে যা একই বাইট গণনা হিসাবে ফলাফল করেString#repeat() )।

কেভিন ক্রুইজসেনকে ধন্যবাদ 52 টি বাইট গল্ফ !

Ungolfed:

n -> { // lambda taking an int argument and returning a String
    String r = "", // the output String
           a,      // temporary String containing the '*'s
           b;      // temporary String containing the '#'s
    for(int j = 0; j < n; // loop over the lines
        b = "#".repeat( // repeat the '#' character ...
            j < n/2 ? n + ~j // ... n-j-1 times in the first half of the output ...
            : j), // ... j times in the second half
        r += (j++ % 2 < 1 ? a + b : b + a) + "\n") // assemble the j'th line and append it to the output: on even lines, the '*'s go first; on odd lines, the '#'s go first
        a = "*".repeat( // repeat the '*' character ...
              j < n/2 ? j + 1 // ... j+1 times in the first half of the output ...
              : n - j); // n-j times in the second half
    return r; // return the completed output
}
— OOBalance
সূত্র
3
আপনি যদি জাভা ১১-এ পরিবর্তন করেন তবে আপনি এটি ব্যবহার করে "*".repeat(...)এবং "#".repeat(...)(পাশাপাশি সরাসরি মুদ্রণের পরিবর্তে কোনও স্ট্রিং ফিরতে এবং গল্ফ n-j-1করার জন্য n+~j) এটিকে 127 বাইটে গল্ফ করতে পারেন :n->{String r="",a,b;for(int j=0;j<n;b="#".repeat(j<n/2?n+~j:j),r+=(j++%2<1?a+b:b+a)+"\n")a="*".repeat(j<n/2?j+1:n-j);return r;}
— কেভিন ক্রুইজসেন
ধন্যবাদ, এটি বাইটে একটি দুর্দান্ত সঞ্চয়। আমি নেস্টেড লুপগুলি ব্যবহার করে জাভা 10 এর জন্য একটি 145-বাইট সংস্করণ তৈরি করতে পেরেছি - জাভা 11 প্রকাশের জন্য অপেক্ষা করতে পারছি না, এই repeat()পদ্ধতিটি গল্ফের জন্য সত্যিই দুর্দান্ত।
— ওবালেন্স
4

লুয়া ,  148  133 বাইট

function(n)t,a,b={},".","#"for i=1,n do r=i<n/2+1 and i or-~n-i s=a:rep(r)..b:rep(n-r)t[i]=i%2<1 and s:reverse()or s end return t end

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

-15 বাইটস @ কেভিন ক্রুইজসেন এবং @ জোকিংকে ধন্যবাদ।

function(n)
   t = {}; a = "."; b = "#"          -- initialize variables, output is in table
                                     -- strings are needed in variables for
                                     --   the str:rep and str:reverse syntax

   for i = 1, n do                          -- build the rows of the table
      r = i<=(n+1)/2 and i or n-i+1         -- logic used to count up then down
      str = a:rep(r)..b:rep(n-r)            -- append correct number of '.'s, fill
                                            --   in the rest with '#'s
      t[i]=i%2==0 and str:reverse() or str  -- logic used to control reversing
   end
   return t                                 -- return table
end
— অ্যাজুরে হাইটস
সূত্র
2
আমি লুয়াকে খুব বেশি জানি না, তবে মনে হয় আপনি পাঁচটি বাইট সংরক্ষণ করতে পারবেন: (n+1)/2থেকে -~n/2; or n-i+1to or-~n-i; i%2==0to i%2<1; এবং reverse() orথেকে reverse()or। এছাড়াও, আপনার টিআইও সংস্করণ এবং বাইট-কাউন্ট উভয়টিতে একটি পিছনের অর্ধ-কোলন রয়েছে যা প্রয়োজনীয় বলে মনে হচ্ছে না। যদিও প্রথম ভাল উত্তর। আমার কাছ থেকে +1 এবং পিপিসিজিতে আপনাকে স্বাগতম! :)
— কেভিন ক্রুইজসেন 21
2
আপনার আসলে কোনও আধা-কোলনের প্রয়োজন নেই। কেভিনের পরামর্শ সহ 133 বাইট ।
— জো কিং
ধন্যবাদ কেভিন ক্রুজসেন! আমি জিজ্ঞাসা করতে পারি যে -~nআপনার পরামর্শগুলিতে কী করছে? এটি অবশ্যই কাজ করে, তবে কেন আমি তা বুঝতে পারি না।
— আজুর
1
পুনঃটুইট ~একটি অ্যানারি বিটওয়াইজ নেগেশন অপারেটর। কোডগলফিংয়ের জন্য যা গুরুত্বপূর্ণ তা ~iহ'ল এটি একই মান -i-1। আমরা এর -~iপরিবর্তে i+1এবং ~-iপরিবর্তে ব্যবহার করতে পারি i-1। এটি দুটি ক্ষেত্রে কার্যকর, যা আমি উভয়ই আপনার উত্তরে ব্যবহার করতে পারি: প্রথম বন্ধনী থেকে মুক্তি পাওয়া, কারণ -এবং ~অন্যান্য গাণিতিক ক্রিয়াকলাপগুলির তুলনায় অপারেটর প্রাধান্য রয়েছে, তাই (n+1)/2এটি হতে পারে -~n/2। এবং অন্য দরকারী অংশটি হ'ল কিছু ক্ষেত্রে ফাঁকা পড়ে যাওয়া যেমন আমি করেছি or-~n-i।
— কেভিন ক্রুইজসেন
1
আপনি যদি এ সম্পর্কে আরও কিছুটা পড়তে চান তবে এখানে দুটি প্রাসঙ্গিক টিপস রয়েছে: এর জন্য অ্যানারি ~ব্যবহার করুনx+1 এবংx-1 এবং ব্যবহারের ইউনারী ~জন্য a-b-1এবংa+b+1 । সমস্ত সাধারণ টিপস, পাশাপাশি ভাষা নির্দিষ্ট টিপস (এই ক্ষেত্রে লুয়ায় গল্ফ করার টিপস) পড়তে আগ্রহী হতে পারে। :)
— কেভিন ক্রুইজসেন
3

সি (জিসিসি) , 118 108 বাইট

এটি একটি জিততে পারে না, তবে এটি একটি ভিন্ন পদ্ধতির (বা কমপক্ষে, আমারও তাই মনে হয়!) স্ট্রিং ম্যানিপুলেশনগুলি না করে আমি এই সত্যটি ব্যবহার করি 10এক্স-1 উপর [1 ..এন]={9,99,999,।।।}, যা উপযুক্ত প্যাটার্ন পেতে গুন করা যেতে পারে; printf()তারপরে ডান-ন্যায্যতার জন্য শূন্য-প্যাডিং করে।

দুঃখের বিষয়, int9 টি সংখ্যা (32-বিট প্ল্যাটফর্মগুলিতে) করার longজন্য কেবল পর্যাপ্ত পরিসর রয়েছে, তাই আপনাকে আরও বৃহত্তর নিদর্শনগুলির জন্য যেতে হবে ; স্থানীয়ভাবে এমপি গাণিতিক ভাষা এমন কোনও কিছুর জন্য এটি ব্যবহার করতে সক্ষম হতে পারে।

পরামর্শের জন্য সিলিংক্যাট ধন্যবাদ।

h,j,k;p(h){h=h?10*p(--h):1;}f(i){for(j=0,h=i++;k=++j>i/2?i-j:j,j<i;printf("%0*d\n",h,~-p(k)*p(j%2*(h-k))));}

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

ধারণাটির প্রমাণ যে এটি এমপি গাণিতিকের সাথে কাজ করে:

সি # (মনো সি # সংকলক) , 187 165 বাইট

( using System.Numerics;হেডারে থাকাগুলির জন্য 143 বাইট + 22 বাইট )

q=>{var r="";for(int j=0,h=q+1,k;j<q;r+=((BigInteger.Pow(10,k)-1)*BigInteger.Pow(10,j%2*(q-k))).ToString("D"+q)+"\n")k=++j>h/2?h-j:j;return r;}

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

— ErikF
সূত্র
1
সর্বাধিক দেশীয় পূর্ণসংখ্যার রেঞ্জের বাইরে সংখ্যার সাথে ধারণার প্রমাণ (সি # এবং বিগআইন্টিজার ব্যবহার করে): অনলাইনে চেষ্টা করে দেখুন!
— এরিকএফ
3

ভিম, 99 কীস্ট্রোক

ইনপুট আর্গুমেন্টের সাথে ভিএম করার চেষ্টা করা সবসময় আকর্ষণীয়। এটি খুব অপ্রাকৃত, তাই এটি আশ্চর্যরকমভাবে সংক্ষিপ্ত হবে না। এটির জন্য সম্ভবত আরও ভাল পন্থা রয়েছে।

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

"nD@ni<cr><esc>MmaGddM
<c-v>'aI*<esc>qwgvjokoI*<esc>@wq@w<esc>
:set ve=all<cr>@nlh<c-v>@nkr#
:%s/ /#/g<cr>o<esc>
2Gqqdt#$p2j0@qq@q

ব্যাখ্যা

 | Buffer state (odd and even case):
 | 5                    6

"nD              read input into register n
@ni<cr><esc>     add n newlines
MmaGddM<c-v>'a   visual block select center row(s)
I*<esc>          prepend a column of *
qw               record macro w
  gvjoko         expand selection up and down
  I*<esc>
  @w             recurse
q
@w<esc>          run macro w and exit visual block select

 | Buffer state:
 | *                    *
 | **                   **
 | ***                  ***
 | **                   ***
 | *                    **
 |                      *

:set ve=all<cr>  move anywhere!
@nlh<c-v>@nkr#   add last column of #s

 | Buffer state:
 | *   #                *    #
 | **  #                **   #
 | *** #                ***  #
 | **  #                ***  #
 | *   #                **   #
 |                      *    #

:%s/ /#/g<cr>      replace spaces with #

 | Buffer state:
 | *####                *#####
 | **###                **####
 | ***##                ***###
 | **###                ***###
 | *####                **####
 |                      *#####

o<esc>2G           prep and jump to line 2
qqdt#$p2j0@qq@q    (effectively) flip every other onward

 | Buffer state:
 | *####                *#####
 | ###**                ####**
 | ***##                ***###
 | ###**                ###***
 | *####                **####
 |                      #####*

এবং বেস 64 এ, প্রকৃত অক্ষর সহ (ইনপুট রাখুন inputএবং কী-স্ট্রোক keysব্যবহার করে চালাবেন vim -u NONE -s keys input)

Im5EQG5pDRtNbWFHZGRNFidhSSobcXdndmpva29JKhtAd3FAdxs6c2V0IHZlPWFsbA1AbmxoFkBua3IjOiVzLyAvIy9nDW8bMkdxcWR0IyRwMmowQHFxQHE=
— algmyr
সূত্র
2

আর , 75 বাইট

function(n)outer(1:n,1:n,function(x,y,a=x<y|x>n-y+1)+ifelse(x%%2,a,rev(a)))

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

  • @ লিন উত্তর দ্বারা অনুপ্রাণিত
  • ফাংশন nপ্যারামিটার হিসাবে পেতে এবং একটি ম্যাট্রিক্স ফিরে 0/1যেখানে 0অনুরূপ '*'এবং 1অনুরূপ'#'
— digEmAll
সূত্র
2

কে (এনএনজি / কে) , 22 বাইট

{"*#"i|:/'i>/:i&|i:!x}

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

{ } যুক্তি দিয়ে ফাংশন x

!x ক্রমতালিকা (0;1; ...;x-1)

i: ধার্য i

i&|iএর মিনিমা ( &) iএবং এর বিপরীত (| )

i>/:ডানদিকের তালিকা থেকে প্রতিটি উপাদানের বিপরীতে ( >) এর চেয়ে বেশিটির সাথে তুলনা iকরুন (/: - একটি বুলিয়ান ম্যাট্রিক্স ফিরিয়ে দিন (তালিকার তালিকা)

i|:/'প্রতিটি ( ') জে ইন i, বিপরীত ( |:- আমাদের একাত্ম হতে :বাধ্য |করার প্রয়োজন ) সংশ্লিষ্ট উপাদান জ বার ( বার n f/ xপ্রযোজ্য )। কার্যকরভাবে, প্রতিটি অন্যান্য সারিতে বিপরীত।f nx

"*#" স্ট্রিংয়ে সূচক হিসাবে ম্যাট্রিক্স উপাদানগুলি ব্যবহার করুন "*#"

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