আন্টি ক্রম

Question

ভূমিকা

ধরুন আপনার 0 থেকে r-1 পর্যন্ত সংখ্যার একটি শাসক রয়েছে । আপনি কোনও দুটি সংখ্যার মধ্যে একটি পিপড়া রাখুন এবং এটি ক্ষমতার উপর ক্রমবর্ধমান ক্রল হওয়া শুরু করে। শাসক এতটাই সংকীর্ণ যে পিপড়াটি সমস্ত সংখ্যার মাঝখানে হাঁটা ছাড়াই এক অবস্থান থেকে অন্য অবস্থানে যেতে পারে না। যেভাবে পিঁপড়া প্রথমবার কোনও সংখ্যায় চলে যায়, আপনি এটি রেকর্ড করেন এবং এটি আপনাকে আর সংখ্যার একটি অনুমান দেয় । আমরা বলি যে কোনও ক্রমিনেশনটি এন্টিসি হয় যদি এটি কোনও পিঁপড়ে এইভাবে উত্পন্ন করতে পারে। বিকল্পভাবে, একটি প্রবেশপত্র পি হ'ল antsy হয় যদি প্রথমটি ব্যতীত প্রতিটি প্রবেশ পি [i] কিছু পূর্ববর্তী এন্ট্রি থেকে দূরত্ব 1 এর মধ্যে থাকে।

উদাহরণ

দৈর্ঘ্য -6 অনুক্রম

4, 3, 5, 2, 1, 0

, বিরোধ কারণ 3 দূরত্ব 1 মধ্যে 4 , 5 দূরত্ব 1 মধ্যে 4 , 2 থেকে দূরত্ব 1 মধ্যে 3 , 1 থেকে দূরত্ব 1 মধ্যে 2 , এবং 0 থেকে দূরত্ব 1 মধ্যে 1 । অনুচ্ছেদ

3, 2, 5, 4, 1, 0

অ্যান্টসি নয়, কারণ 5 3 বা 2 এর মধ্যে 1 দূরত্বের মধ্যে নয় ; পিপীলিকা মধ্য দিয়ে পাস করতে হবে 4 পেতে 5 ।

কাজটি

যে কোনও যুক্তিসঙ্গত বিন্যাসে 1 ≤ r ≤ 100 এর জন্য 0 থেকে r-1 পর্যন্ত সংখ্যার ক্রমবর্ধন দেওয়া , যদি আদেশটি antsy হয় তবে সত্যবাদী মান এবং যদি না হয় তবে মিথ্যা মান নির্ধারণ করে।

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

[0] -> True
[0, 1] -> True
[1, 0] -> True
[0, 1, 2] -> True
[0, 2, 1] -> False
[2, 1, 3, 0] -> True
[3, 1, 0, 2] -> False
[1, 2, 0, 3] -> True
[2, 3, 1, 4, 0] -> True
[2, 3, 0, 4, 1] -> False
[0, 5, 1, 3, 2, 4] -> False
[6, 5, 4, 7, 3, 8, 9, 2, 1, 0] -> True
[4, 3, 5, 6, 7, 2, 9, 1, 0, 8] -> False
[5, 2, 7, 9, 6, 8, 0, 4, 1, 3] -> False
[20, 13, 7, 0, 14, 16, 10, 24, 21, 1, 8, 23, 17, 18, 11, 2, 6, 22, 4, 5, 9, 12, 3, 15, 19] -> False
[34, 36, 99, 94, 77, 93, 31, 90, 21, 88, 30, 66, 92, 83, 42, 5, 86, 11, 15, 78, 40, 48, 22, 29, 95, 64, 97, 43, 14, 33, 69, 49, 50, 35, 74, 46, 26, 51, 75, 87, 23, 85, 41, 98, 82, 79, 59, 56, 37, 96, 45, 17, 32, 91, 62, 20, 4, 9, 2, 18, 27, 60, 63, 25, 61, 76, 1, 55, 16, 8, 6, 38, 54, 47, 73, 67, 53, 57, 7, 72, 84, 39, 52, 58, 0, 89, 12, 68, 70, 24, 80, 3, 44, 13, 28, 10, 71, 65, 81, 19] -> False
[47, 48, 46, 45, 44, 49, 43, 42, 41, 50, 40, 39, 38, 51, 37, 36, 52, 35, 34, 33, 32, 53, 54, 31, 30, 55, 56, 29, 28, 57, 58, 59, 60, 27, 26, 61, 25, 62, 63, 64, 65, 66, 67, 24, 23, 22, 21, 68, 69, 20, 19, 18, 17, 70, 71, 16, 15, 72, 73, 74, 75, 76, 14, 13, 12, 77, 11, 10, 9, 8, 78, 7, 79, 80, 6, 81, 5, 4, 3, 82, 2, 83, 84, 1, 85, 86, 87, 0, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99] -> True

মজাদার ঘটনা: r ≥ 1 এর জন্য , দৈর্ঘ্যের r এর ঠিক 2 টি ^{আর -1} অ্যান্টসি অনুমতি রয়েছে ।

Comments

এটি বিভিন্ন বিভিন্ন সমাধান সহ একটি খুব আকর্ষণীয় চ্যালেঞ্জ: আমি এখনও অবধি কমপক্ষে 7 টি অনন্য কৌশল ব্যবহৃত হচ্ছে বলে গণ্য করি।

— ETH প্রোডাকশনগুলি

ক্রমবিন্যাসের কাঠামোগত ইনপুট ফর্মটি বিভিন্ন পদ্ধতির ক্ষেত্রে প্রচুর অবদান রাখছে। অ্যান্টসি হওয়ার শর্তটি বিভিন্ন উপায়ে প্রকাশ করা যেতে পারে যা সাধারণ তালিকায় অসম qu

— xnor

আমি হতাশ এখনও কোন এএনটিএসআই সি সমাধান নেই।

— নোসিয়েটবেল্টস

Answer 1

পাইথ, 7 বাইট

/y+_QQS

এটি অনলাইনে চেষ্টা করুন। (ক্ষুদ্রতর রান-টাইমের কারণে কেবলমাত্র ছোট পরীক্ষার কেসগুলি অন্তর্ভুক্ত থাকে Truth) সত্যের জন্য আউটপুট 2, ফ্যালসির জন্য 0।

/          Count the number of occurences of
      S     the sorted input (implicit Q)
 y          in the order-preserved power set
  +_QQ       of the input prepended by its reverse

অন্য কথায়,

lambda l: subseq(sorted(l), concat(reverse(l), l))

