जल्दी से सूचियों को फिर से इकट्ठा करना

17

समूहीकरण एक सूची लेता है और समान आसन्न तत्वों की नई सूचियों में विभाजित करता है। उदाहरण के लिए

[1,1,2,1,1] -> [[1,1],[2],[1,1]]

यदि आप इन समूहों की लंबाई लेते हैं, तो आपको पूर्णांक की एक नई सूची मिलती है

[1,1,2,1,1] -> [2,1,2]

आपका कार्य एक प्रोग्राम लिखना है जो सकारात्मक पूर्णांकों की एक सूची लेता है और आप जितनी बार समूह कर सकते हैं उसकी संख्या ज्ञात करें और परिणामी सूची में एक ही तत्व होने से पहले उसे लंबाई दें। उदाहरण के लिए सूची [1,2,3,3,2,1]को 4 बार फिर से वर्गीकृत किया जा सकता है

[1,2,3,3,2,1]
[1,1,2,1,1]
[2,1,2]
[1,1,1]
[3]

यह कोड-गोल्फ है इसलिए उत्तर बाइट्स में कम बाइट के साथ बेहतर स्कोर किए जाएंगे।

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

[1,2,3,3,2,1] -> 4
[1,2,3,4,5,6,7] -> 2
[1,1,1,1,1,1] -> 1
[2] -> 0
[1,2,4] -> 2
[1,2,2,1,1,2] -> 4
[1,2,2,1,1,2,1,2,2] -> 5
[1] -> 0
code-golf  array-manipulation 
— पोस्ट रॉक गार्फ हंटर
स्रोत
3
यह मूल रूप से मानों को संचय किए बिना रन-लंबाई एन्कोडिंग है।
— 12M2121
[1]एक वैध इनपुट है और 0सही देना चाहिए ?
— ETHproductions
@ETHproductions हां, मैं इसे जोड़ूंगा क्योंकि यह एक मुश्किल मामला है।
— पोस्ट रॉक गार्फ हंटर

जवाबों:

3

जाप , 12 बाइट्स

ÊÉ©1+ßUò¦ ml

इसे ऑनलाइन टेस्ट करें!

व्याख्या

 Ê É © 1+ßUò¦  ml
Ul -1&&1+ßUò!= ml    Ungolfed
                     Implicit: U = input array
Ul -1                Take U.length - 1.
     &&              If this is non-zero:
          Uò!=         Split U between non-equal elements.
               ml      Take the length of each run of equal elements.
         ß             Run the entire program again on the resulting array.
       1+              Add one to the return value.

पुनरावृत्ति Japt के लिए एक बहुत ही गैर-पारंपरिक दृष्टिकोण है, लेकिन यह अगले विकल्प की तुलना में 4 बाइट्स छोटा लगता है ...

— ETHproductions
स्रोत
@ शैगी मेरा 16-बाइट संस्करण F.a()अभी भी संशोधन इतिहास के माध्यम से सुलभ है। मैं हालांकि आपके 14-byter देखना पसंद करूंगा!
— ETHproductions
2

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

j,k,n;f(A,l)int*A;{for(j=k=n=0;j<l;j++)if(n++,A[j]-A[k])A[k++]=--n,A[k]=A[j],n=1;A=l>1?-~f(A,k,A[k++]=n):0;}

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

व्याख्या

j,k,n;                // array pos, group pos, group val
f(A,l)int*A;{         // function takes array and length
 for(j=k=n=0;j<l;j++) // initialize, loop through array
  if(n++,             // increase n (*), check if group ended
  A[j]-A[k])          // group ended
   A[k++]=--n,        // advance group pos, decrease n, counteracting (*)
   A[k]=A[j],         // store new group type
   n=1;               // group is at least one long
 A=l>1?               // check if array length is larger than one
  -~f(A,k,A[k++]=n)   // fix last group length, enter recursion
  :0;}                // array length is less than two, return zero

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

— जोनाथन फ्रेच
स्रोत
2

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

