Twoim zadaniem jest analiza danych wejściowych i wyjściowych formuły dla n-tego terminu, jeśli jest to sekwencja arytmetyczna, w przeciwnym razie powinien wypisać „NAAP”.

Wejście

Dane wejściowe (z STDIN) będą się składać z kilku liczb, od 4 do 10 liczb, przy czym każda liczba będzie w zakresie od -1000 do 1000 włącznie, oddzielonych separatorem (spacja, przecinek lub średnik [którykolwiek z nich ma być Twoje preferencje]). Oto kilka przykładowych danych wejściowych.

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

Wynik

Program powinien najpierw sprawdzić, czy dane wejściowe są postępem arytmetycznym, czy nie.

Postępy arytmetyczne (AP) w pigułce: każdy AP będzie miał wspólną różnicę. Jest to różnica między $ n $ a $ {n-1} $ th warunkami (w zasadzie $ a (n + 1) - a (n) $ gdzie ajest funkcja dla sequnce). Różnica pozostaje taka sama dla dowolnej wartości $ n $ w AP. Jeśli nie ma wspólnego różnica, to nie arytmetyczną sekwencji. Aby obliczyć wartość n-tego terminu, użyj tej formuły $ a (n) = a (1) + (n-1) d $, gdzie $ a (1) $ jest pierwszym terminem, a $ d $ jest powszechne różnica.

Jeśli nie jest to postęp arytmetyczny, program powinien wydrukować komunikat o błędzie „NAAP” (skrót od „Not An Arytmetic Progress”).

Jeśli jest to postęp arytmetyczny, program powinien wypisać uproszczony n-ty termin sekwencji do STDOUT.

Przykład:

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

Objaśnienie: Jest to AP, ponieważ istnieje wspólna różnica (3 $ - 1 = 2 $). Następnie używasz wzoru $ a (n) = a (1) + (n-1) d $

Dlatego wyjściem jest 2n-1(zauważ brak spacji)

Standardowe luki są domyślnie niedozwolone.

Możesz utworzyć funkcję, jeśli chcesz (z tablicą liczb jako parametrem). Jeśli nie, musisz utworzyć pełny program, który pobiera dane wejściowe jako ciąg lub tablicę i odpowiednio wyświetla dane wyjściowe.

Przypadki testowe:

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

To jest golf golfowy, więc wygrywa najkrótszy kod w bajtach! (przepraszam za złą matematykę)

Wszelkie sugestie są mile widziane!

Pyth, 30 bajtów

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

Zestaw testowy

Aby sprawdzić, czy jest to arytmetyka procesja, to wykorzystuje wektorowy odejmowanie między każdym elementem i poprzedni, -VtQQ. Trójka sprawdza, czy w wyniku ( ?tJ{) występuje wiele wartości, i drukuje, NAAPjeśli tak jest. Następnie, aby uzyskać właściwe +lub -, %+dużywa się formowania modów .

Haskell, 103 bajty

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

Przykład użycia:

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

Jak zawsze w Haskell, fantazyjne formatowanie wyjściowe (np. Mieszanie liczb z ciągami znaków) zjada wiele bajtów (około 40). Logika programu jest dość zwarta:

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 bajtów

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

Aby zaradzić brakowi konwersji liczb na ciąg znaków przez TI-BASIC, wykorzystuje on dane wyjściowe na ekranie grafowym ( Text(), jeśli postęp jest arytmetyczny, co automatycznie łączy argumenty razem.

Zakłada się, że liczby ujemne są wprowadzane za pomocą znaku wysokiego minus TI-BASIC (który wygląda trochę jak ⁻), a nie binarnego znaku minus. Jednak dane wyjściowe używają binarnego znaku minus.

Japt , 60 52 51 bajtów

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

Wypróbuj online!

Dane wejściowe można podawać za pomocą dowolnego separatora, ponieważ taki jest projekt interpretera;)

Bez golfa i wyjaśnienia

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 bajty

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 bajtów

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

Jest to anonimowa funkcja, która pobiera tablicę ze stosu jako dane wejściowe i pozostawia ciąg znaków na stosie jako dane wyjściowe. Wypróbuj online z dodatkowym kodem I / O do testowania.

Wyjaśnienie:

: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 bajtów

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

Wyjaśnienie

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
)

Test

<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 bajtów

EDYCJA: Nie neguj różnicy

EDYCJA: użyj anonimowych sub, operatorów logicznych i interpolacji ciągów. Dzięki Brad Gilbert b2gills

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

Program testowy (odczytuje ze standardowego wejścia):

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

Wyjaśnienie:

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

Rubin, 95 78 76 bajtów

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

78 bajtów

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

95 bajtów

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

Nie golfowany:

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

Stosowanie:

->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 bajty
Na podstawie mojej odpowiedzi z Find the Sequence

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]