유한 한 산술 시퀀스가 주어짐중간에서 일부 항이 제거 된 양의 정수로 가 전체 시퀀스를 재구성하십시오.

작업

산술 시퀀스를 고려하십시오. 두 연속 요소의 차이가 동일한 양의 정수 목록입니다.

2 5 8 11 14 17

이제 다음 제약 조건에 따라 하나 이상의 정수가 시퀀스에서 제거되었다고 가정합니다.

• 제거 된 정수는 시퀀스의 연속 항입니다.
• 시퀀스의 첫 번째 정수와 마지막 정수는 제거되지 않습니다.
• 적어도 3 개의 정수가 순서대로 남아 있습니다.

위의 순서에서 가능한 제거는 다음과 같습니다.

2 5 8 14 17  (removed 11)
2 5 17       (removed 8 11 14)
2 14 17      (removed 5 8 11)

작업 : 이러한 부분 시퀀스 중 하나가 주어지면 원래 전체 시퀀스를 재구성하십시오.

세부

입력이 유효하고 (해결책이 있음) 적어도 하나의 용어가 누락되었다고 가정 할 수 있습니다. 시퀀스의 모든 숫자는 양수 (> 0) 정수입니다. 서열은 용어들간에 양 또는 음의 차이를 가질 수있다 (즉, 증가 또는 감소 할 수있다). 상수 시퀀스가 ​​아닙니다 (예 :) 5 5 5.

솔루션은 전체 프로그램 또는 기능 일 수 있습니다 . 의 모든 기본 입력 및 출력 방법 으로 허용된다.

입력 및 출력은 문자열 (적절한 구분 기호가있는), 문자열 목록 또는 숫자 목록 일 수 있습니다. 당신은 당신의 언어에 편리한베이스로 숫자를 나타낼 수 있습니다.

제출시 이상한 I / O 방법 / 형식을 언급하면 ​​다른 사람들이 코드를 더 쉽게 테스트 할 수 있습니다.

테스트 사례

In: 2 5 8 14 17
Out: 2 5 8 11 14 17
In: 2 5 17
Out: 2 5 8 11 14 17
In: 2 14 17
Out: 2 5 8 11 14 17
In: 21 9 6 3
Out: 21 18 15 12 9 6 3
In: 10 9 5
Out: 10 9 8 7 6 5
In: 1 10 91 100
Out: 1 10 19 28 37 46 55 64 73 82 91 100

이것은 코드 골프입니다 . 각 언어에서 가장 짧은 답변이 이깁니다.

하스켈 , 63 바이트

f(a:b:c)|s<-[a,b..last c],all(`elem`s)c=s
f a=r$f$r a
r=reverse

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

기본적으로 앞면에서 결과를 작성하려고 시도하고 실패하면 뒷면에서 결과를 작성합니다. 이것은 입력의 첫 번째와 마지막 멤버가 항상 정확하고 삭제 된 멤버가 연속적이어야한다는 사실과 입력에 항상 3 개 이상의 항목이 있다는 사실을 사용합니다. 내가해야 할 일은 두 번째 또는 두 번째에서 마지막 멤버까지 정확하고 작동하는지 확인하는 것입니다. 운 좋게도 Haskell은 산술 시리즈를 만들기위한 정말 멋진 구문을 가지고 있습니다.

편집 : 버그를 지적하고 솔루션을 제공 한 @xnor에게 감사드립니다!

05AB1E , 9 8 바이트

Ÿs¥¿Äô€н

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

설명

• +/- 1의 차이로 범위 [first, ..., last]를 구성하십시오.
• 입력의 델타 계산
• 델타 gcd의 절대 값을 구합니다
• 해당 크기의 청크로 전체 범위를 분할
• 각 청크의 첫 번째 요소를 가져옵니다

user202729 에서 영감을 얻은 gcd of deltas대신 대신 1 바이트를 저장 했습니다.min delta

Brachylog v2, 9 바이트

⊆.s₂ᵇ-ᵐ=∧

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