যেখানে subseqপ্রথম তালিকার উপাদানগুলি দ্বিতীয় তালিকার ক্রমে উপস্থিত রয়েছে কিনা তা আউটপুট দেয়, অগত্যা সংলগ্ন নয়। subseqPyth দ্বিতীয় তালিকার সব সাব-সেট নির্বাচন, যা উপাদানের ক্রম রাখা গ্রহণ, এবং প্রথম তালিকার ঘটনার সংখ্যা গণনা দ্বারা সম্পন্ন করা হয়। এটি ক্ষতিকারক সময় নেয়।

কেন এই কাজ করে? অ্যান্টসি হওয়ার জন্য ক্রমুয়েশনের জন্য, 0 থেকে এন -1 এ পদক্ষেপটি কেবল বাম দিকে যেতে হবে এবং তারপরে কেবল ডান দিকে যেতে হবে। এটি কারণ প্রথম উপাদানের চেয়ে বড় উপাদানগুলি বাম থেকে ডান বাড়িয়ে তুলতে হবে এবং এর চেয়ে কম সেগুলি অবশ্যই বাম থেকে ডানে হ্রাস পাবে।

[2, 3, 1, 4, 0]
             ^
       ^     0
 ^     1      
 2  ^        
    3     ^
          4

আমরা যদি তার বাম দিকে বিপরীত অনুলিপি রেখে তালিকাটি মিরর করি তবে এই হাঁটা এখন কেবল ডানদিকে যায়।

[0, 4, 1, 3, 2, 2, 3, 1, 4, 0]
 ^            |             
 0     ^      |             
       1      | ^           
              | 2  ^        
              |    3     ^  
              |          4                                  

বিপরীতে, এই আয়না তালিকার যে কোনও ডানদিকে মূল তালিকাটির বাম-পরে-ডান হাঁটার সাথে মিল রয়েছে। এই ডানদিকটি কেবল 0 থেকে এন -1 এর সাজানো উপসংস্থান subse অ্যান্টসি তালিকায়, এই প্রথম বাছাই করা মূল উপাদানটি দুটি সংলগ্ন অনুলিপিগুলির মধ্যে একটি স্বেচ্ছাসেবী পছন্দ ব্যতীত, সাজানো যথাযথটি অনন্য।

Comments

আপনি এটি ব্যবহার করে 6 টি বাইটে কেটে ফেলতে পারেন ... খালি মজা করে।

— jwg

সুস্পষ্ট রৈখিক-সময় সমাধান সহ কোনও সমস্যার জন্য ক্ষতিকারক-সময় পদ্ধতির ব্যবহার সম্পর্কে এমন কিছু ঘৃণ্য কিছু রয়েছে যা এমনকি যদি এটি নিখরচায় পড়ে যায়।

— ডেভিড কনরাড 21

@jwg আমি আসলে এটি বিশ্বাস করব। যদি তালিকার গণনাটি বিপরীত ক্রমে যুক্তি নিয়ে থাকে, আপনি দুটি ইনপুট উত্তোলন করে 6 বাইট পেতে পারেন।

— xnor

অয়্য্য, পাইথ দিকে ঘুরছেন: ডি

— মাল্টেসেন

Answer 2

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

(%)=scanl1
f l=zipWith(+)(min%l)[0..]==max%l

চলমান ম্যাক্সিমার এবং চলমান মিনিমার ভেক্টর পার্থক্য [0,1,2,3 ...] কিনা তা পরীক্ষা করে।

l =             [2, 3, 1, 4, 0]

scanl1 max l =  [2, 3, 3, 4, 0]
scanl1 min l =  [2, 2, 1, 1, 0]  
difference =    [0, 1, 2, 3, 4]

Zgarb এর সাথে 2 বাইট সংরক্ষণ করেছে (%)=scanl1।

Comments

এতো চালাক! +1

— গ্যাব্রিয়েল বেনামি

