Nhiệm vụ của bạn là phân tích đầu vào và đầu ra công thức cho số hạng thứ n nếu đó là một chuỗi số học, nếu không nó sẽ in "NAAP".

Đầu vào

Đầu vào (từ STDIN) sẽ bao gồm một vài số, từ 4 đến 10 số trong đó mỗi số sẽ nằm trong phạm vi từ -1000 đến 1000, được phân tách bằng dấu phân cách (dấu cách hoặc dấu phẩy hoặc dấu chấm phẩy [tùy theo sở thích của bạn]). Dưới đây là một số ví dụ đầu vào.

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 `;`)

Đầu ra

Trước tiên, chương trình nên kiểm tra xem đầu vào có phải là một tiến trình số học hay không.

Tiến trình số học (AP) một cách ngắn gọn: Mỗi AP sẽ có một điểm khác biệt chung. Đây là sự khác biệt giữa các điều khoản $ n $ và $ {n-1} $ th (về cơ bản $ a (n + 1) - a (n) $ trong đó alà hàm cho phần tiếp theo). Sự khác biệt này giữ nguyên cho bất kỳ giá trị nào của $ n $ trong một AP. Nếu không có sự khác biệt chung, thì đó không phải là một chuỗi số học. Để tính giá trị của số hạng thứ n, hãy sử dụng công thức này $ a (n) = a (1) + (n-1) d $ trong đó $ a (1) $ là thuật ngữ đầu tiên và $ d $ là phổ biến Sự khác biệt.

Nếu nó không phải là một tiến trình số học, thì chương trình sẽ in thông báo lỗi "NAAP" (viết tắt của "Không phải là một tiến trình số học").

Nếu đó là một tiến trình số học, thì chương trình sẽ in thuật ngữ thứ n đơn giản hóa của chuỗi thành STDOUT.

Thí dụ:

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

Giải thích: Đây là một AP vì có một sự khác biệt chung ($ 3 - 1 = 2 $). Sau đó, bạn sử dụng công thức $ a (n) = a (1) + (n-1) d $

Do đó, đầu ra là 2n-1(chú ý sự vắng mặt của không gian)

Các sơ hở tiêu chuẩn không được phép theo mặc định.

Bạn được phép tạo một hàm nếu bạn muốn (với mảng số là tham số của bạn). Nếu không, thì bạn phải tạo một chương trình đầy đủ lấy đầu vào dưới dạng chuỗi hoặc mảng và xuất ra tương ứng.

Các trường hợp thử nghiệm:

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

Đây là mã golf, vì vậy mã ngắn nhất tính bằng byte sẽ thắng! (xin lỗi vì toán học tồi

Mọi góp ý đều được chào đón!

Bình thường, 30 byte

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

Bộ kiểm tra

Để kiểm tra xem đó có phải là một đám rước số học hay không, điều này sử dụng phép trừ được vector hóa giữa mỗi phần tử và phần tử trước đó -VtQQ. Một ternary kiểm tra nếu có nhiều giá trị trong kết quả ( ?tJ{) và in NAAPnếu có. Sau đó, để có được +hoặc -đúng, định dạng mod %+dđược sử dụng.

Haskell, 103 byte

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

Ví dụ sử dụng:

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

Như mọi khi trong Haskell, định dạng đầu ra ưa thích (ví dụ: trộn số với chuỗi) ăn rất nhiều byte (khoảng 40). Logic chương trình khá nhỏ gọn:

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"

TI-BASIC, 70 byte

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

Để khắc phục sự thiếu chuyển đổi số thành chuỗi của TI-BASIC, điều này sử dụng đầu ra trên màn hình đồ thị ( Text() nếu tiến trình là số học, tự động nối các đối số lại với nhau.

Điều này giả định rằng các số âm được nhập bằng ký tự trừ cao của TI-BASIC (trông hơi giống ⁻), không phải là dấu trừ nhị phân. Tuy nhiên, đầu ra sử dụng dấu trừ nhị phân.

Japt , 60 52 51 byte

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

Hãy thử trực tuyến!

Đầu vào có thể được cung cấp với bất kỳ dấu phân cách nào bạn thích, vì đó là cách trình thông dịch được thiết kế;)

Ung dung và giải thích

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

Matlab, 103 byte

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

CJam, 38 byte

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

Đây là một hàm ẩn danh lấy một mảng trên ngăn xếp làm đầu vào và để lại một chuỗi trên ngăn xếp làm đầu ra. Hãy thử trực tuyến với mã I / O bổ sung để thử nghiệm.

Giải trình:

: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.

JavaScript (ES6), 91 byte

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))

Giải trình

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
)

Kiểm tra

<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>

Perl 6, 123 102 101 byte

EDIT: Đừng phủ nhận sự khác biệt

EDIT: sử dụng phụ ẩn, toán tử logic và nội suy chuỗi. Cảm ơn Brad Gilbert b2gills

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

Chương trình thử nghiệm (đọc từ stdin):

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

Giải trình:

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

Ruby, 95 78 76 byte

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

78 byte

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

95 byte

->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"}

Ung dung:

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

Sử dụng:

->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

Python 3, 92 byte
Dựa trên câu trả lời của tôi từ Tìm chuỗi

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]