수학에서는 주어진 관계의 유형 (선형, 2 차 등)이 차이를 계산하는 방법을 알아내는 한 가지 방법입니다. 그렇게하려면 대응하는 x 값 사이의 간격이 동일한 y 값 목록을 가져 와서 위의 숫자에서 각 값을 빼서 이전 목록보다 짧은 숫자 목록을 만듭니다. 결과 목록이 완전히 동일한 숫자로 구성된 경우 관계의 차이는 1입니다 (선형 임). 동일하지 않으면 새 목록에서 프로세스를 반복하십시오. 이제 동일하면 관계의 차이가 2입니다 (2 차). 이들이 동일하지 않은 경우,이 프로세스가 완료 될 때까지 계속 진행하십시오. 예를 들어, x 값을 점증 적으로 증가시키기 위해 y 값 [1,6,15,28,45,66]의 목록이있는 경우 :

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

당신의 작업 :

입력으로 정수 배열이 제공 될 때 위에서 설명한대로 배열에 설명 된 관계의 차이를 리턴하는 프로그램 또는 함수를 작성하십시오.

입력:

길이가 1보다 큰 정수 배열.

산출:

입력으로 설명 된 관계의 차이를 나타내는 정수입니다.

테스트 사례 :

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

채점 :

이것은 code-golf 이며 각 언어에서 가장 낮은 점수 (바이트)가 해당 언어에서 이깁니다. 전반적으로 가장 낮은 점수는 녹색 확인 표시를 얻습니다.

껍질 , 6 바이트

감사 레오 나를 해줘서는 대한 작품을 그의 버전을 사용[1,1,1,1,1,1]

←VE¡Ẋ-

온라인으로 사용해보십시오!

설명

   ¡     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

자바 스크립트 (ES6), 47 바이트

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

테스트 사례

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 바이트

