অঞ্চলটিকে slালু দ্বারা শ্রেণিবদ্ধ করুন

16

সংজ্ঞা

ট ম আকারের একটি বর্গাকার ম্যাট্রিক্সের রিং এন , যেখানে 1 ≤ ট ≤ সিলিং (এন / 2) তালিকার উপাদান দ্বারা গঠিত ট ম এবং (এন-K + 1 টি) ম সারি এবং কলাম কিন্তু ছাড়া প্রথম এবং শেষ কে -1 উপাদান।

উদাহরণ:

ম্যাট্রিক্স:

1 2 3 4 5
6 7 8 9 1
8 7 6 5 4
3 2 1 9 8
7 6 5 4 3

রিংগুলিতে সীমাবদ্ধ:

+ + ------------------- + +
| 1 2 3 4 5 |
| + ----------- + |
| 6 | 7 8 9 | 1 |
| | + --- + | |
| 8 | 7 | 6 | 5 | 4 |
| | + --- + | |
| 3 | 2 1 9 | 8 |
| + ----------- + |
| 7 6 5 4 3 |
+ + ------------------- + +

উপরের প্রথম রিংটি 1,2,3,4,5,1,4,8,3,4,5,6,7,3,8,6, দ্বিতীয়টি 7,8,9,5,9,1,2,7এবং তৃতীয়টি 6।

ইতিবাচক পূর্ণসংখ্যার এন ম্যাট্রিক্স দ্বারা একটি এন (এই চ্যালেঞ্জের উদ্দেশ্যে):

  • অবধি যদি কে থ্রি রিংয়ের সমস্ত পূর্ণসংখ্যার (কে + 1) তম রিংয়ের চেয়ে কড়াটি বড় হয় , যেখানে কে 1 এবং এন এর মধ্যে কোনও পূর্ণসংখ্যা হয় (প্রথম রিংটিতে থাকা ব্যক্তিরা দ্বিতীয়টির চেয়ে বড় হয়) পরিবর্তে তৃতীয় ইত্যাদির চেয়ে বড় হয়)। উদাহরণ:

    4 5 6 4 7 -> কারণ 4,5,6,4,7,4,8,5,5,4,6,5,9,5,5,4 এর চেয়ে সমস্ত বেশি
4 3 2 2 4 টি 3,2,2,3,2,3,3,2 এর মধ্যে যা সমস্ত 1 এর চেয়ে বেশি
5 2 1 3 8
5 3 3 2 5
9 5 6 4 5

  • সমতল যদি ম্যাট্রিক্সের সমস্ত পূর্ণসংখ্যা সমান হয়। আরেকটি উদাহরণ (সম্ভবত রিডানড্যান্ট):

    2 2 2 2
2 2 2 2
2 2 2 2
2 2 2 2

  • উত্তোলন যদি কে থ্রি রিংয়ের সমস্ত পূর্ণসংখ্যার (কে + 1) তম রিংয়ের তুলনায় কঠোরভাবে কম হয় , যেখানে k 1 এবং N এর মধ্যে কোনও পূর্ণসংখ্যা হয় (প্রথম রিংটিতে থাকা ব্যক্তিরা দ্বিতীয়টির চেয়ে কম থাকে) পরিবর্তে তৃতীয় ইত্যাদির চেয়ে কম হবে)। উদাহরণ:

    1 2 1 -> কারণ 1 এবং 2 উভয়ই 6 এর চেয়ে কম
2 6 2
1 2 1

  • যদি ম্যাট্রিক্স উপরের কোনও মানদণ্ড পূরণ না করে তবে মিশ্র । উদাহরণ:

    3 3 3 3 3
3 2 2 2 3
3 2 3 2 3
3 2 2 2 3
3 3 3 3 3

চ্যালেঞ্জ

কমপক্ষে 3 আকারের ধনাত্মক পূর্ণসংখ্যার একটি বর্গক্ষেত্র দেওয়া , উপরের সংজ্ঞা অনুসারে এটি শ্রেণিবদ্ধ করুন। এটি হ'ল ম্যাট্রিক্স অবতল, সমতল, উত্তল বা মিশ্রিত কিনা তার উপর ভিত্তি করে চারটি বিভিন্ন সুসংগত মানগুলির মধ্যে একটি আউটপুট ।

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

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

আপনার চয়ন করার জন্য এখানে কয়েকটি উদাহরণ রয়েছে - আমি প্রতিটি বিভাগ থেকে 6 টি নির্বাচন করেছি।

