चंक + अंकों की एक सूची संलग्न करें

12

मेरे पास दशमलव अंकों की एक सूची है:

4, 4, 4, 7, 7, 9, 9, 9, 9, 2, 2, 2, 4, 4

दशमलव अंकों की सूची को आइटम के रूप में जाना जाता है। हम समान और आसन्न संख्याओं को एक साथ जोड़कर इन मदों से "विखंडू" बना सकते हैं। मैं प्रत्येक chunk को एक अद्वितीय संख्या निर्दिष्ट करना चाहता हूं, जो 1 से शुरू हो रहा है, और क्रम में 1 से बढ़ कर विखंडू मूल सूची में दिखाई देते हैं। तो, दिए गए उदाहरण के लिए आउटपुट इस तरह दिखेगा:

1, 1, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 5, 5

इनपुट प्रारूप

अंकों की एक सूची। (0-9) इस सूची को पढ़ने के लिए आप अपनी भाषा बिल्ट-इन का उपयोग कर सकते हैं। एन्कोडिंग: ASCII

आउटपुट स्वरूप

दशमलव संख्या की एक श्रृंखला, एक सीमांकक द्वारा अलग की गई। आपके प्रोग्राम को हमेशा एक ही सीमांकक का उपयोग करना चाहिए। सीमांकक 0 बिट्स से अधिक होना चाहिए। एन्कोडिंग: ASCII

मानक खामियां लागू होती हैं।

code-golf  array-manipulation 
— noɥʇʎԀʎzɐɹƆ
स्रोत
8
सख्त इनपुट और आउटपुट प्रारूप का कोई विशेष कारण?
— असंबंधित स्ट्रिंग
2
@ असंबंधित स्ट्रिंग हम्म, मैं उन्हें ढीला करूंगा।
— no --z।
8
IO अभी भी बल्कि सख्त है। क्या आप केवल यह नहीं कह सकते हैं कि "इनपुट और आउटपुट एक सूची के रूप में है" और साइट के डिफॉल्ट्स को आपके लिए ध्यान रखने दें?
— जो किंग
2
क्या हम मान सकते हैं कि सूची गैर-रिक्त है?
— जो किंग
1
परिभाषा की एक सूची में पहले से ही परिसीमन है। इसलिए यह एक सूची है। मुझे यह भी समझ में नहीं आ रहा है कि आपका क्या मतलब है You may use your language built-ins to read this list however you want.। क्या इसका मतलब है कि हमें अपने सबमिशन में एक स्ट्रिंग को सूची में शामिल करना होगा? और क्या हमें एक सूची के रूप में आउटपुट करने की अनुमति है?
— जो किंग

जवाबों:

7

पायथन 3.8 (पूर्व-रिलीज़) , 41 बाइट्स

lambda l,n=0:[n:=n+(l!=(l:=x))for x in l]

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

:=असाइनमेंट एक्सप्रेशन के मैजिक वालरस की प्रशंसा करें ।

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

n=0
for x in input():n+=x!=id;id=x;print n

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

— XNOR
स्रोत
हम्म, यह कब तक पायथ में होगा?
— no --zɐɹƆ
हुह, मैंने टाल दिया idक्योंकि यह 2 बाइट्स लंबा है ...
— एरिक आउटगोल्फर
Oof का अच्छा विचारid
— फॉरवर्ड
@ no @z translation सीधे अनुवाद के लिए 8 बाइट्स: इसे ऑनलाइन आज़माएं!
— isaacg
3

जेली , 6 5 बाइट्स

ŒɠµJx

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

UnrelatedString के लिए एक बाइट धन्यवाद सहेजा गया !

सरणी के रूप में इनपुट और आउटपुट (ब्रैकेट खोलने / बंद करने के साथ)

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

ŒɠµJx - Main link, takes one argument:                       [7, 7, 5, 5, 5, 1]
Œɠ    - Get the lengths of consecutive elements:             [2, 3, 1]
  µ   - Call these lengths A
   J  - range(length(A))                                     [1, 2, 3]
    x - Repeat each element by the corresponding value in A: [1, 1, 2, 2, 2, 3]