আপনি নির্দিষ্ট করে কিছু বাইট সংরক্ষণ করতে পারেন (#)=scanl1?

— Zgarb

@ জগারব ধন্যবাদ, আমি ভুলে গেছি আপনি এটি করতে পারতেন।

— xnor

Answer 3

জাভাস্ক্রিপ্ট (ES6), 45

a=>a.every((v,i)=>a[v]=!i|a[v-1]|a[v+1],a=[])

আমি ভেবেছিলাম ব্যাখ্যা হিসাবে এটি প্রয়োজন খুব সহজ, তবে একটি কৌশল আছে, এবং কেবলমাত্র ক্ষেত্রে, এখানে আমার প্রথম সংস্করণ, প্রাক-গল্ফ

a => {
  k = []; // I'll put a 1 in this array at position of each value 
          // that I find scanning the input list
  return a.every((v,i) => { // execute for each element v at position i
    // the index i is needed to manage the first iteration
    // return 1/true if ok, 0/false if not valid
    // .every will stop and return false if any iteration return falsy
    k[v] = 1; // mark the current position
    if ( i == 0 )
    {  // the first element is always valid
       return true;
    }
    else
    {
       return k[v-1] == 1 // valid if near a lesser value
              || k[v+1] == 1; // or valid if near a greater value
    }
  })
}

দ্রষ্টব্য: গল্ফ কোডটির aপরিবর্তে ব্যবহৃত হয় k, কারণ আমার everyকলটির অভ্যন্তরে মূল অ্যারের কোনও রেফারেন্স প্রয়োজন নেই । সুতরাং আমি প্যারামিটারটি পুনরায় ব্যবহার করে বিশ্বব্যাপী নেমস্পেসকে দূষিত করা এড়াতে চাই

পরীক্ষা

antsy=
a=>a.every((v,i)=>a[v]=!i|a[v-1]|a[v+1],a=[])

var OkAll=true
;`[0] -> True
[0, 1] -> True
[1, 0] -> True
[0, 1, 2] -> True
[0, 2, 1] -> False
[2, 1, 3, 0] -> True
[3, 1, 0, 2] -> False
[1, 2, 0, 3] -> True
[2, 3, 1, 4, 0] -> True
[2, 3, 0, 4, 1] -> False
[0, 5, 1, 3, 2, 4] -> False
[6, 5, 4, 7, 3, 8, 9, 2, 1, 0] -> True
[4, 3, 5, 6, 7, 2, 9, 1, 0, 8] -> False
[5, 2, 7, 9, 6, 8, 0, 4, 1, 3] -> False
[20, 13, 7, 0, 14, 16, 10, 24, 21, 1, 8, 23, 17, 18, 11, 2, 6, 22, 4, 5, 9, 12, 3, 15, 19] -> False
[34, 36, 99, 94, 77, 93, 31, 90, 21, 88, 30, 66, 92, 83, 42, 5, 86, 11, 15, 78, 40, 48, 22, 29, 95, 64, 97, 43, 14, 33, 69, 49, 50, 35, 74, 46, 26, 51, 75, 87, 23, 85, 41, 98, 82, 79, 59, 56, 37, 96, 45, 17, 32, 91, 62, 20, 4, 9, 2, 18, 27, 60, 63, 25, 61, 76, 1, 55, 16, 8, 6, 38, 54, 47, 73, 67, 53, 57, 7, 72, 84, 39, 52, 58, 0, 89, 12, 68, 70, 24, 80, 3, 44, 13, 28, 10, 71, 65, 81, 19] -> False
[47, 48, 46, 45, 44, 49, 43, 42, 41, 50, 40, 39, 38, 51, 37, 36, 52, 35, 34, 33, 32, 53, 54, 31, 30, 55, 56, 29, 28, 57, 58, 59, 60, 27, 26, 61, 25, 62, 63, 64, 65, 66, 67, 24, 23, 22, 21, 68, 69, 20, 19, 18, 17, 70, 71, 16, 15, 72, 73, 74, 75, 76, 14, 13, 12, 77, 11, 10, 9, 8, 78, 7, 79, 80, 6, 81, 5, 4, 3, 82, 2, 83, 84, 1, 85, 86, 87, 0, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99] -> True`
.split`\n`.forEach(row => {
  var rowElements = row.match(/\w+/g), 
      expected = rowElements.pop()=='True',
      input = rowElements.map(x => +x),
      result = antsy(input),
      ok = result == expected;
  OkAll = OkAll && ok;
  console.log(ok?'OK':'KO', input+' -> '+result)
})
console.log(OkAll ? 'All passed' : 'Failed')

Comments

বাস্তব সুন্দর। আমি পুনরাবৃত্তি সহ এই পদ্ধতির চেষ্টা করেছি, তবে আমি এটি 65 এর নিচে পেতে পারি না:f=([q,...a],x=[])=>x&&(x[q]=!(x+x)|x[q+1]|x[q-1])&&(a+a?f(a,x):1)

— ইটিএইচ প্রডাকশনগুলি

কিভাবে কাজ করে? আপনি কিছু পরিবর্তনযোগ্য তালিকার যাদু ব্যবহার করছেন?

— Zgarb

@ জাগারব ব্যাখ্যা যুক্ত হয়েছে

— edc65

Answer 4

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

f=lambda l:l==[]or max(l)-min(l)<len(l)*f(l[:-1])

তালিকার প্রতিটি উপসর্গ তার ন্যূনতম এবং সর্বোচ্চ অন্তর্ভুক্তের মধ্যে সমস্ত সংখ্যা রয়েছে কিনা তা যাচাই করে। সর্বোচ্চ এবং মিনিটের পার্থক্য তার দৈর্ঘ্যের চেয়ে কম কিনা তা পরীক্ষা করে এটি করে does

---

54 বাইট:

f=lambda l:1/len(l)or-~l.pop()in[min(l),max(l)+2]*f(l)

শেষের উপাদানটি অন্য উপাদানের মিনিটের চেয়ে এক বা তার সর্বোচ্চের চেয়ে আরও বেশি কিনা তা পরীক্ষা করে। তারপরে, শেষ উপাদানটি সরিয়ে পুনরাবৃত্তি করে। একটি একক উপাদান তালিকায়, আউটপুট দেয়।

এটি একটি মজাদার কিন্তু দীর্ঘ তালিকা বোঝার মাধ্যমেও চেক করা যায়।

lambda l:all(l.pop()in[min(l)-1,max(l)+1]for _ in l[1:])

আমি অসমতাটি ব্যবহার করতে চাই min(l)-2<l.pop()<max(l)+2তবে popপ্রয়োজনটি প্রথমে হওয়া দরকার। ত্রুটি কোডের মাধ্যমে আউটপুটটিতে একটি প্রোগ্রাম ব্যবহার করা সম্ভবত সংক্ষিপ্ত হবে।

Answer 5

গণিত, 42 বাইট

!MatchQ[#,{a__,b_,___}/;Min@Abs[{a}-b]>1]&

একটি উপসর্গ চেষ্টা এবং অনুসন্ধান করার জন্য প্যাটার্ন মিল ব্যবহার করে aযার পরবর্তী উপাদান থেকে সর্বাধিক পার্থক্য (এবং ফলাফলটিকে অগ্রাহ্য করা ) bgreater1MatchQ

Answer 6

পার্ল, 39 38 35 বাইট

এর জন্য +1 অন্তর্ভুক্ত -p

এসটিডিনে ক্রম দিন:

antsy.pl <<< "2 1 3 0"

antsy.pl:

#!/usr/bin/perl -p
s%\d+%--$a[$&]x"@a"=~/1  /%eg;$_++

Comments

আমি এটিকে বোঝার চেষ্টা করে খুব কষ্ট পাচ্ছি ... একটু ব্যাখ্যা করার যত্ন নিই? ধন্যবাদ :-) (কেবল মূল ধারণাটি যথেষ্ট হওয়া উচিত)

— দাদা

Answer 7

এমএটিএল , 11 বাইট

&-|R1=a4L)A

এটি অনলাইন চেষ্টা করুন! বা সমস্ত পরীক্ষার কেস যাচাই করুন ।

ব্যাখ্যা

এটি সমস্ত জোড়াযুক্ত পরম পার্থক্যগুলির একটি ম্যাট্রিক্স গণনা করে এবং উপরের ত্রিভুজাকার অংশকে রাখে। ফলাফলটি সত্য যদি প্রথমটি ব্যতীত সমস্ত কলামে কমপক্ষে 1 টি মান থাকে।

&-     % All pairwise differences
|      % Absolute value
R      % Upper triangular part
1=     % Does each entry equal 1?
a      % Logical "or" along each column
4L)    % Remove first value
A      % Logical "and" of all results

Answer 8

আর, 72 64 60 বাইট

v=scan();for(i in seq(v))T=c(T,diff(sort(v[1:i])));all(T==1)

একটি ক্রমায়ন হ'ল অ্যান্টসি এবং কেবলমাত্র যদি তার সমস্ত বাম সাবপারমুটেশন ক্রমাগত থাকে (যেমন বাছাই করার সময় তার মধ্যে পার্থক্য থাকে)।