অবতল

[[3, 3, 3], [3, 1, 3], [3, 3, 3]]
[[2, 3, 4], [5, 1, 6], [7, 8, 9]]
[[19, 34, 45], [34, 12, 14], [13, 13, 13]]
[[3, 4, 3, 4], [4, 2, 1, 3], [3, 1, 2, 4], [4, 3, 4, 3]]
[[4, 5, 6, 4, 7], [4, 3, 2, 2, 4], [5, 2, 1, 3, 8], [5, 3, 3, 2, 5], [9, 5, 6, 4, 5]]
[[7, 7, 7, 7, 7], [7, 6, 6, 6, 7], [7, 6, 5, 6, 7], [7, 6, 6, 6, 7], [7, 7, 7, 7, 7]]

সমান

[[1, 1, 1], [1, 1, 1], [1, 1, 1]]
[[2, 2, 2], [2, 2, 2], [2, 2, 2]]
[[8, 8, 8], [8, 8, 8], [8, 8, 8]]
[[120, 120, 120], [120, 120, 120], [120, 120, 120]]
[[10, 10, 10, 10], [10, 10, 10, 10], [10, 10, 10, 10], [10, 10, 10, 10]]
[[5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5], [5, 5, 5, 5, 5, 5]]

উত্তল

[[1, 2, 1], [2, 6, 2], [1, 2, 1]]
[[1, 1, 1], [1, 2, 1], [1, 1, 1]]
[[19, 34, 45], [34, 76, 14], [13, 6, 13]]
[[3, 3, 3, 3], [3, 4, 4, 3], [3, 4, 4, 3], [3, 3, 3, 3]]
[[192, 19, 8, 6], [48, 324, 434, 29], [56, 292, 334, 8], [3, 4, 23, 23]]
[[291, 48, 7, 5], [47, 324, 454, 30], [58, 292, 374, 4], [9, 2, 53, 291]]

মিশ্র

[[1, 2, 3], [4, 5, 9], [6, 7, 8]]
[[10, 14, 21], [100, 8, 3], [29, 2, 19]]
[[5, 5, 5, 5], [5, 4, 4, 5], [5, 4, 6, 5], [5, 5, 5, 5]]
[[3, 3, 3, 3], [3, 1, 2, 3], [3, 3, 2, 3], [3, 3, 3, 3]]
[[12, 14, 15, 16], [12, 18, 18, 16], [12, 11, 11, 16], [12, 14, 15, 16]]
[[5, 5, 5, 5, 5], [5, 4, 4, 4, 5], [5, 4, 6, 4, 5], [5, 4, 4, 4, 5], [5, 5, 5, 5, 5]]
code-golf  array-manipulation  integer  matrix  classification 
— মিঃ এক্সকোডার
সূত্র
এই চ্যালেঞ্জটি আগে স্যান্ডবক্সে পোস্ট করা হয়েছিল । যারা সেখানে মূল্যবান মতামত দিয়েছেন তাদের ধন্যবাদ।
— মিঃ এক্সকোডার
2
ছেলে, ম্যাট্রিক্স ফাংশনগুলিতে / থেকে বিভিন্ন ভাষায় all সমস্ত পরীক্ষার কেসগুলি প্রক্রিয়া করার জন্য
— হস্তান্তরিত
@ngm আপনারা কি ভাবেন না যে আমাদের ইতিমধ্যে একটি নেই ! : পি
— মিঃ এক্সকোডার

উত্তর:

5

জাভা (জেডিকে 10) , 247 232 220 বাইট

x->{int i=0,j=x.length,k,m,M,p=0,P=0,r=0;for(;i<j;){for(M=m=x[k=i][--j];k<=j;)for(int q:new int[]{x[i][k],x[j][k],x[k][i],x[k++][j]}){m=m<q?m:q;M=M<q?q:M;}r=i++>0?(k=P<m?3:p>M?1:P==m?2:4)*r!=r*r?4:k:0;p=m;P=M;}return r;}

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

আউটপুট:

  • 1 "অবতল" জন্য
  • 2 "ফ্ল্যাট" জন্য
  • 3 "উত্তল" জন্য
  • 4 "মিশ্র" জন্য

Ungolfed:

