एक अंकगणितीय अनुक्रम का पुनर्निर्माण

23

बीच से हटाए गए कुछ शब्दों के साथ सकारात्मक पूर्णांकों के परिमित अंकगणितीय अनुक्रम को देखते हुए , पूरे अनुक्रम को फिर से संगठित करें।

काम

अंकगणितीय अनुक्रम पर विचार करें: सकारात्मक पूर्णांक की एक सूची जिसमें किसी भी दो क्रमिक तत्वों के बीच का अंतर समान है।

2 5 8 11 14 17

अब मान लीजिए कि एक या एक से अधिक पूर्णांक अनुक्रम से हटा दिए गए हैं, निम्न बाधाओं के अधीन हैं:

  • हटाए गए पूर्णांक अनुक्रम के लगातार शब्द होंगे।
  • अनुक्रम में पहला और अंतिम पूर्णांक हटाया नहीं जाएगा।
  • कम से कम तीन पूर्णांक अनुक्रम में रहेंगे।

उपरोक्त अनुक्रम के लिए, संभावित निष्कासन में शामिल हैं:

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

यह कोड-गोल्फ है ; प्रत्येक भाषा में सबसे कम उत्तर जीतता है।

code-golf  sequence  integer  subsequence 
— DLosc
स्रोत
— DLosc
दिलचस्प होगा कि फार्म में इनपुट2 5 ... 17
— श्नाडर

जवाबों:

9

हास्केल , 63 बाइट्स

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

इसे ऑनलाइन आज़माएं!

मूल रूप से सामने से परिणाम बनाने की कोशिश करके काम करता है, और अगर वह विफल रहता है, तो पीछे से। यह इस तथ्य का उपयोग करता है कि इनपुट के पहले और अंतिम सदस्य हमेशा सही होंगे, यह तथ्य कि हटाए गए सदस्यों को लगातार रहना होगा, और यह तथ्य कि इनपुट में हमेशा कम से कम तीन आइटम होंगे। मुझे केवल यह मानना ​​है कि दूसरे या दूसरे-से-अंतिम सदस्य सटीक हैं और जांचें कि क्या यह काम करता है। सौभाग्य से हास्केल के पास अंकगणितीय श्रृंखला बनाने के लिए वास्तव में सुंदर वाक्यविन्यास है।

संपादित करें: बग को इंगित करने और समाधान प्रदान करने के लिए @xnor को धन्यवाद!

— user1472751
स्रोत
5
हालांकि यह सुंदर है, ऐसा लगता है कि यह हमेशा काम नहीं करता है: [1,3,4,5]देता है [1,3,5]।
— xnor
1
और मुझे लगता है कि all(`elem`s)cइसे उसी बाइट की गिनती के साथ ठीक करना चाहिए।
— xnor
6

05AB1E , 9 8 बाइट्स

Ÿs¥¿Äô€н

इसे ऑनलाइन आज़माएं!

व्याख्या

  • +/- 1 के अंतर के साथ सीमा [पहले, ..., अंतिम] का निर्माण करें
  • इनपुट के डेल्टास की गणना करें
  • डेल्टास के gcd का पूर्ण मान प्राप्त करें
  • उस आकार के टुकड़ों में पूरी श्रृंखला को विभाजित करें
  • प्रत्येक चंक का पहला तत्व प्राप्त करें

के gcd of deltasबजाय का उपयोग करके सहेजा गया 1 बाइट min delta, user202729 से प्रेरित है

— Emigna
स्रोत
5

Brachylog v2, 9 बाइट्स

⊆.s₂ᵇ-ᵐ=∧

इसे ऑनलाइन आज़माएं!

यह एक फ़ंक्शन सबमिशन है। ब्रेकीलॉग दुभाषिया को एक फ़ंक्शन का मूल्यांकन करने के लिए बनाया जा सकता है, क्योंकि यह Zएक कमांड लाइन तर्क के रूप में एक पूर्ण कार्यक्रम था; इस मामले में, इनपुट प्रारूप में निर्दिष्ट किया गया है, उदाहरण के लिए, [1, 2, 4]और आउटपुट एक समान प्रारूप में वापस किया जाता है, जैसे Z = [1, 2, 3, 4]। (बेशक, एक फ़ंक्शन सबमिशन के लिए, इनपुट और आउटपुट किसी भी प्रारूप में नहीं हैं, वे सिर्फ सूचियाँ हैं।)

