En mathématiques, une façon de déterminer quel est le type d'une relation donnée (linéaire, quadratique, etc.) pour calculer les différences. Pour ce faire, vous prenez une liste de valeurs y pour lesquelles l'écart entre les valeurs x correspondantes est le même, et soustrayez chacune du nombre au-dessus, créant une liste de nombres plus courte que la liste précédente. Si la liste résultante est entièrement composée de nombres identiques, alors la relation a une différence de 1 (elle est linéaire). S'ils ne sont pas identiques, vous répétez le processus sur la nouvelle liste. S'ils sont maintenant identiques, la relation a une différence de 2 (elle est quadratique). S'ils ne sont pas identiques, vous continuez simplement ce processus jusqu'à ce qu'ils le soient. Par exemple, si vous avez la liste des valeurs y [1,6,15,28,45,66] pour l'augmentation incrémentielle des valeurs x:

First Differences:

1
6   1-6  =-5
15  6-15 =-9
28  15-28=-13
45  28-45=-17
66  45-66=-21

Second differences:

-5 
-9  -5+9  =4
-13 -9+13 =4
-17 -13+17=4
-21 -17+21=4

As these results are identical, this relation has a difference of 2

Ta tâche:

Écrivez un programme ou une fonction qui, lorsqu'elle reçoit un tableau d'entiers en entrée, renvoie la différence de la relation décrite par le tableau, comme expliqué ci-dessus.

Contribution:

Un tableau d'entiers, qui peut être de n'importe quelle longueur> 1.

Sortie:

Un entier représentant la différence de la relation décrite par l'entrée.

Cas de test:

Input                            => Output
[1,2,3,4,5,6,7,8,9,10]           => 1
[1,4,9,16,25,36]                 => 2
[1,2,1]                          => 2 (when there is only one value left, all values are automatically identical, so the largest difference an array can have is equal to the length of the array-1)
"Hello World"                    => undefined behavior (invalid input)
[1,1,1,1,1,1,1,1,1]              => 0 (all elements are already identical)
[1, 3, 9, 26, 66, 150, 313, 610] => 6

Notation:

Il s'agit du code-golf , le score le plus bas en octets dans chaque langue gagne pour cette langue. Le score le plus bas obtient la coche verte.

Husk , 6 octets

Merci Leo de me laisser utiliser sa version qui fonctionne pour[1,1,1,1,1,1]

←VE¡Ẋ-

Essayez-le en ligne!

Explication

   ¡     Repeatedly apply function, collecting results in a list
    Ẋ-     Differences
 VE      Get the index of the first place in the list where all the elements are equal
←        Decrement

JavaScript (ES6), 47 octets

f=a=>-a.every(x=>i=!x)||1+f(a.map(n=>n-a[++i]))

Cas de test

f=a=>-a.every(x=>i=!x)||1+f(a.map(n=>n-a[++i]))

console.log(f([1,2,3,4,5,6,7,8,9,10]))    // 1
console.log(f([1,4,9,16,25,36]))          // 2
console.log(f([1,2,1]))                   // 2
console.log(f([1,1,1,1,1,1,1,1,1]))       // 0
console.log(f([1,3,9,26,66,150,313,610])) // 6

MATL , 8 octets

`dta}x@q

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

Cela compense les différences consécutives de manière itérative jusqu'à ce que le résultat soit entièrement nul ou vide. La sortie est le nombre requis d'itérations moins 1.

`      % Do... while
  d    %   Consecutive diffferences. Takes input (implicitly) the first time
  t    %   Duplicate
  a    %   True if any element is nonzero. This is the loop condition
}      % Finally (execute before exiting the loop)
  x    %   Delete. This removes the array of all zeros
  @    %   Push iteration index
  q    %   Subtract 1. Implicitly display
       % End (implicit). Proceed with next iteration if top of the stack is true

R , 50 44 octets

function(l){while(any(l<-diff(l)))F=F+1
F*1}

Essayez-le en ligne!

Prend un diffde l, le définit sur let vérifie si le résultat contient des valeurs non nulles. Dans le cas contraire, l' incrément F(initialisé FALSEimplicitement), et revient F*1à convertir FALSEà 0dans le cas où tous lest déjà identique.

Mathematica, 49 octets

