Su tarea es analizar la entrada y la salida de la fórmula para el enésimo término si es una secuencia aritmética, de lo contrario debería imprimir "NAAP".

Entrada

La entrada (de STDIN) consistirá en pocos números, entre 4 y 10 números, donde cada número estará en el rango entre -1000 y 1000 inclusive, separados por un delimitador (un espacio o una coma o un punto y coma [lo que sea tu preferencia]). Aquí hay algunos ejemplos de entradas.

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

Salida

El programa primero debe verificar si la entrada es una progresión aritmética o no.

En resumen, las progresiones aritméticas (AP): cada AP tendrá una diferencia común. Esta es la diferencia entre los términos $ n $ y $ {n-1} $ th (básicamente $ a (n + 1) - a (n) $ donde aes la función para la secuencia). Esta diferencia se mantiene igual para cualquier valor de $ n $ en un AP. Si no hay una diferencia común, entonces es no una progresión aritmética. Para calcular el valor del enésimo término, use esta fórmula $ a (n) = a (1) + (n-1) d $ donde $ a (1) $ es el primer término y $ d $ es el común diferencia.

Si no es una progresión aritmética, entonces el programa debe imprimir el mensaje de error "NAAP" (abreviatura de "No es una progresión aritmética").

Si se trata de una progresión aritmética, el programa debe imprimir el enésimo término simplificado de la secuencia en STDOUT.

Ejemplo:

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

Explicación: Este es un AP porque hay una diferencia común ($ 3 - 1 = 2 $). Luego usas la fórmula $ a (n) = a (1) + (n-1) d $

Por lo tanto, la salida es 2n-1(observe la ausencia de espacios)

Las lagunas estándar no están permitidas por defecto.

Se le permite crear una función si lo desea (con la matriz de números como su parámetro). De lo contrario, debe crear un programa completo que tome la entrada como una cadena o una matriz y las salidas en consecuencia.

Casos de prueba:

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

Este es el código de golf, por lo que gana el código más corto en bytes. (Perdón por las malas matemáticas-jax)

Cualquier sugerencia es bienvenida!

Pyth, 30 bytes

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

Banco de pruebas

Para verificar si se trata de una procesión aritmética, se utiliza una resta vectorizada entre cada elemento y el anterior -VtQQ. Un ternario comprueba si hay varios valores en el resultado ( ?tJ{) e imprime NAAPsi es así. Entonces, para obtener el +o -la derecha, el mod-formateo %+dse utiliza.

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"

Ejemplo de uso:

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

Como siempre en Haskell, el formato de salida elegante (por ejemplo, mezclar números con cadenas) consume muchos bytes (alrededor de 40). La lógica del programa es bastante compacta:

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

Para remediar la falta de conversión de número a cadena de TI-BASIC, esto utiliza la salida en la pantalla de gráficos ( Text() si la progresión es aritmética, lo que concatena automáticamente los argumentos.

Esto supone que los números negativos se ingresan utilizando el carácter de menos alto de TI-BASIC (que se parece un poco ⁻), no el signo menos binario. Sin embargo, la salida usa el signo binario menos.

Japt , 60 52 51 bytes

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

Pruébalo en línea!

La entrada se puede proporcionar con el separador que desee, ya que así es como está diseñado el intérprete;)

Sin golfos y explicación

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%+?}

Esta es una función anónima que toma una matriz en la pila como entrada y deja una cadena en la pila como salida. Pruébelo en línea con código de E / S adicional para realizar pruebas.

Explicación:

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

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

Explicación

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
)

Prueba

<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

EDITAR: no niegues la diferencia

EDITAR: utilice sub anónimos, operadores lógicos e interpolación de cadenas. Gracias Brad Gilbert b2gills

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

Programa de prueba (lecturas de stdin):

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

Explicación:

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

Sin golf:

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

Uso:

->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
Basado en mi respuesta 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]