যদি ইনপুটটির দৈর্ঘ্য একের বেশি হওয়ার নিশ্চয়তা থাকে তবে আমরা এর 1:sum(1|v)সাথে প্রতিস্থাপন করতে পারি seq(v), যা চারটি বাইট সংরক্ষণ করে।

seq(v)যদি শর্ত আচরণ করবে ভিন্নভাবে যখন ইনপুট দৈর্ঘ্য এক হয় --- এটি ক্রম উত্পন্ন 1:vপরিবর্তে seq_along(v)। যাইহোক, ভাগ্যক্রমে, আউটপুট TRUEএই ক্ষেত্রে হতে দেখা যায় , যা পছন্দসই আচরণ। শূন্য-দৈর্ঘ্যের ইনপুটগুলির ক্ষেত্রেও একই ঘটনা ঘটে।

আর-তে, Tএকটি পূর্ব নির্ধারিত ভেরিয়েবল সমান TRUE(তবে আর আপনাকে এটি পুনরায় সংজ্ঞায়িত করতে দেয়)। TRUEসমান বলে গণ্য হয় 1।

আসল সমাধানটিতে কিছু সহায়ক উন্নতির জন্য @ বিলিওবকে ধন্যবাদ

Comments

ইনপুট ব্যবহার করে পড়া scanআপনার দুটি বাইট সংরক্ষণ করতে পারে। সেক্ষেত্রে এটি forলুপ পদ্ধতির মতো হুবহু একই সংখ্যক বাইট : v=scan();c=c();for(i in 1:sum(1|v))c=c(c,diff(sort(v[1:i])));all(c==1)যা আপনার ভেক্টরাইজড পদ্ধতির চেয়ে 2 বাইট কম হবে।

— বিলিওব

চমৎকার ধারণা, এবং আমি যেতে পারেন এক ভাল আমি অপব্যবহারের দ্বারা মনে T। সম্পাদনা করবে।

— জেডিএল

Answer 9

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

