कभी बढ़ता ग्राफ

Question

एक निश्चित सीमा के भीतर संख्याओं के एक आयामी क्रम पर विचार करें, अर्थात

[1, 2, 4, 6, 8, 0, 2, 7, 3] in range [0, 10⟩

एवर-बढता ग्राफ * ** एक ऐसी लाइन है जो इस क्रम के सभी बिंदुओं को दाएं से जोड़ती है, और हमेशा ऊपर की ओर जाती है या स्तर पर रहती है। यदि आवश्यक हो, तो रेखा ऊपर से नीचे तक चारों ओर घूमती है और अगले बिंदु को पूरा करने के लिए वहां से ऊपर जाती रहती है।

इस चुनौती का लक्ष्य अनुक्रम को अलग-अलग क्रमों में विभाजित करना है जो सभी गैर-लाभकारी हैं, ताकि जब एक सीमित ऊर्ध्वाधर अक्ष के साथ एक साथ साजिश रची जाए तो वे एक एवर-बढ़ते ग्राफ बनाएंगे। यह एक बाद के अंत में और अगले बाद की शुरुआत के लिए एक बिंदु जोड़कर किया जाता है, ताकि पंक्ति का कोण जो शीर्ष सीमा को पार करता है उस रेखा के साथ संरेखित होता है जो नीचे की सीमा को पार करता है, और दो क्रॉसिंग अंक समान क्षैतिज समन्वय है। ऊपर दिया गया उदाहरण निम्नलिखित आउटपुट देगा:

[1, 2, 4, 6, 8, 10]
[-2, 0, 2, 7, 13]
[-3, 3]

और संबंधित ग्राफ निम्नानुसार दिखेगा: और एक बेहतर दृश्य के लिए बढ़ाए गए अक्ष के साथ: आवश्यक आउटपुट एवरेज-ग्राफिंग के कुछ हिस्सों को बनाने वाले बाद की सूची है। एक भूखंड बनाने की आवश्यकता नहीं है, लेकिन आप बोनस अंक अर्जित करेंगे;)। आउटपुट को बाद में किसी तरह स्पष्ट रूप से अलग करना होगा।

टिप्पणियाँ

• सीमा हमेशा बाईं (समावेशी) सीमा के रूप में शून्य होगी, और सही सीमा कुछ पूर्णांक एन होगी।
• अनुक्रम में वे मान कभी नहीं होंगे जो सीमा के भीतर नहीं हैं।
• पहली अनुवर्ती शुरुआत में एक अतिरिक्त बिंदु नहीं है।
• अंतिम परिणाम अंत में एक अतिरिक्त बिंदु नहीं है।
• यह प्रारंभिक संकेत प्रदान करने के लिए आवश्यक नहीं है जो बाद में साजिश करने के लिए आवश्यक होगा।

परीक्षण के मामलों

Input: [0, 2, 4, 6, 1, 3, 5, 0], 7
Output: [0, 2, 4, 6, 8], [-1, 1, 3, 5, 7], [-2, 0]
Input: [1, 1, 2, 3, 5, 8, 3, 1], 10
Output: [1, 1, 2, 3, 5, 8, 13],[-2, 3, 11],[-7, 1]
Input: [5, 4, 3, 2, 1], 10
Output: [5, 14],[-5, 4, 13],[-6, 3, 12],[-7, 2, 11],[-8, 1]
Input: [0, 1, 4, 9, 16, 15, 0], 17
Output: [0, 1, 4, 9, 16, 32], [-1, 15, 17], [-2, 0]

स्कोरिंग

यह कोड-गोल्फ है, बाइट्स जीत में सबसे छोटा कोड।

* वास्तविक शब्दजाल नहीं ** वास्तव में एवर नॉन-घटता ग्राफ कहा जाना चाहिए, जैसा कि @ngm ने बताया, लेकिन यह कम प्रभावशाली लगता है।

Comments

PPCG में आपका स्वागत है! अच्छी पहली चुनौती!

— AdmBorkBork

ऐसा लगता है कि मैंने चुनौती के कुछ हिस्से को गलत समझा। मुझे लगता है कि यह वही होना चाहिए जो आपने इरादा किया था।

— user202729

चुनौती को समझने में आसान बनाने के लिए क्या आप 0 और 10 से ऊपर के नमूने में y अक्ष को बढ़ा सकते हैं?

