Ortadan çıkarılan bazı terimlerle pozitif tamsayıların sınırlı bir aritmetik dizisi göz önüne alındığında , dizinin tamamını yeniden yapılandırın.

Görev

Bir aritmetik dizi düşünün: herhangi iki ardışık eleman arasındaki farkın aynı olduğu pozitif tamsayıların bir listesi.

2 5 8 11 14 17

Şimdi, aşağıdaki sınırlamalara tabi olarak bir veya daha fazla tamsayının diziden kaldırıldığını varsayalım:

• Kaldırılan tam sayılar, dizinin ardışık terimleri olacaktır.
• Dizideki ilk ve son tamsayılar kaldırılmayacak.
• Sıralamada en az üç tam sayı kalacaktır.

Yukarıdaki dizi için olası taşınma şunları içerir:

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

Göreviniz: Bu kısmi dizilerden biri verildiğinde, orijinal tam diziyi yeniden oluşturun.

ayrıntılar

Girişin geçerli olduğunu (çözüme sahip olduğunu) ve en az bir terim eksik olduğunu varsayabilirsiniz. Dizideki tüm sayılar pozitif (> 0) tam sayılar olacaktır. Dizi, terimler arasında pozitif veya negatif bir farklılığa sahip olabilir (yani, artan veya azalan olabilir). Sabit bir dizi olmayacak (örn. 5 5 5).

Çözümünüz tam bir program veya işlev olabilir . Herhangi bir varsayılan giriş ve çıkış yöntemleri kabul edilebilir.

Giriş ve çıkışınız bir dize (herhangi bir makul sınırlayıcıyla birlikte), bir dize listesi veya sayı listesi olabilir. Numaraları, dilinize uygun hangi temelde bulabilirsiniz.

Lütfen gönderiminizdeki olağandışı G / Ç yöntemlerinden / biçimlerinden bahsedin, böylece diğerleri kodunuzu daha kolay test edebilecek.

Test durumları

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

Bu kod golf ; Her dilde en kısa cevap kazanır.

Haskell , 63 bayt

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

Çevrimiçi deneyin!

Temel olarak sonucu önden ve başarısız olursa arkadan oluşturmaya çalışarak çalışır. Bu, girişin ilk ve son üyelerinin her zaman doğru olacağı gerçeğini, silinen üyelerin ardışık olması gerektiği gerçeğini ve girdide her zaman en az üç öğe olacağı gerçeğini kullanır. Tek yapmam gereken ikinci veya ikinci-son üyelerin doğru olduğunu varsaymak ve çalışıp çalışmadığını kontrol etmek. Neyse ki Haskell, aritmetik seri oluşturmak için gerçekten güzel bir sözdizimine sahip.

EDIT: Bir hatayı işaret ettiği ve çözümü sağladığı için @xnor'a teşekkürler!

05AB1E , 9 8 bayt

Ÿs¥¿Äô€н

Çevrimiçi deneyin!

açıklama

• [İlk, ..., son] aralığını +/- 1 farkla oluşturun
• Giriş deltalarını hesapla
• Deltaların gcd'sinin mutlak değerini alın
• Tüm aralığı bu boyuttaki parçalara böl
• Her yığının ilk elemanını al

User202729 tarafından ilham gcd of deltasyerine 1 bayt kullanılarak kaydedildimin delta

Brachylog v2, 9 bayt

⊆.s₂ᵇ-ᵐ=∧

Çevrimiçi deneyin!

Bu bir işlev sunumu. Brachylog yorumlayıcısı, bir işlevi Zkomut satırı argümanı olarak vererek tam bir programmış gibi değerlendirmek için yapılabilir ; Bu durumda, giriş, örneğin formatta belirtilir [1, 2, 4]ve çıkış, örneğin benzer bir formatta döndürülür Z = [1, 2, 3, 4]. (Elbette, bir işlev sunumu için, giriş ve çıkış hiçbir biçimde değildir; sadece listelerdir.)