— केर्ड सिक्काहिरिंग
स्रोत
— असंबंधित स्ट्रिंग
1
@ सभी असंबंधित परमाणुओं को असंबंधित किया गया!
— caird coinheringaahing
2

पर्ल 6 , 21 बाइट्स

{+<<[\+] $,|$_ Zne$_}

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

अनाम कोड ब्लॉक जो एक सूची लेता है और एक सूची देता है। यह सूची के संचयी योग लेने की तुलना में आसन्न तत्वों के प्रत्येक जोड़े के बराबर नहीं है या नहीं, यह तुलना करके काम करता है।

— मजाक कर रहा है
स्रोत
1

पर्ल 5 , 27 बाइट्स

s/\d/$i+=$&!=$p;$p=$&;$i/ge

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

कमांड लाइन ऑप्शन -pSTDIN से इनपुट लाइन को "डिफॉल्ट वेरिएबल" में पढ़ता है $_। यह तब $_काउंटर के साथ सभी अंकों की खोज करता है $i। और $iप्रत्येक अंक के लिए बढ़ा दिया जाता है जो पिछले अंक से भिन्न होता है, जो कि पहले अंक में भी होता है इसलिए काउंटर शुरू होता है 1। पिछले अंक में संग्रहीत किया जाता है $p।

— केजेटिल एस।
स्रोत
1

पायथ , 13 11 बाइट्स

s.e*]hkhbr8

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

         r8  # Run-length encode (implicit argument is the input) (-> [[frequency, char], ...]
 .e          # Enumerated map (current element is b, index is k) over rQ8
   *]hk      # [ k+1 ] *
       hb    #           b[0]
s            # Reduce list on + ([a]+[b] = [a,b])

-2 बाइट्स मिस्टर एक्सकोडर की बदौलत

— ar4093
स्रोत
hMsM._+0nVt-2 बाइट्स के लिए।
— श्री Xcoder
या फिर आप अपने दृष्टिकोण रखना चाहते हैं, rQ8के रूप में ही है r8और .nहो सकता है sके लिए -2 के रूप में अच्छी तरह से
— श्री Xcoder
अच्छा है, डॉक्स ने उल्लेख नहीं किया कि क्या कार्य एक निहितQ
— ar4093
1

स्काला , 75 बाइट्स

s=>s.scanLeft(("",0))((x,y)=>(y,x._2+(if(x._1!=y)1 else 0))).tail.map(_._2)

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

यदि इनपुट और आउटपुट कॉमा को अलग किया जाना चाहिए स्ट्रिंग (और सूची नहीं) तो 102 बाइट्स।

s=>s.split(", ").scanLeft(("",0))((x,y)=>(y,x._2+(if(x._1!=y)1 else 0))).tail.map(_._2).mkString(", ")
— डॉ। वाई विट
स्रोत
1

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

nƝÄŻ‘

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

मैंने शुरू में 4-बटर (एक ही कार्यक्रम लेकिन बिना Ż) के लिए लक्ष्य किया था, लेकिन फिर जल्दी से महसूस किया कि ए 1 को हर बार ओवरसिट होने के कारण पहले से तैयार रहना पड़ता था ... हालांकि जेली में एक और 5-बायटर है, फिर भी मैं करूँगा। वास्तव में इसे बनाए रखें क्योंकि यह एक अलग विधि का उपयोग करता है।

इनपुट सूची के पड़ोसी आइटम के प्रत्येक जोड़े के लिए एलपरीक्षण, अगर एलमैं≠एलमैं+1,∀1≤मैं<|एल|और इन परिणामों को एक सूची में सहेजें। फिर इस सूची का संचयी योग लेते हैं और उन्हें 1 के द्वारा बढ़ाते हुए चंक इंडेक्सिंग सिस्टम से मिलाते हैं। टी एल; डॉ। जब भी हम विभिन्न पड़ोसी वस्तुओं का सामना करते हैं, तो हम चंक इंडेक्स को 1 से बढ़ाते हैं ।

— मिस्टर एक्सकोडर
स्रोत
— श्री Xcoder
1

जावास्क्रिप्ट (ईएस 6), 30 बाइट्स

पूर्णांक के एक सरणी के रूप में इनपुट लेता है।

a=>a.map(p=n=>i+=p!=(p=n),i=0)

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

टिप्पणी की गई