Âìæ¹{¢O

এটি অনলাইন চেষ্টা করুন! বা পরিবর্তিত পরীক্ষার স্যুট হিসাবে ।

ব্যাখ্যা

Xnor দ্বারা বর্ণিত প্রক্রিয়াটি তার উজ্জ্বল পাইথ উত্তরে ব্যবহার করুন ।
সত্যবাদী দৃষ্টান্তের জন্য 2 এবং মিথ্যা বলে 0 প্রদান করে।

Âì        # prepend a reversed copy of input to input
  æ       # take powerset
   ¹{     # push a sorted copy of input
     ¢    # count occurances of sorted input in powerset
      O   # sum occurances (which for some reason is needed, feels like a bug)

Answer 10

পার্ল, 63 বাইট

নোট করুন যে @ গ্যাব্রিয়েল বনামি একটি সংক্ষিপ্ত (55 বাইট) উত্তর নিয়ে এসেছেন । তবে আমি মনে করি এই সমাধানটি এখনও আকর্ষণীয়, তাই আমি এটি পোস্ট করছি।

বাইটস গণনায় কোড এবং -nপতাকা 62 বাইট অন্তর্ভুক্ত ।

s/\d+/1x($&+1)/ge;/ 1(1*)\b(?{$.&=$`=~m%\b(11)?$1\b%})^/;say$.

এটি চালানোর জন্য:

perl -nE 's/\d+/1x($&+1)/ge;/ 1(1*)\b(?{$.&=$`=~m%\b(11)?$1\b%})^/;say$.' <<< "3 2 5 4 1 0"

সংক্ষিপ্ত ব্যাখ্যা : প্রতিটি সংখ্যাকে kঅবিচ্ছিন্ন উপস্থাপনায় রূপান্তরিত করে k+1(এটি +1প্রয়োজন যাতে 0এস অবহেলা না হয়)। তারপর প্রতিটি সংখ্যার জন্য k+1(যেমন ইউনারী প্রকাশ 1(1*)), আমরা চেহারা যদি পারেন k( $1ঝুলিতে k) অথবা k+2(যা তারপর 11$1) পূর্ববর্তী স্ট্রিং (দ্বারা সমর্থিত উপস্থিত $-backtick)। যদি না হয়, তবে আমরা $.শূন্যতে সেট করি । তারপরে আমরা মুদ্রণ করব $.যা আমরা 1যদি এটি কখনই শূন্য বা অন্যথায় শূন্যতে না সেট করি।

Answer 11

মস্তিষ্ক-ফ্লাক 302 264 256 বাইট

46 বাইট সংরক্ষণের জন্য গম উইজার্ডকে ধন্যবাদ

([]){{}({}<>)<>([])}{}<>(({}))([]){{}({}<>)<>([])}{}<>(({}<>))<>(()){{}(({})<(({})<>[({})]<>(())){((<{}{}>))}{}{{}({}<><{}>)(<>)}{}<>({}<<>(({})<>[({})<>(())]){((<{}{}>))}{}{{}({}<><{}>)(<>)}{}<>>)<>>[({})](<()>)){{}{}(<(())>)}{}}([][()(())]){((<{}{}>))}{}

স্ট্যাকের শীর্ষটি সত্যবাদিতার জন্য 1 এবং মিথ্যাচারের জন্য 0 হবে।

সত্যবাদী: অনলাইনে চেষ্টা করে দেখুন!
মিথ্যা: অনলাইন চেষ্টা করে দেখুন!

অফটি স্ট্যাকটিতে পিপড়াটি যে সর্বনিম্ন এবং সর্বাধিক সংখ্যক পরিদর্শন করেছে সেটিকে ধারণ করার ধারণা The তারপরে প্রতিটি সংখ্যাটিকে উভয়ের সাথে তুলনা করুন এবং উপযুক্ত একটিটি আপডেট করুন। যদি পরবর্তী সংখ্যাটি নূন্যতমের চেয়ে 1 কম বা সর্বোচ্চের চেয়ে 1 না বেশি হয় তবে লুপটি ভেঙে মিথ্যা প্রত্যাবর্তন করুন।

---

সংক্ষিপ্ত বর্ণনা:

([])                             # duplicate the bottom element by
{{}({}<>)<>([])}{}<>             # reversing everything onto the other stack 
(({}))([])                       # duplicating the top element
{{}({}<>)<>([])}{}<>             # and reversing everything back

(({}<>))<>                       # copy the top element to the other stack (push twice)
(()){{}                          # push a 1 so the loop starts, and repeat until the top
                                 # two elements are equal
(({})<                           # hold onto the top element to compare later
(({})<>[({})]<>(()))             # push a 0 if diff with the top of the other stack is +1
{{}({}<><{}>)(<>)}{}             # logical not (the previous line pushed a 1 as the second
                                 # element already)
{{}({}<><{}>)<>(<()>)}{}         # replace the top of the other stack with this element if
                                 # the logical not gave us 1
<>({}<<>                         # take the minimum off the other stack temporarily 
(({})<>[({})<>(())])             # push a 0 if diff with the top of the other stack is -1
{((<{}{}>))}{}                   # logical not (the previous line pushed a 1 as the second
                                 # element already)
{{}({}<><{}>)(<>)}{}             # replace the top of the other stack with this element if
                                 # the logical not gave us 1
<>>)<>                           # put the minimum on back on
>)                               # put the element you were comparing back on
[({})](<()>)){{}{}(<(())>)}{}    # push 1 or 0 for not equal to the element we held earlier
                                 # (push the second number back on)
}                                # repeat the loop if the top 2 weren't equal
([][()(())]){((<{}{}>))}{}       # logical not of the height of the stack

Comments

আমি পুশ পপ হ্রাসের জন্য যাচাই করব আমি ইতিমধ্যে কয়েকটি জায়গা দেখছি যেখানে আপনি এই কৌশলটি ব্যবহার করতে পারেন।

— গম উইজার্ড

@ ওয়েট উইজার্ড আমি নিশ্চিত যে কয়েকটি আছে, এখনও তাদের কাজ করার মতো সময় আমার হাতে নেই। অনুস্মারকটির জন্য ধন্যবাদ।

— রিলে

আমি আনন্দের সাথে এটি কমপক্ষে আপনার কাছে বোধগম্য

— হয়েছি

আপনি আরও কয়েকটি বাইট সংরক্ষণের উদাহরণগুলির ([]){({}[()]<({}<>)<>>)}{}সাথে প্রতিস্থাপন করতে পারেন([]){{}({}<>)<>([])}{}

— গম উইজার্ড

Answer 12

জেলি , 9 8 7 বাইট

;@UŒPċṢ

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

Xnor এর উত্তরের একটি জেলি অনুবাদ।

পুরানো সমাধান:

;\Ṣ€IỊȦ
;\Ṣ€IE€P

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

নীচে আমার পাইথ উত্তরের সাথে খুব একইভাবে কাজ করে:

;\          All prefixes (Accumulate (\) over concatenation (;))
  Ṣ€        (Ṣ)ort each (€) prefix
    I       (I)ncrements of each prefix (differences between consecutive elements).  Implicit vectorization.
     E€     Check if all elements are (E)qual (they will be iff the permutation is antsy,
               and all elements will be 1) for each (€) prefix
       P    Is this true for all prefixes?
     ỊȦ     For the other answer, are (Ȧ)ll elements 1 or less (Ị)?

Comments

জিনির সাথে এক্সনরের অন্যান্য পদ্ধতির রূপান্তরটিও tes বাইট »\_«\⁼Ṣতবে আরও কার্যকর

— মাইল মাইল

ŒBŒPċṢএবং ;\Ṣ€IỊȦপ্রতিটি পদ্ধতির একটি বাইট সংরক্ষণ করা উচিত।

— ডেনিস

দুর্ভাগ্যক্রমে, প্রথমটি কাজ করে না কারণ আমার বিপরীত ইনপুটটি বাউন্স করা দরকার, UŒBŒPċṢযা কোনও বাইট সংরক্ষণ করে না। Ịযদিও সুন্দর; আমি এটাকে ভুলভাবে লিখেছিলাম যে এটি আসলে কী করেছে তার যৌক্তিক নোট আউটপুট করতে।

— স্টিভেন এইচ।

আপনার কেন প্রয়োজন হবে তা আমি নিশ্চিত নই U(বা @এখন যা আমি এটি সম্পর্কে চিন্তা করি)। যদি একটি অ্যারে অ্যান্টসি হয়, তবে বিপরীত অ্যারে, না?

— ডেনিস

অগত্যা নয়: [2, 1, 3, 0]অ্যান্টসি তবে [0, 3, 1, 2]তা নয়।

— স্টিভেন এইচ।

Answer 13

সিজেএম ( 21 20 বাইট)

{:A,{_)A<$2*)@-#},!}

অনলাইন পরীক্ষা স্যুট

ব্যবচ্ছেদ

এটি তার হাস্কেল উত্তরে xnor দ্বারা পর্যবেক্ষণ ব্যবহার করে যে প্রথম nউপাদানগুলির সর্বোচ্চ এবং সর্বনিম্নের মধ্যে পার্থক্য হওয়া উচিত n-1।

{         e# Define a block. Stack: array
  :A,     e#   Store the array in A and get its length
  {       e#   Filter (with implicit , so over the array [0 ... len-1])
    _)A<  e#     Get the first i+1 elements of A (so we iterate over prefixes)
    $2*)  e#     Extract the last element without leaving an empty array if the
          e#     prefix is of length 1 by first duplicating the contents of the
          e#     prefix and then popping the last element
    @-#   e#     Search the prefix for max(prefix)-i, which should be min(prefix)
          e#     giving index 0
  },      e#   So the filter finds values of i for which the prefix of length i+1
          e#   doesn't have max(prefix) - min(prefix) = i
  !       e#   Negate, giving truthy iff there was no i matching the filter
}

---

বিকল্প পদ্ধতি (এছাড়াও 20 বাইট)

{_{a+_)f-:z1&,*}*^!}

অনলাইন পরীক্ষা স্যুট

এটি সরাসরি পরীক্ষা করে যে প্রথমটির পরে প্রতিটি উপাদান পূর্ববর্তী উপাদান থেকে 1 এর দূরত্বে থাকে। যেহেতু ইনপুটটি একটি ক্রমশক্তি এবং তাই মানগুলি পুনরাবৃত্তি করে না, এটি যথেষ্ট পরীক্ষা is 1-বাইট সংরক্ষণের জন্য মার্টিনকে ধন্যবাদ।

ব্যবচ্ছেদ

{_{a+_)f-:z1&,*}*^!}

{         e# Declare a block. Stack: array
  _       e#   Work with a copy of the array
  {       e#   Fold...
    a+    e#     Add to the accumulator.
    _)f-  e#     Dup, pop last, map subtraction to get distance of this element from
          e#     each of the previous ones
    :z1&, e#     Check whether the absolute values include 1
    *     e#     If not, replace the accumulator with an empty array
  }*
  ^!      e#   Test whether the accumulator is equal to the original array
          e#   Note that this can't just be = because if the array is of length 1
          e#   the accumulator will be 0 rather than [0]
}