이것은 기능 제출입니다. Brachylog 인터프리터는 함수를 Z명령 행 인수로 제공하여 함수가 전체 프로그램 인 것처럼 평가하도록 만들 수 있습니다 . 이 경우 입력은 예를 들어 형식으로 지정되고 [1, 2, 4]출력은 예를 들어 유사한 형식으로 반환됩니다 Z = [1, 2, 3, 4]. (물론 함수 제출의 경우 입력 및 출력은 전혀 형식이 아니며 목록 일뿐입니다.)

이것은 실제로 OP가 요청한 것보다 어려운 문제를 해결합니다. 삭제가 연속적인지 여부에 관계없이 지정된 순서로 지정된 값을 포함하는 정수의 최단 산술 시퀀스를 수행합니다. 무차별 대입을 사용하므로 많은 값이 삭제되면 속도가 매우 느려질 수 있습니다.

설명

이 프로그램에는 세 가지 주요 부분이 있습니다.

⊆입력의 수퍼 시퀀스 (즉, 입력을 서브 시퀀스로 갖는 시퀀스)를 찾습니다. Brachylog 프로그램의 출력이 둘 이상인 경우 선택한 출력은 순위 결정 순서의 첫 번째 출력이며 순위 결정 순서는 프로그램에 대한 의견이있는 첫 번째 명령에 의해 결정됩니다. 이 경우 ⊆긴 출력보다 짧은 출력을 선호하는 순서를 지정합니다. 따라서 우리가 얻게 될 결과는 나머지 프로그램의 제한 사항을 따르는 입력의 가장 짧은 수퍼 시퀀스입니다.

. … ∧ 는 입력으로 간주되는 값 (이 경우 슈퍼 시퀀스)을 출력하는 데 사용되며 특정 조건이이를 유지한다고 주장합니다. 다시 말해, 우리는 특정 조건을 따르는 가장 짧은 수퍼 시퀀스를 출력합니다 (그리고 조건을 준수하는지 확인하기 위해 사용 된 중간 결과는 무시합니다).

마지막으로, 우리는 s₂ᵇ-ᵐ =출력에 적용하는 조건 인 "시퀀스의 모든 델타가 동일합니다"를가집니다. (이것의 반환 값은 슈퍼 시퀀스 자체가 아닌 델타 목록이므로 올바른 결과가 출력되도록 하려면 .... ∧이 필요합니다 .)

Brachylog는 델타 계산을 처리하거나 목록의 겹치는 쌍 등에 연산을 적용 할 수있는 빌트인이 없어서 여기서 보류됩니다. 대신, 우리는 우리가 명시 적으로 무엇을 의미하는지 말할 필요가 : s₂ᵇ모든 (발견 ᵇ) 문자열 ( s길이 2 (의) ₂()의 사용 ᵇ하위 문자열에서와 supersequence에서 미지수 사이의 링크를 유지하기 위해 필요하다, 더 일반적으로 사용되는 ᶠ이 휴식 것 링크). 그런 다음 -ᵐ각 쌍에서 빼기를 수행하여 델타를 생성합니다. s₂ᵇ-ᵐ대부분의 현대 골프 언어에 내장 된 무언가에 대해 5 바이트를 써야하는 것은 성가신 일이지만, 때때로 코드 골프가가는 방식이라고 생각합니다.

파이썬 2, 104 97 89 83 71 67 60 바이트

4 바이트를 절약 한 Chas Brown 에게 감사 합니다. 7 바이트를 절약 한 ovs 에게
감사 합니다.

인수로 목록을 입력하십시오.

lambda a,b,*c:range(a,c[-1],min(b-a,c[0]-b,key=abs))+[c[-1]]

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

설명:

제거 된 요소는 연속적이므로 두 쌍의 연속 요소 간의 차이를 확인하면 충분합니다.

Pyth , 11 바이트

%hS.+SQ}hQe

여기 사용해보십시오!

바이트를 절약 한 Steven H. 에게 감사합니다 !

Pyth , 12 바이트

%.aiF.+Q}hQe

여기 사용해보십시오!

작동 원리

% .aiF. + Q} hQe ~ 전체 프로그램.

     . + Q ~ 델타를 구합니다.
   iF ~ GCD로 줄입니다.
 .a ~ 절대 값.
