আপনার কাজটি হ'ল গাণিতিক ক্রম হলে ইনপুট এবং সূত্রটি এন-থার্মের জন্য আউটপুট বিশ্লেষণ করা, অন্যথায় এটি "এনএএপি" মুদ্রণ করা উচিত।

ইনপুট

ইনপুট (এসটিডিআইএন থেকে) কয়েকটি সংখ্যার সমন্বয়ে 4 থেকে 10 সংখ্যার সমন্বয়ে থাকবে যেখানে প্রতিটি সংখ্যা -1000 এবং 1000 সমেত অন্তর্ভুক্ত থাকবে, একটি ডিলিমিটার (স্পেস বা কমা বা একটি আধা-কোলন দ্বারা পৃথক) [যেটি হবে আপনার পছন্দ]]। এখানে কিছু উদাহরণ ইনপুট।

12,14,16,18       //valid
-3 4 5 1 -2 -4    //valid
45;35;-35         //invalid (only three numbers are present instead of the minimum of 4 numbers)
2,32;21,321       //invalid (it uses two different delimiters: `,` and `;`)

আউটপুট

প্রোগ্রামটি প্রথমে পরীক্ষা করে দেখা উচিত যে ইনপুটটি গাণিতিক অগ্রগতি কিনা ।

সংক্ষেপে পাটিগণিত অগ্রগতি (এপি): প্রতিটি এপিতে একটি সাধারণ পার্থক্য থাকবে। এটি $ n $ এবং $ {n-1} $ th পদগুলির মধ্যে মূলত (মূলত $ a (n + 1) - a (n) aq যেখানে সিকুন্সের জন্য ফাংশন)। এই পার্থক্যটি কোনও এপিতে any n any এর যে কোনও মানের জন্য একই থাকে। যদি কোনও সাধারণ পার্থক্য না থাকে তবে এটি কোনও গাণিতিক ক্রম নয়। N-th শর্তের মান গণনা করতে, এই সূত্রটি ব্যবহার করুন $ a (n) = a (1) + (n-1) d $ যেখানে $ a (1) term প্রথম শব্দ এবং $ d the সাধারণ পার্থক্য।

এটি যদি গাণিতিক অগ্রগতি না হয় তবে প্রোগ্রামটির ত্রুটি বার্তাটি "এনএএপি" মুদ্রণ করা উচিত ("অ্যানিমেটিক প্রগ্রেস নয়" এর সংক্ষিপ্ততা)।

যদি হয় একটি গাণিতিক অগ্রগতি, তারপর প্রোগ্রাম stdout- এ ক্রম সরলীকৃত n- তম শব্দটি প্রিন্ট করা উচিত নয়।

উদাহরণ:

> 1,3,5,7,9
2n-1

ব্যাখ্যা: এটি একটি এপি কারণ একটি সাধারণ পার্থক্য রয়েছে ($ 3 - 1 = 2।)। তারপরে আপনি সূত্রটি $ a (n) = a (1) + (n-1) d use ব্যবহার করেন $

{একটি}_{এন} = {একটি}_{1} + + (এন - 1) ঘ

$a_n = a_1 + (n-1)d$

{একটি}_{এন} = 1 + + (এন - 1) 2

$a_n = 1 + (n-1)2$

{একটি}_{এন} = 1 + + 2 এন - 2

$a_n = 1 + 2n - 2$

{একটি}_{এন} = 2 এন - 1

$a_n = 2n - 1$

সুতরাং আউটপুট হয় 2n-1 (স্থান অনুপস্থিতি লক্ষ্য করুন)

স্ট্যান্ডার্ড লুফোলগুলি ডিফল্টরূপে অনুমোদিত নয়।

আপনি চাইলে আপনাকে কোনও ফাংশন তৈরি করার অনুমতি দেওয়া হয় (আপনার প্যারামিটার হিসাবে সংখ্যার অ্যারে সহ)। যদি তা না হয় তবে আপনাকে অবশ্যই একটি পূর্ণ তৈরি করতে হবে প্রোগ্রাম যা স্ট্রিং বা অ্যারের হিসাবে ইনপুট নেয় এবং সেই অনুযায়ী আউটপুট দেয়।

পরীক্ষার কেস:

1।

1,3,5,7,9
2n-1

2।

1 3 12312 7 9
NAAP

3।

-6;8;22;36;50
14n-20

4।

5,1,-3,-7,-11,-15
-4n+9

5।

-5,-7,-9,-11,-13,-15
-2n-3

6।

3,3,3,3,3,3,3,3,3
0n+3