x -> { // lambda that takes in the input int[][]
  int i = 0, // index of right bound of ring
      j = x.length, // index of left bound of ring
      k, // index of row-column-pair in ring
      m, // minimum of ring
      M, // maximum of ring
      p = 0, // minimum of previous ring
      P = 0, // maximum of previous ring
      r = 0; // result
  for (; i < j; ) { // iterate the rings from outside inwards
    // set both min and max to be to top right corner of the ring (and sneakily set some loop variables to save space)
    for (M = m = x[k = i][--j]; k <= j; ) // iterate the row-column pairs of the ring from top-right to bottom-left
      for (int q : new int[] {x[i][k], x[j][k], x[k][i], x[k++][j]}) { // iterate all of the cells at this row-column pair (and sneakily increment the loop variable k)
        // find new minimum and maximum
        m = m < q ? m : q;
        M = M < q ? q : M;
      }
    r = // set the result to be...
      i++ > 0 ? // if this is not the first ring... (and sneakily increment the loop variable i)
              // if the new result does not match the old result...
              (k = P < m ? // recycling k here as a temp variable to store the new result, computing the result by comparing the old and new mins/maxes
                         3
                         : p > M ?
                                 1
                                 : P == m ? 
                                          2
                                          : 4) * r != r * r ? // multiplying by r here when comparing because we want to avoid treating the case where r = 0 (unset) as if r is different from k
                                                            4 // set the result to "mixed"
                                                            : k // otherwise set the result to the new result
              : 0; // if this is the first ring just set the result to 0
    // set the old ring mins/maxes to be the current ones
    p = m; 
    P = M;
  }
  return r; // return the result
}
— SamYonnou
সূত্র
5

জেলি ,  18 17  16 বাইট

আমি বিশ্বাস করি এই প্রচেষ্টার বাইরে যাওয়ার প্রচুর সম্ভাবনা রয়েছে

L‘HạŒỤṀ€IṠQṢ«FE$

সংখ্যার তালিকার একটি তালিকা গ্রহণ করে একটি মোনাডিক লিঙ্ক যা পূর্ণসংখ্যার একটি তালিকা প্রদান করে:

Concave ->  [0, 0]
Flat    ->  [-1, 0, 1]
Convex  ->  [-1, 0]
Mixed   ->  [-1, 0, 0]

এটি অনলাইন চেষ্টা করুন! অথবা পরীক্ষা-স্যুটটি দেখুন ।

L‘Hকম দক্ষ তবে পারমাণবিকভাবে খাটো দ্বারা প্রতিস্থাপিত হতে পারে JÆm।

কিভাবে?

L‘HạŒỤṀ€IṠQṢ«FE$ - Link: list of (equal length) lists of numbers
L                - length
 ‘               - increment
  H              - halve
                 -   = middle 1-based index (in both dimensions as the input is square)
    ŒỤ           - sort multi-dimensional indices by their corresponding values
                 -   = a list of pairs of 1-based indexes
   ạ             - absolute difference (vectorises)
                 -   = list of [verticalDistanceToMiddle, horizontalDistanceToMiddle] pairs
      Ṁ€         - maximum of €ach
                 -   each = N/2-k (i.e. 0 as middle ring and N/2 as outermost)
        I        - incremental deltas (e.g. [3,2,2,3,1]->[3-2,2-2,3-2,1-3]=[-1,0,1,-2])
         Ṡ       - sign (mapping -n:-1; 0:0; and +n:1)
          Q      - de-duplicate
           Ṣ     - sort
                 -   = concave:[0, 1]; convex:[-1, 0]; flatOrMixed:[-1, 0, 1]
               $ - last two links as a monad
             F   -   flatten
              E  -   all equal? (1 if flat otherwise 0)
            «    - minimum (vectorises)
                 -   = concave:[0, 0]; convex:[-1, 0]; mixed:[-1, 0, 0]; flat:[-1, 0, 1]
— জোনাথন অ্যালান
সূত্র
5

পাইথন 2 , 219 216 189 176 বাইট

def g(M):A=[sorted((M[1:]and M.pop(0))+M.pop()+[i.pop(j)for j in[0,-1]for i in M])for k in M[::2]];S={cmp(x[j],y[~j])for x,y in zip(A,A[1:])for j in[0,-1]};return len(S)<2and S

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

আউটপুটস set([1]), set([0]), set([-1]),বা Falseযথাক্রমে অবতল, সমতল, উত্তল বা মিশ্রিত জন্য।

Thx এর জন্য: ovs দ্বারা কয়েকটি অপ্টিমাইজেশন থেকে পুরোপুরি 27 বাইট । এবং তারপরে আরও 13 বাইট পরে।