% ~ 모듈 식. 모든 n 번째 요소를 가져옵니다 ...
        } ~ 사이에 포함 된 숫자 범위 ...
         hQ ~ 첫 번째 요소
           e ~ 마지막 요소.

젤리 , 8 바이트

ṂrṀmIg/$

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

노트:

• 일부 이전 버전의 Jelly에서만 작동합니다. ( 이 커밋 은 예를 들어, guse fractions.gcd, 결과 기호는 math.gcd항상 양수 값을 반환하는 대신 입력 기호와 동일 함 ).

• 산화 티타늄 링크 위의 파이썬 3 TIO 링크입니다, 파이썬 코드는이 (TIO 실행하는 데) 같은 파일로 포장 모든 (3 개 파일)을 제외하고, 내가 위에서 언급 한 커밋에서 젤리 소스 코드로 구성되어 dictionary.py감소하였습니다 일부 라인 만. 그럼에도 불구하고 dictionary.py압축 문자열을 사용하지 않기 때문에이 답변과 관련이 없습니다. ( “...»구체 물)

설명:

첫째, 연속 세그먼트가 삭제되고 최소 3 개의 요소가 남아 있기 때문에 이전 목록에는 두 개의 연속 숫자가 남아 있으며 델타는 모두 단계의 배수가됩니다. 따라서 gcd차이 ( I, 증분) 목록 의 차이 는 단계의 절대 값입니다.

다행스럽게도 gcd서명이되었습니다

따라서 프로그램은 다음을 수행합니다.

ṂrṀ

정수에서 Ṃ축으로의 정수 범위가 증가합니다 Ṁ.

m

모듈 식, n 번째 요소마다 선택

Ig/$

모나 딕 ( $) 체인 결합 I(증가, 차이) 및 g/( gcd목록의 요소 축소 ) 증분이 양수이면 gcd양수가되고 반환 목록은 왼쪽에서 오른쪽으로 (증가), 그 반대로됩니다.

MATL , 13 바이트

1)0GdYkG0)3$:

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

설명:

Consider the example input [2 14 17]:
           # implicit input, STACK: [[2 14 17]]
1)         # push 1, index, STACK: [2]
0G         # push 0, duplicate input, STACK: [2, 0, [2 14 17]]
d          # take differences, STACK: [2, 0, [12, 3]]
Yk         # get value in [12, 3] nearest to 0, STACK: [2, 3]
G0)        # get last element in input, STACK: [2, 3, 17]
3$:        # 3-input :, computes 2:3:17, the range from 2 to 17 by 3
           # STACK: [[2 5 8 11 14 17]], implicit output.

자바 스크립트 (ES6), 92 90

Arnauld에 저장된 2 바이트 편집

처음 두 개와 마지막 두 개의 차이점을 확인하기에 충분하므로 쉽습니다. 그러나 여전히 믿을 수 없을 정도로 길다.

s=>(e=(z=s.pop(a=s[0]))-s.pop(d=s[1]-a),[...Array((z-(a-=d=e*e>d*d?d:e))/d)].map(_=>a+=d))

덜 골프

s=>{
  a =s[0]
  b =s[1]
  z = s.pop()
  y = s.pop()
  d = b-a
  e = z-y
  d = e*e>d*d?d:e  
  n = (z-a)/d+1
  return [...Array(n)].map((_,i) => a + i*d)
}

테스트

var F=
s=>(e=(z=s.pop(a=s[0]))-s.pop(d=s[1]-a),[...Array((z-(a-=d=e*e>d*d?d:e))/d)].map(_=>a+=d))

var test=`In: 2 5 8 14 17 Out: 2 5 8 11 14 17
In: 2 5 17 Out: 2 5 8 11 14 17
In: 2 14 17 Out: 2 5 8 11 14 17
In: 21 9 6 3 Out: 21 18 15 12 9 6 3
In: 10 9 5 Out: 10 9 8 7 6 5
In: 1 10 91 100 Out: 1 10 19 28 37 46 55 64 73 82 91 100`.split`\n`
.map(r=>r.split`Out`.map(x=>x.match(/\d+/g)))

test.forEach(([i,k])=>{
  var o=F(i.slice(0))
  var ok = o+''==k
  console.log(ok?'OK':'KO',i+' => '+o)
})

