Votre tâche consiste à analyser l'entrée et la sortie de la formule du n-ième terme s'il s'agit d'une séquence arithmétique, sinon il devrait afficher "NAAP".

Contribution

L'entrée (à partir de STDIN) se composera de quelques nombres, entre 4 et 10 nombres où chaque nombre sera compris entre -1000 et 1000 inclus, séparés par un délimiteur (un espace ou une virgule ou un point-virgule [selon le cas) votre préférence]). Voici quelques exemples d'entrées.

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

Production

Le programme doit d'abord vérifier si l'entrée est une progression arithmétique ou non.

Progressions arithmétiques (AP) en bref: chaque AP aura une différence commune. Il s'agit de la différence entre les termes $ n $ et $ {n-1} $ th (essentiellement $ a (n + 1) - a (n) $ où aest la fonction pour la séquence). Cette différence reste la même pour toute valeur de $ n $ dans un AP. S'il n'y a pas de différence commune, ce n'est pas une séquence arithmétique. Pour calculer la valeur du n-ième terme, utilisez cette formule $ a (n) = a (1) + (n-1) d $ où $ a (1) $ est le premier terme et $ d $ est le commun différence.

S'il ne s'agit pas d' une progression arithmétique, le programme doit afficher le message d'erreur "NAAP" (abréviation de "Not An Arithmetic Progression").

S'il s'agit d' une progression arithmétique, le programme doit imprimer le nième terme simplifié de la séquence dans STDOUT.

Exemple:

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

Explication: Il s'agit d'un point d'accès car il existe une différence commune (3 $ - 1 = 2 $). Ensuite, vous utilisez la formule $ a (n) = a (1) + (n-1) d $

Par conséquent, la sortie est 2n-1(notez l'absence d'espaces)

Les failles standard sont interdites par défaut.

Vous êtes autorisé à créer une fonction si vous le souhaitez (avec le tableau de nombres comme paramètre). Sinon, vous devez créer un programme complet qui prend les entrées sous forme de chaîne ou de tableau et sort en conséquence.

Cas de test:

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

sept.

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

C'est du code-golf donc le code le plus court en octets gagne! (désolé pour mauvais math-jax)

Toutes les suggestions sont les bienvenues!

Pyth, 30 octets

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

Suite de tests

Pour vérifier s'il s'agit d'une procession arithmétique, celle-ci utilise une soustraction vectorisée entre chaque élément et le précédent -VtQQ,. Un ternaire vérifie s'il y a plusieurs valeurs dans le résultat ( ?tJ{) et imprime le NAAPcas échéant. Ensuite, pour obtenir le bon +ou le -meilleur, le mod-formatage %+dest utilisé.

Haskell, 103 octets

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

Exemple d'utilisation:

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

Comme toujours dans Haskell, un formatage de sortie sophistiqué (par exemple, mélanger des nombres avec des chaînes) consomme beaucoup d'octets (environ 40). La logique du programme est assez compacte:

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 octets

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

Pour remédier au manque de conversion de nombre en chaîne de TI-BASIC, cela utilise la sortie sur le graphscreen ( Text() si la progression est arithmétique, qui concatène automatiquement les arguments ensemble.

Cela suppose que les nombres négatifs sont entrés en utilisant le caractère haut négatif de TI-BASIC (qui ressemble un peu ⁻), pas le signe moins binaire. Cependant, la sortie utilise le signe moins binaire.

Japt , 60 52 51 octets

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

Essayez-le en ligne!

L'entrée peut être donnée avec le séparateur que vous aimez, car c'est ainsi que l'interprète est conçu;)

Non golfé et explication

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 octets

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 octets

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

Il s'agit d'une fonction anonyme qui prend un tableau sur la pile en entrée et laisse une chaîne sur la pile en sortie. Essayez-le en ligne avec du code d'E / S supplémentaire pour les tests.

Explication:

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

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

Explication

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
)

Tester

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

EDIT: Ne niez pas la différence

EDIT: utilisez des sous-opérateurs anonymes, des opérateurs logiques et une interpolation de chaînes. Merci Brad Gilbert b2gills

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

Programme de test (lit depuis stdin):

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

Explication:

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

Rubis, 95 78 76 octets

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

78 octets

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

95 octets

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

Non golfé:

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

Usage:

->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 octets
Basé sur ma réponse de 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]