... তবে আরে, কড়া হওয়ার দরকার নেই।

কঠোরভাবে ইতিবাচক পূর্ণসংখ্যার একটি খালি খালি অ্যারে দেওয়া, এটি কিনা তা নির্ধারণ করুন:

মনোোটোন কঠোরভাবে হ্রাস পাচ্ছে । এর অর্থ হ'ল প্রতিটি প্রবেশ আগের তুলনায় কম than
মনোোটোন অ-বর্ধমান, তবে কঠোরভাবে হ্রাস পাচ্ছে না । এর অর্থ হ'ল প্রতিটি এন্ট্রি পূর্ববর্তী থেকে কম বা সমান এবং অ্যারেটি উপরের বিভাগে পড়ে না।
উপরের কিছুই নয় ।

নিম্নলিখিত কোণার কেস নোট করুন:

একক সংখ্যা সহ একটি অ্যারে একঘেয়েমি কঠোরভাবে হ্রাস হয় (শূন্যপথে)।
একই সংখ্যার সাথে পুনরাবৃত্তি হওয়া অ্যারে হ'ল মনোোটোন অ-বৃদ্ধি, তবে কঠোরভাবে হ্রাস পাচ্ছে না।

বিধি

আপনি কোনও প্রোগ্রাম বা একটি ফাংশন সরবরাহ করতে পারেন

ইনপুট যেকোন যুক্তিসঙ্গত বিন্যাসে নেওয়া যেতে পারে: অ্যারে, তালিকা, ফাঁকা স্থান দ্বারা পৃথক সংখ্যার স্ট্রিং, ...

আপনি যথাক্রমে তিনটি বিভাগের জন্য যে কোনও তিনটি ধারাবাহিক আউটপুট চয়ন করতে পারেন। উদাহরণস্বরূপ, আউটপুট সংখ্যার হতে পারে 0, 1, 2; বা স্ট্রিং 1 1, 1 0খালি স্ট্রিং।

বাইটস মধ্যে সংক্ষিপ্ত কোড

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

মনোোটোন কঠোরভাবে হ্রাস:

7 5 4 3 1
42 41
5

মনোোটোন অ-বর্ধমান, তবে কঠোরভাবে হ্রাস পাচ্ছে না:

27 19 19 10 3
6 4 2 2 2
9 9 9 9

উপরের কেউই না:

1 2 3 2
10 9 8 7 12
4 6 4 4 2

— লুইস মেন্ডো
সূত্র

কোনও বৈকল্পিক ফাংশন (যেখানে ইনপুট মানগুলি কোনও ধরণের ডেটা টাইপগুলিতে মোটে আবৃত হয় না তবে সমস্তগুলি সরাসরি যুক্তি হিসাবে ফাংশনে প্রেরণ করা হয়) "কি কোনও যুক্তিসঙ্গত বিন্যাসের" আওতায় পড়ে?

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

@ মার্টিন হ্যাঁ, এটা হয়!

— লুইস মেন্ডো

9

জেলি , 10 9 5 বাইট

-ডেথএমসিএমলেক্সের পাওয়া মেঠোড, কিছু ক্রেডিট দিন!

;0IṠṀ

TryItOnline! বা সমস্ত পরীক্ষা চালান

আয়: -1= একঘেয়েমি কঠোরভাবে হ্রাস; 0= একঘেয়েমি বৃদ্ধি; 1= অন্যান্য।

কিভাবে?

;0IṠṀ - Main link: list
;0    - concatenate with a zero
  I   - incremental differences
   Ṡ  - sign
    Ṁ - maximum

— জোনাথন অ্যালান
সূত্র

ডায়াক্রিটিক কি Mকোনও 8 বিট চরিত্রের মানচিত্রের অংশ? এটি 5 বাইট বলে আপনি বলতে পারবেন না কারণ এটি নয়। সিপি 1252 এর উদাহরণস্বরূপ এটি নেই।

— ইউরি পিনহলো

2

@ ইউরিপিনহলো জেলি এই কাস্টম কোড পৃষ্ঠাটি বাইট গণনা করতে ব্যবহার করে যা byteএই পোস্টের শিরোনামের শব্দের সাথে লিঙ্কযুক্ত ।

— সময়সীকরণ করুন

@ ফ্যাটালাইজ: থেক্স, এটি পেয়েছে।

— ইউরি পিনহলো

22

পার্ল 6 , 17 বাইট

{[>](@_)+[>=] @_}

মনোোটোন কঠোরভাবে হ্রাস: 2
একজাতীয় অ-বর্ধমান: 1
অন্য: 0

সম্প্রসারিত:

{            # bare block lambda with implicit parameter list ｢@_｣
  [>]( @_ )  # reduce using ｢&infix:« > »｣
  +
  [>=] @_    # reduce using ｢&infix:« >= »｣
}

— ব্র্যাড গিলবার্ট বি 2 গিলস
সূত্র

4

পার্ল

— icalন্দ্রজালিক

এটি >সাথে afterএবং >=সাথে স্যুইচ করা থাকলে কোনও প্রকারের সাথে কাজ করার জন্য এটি বাড়ানো যেতে পারে !before। say {[after](@_)+[!before] @_}(<d c b a>) #=> 2

— ব্র্যাড গিলবার্ট বিবিগিল