Wolfram Language (Mathematica) , 50 바이트

Range[#&@@#,#[[-1]],#&@@Differences@#~SortBy~Abs]&

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

루비 , 65 62 55 54 바이트

->l{a,*,b,c=l;[*a.step(c,[l[1]-a,c-b].min_by(&:abs))]}

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

Justin Mariner 덕분에 -1 바이트

하스켈 , 73 69 바이트

f(h:t)=do(#)<-[(-),(+)];[h,h#minimum(abs<$>zipWith(-)t(h:t))..last t]

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

J , 49, 47 46 바이트

(0-[:<./2|@-/\]){.@[&]\({.<.{:)+[:i.{:(+*)@-{.

Emigna의 솔루션에서 영감을 얻었습니다.

작동 방식 :

 (0-[:<./2|@-/\]){.@[&]\({.<.{:)+[:i.{:(+*)@-{. - fork of 3 verbs

                        ({.<.{:)+[:i.{:(+*)@-{. - generates a list in the entire range of values
                                     {:     -{. - last minus first element  
                                       (+*)@    - adds the signum of the difference
                                 [:i.           - makes a list 
                       ({.<.{:)                 - the smallest of first and last elements                                     
                               +                - adds the offset to the list (translates all elements according to the first one)

 (0-[:<./2|@-/\])                               - finds the step
         2|@-/\]                                - the absolute differences between all consecutive elements
    [:<./                                       - the smallest one
  0-                                            - negate (for splitting)

                 {.@[&]\                        - splits the list from the right verb into left verb's result sublists and takes their first elements

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

껍질 , 9 바이트

m←C▼Ẋ≠⁰…⁰

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

바이트 수를 반으로 줄인 H.PWiz 에게 많은 감사를 …표합니다.

C # (. NET 코어) , 167 + 13 = 180 145 + 13 = 158 바이트

a=>{int x=a[1]-a[0],y=a[2]-a[1],d=x*x<y*y?x:y,s=Math.Abs((a[a.Length-1]-a[0])/d),i=0,j=a[0];var r=new int[s+1];for(;i<=s;j+=d)r[i++]=j;return r;}

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

+13 using System;

놀랍게도,이 도전은 내가 처음에 예상했던 것보다 더 미묘한 차이가있었습니다.

감사의 말

@DLosc의 깔끔한 단순화로 인해 -22 바이트가 절약되었습니다.

골프

a=>{
    int x = a[1]-a[0],        // difference between first and second numbers
        y = a[2]-a[1],        // difference between second to last and last numbers
        d = x*x < y*y? x : y, // smallest absolute value difference
        s = Math.Abs((a[a.Length-1] - a[0]) / d), // number of steps in the reconstructed sequence (not the number of elements)
        i = 0,                // step position
        j = a[0];             // next number in reconstructed sequence

    var r = new int[s+1];

    // reconstruct the sequence
    for(; i <= s; j+=d)
        r[i++]=j;

    return r;
}

파이썬 2 , 147 바이트

from fractions import*
a=input()
b=[j-i for i,j in zip(a[:-1],a[1:])]
l=min(gcd(i,j)for i in b for j in b)
print list(range(a[0],a[-1]+l/abs(l),l))

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

파이썬 2 , 78 바이트

lambda a:range(a[0],a[-1],[min,max][a[0]>a[1]](a[1]-a[0],a[-1]-a[-2]))+[a[-1]]

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

젤리 , 8 바이트

ṂrṀmILÞṪ

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

dc , 64 바이트

?dsx[ksE0_1]sg[scdlcr-d2^vdK>gK0=g+sqz1<l]dslx[pdlE+dlx!=Z]dsZxp

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

Japt , 12 바이트

ÌõUg Uäa ñ g

시도 해봐

설명

õ입력 배열의 마지막 요소 ( Ì)에서 첫 번째 ( Ug) 까지 정수 배열 ( )을 생성하십시오 . 입력에서 두 요소 쌍을 모두 가져와 절대 차이 ( Uäa)로 줄인 다음 ñ해당 배열 을 정렬 ( )하고 첫 번째 요소 ( g)를 취하여 요소 사이의 단계를 계산하십시오 .