তালিকা অনুধাবন A(ওভসের কারণে) বাছাই করা প্রতিটি রিংয়ের উপাদানগুলির একটি তালিকা তৈরি করে।

এরপরে, আমরা এ এর মধ্যে প্রতিটি সাজানো তালিকার তৃতীয় এবং তম উপাদানগুলি দেখে সংলগ্ন রিংগুলির মধ্যে maxএবং minমানগুলি তুলনা করি নোট করুন যে, উদাহরণস্বরূপ, যদি অবতল হয়, তবে প্রতিটি অভ্যন্তরীণ রিংটি পরবর্তী অভ্যন্তরের সর্বাধিক রিংয়ের চেয়ে বড় হতে হবে ; এবং এরপরে প্রতিটি বাহ্যিক রিংটি পরবর্তী অভ্যন্তরের সর্বাধিক রিংয়ের চেয়ে বড় হবে ।0-1Mminmaxmaxmin

তাহলে Mঅবতল, সমতল, বা উত্তল, এই সেট min/maxতুলনা থেকে মাত্র 1 উপাদান থাকবে {-1, 0, 1}; যদি এটি মিশ্রিত হয় তবে দুটি বা আরও বেশি উপাদান থাকবে।

— চ্যাস ব্রাউন
সূত্র
@ovs: এটি বেশ করল; আমি অন্য বাইটটিকে একটি তালিকা বোধগম্য করে রূপান্তর করে সংরক্ষণ করেছি (এবং এই ভেবে যে এটি অন্যান্য অনুরূপ চ্যালেঞ্জগুলির জন্য খুব কার্যকর কৌশল হতে পারে)।
— চ্যাস ব্রাউন
তালিকার সংক্ষিপ্তসারটি ছোট করার কোনও উপায় রয়েছে, তবে কিছুক্ষণের জন্য লুপটি এখনও ছোট বলে মনে হচ্ছে: while M:k=M[0]+M[-1];M=M[1:-1];A+=sorted(k+[i.pop(j)for j in[0,-1]for i in M]),(174 বাইট)
— ওভস
@ ওভস: আপনি ,A=()আপনার বাইট গণনা থেকে বাদ দিয়েছেন ...
— চ্যাস ব্রাউন
আমি পেতে 174 বাইট সঙ্গেA=()
— ovs
আহ! দুঃখিত, আমি ভুল বুঝেছি। এই ফর্মটি ছিল যা আপনার পূর্ববর্তী সংস্করণ চেয়ে আলাদা: while M: A+= (some expression)।
— চ্যাস ব্রাউন
4

জাভাস্ক্রিপ্ট (ES6), 168 বাইট

রিটার্নস:

  • -1 ফ্ল্যাট জন্য
  • 0 মিশ্র জন্য
  • 1 উত্তল জন্য
  • 2 অবতল জন্য
f=(a,k=w=~-a.length/2,p,P,i,m,M,y=w)=>k<0?i%4%3-!i:a.map(r=>r.map(v=>Y|(X=k*k-x*x--)<0&&X|Y<0||(m=v>m?m:v,M=v<M?M:v),x=w,Y=k*k-y*y--))|f(a,k-1,m,M,i|M-m<<2|2*(M<p)|m>P)

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

কিভাবে?

প্রতিটি রিংয়ে সর্বনিম্ন এবং সর্বাধিক

আমরা প্রতিটি রিংয়ের সর্বনিম্ন মি এবং সর্বোচ্চ এম গণনা করি ।

আমরা পরীক্ষা করি যে প্রতিটি অক্ষের ম্যাট্রিক্সের কেন্দ্র থেকে বর্গক্ষেত্রের দূরত্ব গণনা করে কোনও ঘর কোনও প্রদত্ত রিংয়ের উপরে অবস্থিত কিনা। পরম মান গ্রহণ করা ঠিক তেমনি কাজ করবে তবে স্কোয়ারিং আরও কম।

এ সেল (X, Y) অবস্থিত এন -th রিং (0-ইন্ডেক্স, দূরতম এক থেকে শুরু) যদি নিম্নলিখিত সূত্র মিথ্যা :

((Y != 0) or (X < 0)) and ((X != 0) or (Y < 0))

কোথায়:

  • এক্স = কে² - (এক্স - ডাব্লু) ²
  • Y = k² - (y - w) ²
  • ডাব্লু = (আঃ দৈর্ঘ্য - 1) / 2
  • k = w - n