यह वास्तव में ओपी के लिए पूछे गए एक से अधिक कठिन समस्या का हल करता है: यह पूर्णांक के सबसे कम अंकगणितीय अनुक्रम को निर्दिष्ट क्रम में निर्दिष्ट मानों के साथ काम करता है, भले ही हटाए गए लगातार हो या नहीं। क्योंकि यह क्रूर बल का उपयोग करता है, यह बहुत धीमा हो सकता है यदि कई मान हटा दिए जाते हैं।

व्याख्या

कार्यक्रम के तीन मुख्य भाग हैं।

⊆इनपुट की एक स्थिति का पता लगाता है (यानी एक अनुक्रम जिसमें बाद में इनपुट होता है)। जब ब्रेकीलॉग प्रोग्राम से एक से अधिक संभावित आउटपुट होते हैं, तो चुना गया आउटपुट टाईब्रेक ऑर्डर में पहला आउटपुट होता है, और टेलब्रेक ऑर्डर उस प्रोग्राम में पहले कमांड द्वारा निर्धारित किया जाता है, जिस पर एक राय होती है; इस मामले में, ⊆एक आदेश को निर्दिष्ट करता है जो लंबे समय से कम आउटपुट का पक्ष लेता है। इसलिए हम जो आउटपुट प्राप्त करेंगे, वह उस इनपुट का सबसे छोटा वर्चस्व होगा जो कार्यक्रम के बाकी हिस्सों में प्रतिबंधों का पालन करता है।

.... ∧इसका उपयोग इनपुट के रूप में देखे जाने वाले मूल्य (यानी इस मामले में स्थिति) के उत्पादन के लिए किया जाता है, लेकिन यह भी दावा करता है कि एक विशिष्ट स्थिति इस पर रहती है। दूसरे शब्दों में, हम एक विशिष्ट स्थिति का पालन करने वाले सबसे छोटे सुपरसक्वेन्स का उत्पादन कर रहे हैं (और यदि यह शर्त का पालन करता है, तो यह देखने के लिए उपयोग किए जाने वाले किसी भी मध्यवर्ती परिणामों की अनदेखी करना)।

अंत में, हमारे पास s₂ᵇ-ᵐ =, "अनुक्रम के सभी डेल्टा बराबर हैं", ऐसी स्थिति जो हम आउटपुट पर लागू कर रहे हैं। (इस से वापसी मान बल्कि supersequence ही है, जिसके कारण हम जरूरत से, डेल्टा की एक सूची है .... ∧यह सुनिश्चित करें कि सही काम उत्पादन होता है।)

ब्रैचीलॉग को यहाँ वापस रखा गया है, जिसमें कोई भी बिल्ट नहीं है जो डेल्टास की गणना को संभाल सकता है, एक सूची से जोड़े को ओवरलैप करने के लिए एक ऑपरेशन को लागू कर सकता है, या जैसे। इसके बजाय, हमें यह कहना होगा कि स्पष्ट रूप से हमारा क्या अर्थ है: s₂ᵇसभी को ( ᵇ) सब्सट्रिंग्स ( sलंबाई 2 का ₂) () का उपयोग ᵇसब्सट्रिंग में अज्ञात के बीच एक कड़ी रखने और अति-आवश्यकता में उपयोग करने के लिए आवश्यक है; जितना अधिक आमतौर पर उपयोग किया जाता है ᶠयह टूट जाएगा संपर्क)। फिर -ᵐडेल्टा बनाने के लिए इनमें से प्रत्येक जोड़े पर एक घटाव होता है। s₂ᵇ-ᵐकुछ के लिए पाँच बाइट्स लिखने के लिए कष्टप्रद है कि अधिकांश आधुनिक गोल्फ भाषाओं के लिए एक बेसिन है, लेकिन यह उस तरह से कोडगॉल्फ कभी-कभी जाता है, मुझे लगता है।

4

पायथन 2, 104 97 89 83 71 67 60 बाइट्स

4 बाइट बचाने के लिए चास ब्राउन का धन्यवाद । 7 बाइट्स बचाने
के लिए ओव्स का धन्यवाद ।

तर्कों द्वारा सूची इनपुट करें।

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

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

चूंकि हटाए गए लगातार होते हैं, यह लगातार तत्वों के दो जोड़े के बीच अंतर की जांच करने के लिए पर्याप्त है।