a =>                // a[] = input array
  a.map(p =         // initialize p to a non-numeric value
  n =>              // for each value n in a[]:
    i +=            //   increment i if:
      p != (p = n), //     p is not equal to n; and update p to n
    i = 0           //   start with i = 0 (chunk counter)
  )                 // end of map()
— Arnauld
स्रोत
1

PHP , 52 बाइट्स

while(''<$d=$argv[++$x])echo$i+=$argv[$x-1]!=$d,' ';

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

कमांड लाइन के माध्यम से इनपुट, आउटपुट को STDOUT ।

Pxky '0' == 0तुलना बगफिक्स के लिए Thx @ नाइट 2 !

— 640KB
स्रोत
@ नाइट 2 अच्छा कैच! अद्यतन और तय किया गया। धन्यवाद!
— 640KB
0

++ , 23 बाइट्स जोड़ें

D,f,@*,BGd€bL$bLRz€¦XBF

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

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

D,f,@*,     - Define a function, f, that takes one argument:  [7 7 5 5 5 1]
       BG   - Group neighbouring elements together:           [[[7 7] [5 5 5] [1]]]          
       d    - Duplicate:                                      [[[7 7] [5 5 5] [1]] [[7 7] [5 5 5] [1]]]
       €bL  - Get the length of each:                         [[[7 7] [5 5 5] [1]] [2 3 1]]
       $bLR - Length, then range of length:                   [[2 3 1] [1 2 3]]
       z    - Zip together:                                   [[2 1] [3 2] [1 3]]
       €¦X  - Reduce each by repetition:                      [[1 1] [2 2 2] [3]]
       BF   - Flatten:                                        [1 1 2 2 2 3]
            - Due to the * in the function definition,
                 return the whole stack:                      [1 1 2 2 2 3]
— केर्ड सिक्काहिरिंग
स्रोत
0

रेटिना 0.8.2 , 34 बाइट्स

\b\d+\b(?<=(\b(\3|(\d+))\D*)*)
$#3

इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

\b\d+\b

प्रत्येक संख्या को बारी-बारी से मिलाएं।

(?<=(...)*)

अधिक से अधिक मैचों के लिए पीछे की ओर देखना शुरू करें। (अगली प्रविष्टियाँ दाएं-से-बाएं क्रम में होंगी क्योंकि यह कैसे काम करता है।)

\D*

विभाजकों को छोड़ दें।

(\3|(\d+))

पिछली बार की ही तरह मैच करने की कोशिश करें, लेकिन यह असफल रहा, बस किसी भी संख्या से मेल खाए, लेकिन याद रखें कि हमें एक नए नंबर से मेल खाना था।

\b

सुनिश्चित करें कि पूरी संख्या का मिलान किया गया है।

$#3

नए नंबरों की संख्या गिनें।

— नील
स्रोत
0

स्टैक्स , 10 बाइट्स

▓ª2ªmD?Ä╧╖

इसे चलाएं और डीबग करें

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

— पुनरावर्ती
स्रोत
0

सी (जीसीसी) , 62 61 बाइट्स

यह उन कुछ प्रविष्टियों में से एक है जो मैंने किया है जहाँ एक पूर्ण कार्यक्रम एक फ़ंक्शन सबमिशन से कम है!

पहले पास पर, मुझे पिछले मूल्य की परवाह नहीं है, इसलिए मुझे इस बात पर भरोसा करना है कि argvकहीं न कहीं एक सूचक है और [0..9] के बीच होने की बहुत संभावना नहीं है!

s;main(i,j){for(;~scanf("%d,",&i);j=i)printf("%d ",s+=j!=i);}

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

— ErikF
स्रोत
0

सी (जीसीसी) , 62 बाइट्स

f(_,l)int*_;{printf("%d ",l=--l?f(_,l)+(_[l]!=_[l-1]):1);_=l;}

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

एक फ़ंक्शन जो सूची और उसकी लंबाई को तर्क के रूप में लेता है।

सी (जीसीसी) , 60 बाइट्स

f(_,l)int*_;{_=printf("%*d",--l?f(_,l)+(_[l]!=_[l-1]):2,0);}

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

यूनियनों में आउटपुट, 0s द्वारा सीमांकित

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