Bu aslında OP'nin istediğinden daha zor bir problemi çözüyor: silme işlemlerinin ardışık olup olmadığına bakılmaksızın, belirtilen değerleri belirtilen sırada içeren tam sayıların en kısa aritmetik sırasını çözer. Kaba kuvvet kullandığından, birçok değer silinirse çok yavaş olabilir.

açıklama

Program üç ana bölümden oluşmaktadır.

⊆girişin bir üstünü bulur (yani girişi bir sonraki sekansa sahip olan bir sekans). Bir Brachylog programından birden fazla çıktının olması durumunda, seçilen çıktı tiebreak sırasındaki ilk çıktıdır ve tiebreak sırasının programdaki ilk komutu ile belirlenir; Bu durumda, ⊆kısa olanları uzun olanlara tercih eden bir sipariş belirler. Böylece alacağımız çıktı, programın geri kalan kısmındaki kısıtlamaları yerine getiren girdilerin en kısa değeri olacaktır.

.… ∧Giriş olarak gördüğü değeri (yani bu durumda üstünlük) vermek için kullanılır, ancak aynı zamanda belirli bir koşulun üzerinde durduğunu iddia eder. Başka bir deyişle, belirli bir koşula uyan en kısa üstünlüğü çıkarıyoruz (ve duruma uyup uymadığını görmek için kullanılan ara sonuçları yok sayarak).

Son olarak, s₂ᵇ-ᵐ =çıktıya uyguladığımız koşulda “dizinin tüm deltaları eşit” demektir. (Bundan dönen değer, üst sekansın kendisinden ziyade bir deltalar listesidir, bu yüzden .… ∧doğru şeyin çıkmasını sağlamak için ihtiyacımız var .)

Brachylog, delta hesaplamalarını kaldırabilecek herhangi bir yapıya sahip olmadan, bir listeden üst üste binen çiftlere bir işlem uygulayarak ya da benzerlerini kullanarak burada tutulur. Bunun yerine, biz açıkça ne anlama geldiğini söylemek zorunda: s₂ᵇTüm (bulur ᵇ) alt dizeleri ( suzunluk 2 (içinde) ₂) (kullanımında ᵇalt dizeleri ve supersequence içinde bilinmeyenler arasında bir bağlantı tutmak için gereklidir; daha yaygın olarak kullanılan ᶠbu kırardı link). Sonra -ᵐbir delta üretmek için bu çiftlerin her biri üzerinde bir çıkarma yapar. s₂ᵇ-ᵐÇoğu modern golf dilinin yerleşik olduğu bir şey için beş bayt yazmak zorunda kalmak can sıkıcıdır , ama kod kodlamanın bazen böyle yürüdüğünü düşünüyorum.

Python 2, 104 97 89 83 71 67 60 bayt

4 byte tasarruf için Chas Brown'a teşekkürler . 7 byte tasarruf
için ovs teşekkürler .

Listeyi argümanlara göre girin.

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

Çevrimiçi deneyin!

Açıklama:

Kaldırılan ardışık olduğu için, iki ardışık eleman arasındaki farkları kontrol etmek yeterlidir.

Pyth , 11 bayt

%hS.+SQ}hQe

Burada dene!

Bayt'ı kurtardığı için Steven H.'e teşekkürler !

Pyth , 12 bayt

%.aiF.+Q}hQe

Burada dene!

Nasıl çalışır

% .aiF. + Q} hQe ~ Tam program.

     . + Q ~ Deltaları alın.
   iF ~ GCD ile azaltın.
 .a ~ Mutlak değer.
% ~ Modüler. Her nth elemanını al ...
        } ~ Arasında kapsayıcı sayısal aralık ...
         hQ ~ İlk eleman ve ...
           e ~ Son eleman.

Jöle , 8 bayt

ṂrṀmIg/$

Çevrimiçi deneyin!

Notlar:

• Sadece eski bazı Jelly sürümlerinde çalışın. ( örneğin bu taahhüdü ) (nerede sonuç işareti olan gkullanım fractions.gcd, math.gcdher zaman pozitif değer veren yerine, giriş işareti ile aynıdır ).

• TIO Yukarıdaki bağlantı Python 3 TIO link, Python kodu (TIO çalıştırmak için) aynı dosya içine paketlenmiş her şey (3 dosya) hariç olmak üzere, yukarıda belirtilen taahhüt gelen Jelly kaynak kodu oluşur ve dictionary.pydüşürüldü sadece bazı çizgiler. Bununla birlikte dictionary.py, sıkıştırılmış dize kullanmadığından, bu cevapla ilgisi yoktur. ( “...»yapı)

Açıklama:

İlk olarak, sürekli bir bölüm silindiğinden ve en az 3 eleman kaldığından, eski listede kalan iki sayı vardır ve deltaların hepsi adımın katları olacaktır. Bu nedenle, gcdfarklılıkların ( I, artışlar) listesi, adımın mutlak değeri olacaktır.

Neyse ki gcdimzalandı (yukarıdaki nota bakınız)

Yani program yapar:

ṂrṀ

Artan bir tamsayı menzilden Ṃaksonya Ṁkadardır.

m

Modüler, her öğeyi seç.

Ig/$

Monadic ( $) zinciri birleştirir I(artışlar, farklılıklar) ve g/( gcdlistedeki unsurları azaltır ). Eğer artışlar pozitifse, gcdo zaman pozitif olacak ve dönen liste sağdan sola (artan) ve tersi olacaktır.

MATL , 13 bayt

1)0GdYkG0)3$:

Çevrimiçi deneyin!

Açıklama:

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.

JavaScript (ES6), 92 90

2 bayt düzenle

Kolay, çünkü ilk ikisi ve son ikisi arasındaki farkları kontrol etmek yeterli. Ama yine de inanılmaz derecede uzun.

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

Daha az golf oynadı

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

Ölçek

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 Dili (Mathematica) , 50 bayt

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

Çevrimiçi deneyin!

Ruby , 65 62 55 54 bayt

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

Çevrimiçi deneyin!

Justin Mariner sayesinde -1 bayt

Haskell , 73 69 bayt

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

Çevrimiçi deneyin!

J , 49, 47 46 bayt

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

Emigna'nın çözümünden ilham aldı.

Nasıl çalışır:

 (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

Çevrimiçi deneyin!

Kabuğu , 9 bayt

m←C▼Ẋ≠⁰…⁰

Çevrimiçi deneyin!

Bayt sayısını yarıya çektiği için H.PWiz'e çok teşekkürler …, bir listeye başvurmanın onu belirlediğini işaret ederek ! ...

C # (.NET Core) , 167 + 13 = 180 145 + 13 = 158 bayt

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

Çevrimiçi deneyin!

İçin +13 using System;

Şaşırtıcı bir şekilde, bu zorluk başlangıçta beklediğimden daha fazla nüansa sahipti.

Teşekkür

@DLosc'taki bazı basit sadeleştirmeler nedeniyle -22 bayt kaydedildi.

DeGolfed

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

Python 2 , 147 bayt

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

Çevrimiçi deneyin!

Python 2,78 bayt

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

Çevrimiçi deneyin!

Jöle , 8 bayt

ṂrṀmILÞṪ

Çevrimiçi deneyin!

dc , 64 bayt

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

Çevrimiçi deneyin!

Japt , 12 bayt

ÌõUg Uäa ñ g

Dene

açıklama

õGiriş dizisinin ( Ì) son elemanından first ( Ug) öğesine bir tamsayı dizisi ( ) oluşturun . Girişten iki eleman çiftinin tümünü alarak elemanlar arasındaki adımı hesaplayın ve bunları mutlak farkla ( Uäa) sonra sıralayarak ( ñ) sıralayın ve ilk elemanı ( g) alarak azaltın .