(s=#;t=0;While[!SameQ@@s,s=Differences@s;t++];t)&  

merci @alephalpa pour -6 octets et @hftf -1 octet

et voici une autre approche de @hftf

Mathematica, 49 octets

Length@NestWhileList[Differences,#,!SameQ@@#&]-1&

Gelée , 7 octets

-Iß$E?‘

Essayez-le en ligne!

Explication

-Iß$E?‘  Input: array A
     ?   If
    E    All elements are equal
         Then
-          Constant -1
         Else
   $       Monadic chain
 I           Increments
  ß          Recurse
      ‘  Increment

Japt , 10 7 octets

è@=ä-)d

Essayez-le en ligne!

S'appuie sur le fait que le résultat est garanti dans la longueur du tableau d'entrée.

Explication

è@=ä-)d     Implcit input of array U
 @          For each value in U...
  =ä-)      Update U to be equal to its subsections, each reduced by subtraction
      d     Check if any values in that are truthy
è           Count how many items in that mapping are true

À la fin, cela mappera le tableau
[1, 3, 9, 26, 66, 150, 313, 610]à [true, true, true, true, true, true, false, false],
qui contient 6 trues.

Version précédente de 10 octets

@=ä-)e¥0}a

Essayez-le en ligne!

Perl 6 , 37 octets

{($_,{@(.[] Z- .[1..*])}...*.none)-2}

Essayez-le en ligne!