f=a=>a[1]?1+f(q=j=i=[],a.map(x=>x^a[++i]?j=!q.push(++j):++j)):0

ताज्जुब है, जावास्क्रिप्ट और Japt एक ही बार के लिए सबसे कम एल्गोरिथ्म है ...

— ETHproductions
स्रोत
2

के (ओके) , 20 19 बाइट्स

समाधान:

#2_{#:'(&~~':x)_x}\

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

उदाहरण:

#2_{#:'(&~~':x)_x}\1 2 3 3 2 1
4
#2_{#:'(&~~':x)_x}\1 2 3 4 5 6 7
2
#2_{#:'(&~~':x)_x}\1 1 1 1 1 1
1
#2_{#:'(&~~':x)_x}\1#2
0
#2_{#:'(&~~':x)_x}\1 2 4
2

स्पष्टीकरण:

यह एक बहुत सरल है, अगर कोई बेहतर तरीका है, तो मैं सोच रहा हूं ... उन सूचकांकों का पता लगाएं जहां इनपुट भिन्न होते हैं, उन सूचकांकों में विभाजित होते हैं और फिर प्रत्येक उप-सूची की लंबाई की गणना करते हैं। परिणाम 1 तक अभिसरण होने तक Iterate करें।

#2_{#:'(&~~':x)_x}\ / the solution
   {             }\ / scan over lambda until results converge
                x   / implicit input
               _    / cut at indices
       (      )     / do this together
         ~~':x      / differ... not (~) match (~) each-previous (':) x)
        &           / indices where true
    #:'             / count (#:) each (')
 2_                 / drop first two results
#                   / count result

टिप्पणियाँ:

एकल आइटम सूची को छोड़कर सभी के लिए निम्नलिखित 14 बाइट समाधान काम करता है :

#1_(-':&~~':)\

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

— streetster
स्रोत
2

जे , 25 23 बाइट्स

1 बाइट ने स्ट्रीटस्टर को धन्यवाद दिया

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

2#@}.#;.1@(0,2=/\])^:a:

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

प्रारंभिक समाधान:

_2+[:#(#;.1~1,2~:/\])^:a:

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

व्याख्या

      (               )^:a: - repeat until result stops changing, store each iteration
        ;.1~                - cut the input (args swapped)              
            1,2~:/\]      - where the items are no longer the same
       #                    - and take the length of the sublists
 2+[:#                      - finally subtract 2 from the number of steps
— गैलेन इवानोव
स्रोत
1
क्या आप _2+बाइट को बचाने के बजाय 'ड्रॉप टू' तो 'काउंट' कर सकते हैं ?
— स्ट्रीटस्टर
1
मुझे लगता #;.1@(0,2=/\])है कि 1 बाइट बचाता है।
— FrownyFrog
@ FrownyFrog हाँ, यह करता है। धन्यवाद!
— गैलेन इवानोव
@streetster हां, यह एक बाइट को बचाने में मदद करता है। धन्यवाद!
— गैलेन इवानोव
2

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

ÆÑfá╒]`*Ä

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

उसी कार्यक्रम का एससीआई प्रतिनिधित्व यह है।

{D}{|RMHgf%

यह एक स्टेक्स फीचर का उपयोग करता है जिसे जनरेटर कहा जाता है जो परिवर्तन और फिल्टर ब्लॉक के अनुसार मूल्य पैदा करता है।

{ }            the filter for the generator
 D             tail of array; this is truthy for length >= 2
   {    gf     generator block - termination condition is when the filter fails
    |R         run-length encode into pairs [element, count]
      M        transpose matrix
       H       last element
          %    length of final generated array
— पुनरावर्ती
स्रोत
2

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

f=lambda a:len(a)>1and-~f(eval(''.join('1'+',+'[x==y]for x,y in zip(a,a[1:]))+'1,'))

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

कैसे?

fएक पुनरावर्ती कार्य है, यदि इसके इनपुट में a, लंबाई 2 या अधिक है ( len(a)>1) रिटर्न 1+f(x)* जहां xसमूह की लंबाई है a; जबकि यदि इसका इनपुट लंबाई 1 या 0 रिटर्न है False(पायथन में 0 के बराबर) - इसका कारण यह है कि बाएं हाथ के गलत होने पर दाएं हाथ का andमूल्यांकन नहीं होता है।

* -~f(x)है -(-1 - f(x))लेकिन abut कर सकते हैं andके विपरीत 1+f(x)या f(x)+1)

समूह की लंबाई की गणना कोड बनाकर की जाती है, जिसके साथ मूल्यांकन किया जाता है eval(...)। बनाया गया कोड कुछ ऐसा होता है, 1,1,1+1+1,1,1+1,1,जिसका मूल्यांकन टपल की तरह होता है (1,1,3,1,2,1)।

यह कोड उसके सिर के बिना aऔर aउसके बिना ( प्रत्येक आसन्न जोड़े को ...for x, y in zip(a,a[1:])बनाते xऔर बनाते हुए बनाया गया yहै a। यदि यह जोड़ी समान x==yमूल्यांकन के लिए है True(1) अन्यथा False(0) - तो इस परिणाम का उपयोग स्ट्रिंग ,+ उपज +और ,क्रमशः में अनुक्रमित करने के लिए किया जाता है। परिणामी वर्ण पहले 1( '1'+...) से बना है - पूरी चीज के बाद एक अंतिम, अनुगामी 1,जोड़ होता है। उदाहरण के लिए यदि जोड़े aथे [5,5,2,9,9,9]तो समानताएं बनाएंगे फिर वर्ण होंगे , जो कि पूर्ववर्ती के साथ बन जाता है और अंतिम अनुगामीx,y(5,5)(5,2)(2,9)(9,9)(9,9)10011+,,++11+1,1,1+1+1, बनाते हैं1+1,1,1+1+1,जो (2,1,3)आवश्यकतानुसार मूल्यांकन करता है।

ध्यान दें कि अनुगामी ,यह सुनिश्चित करती है कि किसी एकल समूह के साथ एक इनपुट का मूल्यांकन पूर्णांक के बजाय टपल के रूप में किया जाता है (अर्थात [3,3]-> 1+1,- (2)बजाय [3,3]-> 1+1-> 2)

— जोनाथन एलन
स्रोत
1

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

-1 बाइट @Zgarb को धन्यवाद!

←Vε¡(mLg

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

व्याख्या

←Vε¡(mLg)  -- example input: [1,2,3,3,2,1]
   ¡(   )  -- repeatedly apply the function & collect results
    (  g)  -- | group: [[1],[2],[3,3],[2],[1]]
    (mL )  -- | map length: [1,1,2,1,1]
           -- : [[1,2,3,3,2,1],[1,1,2,1,1],[2,1,2],[1,1,1],[3],[1],[1],...
 V         -- index where
  ε        -- | length is <= 1: [0,0,0,0,1,1...
           -- : 5
←          -- decrement: 4
— ბიმო
स्रोत
1
←Vεसिंगलटन सूची के सूचकांक को खोजने के लिए एक छोटी जांच है।
— जर्ग्बेल
1

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

ŒgL€$ḊпL’

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

— डेनिस
स्रोत
इसके लिए विफल रहता है[1] । इसके बजाय आप इसे दो dequeues / चबूतरे का उपयोग करके ठीक करने में सक्षम होना चाहिए_2
— श्री Xcoder
ÐĿपहली जगह में एक अच्छा विकल्प नहीं था ... थोड़ी देर के लूप के साथ फिर से।
— डेनिस
1

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

मार्टिन एंडर की बदौलत 2 बाइट्स बचाए। CP-1252 एन्कोडिंग का उपयोग करना, जहां ±एक बाइट है।

±{_}=0;±x_:=1+±(Length/@Split@x)

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

— alephalpha
स्रोत
1
एक ऑपरेटर को परिभाषित करना दो बाइट्स बचाता है: ±{_}=0;±x_:=1+±(Length/@Split@x)( WindowsANSIएन्कोडिंग मानकर )
— मार्टिन एंडर
1

स्माइलबासिक, 110 108 बाइट्स

DEF R L,J
K=LEN(L)FOR I=1TO K
N=POP(L)IF O-N THEN UNSHIFT L,0
INC L[0]O=N
NEXT
IF I<3THEN?J ELSE R L,J+1
END

कॉल फ़ंक्शन के रूप में R list,0; आउटपुट कंसोल पर मुद्रित होता है।

— 12Me21
स्रोत
0

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

,.*
$&_
}`(\b\d+)(,\1)*\b
$#2
_

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