Comments

আমি মনে করি এটি একটি বাঁচায়? {_{a+_)f-:z1&,*}*^!}

— মার্টিন ইন্ডার

@ মার্টিনএেন্ডার, খুব সুন্দর কৌতূহলীভাবে আপনি পোস্ট করেছেন যে আমি একই বাইট গণনা সহ সম্পূর্ণ ভিন্ন পদ্ধতির পোস্ট করছি।

— পিটার টেলর 21

Answer 14

জাভা, 100 98 79 75 বাইট

a->{int n=a[0],m=n-1;for(int i:a)n-=i==m+1?m-m++:i==n-1?1:n+1;return n==0;}

পূর্বে:

a->{int m,n;m=n=a[0];--m;for(int i:a)if(i==m+1)m=i;else if(i==n-1)n=i;else return 0>1;return 1>0;}

প্রতিস্থাপন 3 বাইট সংরক্ষিত trueএবং falseসঙ্গে 1>0এবং 0>1।

23 বাইট সংরক্ষণ করা হয়েছে পিটার টেলারের দুর্দান্ত পরামর্শের জন্য ধন্যবাদ!

Ungolfed:

a -> {
    int n = a[0], m = n - 1;
    for (int i : a)
        n -= i == m + 1? m - m++ : i == n - 1? 1 : n + 1;
    return n == 0;
}

এখন পর্যন্ত দেখা সর্বোচ্চ এবং সর্বনিম্ন মানগুলির উপর নজর রাখুন mএবং n; কেবলমাত্র একটি নতুন মান যদি এটি হয় m + 1বা n - 1পরবর্তী উচ্চতর বা নিম্ন মানের হয় তবে তা গ্রহণ করুন ; উচ্চ মানের, mপ্রথম উপাদানের তুলনায় একটিকে কম আরম্ভ করুন যাতে এটি লুপের চারপাশে প্রথম "মিলবে"। দ্রষ্টব্য: এটি একটি লিনিয়ার-সময়, অনলাইন অ্যালগরিদম। বর্তমানের সর্বোচ্চ, এতদূর এবং নিম্নতম-এতদূরের মানগুলির জন্য এটি কেবলমাত্র তিনটি শব্দের প্রয়োজন, অন্যান্য সমাধানগুলির অনেকগুলি ভিন্ন।

যদি পরবর্তী মানটি রেঞ্জের উচ্চ এবং নিম্ন প্রান্ত উভয়টি মিস করে তবে সর্বনিম্ন-এতদূর মান সেট করা থাকে -1এবং তারপরে নিম্ন প্রান্তটি কখনই এগিয়ে যেতে পারে না এবং শূন্যে পৌঁছতে পারে না। এরপরে আমরা নিম্ন মানের মান nশূন্যে পৌঁছেছে কিনা তা পরীক্ষা করে একটি অ্যান্টসি ক্রম সনাক্ত করি ।

(দুর্ভাগ্যক্রমে এটি কম দক্ষ কারণ আমাদের সর্বদা প্রথম ভুল সংখ্যার পরে জামিন দেওয়ার চেয়ে পুরো ক্রমটি সন্ধান করতে হবে, তবে অন্যান্য সমাধানগুলি ও (এন ^ 2 ব্যবহার করার সময় 23-বাইট সঞ্চয় (!) দিয়ে তর্ক করা শক্ত) ) এবং তাত্পর্যপূর্ণ সময় সমীকরণ।)

ব্যবহার:

import java.util.function.Predicate;

public class Antsy {
    public static void main(String[] args) {
        int[] values = { 6, 5, 4, 7, 3, 8, 9, 2, 1, 0 };
        System.out.println(test(values,
            a -> {
                int n = a[0], m = n - 1;
                for (int i : a)
                    n -= i == m + 1? m - m++ : i == n - 1? 1 : n + 1;
                return n == 0;
            }
        ));
    }

    public static boolean test(int[] values, Predicate<int[]> pred) {
        return pred.test(values);
    }
}

দ্রষ্টব্য: জাভা 8 লম্বাডাসের সুবিধা না নিয়েও এটি লেখা যেতে পারে:

জাভা 7, 89 বাইট

boolean c(int[]a){int n=a[0],m=n-1;for(int i:a)n-=i==m+1?m-m++:i==n-1?1:n+1;return n==0;}

Comments

বিশেষ ক্ষেত্রে ভাল পরিচালনা। int m,n;m=n=a[0];--m;হতে পারে int n=a[0],m=n-1;, এবং ব্যয়বহুল returnএবং এর elseসাথে হ্রাস করা যেতে পারে i==m+1?m++:n=(i==n-1)?i:-1;return n==0;(বা অনুরূপ কিছু - আমি এটি পরীক্ষা করিনি)।

— পিটার টেলর

@ পিটারটেলর ফ্যান্টাস্টিক! দুর্ভাগ্যক্রমে, জাভা কোনও পার্শ্ব প্রতিক্রিয়া যেমন m++বা m+=1সেখানে অনুমতি দেবে না , তাই আমার এখনও একটি ifএবং একটি দরকার elseএবং এটি প্রথম খারাপ মানটির উপর দিয়ে শর্ট সার্কিটের দিকটি হারাতে থাকে তবে এটি একটি বড় উন্নতি। ধন্যবাদ!

— ডেভিড কনরাড

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

— পিটার টেলর

@ পিটারটেলর ওয়েল, আমি এটিকে কয়েকটি ডামি ভেরিয়েবল সহ নির্ধারণ সহ কয়েকটি প্রকারের চেষ্টা করেছি gএবং আমি এটি কাজে লাগাতে পারিনি। (আমি জাভা 9-ইএ + 138 ব্যবহার করছি, এটি জাভা 8 এবং জাভা 9 এর মধ্যে পার্থক্য আছে?) আমি আগামীকাল আবার চেষ্টা করতে পারি।

— ডেভিড কনরাড

বুঝেছি. n-=i==m+1?m-m++:i==n-1?1:n+1;

— পিটার টেলর

Answer 15

পাইথ ( কাঁটাচামচ ), 13 বাইট

!sstMM.+MSM._

পাইথের এই কাঁটাচামড়ার জন্য অনলাইনে চেষ্টা করুন না অনলাইন লিঙ্ক। কাঁটাচামচ ডেল্টাস ফাংশন অন্তর্ভুক্ত .+, যা স্ট্যান্ডার্ড পাইথ লাইব্রেরির অংশ নয়।