Explication: La fonction prend l'entrée comme une seule liste. Il construit ensuite une séquence récursive comme celle-ci: le premier élément est la liste d'origine ( $_), les éléments suivants sont retournés en {@(@$_ Z- .[1..*])}étant appelés sur l'élément précédent, et cela est itéré jusqu'à ce que la condition *.nonesoit vraie, ce qui ne se produit que lorsque la liste est soit vide ou ne contient que des zéros (ou, techniquement, d'autres valeurs de falsey). Nous prenons ensuite la liste et soustrayons 2 de celle-ci, ce qui la force d'abord au contexte numérique (et les listes dans le contexte numérique sont égales au nombre de leurs éléments) et, à la fin, renvoie 2 de moins que le nombre d'éléments dans le liste.

Le bloc étrange {@(@$_ Z- .[1..*])}prend simplement la liste donnée ( .[]- ce qu'on appelle la tranche Zen - l'indexation avec des crochets vides donne la liste entière), la zippe en utilisant l'opérateur moins ( Z-) avec la même liste sans le premier élément ( .[1..*]) et la force à une liste ( @(...)- nous en avons besoin parce que zip ne renvoie qu'un Seq, qui est fondamentalement une liste à sens unique qui ne peut être itérée qu'une seule fois. C'est quelque chose que nous n'aimons pas.) Et c'est tout.

Java 8, 191 + 58 = 249 198 140 octets.

Merci PunPun1000 pour 51 octets.
Merci Nevay pour 58 octets.

int f(int[]a){int x=a.length-1,b[]=new int[x];for(;x-->0;)b[x]=a[x+1]-a[x];return java.util.Arrays.stream(a).distinct().count()<2?0:1+f(b);}

Essayez-le en ligne!

Essayez-le en ligne (version 198 octets)

Donc, c'est ma première publication ici dans PPCG (et la première fois que je fais un défi de golf de code). Toute critique constructive est la bienvenue et appréciée. J'ai essayé de suivre les directives de publication, si quelque chose ne va pas, n'hésitez pas à le signaler.

Version embellie:

int f(int[] a) {
    int x = a.length - 1, b[] = new int[x];
    for (; x-- > 0;) {
        b[x] = a[x + 1] - a[x];
    }
    return java.util.Arrays.stream(a).distinct().count() < 2 ? 0 : 1 + f(b);
}

Haskell, 46 octets

g l|all(==l!!0)l=0|0<1=1+g(zipWith(-)l$tail l)

cela revient simplement - zipWith(-)l$last lest la liste des différences l. et gc'est la fonction qui répond à la question.

Kotlin , 77 octets

premier message, a essayé de modifier la dernière réponse sur kotlin 2 fois; D

{var z=it;while(z.any{it!=z[0]})z=z.zip(z.drop(1),{a,b->a-b});it.size-z.size}

a pris une partie de test de @jrtapsell

TryItOnline

APL (Dyalog Classic) , 22 17 octets

{1=≢∪⍵:0⋄1+∇2-/⍵}

Essayez-le en ligne!

Merci à @ngn pour -5 octets!

Comment?

• { ... }, la fonction
• 1=≢∪⍵:0, si chaque élément est égal dans l'argument, retourne 0
• 1+∇2-/⍵, sinon, renvoyer 1 + ndes différences (ce n-1qui signifie qu'en y ajoutant un donne n)

Gelée , 7 octets

IÐĿEÐḟL

Essayez-le en ligne!

Explication

IÐĿEÐḟL  Main link
 ÐĿ      While results are unique (which is never so it stops at [])
I        Take the increments, collecting intermediate values # this computes all n-th differences
    Ðḟ   Filter out
   E     Lists that have all values equal (the first n-th difference list that is all equal will be removed and all difference lists after will be all 0s)
      L  Take the length (this is the number of iterations required before the differences become equal)

-1 octet merci à Jonathan Allan

05AB1E , 7 octets

[DË#¥]N

Essayez-le en ligne!

Explication

[         # start loop
 D        # duplicate current list
  Ë       # are all elements equal?
   #      # if so, break
    ¥     # calculate delta's
     ]    # end loop
      N   # push iteration counter

JavaScript (ES6), 58 octets

f=a=>+(b=a.slice(1).map((e,i)=>e-a[i])).some(e=>e)&&1+f(b)

Python 2 , 65 octets

-7 octets grâce à Jonathan Allan.

f=lambda l,c=1:any(l)and f([j-i for i,j in zip(l,l[1:])],c-1)or-c

Essayez-le en ligne!

Dyalog APL, 19 octets

≢-1+(≢2-/⍣{1=≢∪⍵}⊢)

Explication:

≢                      length of input
 -1+(             )    minus 1+
     ≢                 length of
      2-/              differences between elements
         ⍣             while
          {1=≢∪⍵}      there is more than 1 unique element
                 ⊢     starting with the input

k , 21 octets

#1_(~&/1_=':)(1_-':)\

Cela fonctionne en k, mais pas en oK, car la boucle while de oK s'exécute avant de vérifier la condition (par opposition à la première vérification de la condition, puis à l'exécution du code). Par conséquent, en ok, l' 1 1 1 1 1exemple ne fonctionnera pas correctement.

Essayez oK en ligne!

Explication:

   (        )       \ /while(
    ~&/               /      not(min(
       1_=':          /              check equality of all pairs))) {
             (1_-':)  /    generate difference list
                      /    append to output }
#1_                   /(length of output) - 1

Haskell , 66 61 60 octets

z=(=<<tail).zipWith
f=length.takeWhile(or.z(/=)).iterate(z(-))

Essayez-le en ligne!

Enregistré 5 octets grâce à Christian Sievers

1 octet enregistré grâce à fier-haskeller

iterate(z(-)) calcule les listes de différences.

or.z(/=) teste s'il y a des éléments non égaux dans ces listes.

length.takeWhile compte les listes de différences avec des éléments non égaux.

Java (OpenJDK 8) , 98 94 octets

a->{int o=0,i,z=1;for(;z!=0;o++)for(i=a.length-1,z=0;i>o;a[i]-=a[--i])z|=a[o]^a[i];return~-o;}

Essayez-le en ligne!

Japt , 7 octets

Même approche (mais dérivée indépendamment) que Justin avec une implémentation différente.

£=äaÃèx

Essaye-le

Explication

Entrée implicite du tableau U.

£   Ã

Cartographiez chaque élément.

äa

Prenez chaque paire séquentielle ( ä) d'éléments Uet réduisez-la par différence absolue ( a).

=

Réaffectez ce tableau à U.

èx

Count ( è) le nombre de sous-tableaux qui retournent vrai (c'est-à-dire non nul) lorsqu'ils sont réduits par addition.

TI-Basic, 19 octets

While max(abs(ΔList(Ans
ΔList(Ans
IS>(A,9
End
A

Par défaut, les variables commencent à zéro. De plus, je n'ai jamais pensé utiliser IS>(quelque chose d'utile.

C # (.NET Core) , 70 69 + 18 octets

-1 octet grâce à Kevin Cruijssen

g=a=>i=>a.Distinct().Count()>1?g(a.Zip(a.Skip(1),(y,z)=>y-z))(i+1):i;

Doit être 0 lors de l'appel pour fonctionner correctement. Également inclus dans le nombre d'octets:

using System.Linq;

Essayez-le en ligne!

Explication:

g = a => i =>                      // Function taking two arguments (collection of ints and an int)
    a.Distinct()                   // Filter to unique elements
    .Count() > 1 ?                 // If there's more than one element
        g(                         //     Then recursively call the function with
            a.Zip(                 //     Take the collection and perform an action on corresponding elements with another one
                a.Skip(1),         //         Take our collection starting at second element
                (y, z) => y - z    //         Perform the subtraction
            )
        )(i + 1)                   //     With added counter
        : i;                       // Otherwise return counter

Version itérative 84 + 18 octets:

a=>{int i=0;for(;a.Distinct().Count()>1;i++)a=a.Zip(a.Skip(1),(y,z)=>y-z);return i;}

Essayez-le en ligne!

Clojure, 62 octets

#(loop[c % i 0](if(apply = c)i(recur(map -(rest c)c)(inc i))))

Nice =peut prendre n'importe quel nombre d'arguments, et un seul argument est identique à "lui-même". (apply = [1 2 3])est exécuté comme (= 1 2 3).

Pyth , 15 octets

W.E.+Q=.+Q=hZ)Z

Vérifiez tous les cas de test.

Comment?

Explication # 1

W.E.+Q=hZ=.+Q)Z   ~ Full program.

W                 ~ While...
 .E.+Q            ~ ... The deltas of Q contain a truthy element.
      =hZ         ~ Increment a variable Z, which has the initial value of 0.
         =        ~ Transform the variable to the result of a function applied to itself...
          .+Q     ~ ... Operate on the current list and deltas.
             )Z   ~ Close the loop and output Z.

Perl 5 , 83 + 1 (-a) = 84 octets

sub c{$r=0;$r||=$_-$F[0]for@F;$r}for(;c;$i=0){$_-=$F[++$i]for@F;$#F--}say y/ //-$#F

Essayez-le en ligne!

Saisissez une liste de nombres séparés par un espace.

Pyke , 11 octets

W$D}ltoK)Ko

Essayez-le ici!

Pyth, 10 octets

tf!t{.+FQt

Si nous pouvons indexer à partir de 1, nous pouvons enregistrer un octet en supprimant l'interlignage t.

Essayez-le en ligne

Explication

tf!t{.+FQt
 f        T  Find the first (1-indexed) value T...
     .+FQt   ... such that taking the difference T - 1 times...
  !t{        ... gives a set with more than one value in it.
t            0-index.

Kotlin , 83 octets

{var z=it
var c=0
while(z.any{it!=z[0]}){c++
z=(0..z.size-2).map{z[it+1]-z[it]}}
c}

Embellie

{
    // Make input mutable
    var z=it
    // Count for returning
    var c=0
    // While the array is not identical
    while (z.any { it != z[0] }) {
        // Increment count
        c++
        // Update list to differences
        z = (0..z.size-2).map { z[it+1] - z[it] }
    }
    // Return count
    c
}

Tester

var n:(List<Int>)->Int =
{var z=it
var c=0
while(z.any{it!=z[0]}){c++
z=(0..z.size-2).map{z[it+1]-z[it]}}
c}

data class TestData(var input: List<Int>, var output: Int)

fun main(args: Array<String>) {
    val items = listOf(
        TestData(listOf(1,2,3,4,5,6,7,8,9,10), 1),
        TestData(listOf(1,4,9,16,25,36), 2),
        TestData(listOf(1,2,1), 2),
        TestData(listOf(1,1,1,1,1,1,1,1,1), 0),
        TestData(listOf(1, 3, 9, 26, 66, 150, 313, 610), 6)
    )

    val fails = items.map { it to n(it.input) }.filter { it.first.output != it.second }

    if (fails.isEmpty()) {
        println("Test passed")
    } else {
        fails.forEach {println("FAILED: $it")}
    }
}

TryItOnline

Swift 4 , 90 octets

func f(_ a:[Int])->Int{return a.contains{$0 != a[0]} ?f(zip(a, a.dropFirst()).map(-))+1:0}

Mise en œuvre alternative, basée sur la fermeture:

var f: ((_ input: [Int]) -> Int)!
f = {a in a.contains{$0 != a[0]} ?f(zip(a, a.dropFirst()).map(-))+1:0}

cas de test:

let testcases: [(input: [Int], expected: Int)] = [
    (input: [1,2,3,4,5,6,7,8,9,10],           expected: 1),
    (input: [1,4,9,16,25,36],                 expected: 2),
    (input: [1,2,1],                          expected: 2),
    (input: [1,1,1,1,1,1,1,1,1],              expected: 0),
    (input: [1, 3, 9, 26, 66, 150, 313, 610], expected: 6),
]

for (caseNumber, testcase) in testcases.enumerated() {
    let actual = f(testcase.input)
    assert(actual == testcase.expected,
        "Testcase #\(caseNumber) \(testcase.input) failed. Got \(actual), but expected \(testcase.expected)!")
    print("Testcase #\(caseNumber) passed!")
}