— कोलेरा सु
स्रोत
आप की जगह 3 बाइट्स बचा सकता है b if b%c else cके साथ [c,b][b%c>0]।
— चास ब्राउन
@ChasBrown धन्यवाद, हालांकि मैं जल्द ही एक बेहतर दृष्टिकोण के साथ आया।
— कोलेरा सु
1
के साथ अच्छा लगा key=abs! ऐसा लगता है कि हर्बआउट, लोग अक्सर f=भाग को छोड़ देते हैं जब तक कि एक पुनरावर्ती फ़ंक्शन का उपयोग नहीं किया जाता है; तो आप इस तरह से 2 बाइट्स बचा सकते हैं।
— चेस ब्राउन
1
इसके अलावा, के a[-1]-a[-2]साथ बदलें a[2]-a[1]- तर्क समान है, और आपको एक और 2 बाइट्स मिलते हैं।
— चास ब्राउन
1
— ओव्स
4

अजगर , 11 बाइट्स

%hS.+SQ}hQe

यहाँ यह कोशिश करो!

बाइट बचाने के लिए स्टीवन एच का धन्यवाद !

पायथ , 12 बाइट्स

%.aiF.+Q}hQe

यहाँ यह कोशिश करो!

यह काम किस प्रकार करता है

% .aiF। + Q} hQe ~ पूर्ण कार्यक्रम।

     । + Q ~ डेल्टा प्राप्त करें।
   iF ~ जीसीडी द्वारा कम करें।
 .a ~ पूर्ण मूल्य।
% ~ मॉड्यूलर। हर nth तत्व प्राप्त करें ...
        } ~ के बीच समावेशी संख्यात्मक सीमा ...
         एचक्यू ~ पहला तत्व, और ...
           ई ~ अंतिम तत्व।
— मिस्टर एक्सकोडर
स्रोत
Presort Qआप सॉर्ट और पहला तत्व लेने के बजाय कर सकते हैं ताकि abs(GCD(Q))के रूप में में %hS.+SQ}hQe11 बाइट्स के लिए। टेस्ट सूट
— स्टीवन एच।
3

जेली , 8 बाइट्स

ṂrṀmIg/$

इसे ऑनलाइन आज़माएं!

टिप्पणियाँ:

  • केवल जेली के कुछ पुराने संस्करण पर काम करते हैं। ( यह उदाहरण के लिए प्रतिबद्ध है) (जहां gउपयोग किया जाता है fractions.gcd, जिसके परिणामस्वरूप परिणाम है, इनपुट संकेत के समान है math.gcd, जिसके बजाय हमेशा सकारात्मक मान लौटाते हैं)।

  • ऊपर दिया गया TIO लिंक Python 3 TIO लिंक है, Python कोड में ऊपर बताए गए कमेटी से जेली सोर्स कोड होता है, जो एक ही फाइल (TIO को चलाने के लिए) में पैक की गई हर चीज (3 फाइल) के अपवाद के साथ और dictionary.pyकम हो गया है केवल कुछ पंक्तियाँ। फिर भी dictionary.pyइस उत्तर से असंबंधित है, क्योंकि यह संकुचित स्ट्रिंग का उपयोग नहीं करता है। ( “...»निर्माण)

स्पष्टीकरण:

सबसे पहले, क्योंकि एक निरंतर खंड हटा दिया जाता है और कम से कम 3 तत्व बने हुए हैं, पुरानी सूची में दो लगातार संख्याएं बनी हुई हैं, और डेल्टा सभी चरण के गुणक होंगे। इसलिए gcdमतभेदों ( I, वेतन वृद्धि) की सूची चरण का निरपेक्ष मान होगी।

सौभाग्य gcdसे हस्ताक्षरित है (ऊपर नोट देखें)

तो कार्यक्रम करता है:

ṂrṀ

एक बढ़ती हुई पूर्णांक से लेकर अक्षीयतम Ṃतक की Ṁअक्षीय सीमा होती है।

m

मॉड्यूलर, हर n तत्व को चुनें।

Ig/$

मोनाडिक ( $) श्रृंखला गठबंधन I(वेतन वृद्धि, अंतर) और g/( gcdसूची के तत्वों को कम )। अगर वेतन वृद्धि सकारात्मक है, तो सकारात्मक gcdहोगा और वापसी सूची बाएं से दाएं (बढ़ती), और इसके विपरीत होगी।

— user202729
स्रोत
वाह! 1 बाइट द्वारा 05AB1E उत्तर को धड़कता है!
— user202729
के gcdबजाय का उपयोग कर minहमें बनाया टाई। बहुत बुरा मुझे संकेत के साथ एक gcd मिलता है, अन्यथा मैं 7 साल का होता;)
— Emigna
3

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.

