Progressions arithmétiques

11

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 $

unen=une1+(n-1)

unen=1+(n-1)2

unen=1+2n-2

unen=2n-1

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 donc le code le plus court en octets gagne! (désolé pour mauvais math-jax)

Toutes les suggestions sont les bienvenues!

user41805
la source
4
Vous devriez probablement garder votre message dans le bac à sable pendant plus d'une heure ...
Mego
3
Une heure, c'est très court. Tout le monde ne vérifie pas constamment le bac à sable. 24 heures est un bon minimum.
Mego
8
Désolé, mais bien que MathJax fonctionne sur Meta, cela ne fonctionne pas sur le site principal de PPCG ...
ETHproductions
1
Vous devez ajouter des cas de test avec des séquences décroissantes.
lirtosiast
2
Sont 0,0,0,0et 3,1,-1,-3,-5progressions arithmétiques? Si c'est le cas, je pense que ce seraient de bons cas de test, car ils ont cassé une méthode que j'essayais.
xnor

Réponses:

5

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

isaacg
la source
3

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"
nimi
la source
2

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.

lirtosiast
la source
2

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
ETHproductions
la source
1

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
Luis Mendo
la source
1

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.
Reto Koradi
la source
1

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>

user81655
la source
1

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
Ming-Tang
la source
En règle générale, vous utiliseriez l'un des formulaires d'expression lambda afin de pouvoir supprimer le sub f. De plus, si vous l'utilisiez @_au lieu de @avous, vous économiseriez plusieurs octets. {my@b=@_.rotor.... Aussi , vous ne devriez pas mettre parens autour de la condition d'une ifdéclaration, ce n'est pas Perl 5. Si vous avez changé que ifpour @b.end&&"NAAP"||$_=...vous économiseriez quelques octets. Vous pouvez également supprimer cette dernière ifinstruction si vous l'avez utilisée à la "@b[0]n{'+'x($_>=0)}$_"place, en économisant 4 octets.
Brad Gilbert b2gills
Vous n'avez pas besoin subau début, sans cela il devient un bloc anonyme. Juste pour que vous le sachiez, je n'aurais pas pensé à utiliser .map({[-] $_})j'aurais probablement utilisé ».map(*-*).flatce qui est plus long, maintenant je dois parcourir mes propres entrées pour voir si je peux le raccourcir avec votre astuce.
Brad Gilbert b2gills
1

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
Vasu Adari
la source
0

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]

George
la source