13

এমএটিএল , 10 , 7 বাইট

0hdX>ZS

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

3 লাইট সংরক্ষণ করা হয়েছে, @ লুইসমেন্ডোকে ধন্যবাদ!

ফলাফলগুলি হয়

কঠোরভাবে হ্রাস হচ্ছে: -1
ক্রমবর্ধমান: 0
অন্যান্য: ১

ব্যাখ্যা:

0           % Push a '0'
 h          % Join the 0 to the end of the input array.
  d         % Get consecutive differences
   X>       % Get the largest difference
     ZS     % Get its sign
            % Implicitly print it

— ডিজেএমসিএমহেম
সূত্র

1

আপনি 0শেষ প্লাসটি প্রেন্ডিংয়ের পরিবর্তে একটি যুক্ত করতে পারবেন না 1? এর মতো কিছু0hdX>ZS

— লুইস মেন্ডো

2

@ লুইস মেন্ডো আহ, এটাই প্রতিভা! ধন্যবাদ!

— DJMcMayhem

সহায়তা করে না, তবে 0hdX>0/অবলোকনের জন্য আপনি এটি ব্যবহার করতে পারেন: - আপনার এবং @ লুইস মেন্ডোর জন্য প্রশ্ন: শেষ মানটি স্পষ্টভাবে ব্যবহার করে কেবল 1 টি চর (এর বিপরীতে X>) হওয়া কি এই প্রশ্নটি উত্থাপন করা সম্ভব ?

— ডেনিস জাহেরুদ্দিন

@ ডেনিসজাহেরউদ্দিন আমিও ব্যবহারের কথা ভেবেছিলাম S, তবে এটিকে ছোট করার কোনও উপায় আমি পাইনি ...

— লুইস মেন্ডো

9

গণিত, 22 বাইট

Sign@*Max@*Differences

নামহীন ফাংশন ইনপুট হিসাবে সংখ্যার একটি তালিকা গ্রহণ। রিটার্নস -1তালিকা কঠোরভাবে কমছে যদি 0তা nonincreasing কিন্তু কঠোরভাবে কমছে না এবং 1এটা ত্ত যদি।

বেশ সহজ সরল অ্যালগরিদম: একটানা জোড়গুলির পার্থক্য গ্রহণ করুন, বৃহত্তমটি নিন এবং সেই বৃহত্তমটির চিহ্নটি নিন।

(আমার মনে হচ্ছে এমন কোনও ভাষা অবশ্যই থাকতে হবে যাতে এই অ্যালগরিদমটি 3 বাইটের ....)

একক এন্ট্রি সহ একটি অ্যারে সম্পর্কিত: Differencesএকটি খালি তালিকা দেয়; Maxএকটি খালি তালিকা দেয় -∞(!); এবং Sign[-∞]মূল্যায়ন -1(!!)। সুতরাং এটি আসলে এই কর্নারের ক্ষেত্রে কাজ করে। কখনও কখনও ম্যাথমেটিকাকে ভালোবাসি। (প্রকৃতপক্ষে, ফাংশনটি কঠোরভাবে হ্রাস হওয়ার সাথে সাথে একটি খালি তালিকাও সঠিকভাবে লেবেল করেছে)

— গ্রেগ মার্টিন
সূত্র

আমি দেখি যে DrMcMoylex আমাকে 7 মিনিট ধরে মারছে! :)

— গ্রেগ মার্টিন

2

"আমার মনে হচ্ছে এমন কোনও ভাষা অবশ্যই থাকতে হবে যাতে এই অ্যালগরিদমটি 3 বাইট হয়" chat.stackexchange.com/transcript/message/33720906#33720906 :(

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

7

হাস্কেল, 40 38 37 বাইট

foldl min GT.(zipWith compare<*>tail)

রিটার্নস

GT মনোোটোন কঠোরভাবে হ্রাস জন্য
EQ মনোোটোন অ-বৃদ্ধির জন্য
LT আর

compareদুটি সংখ্যা এবং রিটার্নের তুলনা করে GT( EQ, LT) যদি প্রথম সংখ্যাটি দ্বিতীয় সংখ্যার (সমান, এর চেয়ে কম) বেশি হয়। zipWith compare<*>tailপ্রতিবেশী উপাদানগুলির সাথে তুলনা করে। foldl min GTজি.টি. দিয়ে শুরু মিনিট ফাংশন তুলনা ফলাফল তালিকা হ্রাস করা (: নোট LT< EQ< GT)।

সম্পাদনা: @ xnor 2 3 বাইট খুঁজে পেয়েছে । ধন্যবাদ!

— nimi
সূত্র

আপনি 0 যুক্ত করার পরিবর্তে কোনও এলটি প্রেন্ডেন্ড করতে পারেন?

— xnor

@ এক্সনর: হ্যাঁ, ধন্যবাদ, তবে এটি অবশ্যই একটি হতে হবে GT, কারণ আমাদের তালিকাটির সর্বনিম্ন প্রয়োজন (আমার সর্বাধিক ছিল, যা ভুল ছিল এবং এটির =<<পরিবর্তে আমি যে সংস্করণটি ব্যবহার করেছি তার প্রথম সংস্করণে একটি প্রতিলিপি <*>)।

— নিমি

1

