Ihre Aufgabe ist es, die Eingabe zu analysieren und die Formel für den n-ten Term auszugeben, wenn es sich um eine arithmetische Folge handelt, andernfalls sollte "NAAP" gedruckt werden.

Eingang

Die Eingabe (von STDIN) besteht aus wenigen Zahlen zwischen 4 und 10 Zahlen, wobei jede Zahl im Bereich zwischen -1000 und einschließlich 1000 liegt und durch ein Trennzeichen (ein Leerzeichen oder ein Komma oder ein Semikolon) getrennt ist deine Vorliebe]). Hier sind einige Beispieleingaben.

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

Ausgabe

Das Programm sollte zuerst prüfen, ob die Eingabe eine arithmetische Folge ist oder nicht.

Arithmetische Progressionen (AP) auf den Punkt gebracht: Jeder AP hat einen gemeinsamen Unterschied. Dies ist der Unterschied zwischen den Termen $ n $ und $ {n-1} $ (im Grunde $ a (n + 1) - a (n) $, wobei adie Funktion für die Sequenz ist). Dieser Unterschied bleibt für jeden Wert von $ n $ in einem AP gleich. Wenn es keinen gemeinsamen Unterschied gibt, handelt es sich nicht um eine arithmetische Folge. Um den Wert des n-ten Terms zu berechnen, verwenden Sie diese Formel $ a (n) = a (1) + (n-1) d $, wobei $ a (1) $ der erste Term und $ d $ der gemeinsame ist Unterschied.

Wenn es sich nicht um eine arithmetische Folge handelt, sollte das Programm die Fehlermeldung "NAAP" (kurz für "Not An Arithmetic Progression") ausgeben.

Wenn es sich um eine arithmetische Folge handelt, sollte das Programm den vereinfachten n-ten Term der Sequenz in STDOUT drucken.

Beispiel:

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

Erläuterung: Dies ist ein AP, da es einen gemeinsamen Unterschied gibt ($ 3 - 1 = 2 $). Dann verwenden Sie die Formel $ a (n) = a (1) + (n-1) d $

Daher ist die Ausgabe 2n-1(beachten Sie das Fehlen von Leerzeichen)

Standardlücken sind standardmäßig nicht zulässig.

Sie können eine Funktion erstellen, wenn Sie möchten (mit dem Zahlenarray als Parameter). Wenn nicht, müssen Sie ein vollständiges Programm erstellen , das Eingaben als Zeichenfolge oder Array verwendet und entsprechend ausgibt.

Testfälle:

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

Dies ist Code-Golf, also gewinnt der kürzeste Code in Bytes! (Entschuldigung für den schlechten Mathe-Jax)

Anregungen sind willkommen!

Pyth, 30 Bytes

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

Testsuite

Um zu überprüfen, ob es sich um eine arithmetische Prozession handelt, wird eine vektorisierte Subtraktion zwischen jedem Element und dem vorherigen verwendet -VtQQ. Ein Ternär prüft, ob das Ergebnis ( ?tJ{) mehrere Werte enthält, und druckt in diesem NAAPFall. Um das +oder das -Richtige zu finden, wird die Mod-Formatierung %+dverwendet.

Haskell, 103 Bytes

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

Anwendungsbeispiel:

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

Wie immer in Haskell verbraucht eine ausgefallene Ausgabeformatierung (z. B. Mischen von Zahlen mit Zeichenfolgen) viele Bytes (etwa 40). Die Programmlogik ist recht kompakt:

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 Bytes

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

Um die fehlende Konvertierung von Zahlen in Zeichenfolgen von TI-BASIC zu beheben, wird die Ausgabe auf dem Grafikbildschirm ( Text() verwendet, wenn der Verlauf arithmetisch ist, wodurch die Argumente automatisch miteinander verknüpft werden .

Dies setzt voraus, dass negative Zahlen mit dem High-Minus-Zeichen von TI-BASIC (das ein wenig aussieht ⁻) und nicht mit dem binären Minuszeichen eingegeben werden . Die Ausgabe verwendet jedoch das binäre Minuszeichen.

Japt , 60 52 51 Bytes

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

Probieren Sie es online aus!

Die Eingabe kann mit einem beliebigen Trennzeichen erfolgen, da der Interpreter so aufgebaut ist;)

Ungolfed und Erklärung

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 Bytes

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 Bytes

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

Dies ist eine anonyme Funktion, die ein Array auf dem Stapel als Eingabe verwendet und eine Zeichenfolge als Ausgabe auf dem Stapel belässt. Probieren Sie es online mit zusätzlichem E / A-Code zum Testen aus.

Erläuterung:

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

Erläuterung

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
)

Prüfung

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

EDIT: Negiere keinen Unterschied

BEARBEITEN: Verwenden Sie anonymes Sub, logische Operatoren und String-Interpolation. Danke Brad Gilbert b2gills

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

Testprogramm (liest von stdin):

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

Erläuterung:

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 Bytes

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

78 Bytes

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

95 Bytes

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

Verwendung:

->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 Bytes
Basierend auf meiner Antwort von 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]