7।

-4,-5,-6,-7
-1n-3

এটি কোড-গল্ফ তাই বাইটের মধ্যে সংক্ষিপ্ততম কোডটি জয়! (খারাপ গণিত-জ্যাক্সের জন্য দুঃখিত)

কোন পরামর্শ স্বাগত!

— user41805
সূত্র

4

আপনার পোস্টটি সম্ভবত এক ঘণ্টার বেশি সময় স্যান্ডবক্সে রাখা উচিত ...

— মেগো

3

এক ঘন্টা সত্যিই স্বল্প সময়ের। প্রত্যেকে নিয়মিত স্যান্ডবক্স চেক করে না। 24 ঘন্টা একটি ভাল সর্বনিম্ন।

— মেগো

8

দুঃখিত, তবে ম্যাথজ্যাক্স মেটাতে কাজ করলেও এটি মূল পিপিসি সাইটটিতে কাজ করে না ...

— ETH প্রোডাকশন

1

ক্রমহ্রাসমান ক্রমগুলির সাথে আপনার পরীক্ষার কেস যুক্ত করা উচিত।

— lirtosiast

2

হয় 0,0,0,0এবং 3,1,-1,-3,-5গাণিতিক progressions,? যদি তা হয় তবে আমি মনে করি তারা ভাল পরীক্ষার কেস হতে পারে, যেহেতু তারা যে পদ্ধতিটি আমি চেষ্টা করেছিলাম তা তারা ভেঙে দিয়েছে।

— xnor

5

পাইথ, 30 বাইট