— ग्यूसेप
स्रोत
3

जावास्क्रिप्ट (ईएस 6), 92 90

संपादित 2 बाइट्स thx Arnauld बचाया

आसान है, क्योंकि यह पहले दो और अंतिम दो के बीच के अंतर की जांच करने के लिए पर्याप्त है। लेकिन फिर भी अविश्वसनीय रूप से लंबा है।

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)
})
स्निपेट का विस्तार करें

— edc65
स्रोत
a-=d=e*e>d*d?d:eकाम करना चाहिए और 2 बाइट्स बचाएं।
— अरनौलद
@ अर्नुलड यह वास्तव में काम करता है धन्यवाद
— edc65
2

वोल्फ्राम भाषा (गणितज्ञ) , 50 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— जंगहवान मिन
स्रोत
क्या "संख्याओं की सूची" में व्यक्तिगत तर्कों के रूप में संख्याएँ शामिल हैं? यदि हां, तो ऐसा लगता है कि आप अच्छी संख्या में बाइट्स बचा सकते हैं।
— नंबरमानिश
@numbermaniac मुझे ऐसा नहीं लगता है, क्योंकि वहाँ एक बिलिन नहीं है जो आखिरी इनपुट लाती है ...
— जंगवान मिन
आह ... सच। उसके बारे में भूल गए।
— संख्यामान
आप का उपयोग कर सकते हैं {##}और Last@{##}सबसे अच्छा मैं उस के साथ मिल सकता था 51 बाइट्स।
— नंबरमानस
1

हास्केल , 73 69 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— Laikoni
स्रोत
1
मैं एक 63 बाइट समाधान पाया, लेकिन यह तुम्हारा से बहुत अलग है। क्या मुझे एक अलग पोस्ट बनाना चाहिए?
— user1472751
@ user1472751 मैं लैकोनी नहीं हूं, लेकिन यह साइट प्रतियोगिता के लिए, साथ ही सहयोग के लिए थी। इसलिए मैं इसे पोस्ट करूंगा।
— H.PWiz
@ user1472751 अच्छा तरीका! कृपया आगे बढ़ें और इसे अपने उत्तर के रूप में पोस्ट करें।
— लिकोनी
1

जम्मू , 49, 47 46 बाइट्स

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

एमिग्ना के समाधान से प्रेरित।

यह काम किस प्रकार करता है:

 (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

इसे ऑनलाइन आज़माएं!

— गैलेन इवानोव
स्रोत
1

भूसी , 9 बाइट्स

m←C▼Ẋ≠⁰…⁰

इसे ऑनलाइन आज़माएं!

बाइट काउंट को आधा करने के लिए H.PWiz को बहुत-बहुत धन्यवाद , यह इंगित करके कि …सूची में आवेदन करने से इसकी सीमा तय होती है ...!

— मिस्टर एक्सकोडर
स्रोत
@ HP.Wiz X_X मुझे नहीं पता था कि हस्क इस तरह की पर्वतमाला है ... क्या आप वाकई इसे अपने अलग उत्तर के रूप में पोस्ट नहीं करना चाहते हैं?
— श्री एक्सकोडर
@ HP.Wiz धन्यवाद एक loooot !
— श्री एक्सकोडर
इसके अलावा, F⌋द्वारा प्रतिस्थापित किया जा सकता है ▼?
— H.PWiz
@ H.PWiz @ _ @ वह भी काम क्यों करता है?
— श्री Xcoder
सबसे छोटा (पूर्ण) अंतर मूल अंतर होगा। gcdनकारात्मक
— डेल्टास
1

सी # (.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;

हैरानी की बात यह है कि इस चुनौती की अधिक बारीकियों का अनुमान था जिसे मैंने शुरू में प्रत्याशित किया था।

स्वीकृतियाँ

-22 बाइट्स @DLosc से कुछ साफ-सुथरे सरलीकरण के कारण बच गए।

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;
}
— Ayb4btu
स्रोत
0

जाप , 12 बाइट्स

ÌõUg Uäa ñ g

कोशिश करो

व्याख्या

õइनपुट सरणी के अंतिम तत्व ( Ì) से पहली ( Ug) तक पूर्णांकों की एक सरणी उत्पन्न करें । इनपुट से सभी दो तत्व जोड़े प्राप्त करके तत्वों के बीच के चरण की गणना करें और उन्हें पूर्ण अंतर से घटाएं ( Uäa) फिर ñउस सरणी को क्रमबद्ध करें और पहला तत्व लें ( g)।

— झबरा
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.