— JayCe

@ जयके हाँ, अच्छा सुझाव है।

— RvdV

दूसरा परीक्षण मामला बताता है कि आप दृश्यों को गैर-घटते हुए बढ़ने का इरादा रखते हैं, जैसा कि बढ़ने का विरोध है? दूसरे शब्दों में, इनपुट में एक बार-बार किया गया मान उस वर्तमान उत्तरोत्तर को नहीं रोकता है, और यदि बाद के अंतिम दो मान अगले कोण को शुरू करने के "कोण" के बराबर हैं, तो यह 0 है (इसलिए यह दोहराया मान से शुरू होगा। भी)?

— एन जी एम

Answer 1

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

⁹;+⁴,N¤j.x>ṭḷ
çƝF;Ṫ{

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

इसके बाद परिणाम छपते हैं 0.5।

Answer 2

आर , 179 158 151 बाइट्स

function(s,m){p=1;t=c(which(diff(s)<0),length(s));for(i in t){d=c(s[p]-m,s[(p+1):i],s[i+1]+m);if(p==1)d[1]=s[1];if(p==t[-1])d=head(d,-1);print(d);p=i}}

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

संपादित करें: कोड अब एक फ़ंक्शन है और इनपुट लेता है। (शांत रूप से इंगित करने के लिए Giuseppe, user202729 और JayCe को धन्यवाद) Giuseppe द्वारा सुझाए गए
संपादन: -21 बाइट्स।
संपादित करें: -7 बाइट्स हटाकर d=NULL;।

Comments

PPCG में आपका स्वागत है! यह उत्तर वर्तमान में मान्य नहीं है क्योंकि इसे किसी न किसी तरीके से इनपुट लेना चाहिए (वर्तमान में वे पर्यावरण में हार्ड-कोडेड हैं)। इसके अतिरिक्त, आप आर सहायक में गोल्फ के लिए इन सुझावों को पा सकते हैं । एक बार जब आप पर्याप्त प्रतिष्ठा प्राप्त कर लेते हैं, तो मुझे यहाँ या चैट में बेझिझक!

— ग्यूसेप

बस एक वैध प्रस्तुत करने के बारे में स्पष्ट होना चाहिए: यह होगा । आपका स्वागत है और यहां अपने समय का आनंद लें :)

— JayCe

मुझे लगता है कि यह s[p+1]-((m+s[p+1])-s[p])सरल है s[p]-m, और आपके पास d=c(c(...))केवल d=c(...)आवश्यकता है। मुझे दृढ़ता से संदेह है कि एक गोल्फ रास्ता है लेकिन यह अभी भी एक अच्छा जवाब है।

— ग्यूसेप

@PA को dभी आरंभ करने की आवश्यकता है?

— JayCe

@PA मदद करने के लिए खुश! मैं तो बस फिर से खोला एक अनुसंधान गोल्फ चैटरूम तो मेरे साथ संपर्क में पाने के लिए स्वतंत्र लग रहा है और विशिष्ट प्रश्न के लिए अन्य सभी आर गोल्फरों आप हो सकता है :-)

— ग्यूसेप

Answer 3

पायथन 2 , 60 बाइट्स

इनपुट एन है, सभी बिंदुओं के बाद व्यक्तिगत तर्क के रूप में। आउटपुट में परिणाम इसके बाद अलग हो जाते हैं 0.5।

f=lambda N,k,*l:(k,)+(l and(l[0]+N,.5,k-N)*(l[0]<k)+f(N,*l))

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

---

पायथन 2 , 92 77 68 बाइट्स

बाद में अलग हो जाते हैं [...]।

l,N=input();r=[];k=0
for a in l:r+=[a+N,r,k-N]*(a<k)+[a];k=a
print r

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

Comments

बहुत अच्छा लगा! मैं वास्तव में चुनिंदा वस्तुओं को जोड़ने के लिए चर कश्मीर के उपयोग को पसंद करता हूं, यहां कुछ नया सीखा है!

— आरवीडीवी

Answer 4

क्लीन , 279 269 258 बाइट्स

import StdEnv
s=snd o unzip
$[]=[]
$l#(a,b)=span(uncurry(<))(zip2[-1:l]l)
=[s a: $(s b)]
?l n#[h:t]= $l
=[h:if(t>[])(?(map((+)n)(flatten t))n)t]
@l n#l= ?l n
=[[e-i*n\\e<-k]\\k<-[a++b++c\\a<-[[]:map(\u=[last u])l]&b<-l&c<-tl(map(\u=[hd u])l)++[[]]]&i<-[0..]]

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