`dta}x@q

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

설명

결과가 모두 0이거나 비어있을 때까지 연속적인 차이를 반복적으로 계산합니다. 출력은 필요한 반복 횟수에서 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 바이트

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

온라인으로 사용해보십시오!

걸린다 diff의 l, 그 세트에 대한 l결과가 제로가 아닌 값을 포함하는 경우, 체크한다. 그렇다면 증가하고 F( FALSE암시 적으로 초기화 됨 ) 모두 가 이미 동일한 경우 F*1변환 FALSE으로 돌아갑니다 .0l

매스 매 티카, 49 바이트

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

-6 바이트 및 @hftf -1 바이트의 경우 @alephalpa

그리고 여기 @hftf의 또 다른 접근법이 있습니다.

매스 매 티카, 49 바이트

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

젤리 , 7 바이트

-Iß$E?‘

온라인으로 사용해보십시오!

설명

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

Japt , 10 7 바이트

è@=ä-)d

온라인으로 사용해보십시오!

결과가 입력 배열의 길이 내에 있음을 보장한다는 사실에 의존합니다.

설명

è@=ä-)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

마지막으로,이 배열 매핑됩니다
[1, 3, 9, 26, 66, 150, 313, 610]에 [true, true, true, true, true, true, false, false],
포함 6 true들.

이전 10 바이트 버전

@=ä-)e¥0}a

온라인으로 사용해보십시오!

펄 6 , 37 바이트

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

온라인으로 사용해보십시오!

설명 : 함수는 입력을 하나의 목록으로 사용합니다. 그런 다음 다음과 같이 재귀 시퀀스를 작성합니다. 첫 번째 요소는 원래 목록 ( $_)이고 다음 요소는 {@(@$_ Z- .[1..*])}이전 요소에서 호출되어 리턴되며 조건 *.none이 true가 될 때까지 반복 되며 목록이 다음 중 하나 일 때만 발생합니다. 비어 있거나 0 만 포함합니다 (또는 기술적으로 다른 잘못된 값). 그런 다음 목록을 가져 와서 2를 빼면 먼저 숫자 컨텍스트로 강제하고 (숫자 컨텍스트의 목록은 요소 수와 동일) 끝에서 2의 요소 수보다 명부.

이상한 블록 {@(@$_ Z- .[1..*])}(단지 주어진 목록을 소요 .[]- 소위 선 슬라이스 , 마이너스 연산자 (사용하여 참아 빈 괄호 수율 전체 목록과 색인 -) Z-첫 번째 요소 (없이 동일한 목록)을 .[1..*](목록으로)과 힘을 @(...)— zip은 기본적으로 단 한번만 반복 할 수있는 단방향 목록 인 Seq 만 반환하기 때문에 필요합니다. 이는 우리가 싫어하는 것입니다.) 그리고 그게 다입니다.

Java 8, 191 + 58 = 249 198140 바이트

51 바이트의 PunPun1000에 감사합니다.
58 바이트를위한 Nevay에게 감사합니다.

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

온라인으로 사용해보십시오!

온라인으로 사용해보십시오 (198 바이트 버전)

PPCG에 게시 한 것은 이번이 처음입니다. 어떤 건설적인 비판도 환영합니다. 옳지 않은 점이 있으면 게시 지침을 따르려고 노력했습니다.

미화 버전 :

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

하스켈, 46 바이트

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

이것은 단순히 되풀이됩니다- zipWith(-)l$last l의 차이점 목록입니다 l. 그리고 g질문에 답하는 기능입니다.

코 틀린 , 77 바이트

첫 번째 게시물, kotlin에 대한 마지막 답변을 2 번 수정했습니다.; D

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

@jrtapsell에서 테스트 참여했습니다.

TryItOnline

APL (Dyalog Classic) , 22 17 바이트

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

온라인으로 사용해보십시오!

-5 바이트에 대한 @ngn 덕분에!

방법?

• { ... }, 함수
• 1=≢∪⍵:0인수에서 모든 요소가 동일한 경우 return 0
• 1+∇2-/⍵그렇지 않으면 n차이의 1 + 를 반환 합니다 (즉 n-1, 1을 추가하면 n)

젤리 , 7 바이트

IÐĿEÐḟL

온라인으로 사용해보십시오!

설명

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)

Jonathan Allan 덕분에 -1 바이트

05AB1E , 7 바이트

[DË#¥]N

온라인으로 사용해보십시오!

설명

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

자바 스크립트 (ES6), 58 바이트

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

파이썬 2 , 65 바이트

Jonathan Allan 덕분에 -7 바이트

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

온라인으로 사용해보십시오!

Dyalog APL, 19 바이트

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

설명:

≢                      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 바이트

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

이는 조건을 확인한 다음 코드를 실행하는 것과 반대로 조건을 확인하기 전에 oK의 while 루프가 실행되기 때문에 k에서는 작동하지만 oK에서는 작동하지 않습니다. 따라서 ok에서는 1 1 1 1 1예제가 제대로 작동하지 않습니다.

온라인으로 확인하십시오!

설명:

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

하스켈 , 66 61 60 바이트

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

온라인으로 사용해보십시오!

Christian Sievers 덕분에 5 바이트 절약

proud-haskeller 덕분에 1 바이트 절약

iterate(z(-)) 차이점 목록을 계산합니다.

or.z(/=) 해당 목록에 동일하지 않은 요소가 있는지 테스트합니다.

length.takeWhile 같지 않은 요소로 차이 목록을 계산합니다.

자바 (OpenJDK 8) , 98 94 바이트

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

온라인으로 사용해보십시오!

Japt , 7 바이트

다른 구현 방식 으로 Justin 과 동일한 접근 방식 (그러나 독립적으로 파생 됨) .

£=äaÃèx

그것을 테스트

설명

배열의 암시 적 입력 U.

£   Ã

각 요소 위에 매핑하십시오.

äa

ä요소의 각 순차 쌍 ( )을 가져와 U절대 차이 ( a)만큼 줄입니다.

=

해당 배열을에 다시 할당하십시오 U.

èx

è덧셈에 의해 감소 ​​될 때 진실 (즉, 0이 아닌)을 반환하는 하위 배열의 수를 계산합니다 ( ).

TI 기본, 19 바이트

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

기본적으로 변수는 0에서 시작합니다. 또한, 내가 IS>(유용한 것을 위해 사용할 것이라고 생각하지 않았습니다 .

C # (. NET 코어) , 70 69 + 18 바이트

Kevin Cruijssen 덕분에 -1 바이트

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

올바르게 작동하려면 전화를 걸 때 0이 제공되어야합니다. 바이트 수에도 포함됩니다.

using System.Linq;

온라인으로 사용해보십시오!

설명:

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

반복 버전 84 + 18 바이트 :

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

온라인으로 사용해보십시오!

클로저, 62 바이트

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

멋지게 =많은 수의 인수를 취할 수 있으며 단일 인수는 "자체"와 동일합니다. (apply = [1 2 3])로 실행됩니다 (= 1 2 3).

피스 , 15 바이트

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

모든 테스트 사례를 확인하십시오.

방법?

설명 # 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.

펄 5 , 83 + 1 (-a) = 84 바이트

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

온라인으로 사용해보십시오!

공백으로 구분 된 숫자 목록으로 입력하십시오.

파이크 , 11 바이트

W$D}ltoK)Ko

여기 사용해보십시오!

Pyth, 10 바이트

tf!t{.+FQt

1에서 색인을 생성 할 수 있다면 선행을 제거하여 바이트를 절약 할 수 있습니다 t .

온라인으로 사용해보십시오

설명

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.

코 틀린 , 83 바이트

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

미화

{
    // 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
}

테스트

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

스위프트 4 , 90 바이트

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

대안적인 폐쇄 기반 구현 :

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

테스트 사례 :

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