,.*
$&_

यदि कोई अल्पविराम है, तो हम एक और पुनरावृत्ति करने जा रहे हैं, इसलिए एक गिनती वर्ण जोड़ें।

}`(\b\d+)(,\1)*\b
$#2

प्रत्येक रन को उसकी विखंडित लंबाई से बदलें। उपरोक्त चरण तब तक दोहराते हैं जब तक कोई अल्पविराम शेष न हो।

_

पुनरावृत्तियों की संख्या गिनें।

— नील
स्रोत
0

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

{+($_,*.comb(/(\d+)[" "$0»]*/).map(+*.words)...^1)}

झसे आज़माओ

विस्तारित:

{  # bare block lambda with implicit parameter ｢$_｣

  + (              # turn the following into a Numeric (get the count)


      $_,          # seed the sequence with the input

      *.comb(      # turn into a string, and grab things that match:

        /          # regex
          ( \d+ )  # a run of digits (number)
          [
            " "    # a space
                   # (gets inserted between elements of list when stringified)

            $0     # another instance of that number
            »      # make sure it isn't in the middle of a number

          ]*       # get as many as possible
        /
      ).map(
        +*.words  # turn each into a count of numbers
      )

      ...^        # keep doing that until (and throw away last value)

      1           # it gives a value that smart-matches with 1
                  # (single element list)
  )
}
— ब्रैड गिल्बर्ट b2gills
स्रोत
0

कोटलिन , 123 बाइट्स

स्वीकार करता है List<Int>।

{var a=it;var b=0;while(a.size>1){var c=a[0];var d=0;with(a){a=listOf();forEach{if(it!=c){a+=d;d=0};d++;c=it};a+=d};b++};b}

अधिक पठनीय:

{ l ->
    var input = l
    var result = 0
    while (input.size > 1) {
        var last = input[0]
        var runSize = 0
        with(input) {
            input = listOf()
            forEach { current ->
                if (current != last) {
                    input += runSize
                    runSize = 0
                }
                runSize++
                last = current
            }
            input += runSize
        }
        result++
    }
    result
}

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

131 बाइट्स, टीआईओ

{l->var a=l;var b=0;while(a.size>1){var c=a[0];var d=0;a.let{a=arrayListOf();for(e in it){if(e!=c){a+=d;d=0};d++;c=e};a+=d};b++};b}

181 बाइट्स, टीआईओ

के लिए 39 शामिल हैं import kotlin.coroutines.experimental.*।

{l->var a=l;var b=0;while(a.size>1){var c=a[0];var d=0;a=buildSequence{for(e in a){if(e!=c){yield(d);d=0;};d++;c=e};yield(d)}.toList();b++};b}
— मोइरा
स्रोत
0

लाल , 140 बाइट्स

func[b][n: 0 while[(length? b)> 1][l: copy[]parse split form b" "[any[copy s[set t string! thru any t](append l length? s)]]b: l n: n + 1]n]

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

मैं सिर्फ रेड की पार्स बोली को एक और कोशिश देना चाहता था।

Ungolfed

f: func [b] [
    n: 0
    while [(length? b) > 1][
        l: copy []
        parse split form b " " [
            any [copy s [set t string! thru any t]
                (append l length? s)]
        ]
        b: l
        n: n + 1
    ]
    n
]
— गैलेन इवानोव
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.