উদাহরণ: 6x6 ম্যাট্রিক্সের 2 য় রিং- এ কোষটি (1, 2) রয়েছে?

  | 0 1 2 3 4 5   w = (6 - 1) / 2 = 2.5
--+------------   (x, y) --> ( x-w,  y-w) --> ((x-w)²,(y-w)²)
0 | 0 0 0 0 0 0   (1, 2) --> (-1.5, -0.5) --> (  2.25,   0.5)
1 | 0 1 1 1 1 0   
2 | 0[1]0 0 1 0   k = w - 1 = 1.5
3 | 0 1 0 0 1 0   k² = 2.25
4 | 0 1 1 1 1 0   X = 2.25 - 2.25 = 0 / Y = 2.25 - 0.5 = 1.75
5 | 0 0 0 0 0 0   ((X != 0) or (Y < 0)) is false, so (1,2) is on the ring

পতাকা

প্রতিটি পুনরাবৃত্তির শেষে আমরা নূন্যতম পি এবং পূর্ববর্তী রিংয়ের সর্বাধিক পি এর তুলনায় মি এবং এম তুলনা করি এবং তদনুসারে পতাকাটির পরিবর্তনশীল আপডেট করি :

  • i |= 1if m> পি
  • i |= 2যদি এম <পি
  • আমরা উচ্চতর বিট সেট আমি যদি এম! = মি

প্রক্রিয়া শেষে, আমরা নীচের হিসাবে i এর চূড়ান্ত মান রূপান্তর :

i % 4  // isolate the 2 least significant bits (for convex and concave)
% 3    // convert 3 to 0 (for mixed)
- !i   // subtract 1 if i = 0 (for flat)
— Arnauld
সূত্র
4

কে (এনএনজি / কে) , 100 71 69 বাইট