ব্যাখ্যা:

           ._  For each of the prefixes:
         SM    Sort it
      .+M      Get deltas (differences between consecutive elements), which for antsy
                 permutations would all be 1s
   tMM         Decrement each of the elements (all 0s for antsy permutations)
 ss            Sum all the results from the above together, 0 for antsy and >0 for non-antsy
!              Logical negation.

Comments

এটি দেখে আমার এটি পাইথের সাথে একীভূত করতে দৃin়প্রত্যয়ী হয়।

— isaacg

Answer 16

পার্ল, 66 54 +1 = 55 বাইট

জন্য +1 বাইট -n।

s/\d+/$.&=!@a||1~~[map{abs$_-$&}@a];push@a,$&/eg;say$.

ব্যাখ্যা:

s/\d+/$.&=!@a||1~~[map{abs$_-$&}@a];push@a,$&/eg;say$.
#input is automatically read into $_.
#regex automatically is performed on $_.
s/   /                                       /eg;
    #Substitution regex.
    #/g means to keep searching after the first match
    #/e evaluates the replacement as code instead of regex.
  \d+  #Match of at least 1 digit.  Match automatically gets stored in $&
      $.&=  #$. is initially 1.  This basically says $. = $. & (code)
           !@a  #Since @a is uninitialized, this returns !0, or 1
                #We don't want to check anything for the first match
              || #logical or
                1~~
                   #~~ is the smartmatch operator.  When RHS is scalar and LHS is array reference,
                   #it returns 1 iff RHS is equal to at least one value in de-referenced LHS.
                   [map{abs$_-$&}@a];
                       #Return an array reference to the array calculated by |$_ - $&|
                       #where $_ iterates over @a.  Remember $& is the stored digit capture.
                                     push@a,$& #pushes $& at the end of @a.
                                                 say$. #output the result

প্রিন্ট 0 টি মিথ্যা হলে, 1 সত্য হলে।

-11 বাইটস @ দাদাকে ধন্যবাদ

Comments

যে সত্যিই সুন্দর। আপনি এটিকে 55 বাইটে নামিয়ে দিতে পারেন যদিও perl -nE 's/\d+/$.&=!@a||1~~[map{abs$_-$&}@a];push@a,$&/eg;say$.': -nপরিবর্তে <>=~আপনি /rপরিবর্তক থেকে মুক্তি পেতে পারবেন of ব্যবহার \d+এবং তারপর $&পরিবর্তে (\d+)এবং $1। !@aপরিবর্তে 0>$#a। $.&=পরিবর্তে $.&&=। push@a,$&পরিবর্তে@a=(@a,$&)

— দাদা

কোনও কারণে, আমার সিস্টেম আমাকে বলেছে নতুন ফাইলটি 55 বাইট দীর্ঘ, যা স্পষ্টতই ভুল কারণ এটি কেবল 54 টি অক্ষর, তাই ???

— গ্যাব্রিয়েল বেনামি

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

— দাদা

শেষদিকে অপ্রয়োজনীয় নিউলাইন থাকায় ফাইলের কারণে বাইটের গণনাটি কি সম্ভব?

— ট্রাইকোপলাক্স

Answer 17

ব্রেইনফাক, 60 বাইট

,+[>+>+<<-]
,+
[
  [>->->+<<<-]
  >-
  [
    +>+
    [
      <<<
    ]
  ]
  >[>]
  <[<+<+>>-]
  <<<,+
]
>.

কোনও বিভাজক এবং কোনও সমাপনী নিউলাইন নেই এমন বাইট হিসাবে অনুক্রমটি দেওয়া হয়। যেহেতু \x00ইনপুটটিতে ঘটে তাই এটি প্রয়োগের জন্য ডিজাইন করা হয়েছে EOF = -1। আউটপুটটি \x00মিথ্যা এবং \x01সত্যের জন্য।

একটি বিন্যাস তাহলে \x01পর্যন্ত chr(r)অনুমোদিত হয়, তাহলে আমরা সমস্ত উদাহরণ প্রতিস্থাপন করতে পারেন ,+সঙ্গে ,একটি সঙ্গে 57 স্কোর জন্য EOF = 0বাস্তবায়ন।

এটি অনলাইনে চেষ্টা করে দেখুন (57-বাইট সংস্করণ): ইনপুট বাদে বাদে কোনও বেনিফিটের যথাযথ পরিসীমা হিসাবে দেওয়া যেতে পারে \x00এবং আউটপুটটি \x00মিথ্যা এবং সত্যের জন্য সর্বনিম্নের জন্য হবে।

আমরা এখনও অবধি দেখা সর্বনিম্ন নূন্যতম এবং সর্বাধিক ট্র্যাক করে থাকি এবং প্রথমটির পরে প্রতিটি চরিত্রের জন্য, এটি ন্যূনতম -1 বা সর্বোচ্চ +1 হয় না কিনা তা পরীক্ষা করে দেখুন। উভয়ের ক্ষেত্রেই, পয়েন্টারটিকে স্বাভাবিক কর্মস্থলের বাইরে নিয়ে যান যাতে স্থানীয় কক্ষগুলি শূন্য হয়।

মূল লুপের শুরুতে স্বাভাবিক কাজের জায়গার মেমরি লেআউটটি

c a b 0 0

cবর্তমান চরিত্রটি কোথায় , aসর্বনিম্ন এবং bসর্বোচ্চ। (-০-বাইট সংস্করণের জন্য, 1 এর অফসেট দিয়ে সমস্ত কিছু পরিচালনা করা হয় is ,+)

Answer 18

ব্র্যাচল্যাগ , 22 বাইট