Answer 5

जावास्क्रिप्ट (Node.js) , 104 82 बाइट्स

n=>a=>a.map((e,i)=>e>a[s.push(e),++i]&&s.push(a[r.push(s=[e-n]),i]+n),r=[s=[]])&&r

इसे ऑनलाइन आज़माएं! @ ओव्स पाइथन उत्तर का पोर्ट।

Answer 6

हास्केल, 82 81 80 बाइट्स

यह मेरे स्वच्छ उत्तर का एक बंदरगाह है ।

r!n|let f x(r@(a:_):s)|x>a=[x,n+a]:(x-n:r):s|y<-x:r=y:s=foldr f[[last r]]$init r

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

-1, -1 लैकोनी के लिए धन्यवाद

Comments

@ लिकोनी यह एक दुख की बात है कि हम पैटर्न के fचारों ओर कोष्ठक के बिना स्थानीय रूप से परिभाषित नहीं कर सकते :, जैसे कि let x<r@(a:_):s|...।

Answer 7

क्लीन , 92 बाइट्स

import StdEnv
@r n=foldr(\x[r=:[a:_]:s]|x>a=[[x,n+a]:[x-n:r]:s]=[[x:r]:s])[[last r]](init r)

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

ऑपरेटर तर्क foldrगार्ड के साथ एक लंबोदर है; इसे इस रूप में पार्स किया गया है:

\x [r=:[a:_]:s]
    | x > a     = [[x,n+a]:[x-n:r]:s]
    | otherwise = [[x:run]:s]

मैंने इसे हास्केल में पोर्ट कराया ।

Answer 8

क्लीन , 110 109 104 100 97 बाइट्स

import StdEnv
@[x:r]n=let$s=:[x:r]a|x<last a=[a++[n+x]: $s[last a-n]]= $r(a++[x]);$_ a=[a]in$r[x]

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

-1 बाइट कीलन के लिए धन्यवाद

Answer 9

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

(x:r)#n|let b@(a:_)%s@(x:r)|x<a=(n+x:b):[a-n]%s|c<-x:b=c%r;a%_=[a]=reverse<$>[x]%r

इसे ऑनलाइन आज़माएं! मेरे स्वच्छ उत्तर का पोर्ट ।

---

वैकल्पिक, 82 बाइट्स भी

(x:r)#n|let a%s@(x:r)|x<last a=(a++[n+x]):[last a-n]%s|c<-a++[x]=c%r;a%_=[a]=[x]%r

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

Answer 10

जावास्क्रिप्ट (Node.js) , 98 बाइट्स

a=>m=>(r=[],b=[],a.map((e,i)=>e<a[--i]?(b[p](m+e),r[p](b),b=[a[i]-m,e]):b[p='push'](e)),r[p](b),r)

इसे ऑनलाइन आज़माएं! यह अन्य जेएस जवाब की तुलना में थोड़ा लंबा है, लेकिन यह एक अलग दृष्टिकोण का उपयोग करता है।

असंबद्ध और सरलीकृत स्पष्टीकरण

g=(a,m)=>{
    // r is the final array of arrays to return.
    // b is the current subset of only ascending numbers.
    r=[],b=[];

    a.map((e,i)=>{
        if(e<a[i-1]){
            // if the current value is less than the previous one,
            // then we're descending, so start a new array b.
            // add the proper value to b to match slopes with the next
            b.push(m+e);
            // add r to b, and restart b with the starter value and the current value in a
            r.push(b);
            b=[a[i-1]-m,e];
        } else{
            // otherwise, we're ascending, so just addd to to b.
            b.push(e);
        }
    });
    r.push(b); // add the final b to r, and return r
    return r;
}

Answer 11

जावास्क्रिप्ट (Node.js) , 48 बाइट्स, सरणियों द्वारा अलग,,

s=>n=>s.map(r=t=>(t<r?[t+n,,r-n,,]:``)+(r=t))+``

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

जावास्क्रिप्ट (Node.js) , 50 बाइट्स, सरणियों द्वारा अलग|

s=>n=>s.map(r=t=>(t<r?t+n+`|${r-n},`:``)+(r=t))+``

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