আমি দেখি. আসলে, কেমন foldl min GT?

— xnor

6

কমন লিস্প, 43 40 বাইট

(defun f(x)`(,(apply'> x),(apply'>= x)))

এই পাতার মর্মর তালিকা হিসাবে ইনপুট নেয়, এবং আয় (T T), (NIL T)এবং (NIL NIL)3 টি বিভাগ পার্থক্য। এখানে এটি প্রদত্ত পরীক্ষার কেসগুলিতে চলছে:

CL-USER> (mapcar #'f '((7 5 4 3 1)
                       (42 41)
                       (5)
                       (27 19 19 10 3)
                       (6 4 2 2 2)
                       (9 9 9 9)
                       (1 2 3 2)
                       (10 9 8 7 12)
                       (4 6 4 4 2)))
((T T) (T T) (T T) (NIL T) (NIL T) (NIL T) (NIL NIL) (NIL NIL) (NIL NIL))

— ওমর
সূত্র

1

বাইট হিসাবে ঠিক একই সংখ্যা (defun f(x)(mapcar'apply'(> >=)`(,x,x)))। মনে রাখবেন আপনি কেবল (lambda(x)...)খাটো হয়ে লিখতে পারেন ।

— coredump

6

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

lambda l:max(map(cmp,l[1:],l))

-1কঠোরভাবে হ্রাস 0জন্য, দুর্বল হ্রাস +1জন্য, অ-হ্রাস জন্য

cmpএকটানা উপাদানগুলির তুলনা করতে ব্যবহার করে এবং সর্বোচ্চটি নেয় takes তালিকার একটি অনুলিপিটির প্রথম উপাদানটি সরানোর পরে ম্যাপিংয়ের মাধ্যমে এটি করা হয় cmp। উদাহরণস্বরূপ, l=[2,2,1]দেয়

l[1:]  2   1   None
l      2   2   1
cmp    0  -1   -1

যার max0 রয়েছে কারণ একটি সমতা বিদ্যমান।

সংক্ষিপ্ত তালিকাটি স্বয়ংক্রিয়ভাবে এর সাথে প্রসারিত হবে Noneযা সমস্ত সংখ্যার চেয়ে কম এবং তাই নির্দোষ। যখন এই ইনপুটটির minদৈর্ঘ্য 1 থাকে তখন এই ভৌতিক উপাদানটি খালি তালিকা গ্রহণের বিরুদ্ধেও অন্তরক হয় ।

— xnor
সূত্র

এমনকি খুব অল্প পাইথন সহ আমি জানি আমি এই উত্তরটি কতটা দুর্দান্ত তা উপলব্ধি করতে পারি

— লুইস মেন্ডো

5

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

>,1|>=,

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

এই প্রিন্টগুলি 1কঠোরভাবে হ্রাস পাওয়ার 0জন্য, অ-বৃদ্ধি এবং false.অন্যথায়।

ব্যাখ্যা

  (?)>              Input is a strictly decreasing list
      ,1(.)         Output = 1
|                 Or
  (?)>=             Input is a non-increasing list
       ,(.)         Output is a free variable; gets automatically labeled as an integer at
                      the end of execution. Since its domain is [-inf, +inf], the first
                      value it takes is 0
                  Or
                    No other possibility, thus this main predicate is false.

অন্যান্য 7 বাইট সমাধান

>=!>,;1           Returns 0 for strictly decreasing, false. for non-increasing, 1 otherwise.

>=!>,1|           Returns 1 for strictly decreasing, false. for non-increasing, 0 otherwise.

— Fatalize
সূত্র

4

আর, 44 বাইট

d=diff(scan());c(any(!d)&all(d<=0),all(d<0))

স্টিডিনের কাছ থেকে ইনপুট পড়ে এবং ইনপুটটির উপর নির্ভর করে নিম্নলিখিতটি মুদ্রণ করে:

আউটপুট:

[1] FALSE TRUE: মনোোটোন অ-বৃদ্ধি

[1] TRUE FALSE: মনোোটোন কঠোরভাবে হ্রাস

[1] FALSE FALSE: উপরের কেউই না

— Billywob
সূত্র

d=diff(scan());ifelse(all(d<=0),!prod(d),2)1 বাইট সংক্ষিপ্ত। এটি কঠোরভাবে মানোটোন হলে 0 দেয়, একচেটিয়া না বাড়লে 1 এবং উপরের কোনওটি না হলে 2 ফেরত দেয়। উপরের কোনওটি না হলে যদি এটি কিছু না ফেরার অনুমতি দেয় তবে নিশ্চিত নই তবে আপনি আরও সরল করতে পারবেন d=diff(scan());if(all(d<=0))!prod(d)।

— জেএডি

আসলে, d=diff(scan());if(all(d<=0))any(!d)এক বাইট ভাল।

— জেএডি

3

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

a=>a.some((e,i)=>e>a[i-1])+a.some((e,i)=>e>=a[i-1])

কঠোর হ্রাসের জন্য 0 প্রদান করে, 1 বাড়ছে না, অন্যথায় 2।

— নিল
সূত্র

3

05AB1E ,5 8 বাইট

এমগিনার দ্বারা বাগ ঠিক করা হয়েছে, ধন্যবাদ! এটি DrMcMoylex এর মতো একই পদ্ধতি ব্যবহার করে ।