:@[fb:{oLtT,Lh:T:efL}a

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

ব্যাখ্যা

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

:@[fb                       Take all but the first prefixes of the Input
     :{             }a      This predicate is true for all those prefixes
       oLtT,                Sort the prefix, call it L, its last element is T
            Lh:T            The list [First element of L, T]
                :efL        Find all integers between the First element of L and T. It must
                              result in L

Comments

প্রথম থেকে শেষের ব্যাপ্তি হল সিজেএমে আমার কাছে ঘটেছিল এমন একটি দৃষ্টিভঙ্গি। অন্যটি ছিল সাজানো, জোড়াযুক্ত পার্থক্য, তারা সবাই কি তা পরীক্ষা করুন 1। আমি জানি না ব্র্যাচল্যাগে এটি কতটা সহজ।

— পিটার টেলর

@ পিটারটেলর দুর্ভাগ্যক্রমে (এখনকার জন্য) একটানা জোড় (বা সরাসরি গণনা জুটি পার্থক্য) উত্পন্ন করার কোনও ছোট উপায় নেই।

— 09

Answer 19

ব্যাচ, 133 বাইট

@set/au=%1,l=%1-1,a=0
@for %%n in (%*)do @call:l %%n
@exit/b%a%
:l
@if %1==%u% (set/au+=1)else if %1==%l% (set/al-=1)else set a=1

কমান্ড-লাইন আর্গুমেন্ট হিসাবে ইনপুট নেয়। সাফল্যের জন্য ত্রুটি স্তর 0 সহ প্রস্থান করে, ব্যর্থতার জন্য 1।

Answer 20

জে, 14 বাইট

/:~-:>./\-<./\

এটি @ xnor এর পদ্ধতির উপর ভিত্তি করে ।

ব্যাখ্যা

/:~-:>./\-<./\  Input: array P
        \       For each prefix of P
     >./          Reduce using the maximum
          <./\  Get the minimum of each prefix of p
         -      Subtract between each
   -:           Test if it matches
/:~               P sorted

Answer 21

জাভা, 170 বাইট

boolean f(int[]a){int l=a.length,i=0,b=0,e=l-1;int[]x=new int[l];for(;i<l;i++)x[i]=i;for(i--;i>0;i--)if(a[i]==x[b])b++;else if(a[i]==x[e])e--;else return 0>1;return 1>0;}

অ্যারের xমান 0 থেকে সর্বোচ্চ সংখ্যায় রয়েছে (পাইথন এখানে আরও ভাল হবে ...)। লুপটি সর্বনিম্ন ( x[b]) বা সর্বোচ্চ ( x[e]) সংখ্যার সাথে এখনও মিলের চেষ্টা করে পিছনে চলে যায় ; যদি এটি হয়, যে পদক্ষেপে এই সংখ্যা পৌঁছে যেতে পারে।

টেস্ট কোড এখানে ।

Answer 22

গণিত, 47 বাইট

মার্টিন ইন্ডারের সমাধানের চেয়ে কিছুটা দীর্ঘ (আশ্চর্য অবাক!)। তবে এটি আমার আরও অপঠনযোগ্য প্রচেষ্টাগুলির মধ্যে একটি, তাই এটি ভাল: ডি

#=={}||{Max@#,Min@#}~MemberQ~Last@#&&#0@Most@#&

ব্যাখ্যা:

#=={}                         empty lists are antsy (function halts with True)
 ||                            or
{Max@#,Min@#}~MemberQ~Last@#  lists where the last number is largest or smallest
                              are possibly antsy (else function halts with False)
 &&                            and
#0@Most@#&                    recursively call this function after dropping the
                              last element of the list

Answer 23

জাভা 7, 170 169 বাইট

import java.util.*;Object c(int[]a){List l=new ArrayList();l.add(a[0]);for(int i:a){if(l.indexOf(i)<0&l.indexOf(i-1)<0&l.indexOf(i+1)<0)return 0>1;l.add(i);}return 1>0;}

অবরুদ্ধ এবং পরীক্ষার কোড:

এখানে চেষ্টা করুন।

import java.util.*;
class M{
  static Object c(int[] a){
    List l = new ArrayList();
    l.add(a[0]);
    for(int i : a){
      if(l.indexOf(i) < 0 & l.indexOf(i-1) < 0 & l.indexOf(i+1) < 0){
        return 0>1; //false
      }
      l.add(i);
    }
    return 1>0; //true
  }

  public static void main(String[] a){
    System.out.println(c(new int[]{ 0 }));
    System.out.println(c(new int[]{ 0, 1 }));
    System.out.println(c(new int[]{ 1, 0 }));
    System.out.println(c(new int[]{ 0, 1, 2 }));
    System.out.println(c(new int[]{ 0, 2, 1 }));
    System.out.println(c(new int[]{ 2, 1, 3, 0 }));
    System.out.println(c(new int[]{ 3, 1, 0, 2 }));
    System.out.println(c(new int[]{ 1, 2, 0, 3 }));
    System.out.println(c(new int[]{ 2, 3, 1, 4, 0 }));
    System.out.println(c(new int[]{ 0, 5, 1, 3, 2, 4 }));
    System.out.println(c(new int[]{ 6, 5, 4, 7, 3, 8, 9, 2, 1, 0 }));
    System.out.println(c(new int[]{ 4, 3, 5, 6, 7, 2, 9, 1, 0, 8 }));
    System.out.println(c(new int[]{ 5, 2, 7, 9, 6, 8, 0, 4, 1, 3 }));
    System.out.println(c(new int[]{ 20, 13, 7, 0, 14, 16, 10, 24, 21, 1, 8, 23, 17, 18, 11, 2, 6, 22, 4, 5, 9, 12, 3, 15, 19 }));
    System.out.println(c(new int[]{ 34, 36, 99, 94, 77, 93, 31, 90, 21, 88, 30, 66, 92, 83, 42, 5, 86, 11, 15, 78, 40, 48, 22, 29, 95, 64, 97, 43, 14, 33, 69, 49, 50, 35, 74, 46, 26, 51, 75, 87, 23, 85, 41, 98, 82, 79, 59, 56, 37, 96, 45, 17, 32, 91, 62, 20, 4, 9, 2, 18, 27, 60, 63, 25, 61, 76, 1, 55, 16, 8, 6, 38, 54, 47, 73, 67, 53, 57, 7, 72, 84, 39, 52, 58, 0, 89, 12, 68, 70, 24, 80, 3, 44, 13, 28, 10, 71, 65, 81, 19 }));
    System.out.println(c(new int[]{ 47, 48, 46, 45, 44, 49, 43, 42, 41, 50, 40, 39, 38, 51, 37, 36, 52, 35, 34, 33, 32, 53, 54, 31, 30, 55, 56, 29, 28, 57, 58, 59, 60, 27, 26, 61, 25, 62, 63, 64, 65, 66, 67, 24, 23, 22, 21, 68, 69, 20, 19, 18, 17, 70, 71, 16, 15, 72, 73, 74, 75, 76, 14, 13, 12, 77, 11, 10, 9, 8, 78, 7, 79, 80, 6, 81, 5, 4, 3, 82, 2, 83, 84, 1, 85, 86, 87, 0, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99 }));
  }
}

আউটপুট:

true
true
true
true
false
true
false
true
true
false
true
false
false
false
false
true