{$[1=#?,/a:(,/x)@.=i&|i:&/!2##x;;(&/m>1_M,0)-&/(m:&/'a)>-1_0,M:|/'a]}

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

আয় 1= অবতল, ::= সমতল, -1= উত্তল, 0= মিশ্রিত

( ::কেতে মান অনুপস্থিতির জন্য স্থানধারক হিসাবে ব্যবহৃত হয়)

— ngn
সূত্র
ওকে ব্যবহার করে একটি ভিন্ন কৌশল:&/1_`{&/+(y>|/x;y<&/x;,/x=/:y)}':(,/*:'(|+:)\)'-1_(-1_1_+-1_1_)\
— zgrep
@zgrep সুন্দর! :) একটি পৃথক উত্তর হিসাবে পোস্ট এবং খনি থেকে ধারনা নিতে যদি তুমি চাও বিনা দ্বিধায় - যেমন মনে হয় রিং মধ্যে আমার বিভাজন খাটো, কিন্তু আমি ঠিক আছে এটা চেষ্টা করিনি এখনো
— ngn
— ngn
ওহ, এটি খুব ঝরঝরে রিং বিভক্ত! আমি এটা পছন্দ করি.
— zgrep
2

ওকে , 56 বাইট

&/1_`{&/+(y>|/x;y<&/x;,/x=/:y)}':{(,/x)@.=i&|i:&/!2##x}@

Ngn এর উত্তর ভিত্তিক ।

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

concave:1 0 0
   flat:0 0 1
 convex:0 1 0
  mixed:0 0 0
— zgrep
সূত্র
আপনি যদি সমস্ত কিছুকে একটি বড় ল্যাম্বডায় রূপান্তর করেন তবে @ এর দরকার নেই:{&/1_`{&/+(y>|/x;y<&/x;,/x=/:y)}':(,/x)@.=i&|i:&/!2##x}
— ngn
1

সি ++ 17 (জিসিসি) , 411 বাইট

#import<map>
#define R return
#define T(f,s)X p,c;for(auto&e:r){c=e.second;if(p.a&&!p.f(c)){s;}p=c;}R
using I=int;struct X{I a=0;I z=0;I f(I n){R!a||n<a?a=n:0,n>z?z=n:0;}I
l(X x){R z<x.a;}I g(X x){R a>x.z;}I e(X x){R a==z&a==x.a&z==x.z;}};I
N(I i,I j,I s){i*=s-i;j*=s-j;R i<j?i:j;}auto C=[](auto&&m){I
s=size(m),i=-1,j;std::map<I,X>r;for(;++i<s;)for(j=-1;++j<s;)r[N(i,j,s-1)].f(m[i][j]);T(g,T(l,T(e,R 0)3)2)1;};

একটি নতুন উচ্চ স্কোর! (পোস্ট করার সময়, কমপক্ষে) ওহ ভাল, এটি কিছুটা নিফটি তবে এখনও সি ++।

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

লাম্বদা Cএকটি নেয় std::vector<std::vector<int>>এবং অবতরণের জন্য 1, উত্তলটির জন্য 2, ফ্ল্যাটটির জন্য 3 বা মিশ্রিত 0 টি দেয়।

বর্ণনামূলক শনাক্তকারী, মন্তব্য, R-> returnএবং I-> intলিখিত আউট ইত্যাদি সহ কোডটির আরও সুস্পষ্ট সংস্করণ . :

#include <map>

// Abbreviation for golfing. Spelled out below.
#define R return

// Macro to test whether all pairs of consecutive Ranges in `rings`
// satisfy a condition.
// func: a member function of Range taking a second Range.
// stmts: a sequence of statements to execute if the condition is
//        not satisfied. The statements should always return.
//        May be missing the final semicolon.
// Expands to a statement, then the return keyword.
// The value after the macro will be returned if all pairs of Ranges
// satisfy the test.
#define TEST(func, stmts)                                     \
    Range prev, curr;                                         \
    for (auto& elem : rings) {                                \
        curr = elem.second;                                   \
        // The first time through, prev.a==0; skip the test.  \
        if (prev.a && !prev.func(curr))                       \
        { stmts; }                                            \
        prev = curr;                                          \
    }                                                         \
    return

// Abbreviation for golfing. Spelled out below.
using I = int;

// A range of positive integers.
// A default-constructed Range is "invalid" and has a==0 && z==0.
struct Range
{
    int a = 0;
    int z = 0;
    // Add a number to the range, initializing or expanding.
    // The return value is meaningless (but I is shorter than void for golfing).
    int add(int n) {
        return !a||n<a ? a=n : 0, n>z ? z=n : 0;
        /* That is:
        // If invalid or n less than previous min, set a.
        if (a==0 || n<a)
            a = n;
        // If invalid (z==0) or n greater than previous max, set z.
        if (n>z)
            z = n;
        return dummy_value;
        */
    }

    // Test if all numbers in this Range are strictly less than
    // all numbers in Range x.
    int less(Range x)
    { return z < x.a; }

    // Test if all numbers in this Range are strictly greater than
    // all numbers in Range x.
    int greater(Range x)
    { return a > x.z; }

    // Test if both this Range and x represent the same single number.
    int equal(Range x)
    { return a==z && a==x.a && z==x.z; }
};

// Given indices into a square matrix, returns a value which is
// constant on each ring and increases from the first ring toward the
// center.
// i, j: matrix indices
// max: maximum matrix index, so that 0<=i && i<=max && 0<=j && j<=max
int RingIndex(int i, int j, int max)
{
    // i*(max-i) is zero at the edges and increases toward max/2.0.
    i *= max - i;
    j *= max - j;
    // The minimum of these values determines the ring.
    return i < j ? i : j;
}

// Takes a container of containers of elements convertible to int.
// Must represent a square matrix with positive integer values.
// Argument-dependent lookup on the outer container must include
// namespace std, and both container types must have operator[] to
// get an element.  (So std::vector or std::array would work.)
// Returns:
//   1 for a concave matrix
//   2 for a convex matrix
//   3 for a flat matrix
//   0 for a mixed matrix
auto C /*Classify*/ = [](auto&& mat)
{
    int mat_size=size(mat), i=-1, j;
    std::map<int, Range> rings;

    // Populate rings with the range of values in each ring.
    for (; ++i<mat_size;)
        for (j=-1; ++j<mat_size;)
            rings[RingIndex(i, j, mat_size-1)].add(mat[i][j]);

    // Nested macros expand to
    // Range prev, curr; for ... if (...) {
    //   Range prev, curr; for ... if (...) {
    //     Range prev, curr; for ... if (...) {
    //       return 0;
    //     } return 3;
    //   } return 2;
    // } return 1
    // Note each scope declares its own prev and curr which hide
    // outer declarations.
    TEST(greater, TEST(less, TEST(equal, return 0) 3) 2) 1;
};
— aschepler
সূত্র
1
আমি মনে করি না যে 'নিফটি' এর অর্থ যা বোঝায় তার অর্থ
— ASCII-
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.