?tJ{-VtQQ"NAAP"+hJ%"n%+d"-hQhJ

পরীক্ষা স্যুট

এটি একটি গাণিতিক মিছিল কিনা তা পরীক্ষা করতে, এটি প্রতিটি উপাদান এবং পূর্ববর্তীগুলির মধ্যে ভেক্টরাইজড বিয়োগ ব্যবহার করে -VtQQ। ফলাফল ( ?tJ{) এবং এর মধ্যে যদি একাধিক মান থাকে তবে একটি ত্রিনিয়ারি চেক করে NAAP। তারপরে, ডানে +বা -ডান পেতে , মোড-ফর্ম্যাট %+dব্যবহার করা হয়।

— isaacg
সূত্র

3

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

z=(tail>>=).zipWith
f l@(a:b:_:_:_)|and$z(==)$z(-)l=show(b-a)++'n':['+'|b-a<=a]++show(a+a-b)
f _="NAAP"

ব্যবহারের উদাহরণ:

f [-6,8,22,36,50]   ->   "14n-20"
f [60,70,80,90]     ->   "10n+50"
f [2,3,4,6,7,8]     ->   "NAAP"

হাস্কেলের মতো সর্বদা, অভিনব আউটপুট বিন্যাস (উদাহরণস্বরূপ স্ট্রিংয়ের সাথে সংখ্যার মিশ্রণ) প্রচুর বাইট খায় (প্রায় 40)। প্রোগ্রামটির যুক্তিটি বেশ কমপ্যাক্ট:

f l@(a:b:_:_:_)           -- pattern match an input list with at least 4 elements,
                          -- call the whole list l, the first two elements a and b
z=(tail>>=).zipWith       -- the helper function z takes a function f and a list l
                          -- and applies f element wise to the tail of l and l

           z(-)l          -- make a list of neighbor differences
     z(==)                -- then compare these differences for equality
 and                      -- and see if only True values occur

       show ...           -- if so format output string

f _="NAAP"                -- in all other cases ( < 4 elements or False values)
                          -- return "NAAP"

— nimi
সূত্র

2

টিআই-বেসিক, 70 বাইট

Input X
ΔList(∟X->Y
If variance(Ans
Then
∟X(1)-min(Ans
Text(0,0,min(∟Y),"n",sub("+-",(Ans<0)+1,1),abs(Ans
Else
"NAAP

টিআই-বেসিকের সংখ্যার টু-স্ট্রিং রূপান্তরটির অভাব নিরাময়ের জন্য, এটি গ্রাফস্ক্রিনে আউটপুট ব্যবহার করে (Text( , অগ্রগতি গাণিতিক হলে এটি ) , যা যুক্তিগুলি স্বয়ংক্রিয়ভাবে একত্রিত করে।

এটি ধরে নিয়েছে যে টিআই-বেসিকের উচ্চ-বিয়োগ চরিত্রটি (যা দেখতে কিছুটা দেখতে দেখতে ⁻) ব্যবহার করে নেতিবাচক সংখ্যাগুলি প্রবেশ করা হয়েছিল, বাইনারি বিয়োগ চিহ্ন নয়। তবে আউটপুট বাইনারি বিয়োগ চিহ্ন ব্যবহার করে।

— lirtosiast
সূত্র

2

জাপট , 60 52 51 বাইট

V=N¤£X-NgY+1};W=Vg;Ve_¥W} ?W+'n+'+sU<W +(U-W :"NAAP

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

আপনার পছন্দমতো বিভাজক দিয়ে ইনপুট দেওয়া যেতে পারে, যেমন দোভাষীর নকশা করা হয়;)

অবহেলিত এবং ব্যাখ্যা

V=N¤  £    X-NgY+1};W=Vg;Ve_  ¥ W} ?W+'n+'+sU<W +(U-W :"NAAP
V=Ns2 mXYZ{X-NgY+1};W=Vg;VeZ{Z==W} ?W+'n+'+sU<W +(U-W :"NAAP

            // Implicit: N = list of inputs, U = first input
V=Ns2       // Set variable V to N, with the first 2 items sliced off,
mXYZ{       // with each item X and index Y mapped to:
X-NgY+1}    //  X minus the item at index Y+1 in N.
            // This results in a list of the differences (but the first item is NaN).
W=Vg;       // Set W to the first item in V (the multiplication part).
VeZ{Z==W}   // Check if every item in V is equal to W.
?W+'n+      // If true, return W + "n" +
'+sU<W      //  "+".slice(U<W) (this is "+" if U >= W, and "" otherwise)
+(U-W       //  + (U minus W [the addition part]).
:"NAAP      // Otherwise, return "NAAP".
            // Implicit: output last expression

— ETHproductions
সূত্র

1

মতলব, 103 বাইট

x=str2num(input('','s'));y=diff(x);if range(y) disp('NAAP'),else fprintf('%gn%+g\n',y(1),x(1)-y(1)),end

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

1

সিজেম, 38 বাইট

{:T2ew::-):U-"NAAP"UW*"n%+d"T0=U+e%+?}

এটি একটি অনামী ফাংশন যা স্ট্যাকের ইনপুট হিসাবে একটি অ্যারে নেয় এবং আউটপুট হিসাবে স্ট্যাকের উপর একটি স্ট্রিং ফেলে leaves পরীক্ষার জন্য অতিরিক্ত আই / ও কোড দিয়ে অনলাইনে চেষ্টা করে দেখুন ।

ব্যাখ্যা:

:T      Save a copy of input in variable T for output generation.
2ew     Generate list of pairs of sequential elements.
::-     Reduce all pairs with subtraction operator.
)       Pop last value from list of differences.
:U      Save difference value in variable U for output generation.
-       Set difference. This will leave an empty list (falsy) if all values are the same.
"NAAP"  First value for ternary operator, for case where not all values are the same.
UW*     Start generating output for success case. Need to flip sign of difference saved
        in variable U, since it was 1st value minus 2nd, and we need the opposite.
"n%+d"  Push format string for printf operator. The + sign in the format specifies that
        the sign is always generated, saving us from needing different cases for the
        value being negative or positive.
T0=     Extract first value from original input saved in variable T.
U+      Add the difference (with the "wrong" sign) to it.
e%      "printf" operator.
+       Concatenate two parts of result.
?       Ternary operator for picking one of the two output cases.

— রেটো কোরাদি
সূত্র

1

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

x=>(s=x.split`,`,m=s[1]-s[0],a=s[0]-m,s.some((n,i)=>n!=m*i+m+a)?"NAAP":m+"n"+(a<0?a:"+"+a))

ব্যাখ্যা

x=>(
  s=x.split`,`,       // s = array of input numbers
  m=s[1]-s[0],        // m = the multiplication part of the formula
  a=s[0]-m,           // a = the addition part of the formula
  s.some((n,i)=>      // check if the rest of the numbers follow this sequence
    n!=m*i+m+a
  )?"NAAP":
  m+"n"+(a<0?a:"+"+a) // output the formula
)

পরীক্ষা

<input type="text" id="input" value="5,1,-3,-7,-11,-15" /><button onclick='result.innerHTML=(

x=>(s=x.split`,`,m=s[1]-s[0],a=s[0]-m,s.some((n,i)=>n!=m*i+m+a)?"NAAP":m+"n"+(a<0?a:"+"+a))

)(input.value)'>Go</button><pre id="result"></pre>

স্নিপেট প্রসারিত করুন

— user81655
সূত্র

1

পার্ল 6, 123 102 101 বাইট

সম্পাদনা: পার্থক্যকে অস্বীকার করবেন না

সম্পাদনা: বেনামে সাব, লজিকাল অপারেটর এবং স্ট্রিং ইন্টারপোলেশন ব্যবহার করুন। ধন্যবাদ ব্র্যাড গিলবার্ট বি 2 গিলস

sub{my@b=@_.rotor(2=>-1).map({[-] $_}).squish;$_=@_[0]+@b[0];@b.end&&"NAAP"||"@b[0]n{'+'x($_>=0)}$_"}

পরীক্ষা প্রোগ্রাম (স্টাডিন থেকে পড়া):

my $f = <the code above>
$f(split(/<[;,]>/, slurp)).say

ব্যাখ্যা:

my @b =
  @_.rotor(2=>-1)  # sliding window of 2: (1,2,3,4) => ((1,2),(2,3),(3,4))
  .map({[-] $_})  # calculate difference (subtract all elements and negate)
  .squish;         # remove adjacent elements that are equal

@b.end        # @b.end is last index, @b.end = 0 means @b has only 1 element
&& "NAAP"     # true branch
|| "@b[0]n{'+'x($_>=0)}$_" # string for an+b, 
        # {'+'x($_>=0)} inserts a plus sign using the repetition operator x

— মিং-তাং
সূত্র

সাধারণত আপনি ল্যাম্বডা এক্সপ্রেশন ফর্মগুলির একটি ব্যবহার করবেন যাতে আপনি এটি মুছতে পারেন sub f। এছাড়াও আপনি যদি আপনার @_পরিবর্তে ব্যবহার করেন তবে @aকয়েকটি বাইট সংরক্ষণ করতে পারবেন। {my@b=@_.rotor...। এছাড়াও আপনি একটি অবস্থার কাছাকাছি বাম বন্ধনী করা উচিত নয় ifবিবৃতি, এই পার্ল 5. আপনি পরিবর্তিত নয় ifথেকে @b.end&&"NAAP"||$_=...আপনি আরো কয়েকটি বাইট সংরক্ষণ করবে। আপনি তার পরিবর্তে 4 বাইট সংরক্ষণ করে ifব্যবহার করলে সেই শেষের বিবৃতিটিও সরিয়ে ফেলতে পারেন "@b[0]n{'+'x($_>=0)}$_"।

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

আপনার subশুরুতে প্রয়োজন হবে না , এটি ছাড়া এটি একটি বেনামে ব্লক হয়ে যায়। এছাড়াও ঠিক আপনারা জানেন, আমি .map({[-] $_})সম্ভবত ব্যবহার করতে পারতাম ».map(*-*).flatযা দীর্ঘায়িত ব্যবহার করার কথা ভাবিনি , এখন আমি নিজের কৌতুক দিয়ে এটি ছোট করে তুলতে পারি কিনা তা দেখতে আমার নিজের প্রবেশপথগুলিতে যেতে হবে।

— ব্র্যাড গিলবার্ট বিস্কুট

1

রুবি, 95 78 76 বাইট

->s{i,j=s;puts s.reduce(:+)==s.size*(s[-1]+i)/2?"%dn%+d"%[v=j-i,i-v]:"NAAP"}

78 বাইট

->s{puts s.reduce(:+)==s.size*(s[-1]+i=s[0])/2?"%dn%+d"%[v=s[1]-i,i-v]:"NAAP"}

95 বাইট

->s{puts s.reduce(:+)==s.size*(s[0]+s[-1])/2?"#{v=s[1]-s[0]}n#{"+"if (i=s[0]-v)>0}#{i}":"NAAP"}

Ungolfed:

-> s {
  i,j=s
  puts s.reduce(:+)==s.size*(s[-1]+i)/2?"%dn%+d"%[v=j-i,i-v]:"NAAP"
}

ব্যবহার:

->s{i,j=s;puts s.reduce(:+)==s.size*(s[-1]+i)/2?"%dn%+d"%[v=j-i,i-v]:"NAAP"}[[-6,8,22,36,50]]

=> 14n-20

— ভাসু আদারী
সূত্র

0

পাইথন 3, 92 বাইটস সিকোয়েন্সটি অনুসন্ধান
থেকে আমার উত্তরটির উপর ভিত্তি করে

def m(t):s=str;a=t[0];b=t[1];q=b-a;return((s(q)+'n'+'+'*(0<a-q)+s(a-q)),'NAAP')[t[2]/b==b/a]

— জর্জ
সূত্র

পাটিগণিতের অগ্রগতি