®¸ì¥Z0.S

®¸ì   Implicitly take input and appends -1 to it
¥     Yield deltas
 Z    Take the largest delta
  0.S Take its sign and implicitly display it

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

আউটপুট হল:

-1 if strictly decreasing sequence
 0 if non-strictly decreasing sequence
 1 otherwise

— Osable
সূত্র

1

®¸ì¥Z0.Sএকক উপাদান ইস্যু ঠিক করবে।

— এমিগানা

সুন্দর ধন্যবাদ! আমি মনে করি 0 শুরুতেও কাজ করবে যেহেতু সমস্ত সংখ্যা ইতিবাচক (কঠোরভাবে ডিফল্ট দ্বারা অনুমান করি)।

— 16'9 9:56 এ ব্যবহারযোগ্য

হ্যাঁ 0 এছাড়াও কাজ করবে, তবে এটি দুর্দান্ত যে এটি 0 যুক্ত

— ইনপুটটির

মজাদার ঘটনা: ফরাসি "ইতিবাচক" এর অর্থ ধনাত্মক বা শূন্য এবং ইংরেজীতে "ইতিবাচক" এর একই অর্থটি পৌঁছানোর জন্য আপনাকে "কঠোর ইতিবাচক" নির্দিষ্ট করতে হবে।

— ব্যবহারযোগ্য

3

রুবি, 37 বাইট

->l{[d=l==l.sort.reverse,d&&l|[]==l]}

আউটপুট: [true,true], [true,false]বা[false,false]

— গিগাবাইট
সূত্র

2

গণিত, 15 11 বাইট

##>0|##>=0&

এটি একটি বৈকল্পিক ফাংশন, সমস্ত ইনপুট পূর্ণসংখ্যা পৃথক যুক্তি হিসাবে গ্রহণ করে।

কঠোরভাবে হ্রাস: True | True
অ বৃদ্ধি: False | True
আমরাও: False | False

লক্ষ্য করুন |নয় Orকিন্তু Alternatives, যা প্যাটার্ন ম্যাচিং সিনট্যাক্স, যা কেন এক্সপ্রেশন থেকে মূল্যায়ন পেতে না ব্যাখ্যা অংশ True, True, Falseযথাক্রমে।

কোডটি নিজেই বেশিরভাগ ক্ষেত্রে এই টিপের একটি প্রয়োগ । উদাহরণস্বরূপ ##>0হয় Greater[##, 0]কিন্তু তারপর ##সমস্ত ইনপুট মান বিস্তৃতি তাই আমরা ভালো কিছু পেতে Greater[5, 3, 2, 0], যা নিজেই মানে 5>3>2>0।

— মার্টিন ইন্ডার
সূত্র

2

র‌্যাকেট , 44 বাইট

