당신의 임무는 산술 시퀀스 인 경우 n 번째 항에 대한 공식을 입력하고 출력하여 수식을 출력하는 것입니다. 그렇지 않으면 "NAAP"를 인쇄해야합니다.

입력

입력 (STDIN에서)은 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 `;`)

산출

프로그램은 먼저 입력이 산술 진행 인지 여부를 확인해야합니다 .

간단히 말해서 산술 진행 (AP) : 모든 AP에는 공통의 차이가 있습니다. 이것은 $ n $와 $ {n-1} $의 용어의 차이입니다 (기본적으로 $ a (n + 1) a-a (n) $ ). 이 차이는 AP의 $ n $에 대해 동일하게 유지됩니다. 공통적 인 차이가 없으면 산술 시퀀스 가 아닙니다 . n 번째 항의 값을 계산하려면이 수식 $ a (n) = a (1) + (n-1) d $를 사용하십시오. 여기서 $ a (1) $는 첫 번째 항이고 $ d $는 공통입니다 차.

산술 진행 이 아닌 경우 프로그램은 "NAAP"오류 메시지 ( "산술 진행이 아님"의 줄임말)를 인쇄해야합니다.

이 경우 인 산술 진행하고 프로그램 표준 출력 순서의 간략화 n 번째 항을 인쇄한다.

예:

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

설명 : 이것은 공통된 차이 ($ 3-1 = 2 $)가 있기 때문에 AP입니다. 그런 다음 공식 $ a (n) = a (1) + (n-1) d $를 사용합니다

따라서 출력은 2n-1(공백이 없다는 것을 알 수 있습니다)

표준 허점은 기본적으로 허용되지 않습니다.

원하는 경우 숫자 배열을 매개 변수로 사용하여 함수를 만들 수 있습니다. 그렇지 않은 경우 입력을 문자열 또는 배열로 가져 와서 그에 따라 출력 하는 전체 프로그램을 작성해야합니다 .

테스트 사례 :

1.

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

2.

1 3 12312 7 9
NAAP

삼.

-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

이것은 코드 골프 이므로 바이트 단위의 가장 짧은 코드가 이깁니다! (나쁜 수학 jax 죄송합니다)

어떤 제안이라도 환영합니다!

Pyth, 30 바이트

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

테스트 스위트

산술 행렬인지 확인하기 위해 각 요소와 이전 요소 사이의 벡터화 된 빼기를 사용합니다 -VtQQ. 삼항은 결과에 여러 값이 있는지 확인 ?tJ{하고 ( ) NAAP그렇다면 인쇄 합니다. 그런 다음 오른쪽 +또는 -오른쪽 을 얻기 위해 mod 형식 %+d이 사용됩니다.

하스켈, 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"

Haskell에서 항상 그렇듯이 멋진 출력 형식 (예 : 숫자와 문자열 혼합)은 많은 바이트를 소비합니다 (약 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"

TI-BASIC, 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

TI-BASIC의 숫자-문자열 변환 부족을 해결하기 위해 Text(진행률이 산술 인 경우 그래프 화면의 출력 ( )을 사용 하여 인수를 자동으로 연결합니다.

이것은 ⁻이진수 빼기 부호가 아니라 TI-BASIC의 높은 빼기 부호 문자 (약간 비슷 함 )를 사용하여 음수가 입력되었다고 가정합니다 . 그러나 출력은 이진 빼기 부호를 사용합니다.

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

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

CJam, 38 바이트

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

이것은 스택의 배열을 입력으로 사용하고 스택의 문자열을 출력으로 남겨 두는 익명 함수입니다. 테스트를위한 추가 I / O 코드와 함께 온라인 으로 사용해보십시오 .

설명:

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

자바 스크립트 (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>

펄 6 123 102 101 바이트

편집 : 차이를 부정하지 마십시오

편집 : 익명 하위, 논리 연산자 및 문자열 보간을 사용하십시오. 감사합니다 브래드 길버트 b2gills

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

테스트 프로그램 (stdin에서 읽음) :

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

루비, 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"}

언 골프 드 :

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

파이썬 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]