(λ(x)(map(λ(p)(apply p`(,@x 0)))`(,>,>=)))

প্রার্থনা:

(map (λ(x)(map(λ(p)(apply p`(,@x 0)))`(,>,>=)))
 '((7 5 4 3 1)
   (42 41)
   (5)
   (27 19 19 10 3)
   (6 4 2 2 2)
   (9 9 9 9)
   (1 2 3 2)
   (10 9 8 7 12)
   (4 6 4 4 2)))

ফলাফল:

'((#t #t)
 (#t #t)
 (#t #t)
 (#f #t)
 (#f #t)
 (#f #t)
 (#f #f)
 (#f #f)
 (#f #f))

— ম্যাথু বাটারিক
সূত্র

এটি লজ্জাজনক র‌্যাকেটটি সত্যতার 1 টির মতো আর্টিকে সংজ্ঞায়িত করে না >। কমন লিস্প সঠিকভাবে এটি পায় তবে আরটি 0 কেস (যা সত্য হওয়া উচিত) সংজ্ঞা দিতে ব্যর্থ হয়।

— ওমর

2

সি ++ 14, 85 বাইট

int f(int x){return 3;}int f(int x,int y,auto...p){return((x>=y)+2*(x>y))&f(y,p...);}

কঠোর হ্রাসের জন্য 3 (0b11), বর্ধমান না হওয়ার জন্য 1 (0b01) এবং অন্যথায় 0 প্রদান করে।

Ungolfed:

int f(int x) {return 3;}
int f(int x,int y,auto...p){
  return ((x>=y)+2*(x>y)) & f(y,p...);
}

আমি ভেবেছিলাম এটি সি ++ 17 এর ভাঁজ এক্সপ্রেশনগুলির জন্য একটি নিখুঁত সমস্যা:

int g(auto...x){return(x>...)+(x>=...);}

দুর্ভাগ্যক্রমে এটি রিলেশনাল অপারেটরগুলিকে চেইন করে না তবে করে

((x1>x2)>x3)>x4)...

যা চেয়েছিল তা নয়।

— কার্ল ন্যাপ
সূত্র

2

পাইথন 2, 61 74 বাইট

একক সংখ্যা ইনপুট জন্য +13 বাইট

x=map(str,input())
print[2,eval(">".join(x))+eval(">=".join(x))][len(x)>1]

যেমন বন্ধনী তালিকা ফর্ম ইনপুট প্রয়োজন [3,2,1]। কঠোর হ্রাসের জন্য 2, বৃদ্ধি না পাওয়ার জন্য 1 এবং অন্যথায় 0 প্রদান করে 0

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

print eval(">".join(x))+eval(">=".join(x))

— কার্ল ন্যাপ
সূত্র

2

পাইথন 3, 81 52 বাইট ( FryAmTheEggMan কে ধন্যবাদ )

e=sorted
lambda a:(a==e(a)[::-1])+(e({*a})[::-1]==a)

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

— Sygmei
সূত্র

sorted(s)[::-1]বাছাই করা তালিকার বিপরীতে ছোট হয়। পাইথন 3 এ আপনি {*a}এর উপাদানগুলির একটি সেট পেতে পারেন a। sortedএকটি তালিকা ফেরত দেয় যাতে আপনাকে কোনও তালিকায় সেটটি কাস্ট করতে না হয়। এছাড়াও বুলিয়ান যোগ করা পুরোপুরি কোশার! অবশেষে আপনি একটি বেনাম ল্যাম্বদা জমা দিতে পারেন, যাতে আপনার প্রয়োজন হয় না f=। আমি শেষ পর্যন্ত 52 বাইট পাই repl.it/E7eG/2

— FryAmTheEggman

2

বেফুঞ্জ, 50 বাইট

&: >~1+#^_v>:0`|
1\:^  @.$$<-@.2_
-: ^    >& ^   >

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

স্পেস দ্বারা পৃথক করা int এর ক্রম হিসাবে ইনপুট গ্রহণ করে এবং কঠোরভাবে হ্রাস হলে 0 প্রদান করে, যদি অ-কঠোরভাবে হ্রাস পায় তবে 1, অন্যথায় 2।

যেহেতু আপনি যদি ভাষাটি না জানেন তবে বেফুঞ্জ পড়া এক ধরণের অসম্ভব, সুতরাং এটি সিউডোকোডের আলগোরিদিম:

push(input())

while( getchar()!=EOF ){
  push(input())
  subtract()
  duplicate()
  if(pop()>0){
    subtract() //we are doing a-(a-b), so b is now on top
    duplicate()
  }
  else{
    if(pop()==0){
      push(1) //the sequence is not strictly decreasing
      swap()
      duplicate()
    }
    else{
      push(2) //the sequence has just increased
      output(pop)
      return
    }
  }
}
pop()
pop()
output(pop())

* বেফুঞ্জ মেমোরিতে একটি স্ট্যাক যা এটিতে অসীম পরিমাণে শুরু হয়। পপ (), পুশ (এক্স), ইনপুট () এবং আউটপুট (এক্স) স্ব-ব্যাখ্যামূলক, অন্য সিউড ফাংশনগুলি আমি এর মতো কাজ করেছি:

function duplicate(){
  a=pop()
  push(a)
  push(a)
}

function subtract(){
  a=pop()
  b=pop()
  push(b-a)
}

function swap(){
  a=pop()
  b=pop()
  push(a)
  push(b)
}

Funge!

পূর্ববর্তী সংস্করণ, মাত্র 41 বাইট কিন্তু অবৈধ যেহেতু এটি 0 প্রয়োজন ইনপুট ক্রম বিনষ্ট (অথবা মত একজন দোভাষী ব্যবহার এই )

&:  >&:|>:0`|
1\v@.$_<-@.2_
- >:v  >^   >

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

— সিংহরাশি
সূত্র

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

— লুইস মেন্ডো

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

— লিও

না, শূন্যগুলি ক্রমটির অংশ হতে পারে না (ধনাত্মক পূর্ণসংখ্যার একটি খালি অ্যারে দেওয়া_ আমি কঠোরভাবে ইতিবাচক পূর্ণসংখ্যার অর্থ বোঝাই)। তবে কিছু উত্তর কোড দ্বারা একটি 0সন্নিবেশিত ব্যবহার করে যাতে ইনপুটটিতে কেবল একটি প্রবেশ থাকে। আমি বিবেচনা করার এক কারণ হ'ল ইনপুট সহ এটি বৈধ নয়। যাইহোক, যদি এমন কোনও দোভাষী থাকে যার প্রয়োজন হয় না, আপনি সেই দোভাষীকে প্রমাণ করতে আপনার উত্তরটি বৈধ কিনা তা ব্যবহার করতে পারেন । যদি চেষ্টা-এটি-অনলাইন অনুবাদকের প্রয়োজন হয় , তবে আপনি এটি যথাযথ ব্যাখ্যা নোট সহ বিক্ষোভের উদ্দেশ্যে অন্তর্ভুক্ত করতে পারেন000

— লুইস মেন্ডো

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

— লিও

1

আমি জেমসের পদ্ধতির সাহায্যে উত্তরটি সম্পাদনা করেছি, এখন ইনফোটি ইওএফ দ্বারা শেষ করা হবে

— লিও

2

জে, 14 বাইট

Monadic ক্রিয়াটি ডানদিকে তালিকাটি নেওয়া, 1কঠোরভাবে হ্রাসের জন্য ফিরে আসা , 0দুর্বলভাবে হ্রাস হওয়ার জন্য, এবং _1অন্যথায়।

*@([:<./2-/\])

সাইন লাগে *কমপক্ষে <./পরপর পার্থক্যের 2-/\তালিকার। জে যখন পার্থক্যগুলি সেগুলি গ্রহণের ক্রমটিকে অদলবদল করে না যেমন, ক্রমটি কঠোরভাবে হ্রাস পাচ্ছে যদি এগুলি সমস্ত ইতিবাচক হয়। উল্লেখযোগ্যভাবে, <./শূন্য-উপাদান তালিকায় ইতিবাচক অসীম ফেরৎ দেয়।

আরপিএল-এ ব্যবহৃত:

   *@([:<./2-/\]) 3
1
   *@([:<./2-/\]) 3 2
1
   *@([:<./2-/\]) 3 2 2
0
   *@([:<./2-/\]) 3 2 2 3
_1

— algorithmshark
সূত্র

2

সি, 68 67 বাইট

একটি ফাংশন f, যা lতার দৈর্ঘ্য ( n, এছাড়াও কোনও পূর্বনির্মাণ) এর পূর্বে ints ( ) এর অ্যারে পাস করে । একচেটিয়াভাবে কঠোরভাবে হ্রাস পেলে 3 প্রদান করে, 1 একচেটিয়া না বাড়লে, তবে কঠোরভাবে হ্রাস পাচ্ছে না, অন্যথায় 0।

f(int n,int*l){return n<2?3:((l[0]>l[1])*2|l[0]>=l[1])&f(n-1,l+1);}

পাঠযোগ্যতার জন্য সামান্য গল্ফড:

int f_semiungolfed(int n, int* l) {
    return (n < 2) ? 3 : ((l[0] > l[1]) * 2 | l[0] >= l[1]) & f(n - 1, l + 1);
}

পুনরায় সাজানো এবং যুক্তি প্রদর্শন করতে মন্তব্য করেছে:

int f_ungolfed(int n, int* l) {
    int case1 = 0, case2 = 0, recursion = 0;
    if (n < 2) { // Analogous to the ternary conditional I used - n < 2 means we have a single-element/empty list
        return 3; // Handles the vacuous-truth scenario for single lists
    } else {
        case1 = l[0] > l[1]; // The first case - are the two numbers in the list strictly decreasing? (case1 is 1 if so)
        case2 = l[0] >= l[1]; // The second case - are the two numbers strictly non-increasing (case2 is 1 if so)
        recursion = f_ungolfed(n - 1, l + 1); // Recursively call ourselves on the "rest" of the list (that is, everything other than the first element). Consider that comparison is transitive, and that we already have a vacuous-truth scenario covered.
        case1 *= 2; // Shift case1's value over to the left by one bit by multiplying by 2. If case1 was 1 (0b01), it's now 2 (0b10) - otherwise it's still 0 (0b00)
        return (case1 | case2) & recursion; 
        // The bitwise OR operator (|) will combine any 1-bits from case1's value (either 0b10 or 0b00) or case2's value (either 0b01 or 0b00) into either 3, 2, 1, or 0 (0b11, 0b10, 0b01, or 0b00 respectively).
        // The bitwise AND operator (&) will combine only matching 1-bits from (case1|case2) and the return value of the recursive call - if recursion = 0b11 and case1|case2 = 0b01, then the return value will be 0b01.
    }
}

পরীক্ষার কেস (সৌজন্য আইডিয়োন ):

{7, 5, 4, 3, 1}: 3
{42, 41}: 3
{5}: 3
{27, 19, 19, 10, 3}: 1
{6, 4, 2, 2, 2}: 1
{9, 9, 9, 9}: 1
{1, 2, 3, 2}: 0
{10, 9, 8, 7, 12}: 0
{4, 6, 4, 4, 2}: 0

— hmmwhatsthisdo
সূত্র

2

রেটিনা , 41 বাইট

\d+
$*
A`\b(1+) 1\1
S`\b$
\b(1+) \1\b.*|$

এটি অনলাইন চেষ্টা করুন! (প্রথম লাইন একটি লাইনফিড-বিচ্ছিন্ন পরীক্ষা স্যুট সক্ষম করে))

কঠোরভাবে হ্রাস: 2
অ বৃদ্ধি: 3
আমরাও: 1

ব্যাখ্যা

\d+
$*

ইনপুটটিকে অবিচ্ছিন্ন রূপান্তর করে।

A`\b(1+) 1\1

এখানে রেজেক্স একটানা সংখ্যার একটি বর্ধমান জুটির সাথে মেলে। যদি এটি হয় তবে স্পষ্টভাবে ইনপুটটি বর্ধমান হতে পারে না। Aএকটি "বিরোধী, grep" স্তর হিসেবে -এর মানে এটা যার মানে ইনপুট লাইন বাতিল হবে এবং খালি স্ট্রিং Regex ম্যাচ যদি প্রতিস্থাপিত হয়েছে।

S`\b$

এই একটি বিভক্ত মঞ্চ যা ইনপুট করার জন্য একটি লাইনফীড যোগ করার জন্য ব্যবহৃত হয় শুধুমাত্র যদি ইনপুট বাতিল করা হয় নি। সুতরাং আমরা এ পর্যন্ত দুটি সম্ভাব্য ফলাফল পেয়েছি: বর্ধমান ইনপুটগুলি শেষে লাইনফিড পান এবং অন্যরা এখনও খালি are

\b(1+) \1\b.*|$

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

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

— মার্টিন ইন্ডার
সূত্র

1

এক্সিয়াম, 114 বাইট

m(c:List(INT)):INT==(i:=r:=1;repeat(~index?(i+1,c)=>break;c.i<c.(i+1)=>return 0;if c.i=c.(i+1)then r:=2;i:=i+1);r)

Ungolfed

-- if [a,b,..n] decrescente ritorna 1
--          non crescente   ritorna 2
--          altrimenti      ritorna 0  
m(c:List(INT)):INT==
   i:=r:=1
   repeat
      ~index?(i+1,c)=>break 
      c.i<c.(i+1)   =>return 0
      if c.i=c.(i+1) then r:=2
      i:=i+1
   r

ফলাফল

(x) -> m([3,1])=1, m([1,1])=2, m([])=1, m([1])=1, m([1,3])=0
   (x)  [1= 1,2= 2,1= 1,1= 1,0= 0]

— RosLuP
সূত্র

1

ফোর্স ডোভ্রেস্টি ট্রেডে আমি কমেন্ট করছি :-)

— লুইস মেন্ডো

1

এপিএল, 16 বাইট

(a≡a[⍒a])×1+a≡∪a

দ্রষ্টব্য: একটি উপাদান অ্যারে যেমন উদাহরণস্বরূপ প্রবেশ করান a←1⍴3:a←4 3 2 1

আউটপুট ব্যাখ্যার:

2 Monotone strictly decreasing
1 Monotone non-increasing, but not strictly decreasing
0 None of the above

আইডিয়া: সাজানো অ্যারের সাথে মূল তুলনা করে একঘেয়েত্বের জন্য পরীক্ষা করুন, মুছে ফেলা নকলের সাথে অ্যারের সাথে তুলনা করে অ-বৃদ্ধির জন্য পরীক্ষা করুন।

(এবং আমি মনে করি এটি উন্নত করা যেতে পারে ...)

— রোমান সুসি
সূত্র

একটি সংখ্যায় পরিবর্তন করা হয়েছে। বাইটস 2 দ্বারা বৃদ্ধি পেয়েছে ...

— রোমান সুসি

1

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

f l=[scanl1(min.(+x))l==l|x<-[0,-1]]

(+x)হ্যাশেল (-x)একটি বিভাগের পরিবর্তে মান হিসাবে ভুল ব্যাখ্যা করে । আমি ভাবছি যদি পুরো অভিব্যক্তিটি লাভজনকভাবে পয়েন্টফ্রি করা যায়।

— xnor
সূত্র

1

ল্যাবভিউ, 12 নোড, 18 তারের ==> কনভেনশন দ্বারা 48 বাইট

অন্যান্য কেস ফ্রেমে কোনও ফাংশন লুকানো নেই, কেবলমাত্র একটি একক তারের জুড়ে।

— SRM
সূত্র

1

সিলোন, 86 বাইট

Object m(Integer+l)=>let(c=l.paired.map(([x,y])=>x<=>y))[if(!smaller in c)equal in c];

ফাংশন তার পরামিতি হিসেবে ইনপুট নেয় এবং শূন্য বা এক Booleans একটি tuple ফেরৎ - [false]জন্য Monotone কঠোরভাবে কমছে , [true]জন্য Monotone অ বৃদ্ধি, কিন্তু কঠোরভাবে কমছে না , এবং []জন্য উপরের কোনটিই নয় ।

এটি এর মতো ব্যবহার করা যেতে পারে:

shared void run() {
    print("Monotone strictly decreasing:");
    print(m(7, 5, 4, 3, 1));
    print(m(42, 41));
    print(m(5));

    print("Monotone non-increasing, but not strictly decreasing:");
    print(m(27, 19, 19, 10, 3));
    print(m(6, 4, 2, 2, 2));
    print(m(9, 9, 9, 9));

    print("None of the above:");
    print(m(1, 2, 3, 2));
    print(m(10, 9, 8, 7, 12));
    print(m(4, 6, 4, 4, 2));
}

আউটপুট:

Monotone strictly decreasing:
[false]
[false]
[false]
Monotone non-increasing, but not strictly decreasing:
[true]
[true]
[true]
None of the above:
[]
[]
[]

একটি নিরবচ্ছিন্ন এবং মন্তব্য করা সংস্করণ:

// Let's decrease the monotony! 
//
// Question:  http://codegolf.stackexchange.com/q/101036/2338
// My Answer: http://codegolf.stackexchange.com/a/101309/2338


// Define a function which takes a non-empty list `l` of Integers)
// (which arrive as a tuple) and returns an Object (actually
// a `[Boolean*]`, but that is longer.) 
Object m(Integer+ l) =>
        // the let-clause declares a variable c, which is created by taking
        // pairs of consecutive elements in the input, and then comparing
        // them. This results in lists like those (for the example inputs):
        // { larger, larger, larger, larger }
        // { larger }
        // {}
        // { larger, equal, larger, larger }
        // { larger, larger, equal, equal }
        // { equal, equal, equal }
        // { smaller, smaller, larger }
        // { larger, larger, larger, smaller }
        // { smaller, larger, equal, larger }  
        let (c = l.paired.map( ([x,y]) => x<=>y) )
            // now we analyze c ...
            // If it contains `smaller`, we have an non-decreasing sequence.
            // We return `[]` in this case (an empty tuple).
            // Otherwise we check whether `equal` is in the list, returning
            // `[true]` (a non-strictly decreasing sequence) if so,
            // and `[false]` (a strictly decreasing sequence) otherwise.
            [if(!smaller in c) equal in c];

— পাওলো ইবারম্যান
সূত্র

1

Clojure, 34 বাইট

#(if(apply > %)1(if(apply >= %)2))

খুব সোজা-ফরোয়ার্ড, 1কঠোরভাবে হ্রাস পেলে, 2যদি অ-ইনগ্রেসিন nilনা হয়ে থাকে এবং অন্যথায় ফিরে আসে।

applyম্যাক্রোর সাথে এড়িয়ে যাওয়ার চেষ্টাও করেছিলেন ~@তবে এটি 43 টি চর বেশি মাত্রায় রয়েছে (এর ফলস্বরূপ [1 2 nil]):

(defmacro f[& i]`(if(> ~@i)1(if(>= ~@i)2)))

[(f 7 5 4 3 1)
 (f 27 19 19 10 3)
 (f 1 2 3 2)]

— NikoNyrh
সূত্র

1

পিপ , 8 বাইট

O$>g$>=g

পুরো প্রোগ্রাম। কমান্ড-লাইন আর্গুমেন্ট হিসাবে ইনপুট তালিকাটি নেয়। 11কঠোরভাবে হ্রাস, 01বৃদ্ধির 00জন্য, না উভয় জন্য ফলাফল ।

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

ব্যাখ্যা

পাইপ এর তুলনা অপারেটর যেমন পাইথনের, একসাথে চেইন করে এই পদ্ধতির কাজ করে: সি হিসাবে যেমন মিথ্যা (মিথ্যা) 4>3>2হওয়ার চেয়ে সত্য হয় (4>3)>2এবং তুলনামূলক অপারেটরগুলি $ভাঁজ মেটা-অপারেটরের সাথে সংশোধন করা হয় তখন একই আচরণ করে ।

          g is list of command-line args (implicit)
 $>g      Fold g on >
O         Output without newline
    $>=g  Fold g on >=
          Print (implicit)

— DLosc
সূত্র

1

জাপট , 9 8 7 বাইট

-1"একঘেয়েমি কঠোরভাবে হ্রাস" এর ফলাফল , 0"একঘেয়ে অদৃশ্য" এবং 1অন্যথায়।

än rw g

চেষ্টা করে দেখুন

1 বাইট সংরক্ষিত অলিভার ধন্যবাদ ।

— রোমশ
সূত্র

@ অলিভার, হ্যাঁ; অন্যথায় এটি ডিফল্ট হবে ... অপেক্ষা করুন, কি? কেন যে কাজ করে ?! än mg rwভুল ছাড়াই ভুল ফলাফল প্রদান করে Jতবে তা ঘটেনি än rw g। রহস্যময়।

— শেগি

1

আর , 34 বাইট

function(x)max(sign(diff(c(x,0))))

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

ডিজে'র এমএটিএল উত্তর পোর্ট করে ।

আর , 43 বাইট

function(x)all(diff(x)<0)+all(x==cummin(x))

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

রিটার্নস 2কঠোরভাবে কমছে, জন্য 1জন্য অ বৃদ্ধি, এবং 0অন্যথায়।

all(x==cummin(x))হ'ল TRUE( 1গাণিতিক ব্যবহৃত হলে রূপান্তরিত হয় ) এবং কেবল যদি fকঠোর ক্ষেত্রে সহ বৃদ্ধি-বৃদ্ধি না করে থাকে।

all(diff(x)<0)কঠোরভাবে হ্রাস হয় TRUEশুধুমাত্র যখন f।

— : Giuseppe
সূত্র

একঘেয়েমি হ্রাস করা যাক

... তবে আরে, কড়া হওয়ার দরকার নেই।

বিধি

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

জেলি , 10 9 5 বাইট

কিভাবে?

পার্ল 6 , 17 বাইট

সম্প্রসারিত:

এমএটিএল , 10 , 7 বাইট

গণিত, 22 বাইট

হাস্কেল, 40 38 37 বাইট

কমন লিস্প, 43 40 বাইট

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

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

ব্যাখ্যা

অন্যান্য 7 বাইট সমাধান

আর, 44 বাইট

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

05AB1E ,5 8 বাইট

রুবি, 37 বাইট

গণিত, 15 11 বাইট

র‌্যাকেট , 44 বাইট

সি ++ 14, 85 বাইট

পাইথন 2, 61 74 বাইট

পাইথন 3, 81 52 বাইট ( FryAmTheEggMan কে ধন্যবাদ )

বেফুঞ্জ, 50 বাইট

জে, 14 বাইট

সি, 68 67 বাইট

রেটিনা , 41 বাইট

ব্যাখ্যা

এক্সিয়াম, 114 বাইট

এপিএল, 16 বাইট

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

ল্যাবভিউ, 12 নোড, 18 তারের ==> কনভেনশন দ্বারা 48 বাইট

সিলোন, 86 বাইট

পিপ , 8 বাইট

ব্যাখ্যা

জাপট , 9 8 7 বাইট

আর , 34 বাইট

আর , 43 বাইট