দ্রুত তালিকা পুনরায় গ্রুপিং করা হচ্ছে ping

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
এটি মূলত মানগুলি সংরক্ষণ না করে রান-লেংথ এনকোডিং।
— 12
[1]একটি বৈধ ইনপুট এবং দেওয়া উচিত 0, সঠিক?
— ETH প্রোডাকশনগুলি
@ ইথ প্রডাকশনস হ্যাঁ, আমি এটি যুক্ত করব কারণ এটি কিছুটা জটিল বিষয়।
— পোস্ট রক গার্ফ হান্টার

উত্তর:

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.

পুনরাবৃত্তিটি জাপটের জন্য একটি সত্যই অপ্রচলিত পদ্ধতি, তবে এটি পরবর্তী বিকল্পের চেয়ে 4 বাইট সংক্ষিপ্ত বলে মনে হয় ...

— ETHproductions
সূত্র
@ শেগি আমার 16-বাইট সংস্করণটি F.a()পুনর্বিবেচনার ইতিহাসের মাধ্যমে এখনও অ্যাক্সেসযোগ্য। আমি যদিও আপনার 14-বাইটার দেখতে পছন্দ করব!
— ETH প্রোডাকশনগুলি
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

জাভাস্ক্রিপ্ট (ES6), 67 65 63 বাইট

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

অদ্ভুতভাবে যথেষ্ট, জাভাস্ক্রিপ্ট এবং জাপট একবারের জন্য একই সংক্ষিপ্ত অ্যালগোরিদম বলে মনে হচ্ছে ...

— 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 এ রূপান্তর না হওয়া অবধি ইটারেট করুন।

#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 বাইট সংরক্ষণ করা হয়েছে

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 বাইট সঞ্চয় করে
— ফ্রাউনফ্রোগ
@ ফ্রাউনফ্র্যাগ হ্যাঁ, এটি হয়। ধন্যবাদ!
— গ্যালেন ইভানভ
@ স্ট্রিস্টস্টার হ্যাঁ, এটি একটি বাইট সংরক্ষণ করতে সহায়তা করে। ধন্যবাদ!
— গ্যালেন ইভানভ
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))কিন্তু ঘেঁষা করতে andঅসদৃশ 1+f(x)বা f(x)+1)

গোষ্ঠীর দৈর্ঘ্য কোড তৈরি করে গণনা করা হয় যা এর পরে মূল্যায়ন করা হয় eval(...)। তৈরি কোডটি এমন কিছু 1,1,1+1+1,1,1+1,1,যা একটি টিপলের মতো মূল্যায়ন করে (1,1,3,1,2,1)।

কোড মাধ্যমে zip করা দ্বারা তৈরি করা হয় aএবং aতার মাথা (ছাড়া ...for x, y in zip(a,a[1:])উপার্জন xএবং yসংলগ্ন জোড়া প্রতিটি aযুগল সমান করে। x==yমূল্যায়ণ True(1) অন্যথায় False(0) - এই ফলাফলের স্ট্রিং মধ্যে সূচক করতে ব্যবহৃত হয় ,+ ফলনশীল +এবং ,যথাক্রমে এবং প্রতিটি ফলে অক্ষর একটি পূর্বে হয় 1( '1'+...) - পুরো জিনিস তারপর একটি চূড়ান্ত, trailing হয়েছে 1,। যোগ করা উদাহরণস্বরূপ, যদি aসেটা [5,5,2,9,9,9]তারপর x,yজোড়া হবে (5,5)(5,2)(2,9)(9,9)(9,9)equalities, উপার্জন 10011পরে যে অক্ষরগুলি হবে +,,++, যার পূর্ববর্তী 1গুলি হয়ে 1+1,1,1+1+এবং চূড়ান্ত চিহ্ন 1,তৈরীর1+1,1,1+1+1,যা (2,1,3)প্রয়োজন হিসাবে মূল্যায়ন ।

লক্ষ্য করুন trailing ,নিশ্চিত করে যে একটি একক দলের সঙ্গে একটি ইনপুট বরং একটি পূর্ণসংখ্যা চেয়ে tuple যেমন মূল্যায়ন করা হয় (যেমন [3,3]-> 1+1,-> (2)বদলে [3,3]-> 1+1-> 2)

— জোনাথন অ্যালান
সূত্র
1

কাস্তে , 8 বাইট

-1 বাইট @ জগারবকে ধন্যবাদ!

←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εসিঙ্গেলটন তালিকার সূচকের সন্ধানের জন্য একটি ছোট্ট চেক।
— Zgarb
1

জেলি , 10 বাইট

ŒgL€$ḊпL’

এটি অনলাইন চেষ্টা করুন!

— ডেনিস
সূত্র
এটি জন্য ব্যর্থ[1] । আপনি তার পরিবর্তে দুটি ডেকিউ / পপ ব্যবহার করে এটি ঠিক করতে সক্ষম হবেন_2
— মিস্টার এক্সকোডার
ÐĿপ্রথম জায়গায় ভাল পছন্দ ছিল না ... কিছুক্ষণ লুপ দিয়ে এটি প্রতিস্থাপন করা হয়েছিল।
— ডেনিস
1

ওল্ফ্রাম ভাষা (গণিত) , 32 বাইট

মার্টিন ইন্ডারকে ধন্যবাদ 2 বাইট সংরক্ষণ করা। সিপি-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)
  )
}
— ব্র্যাড গিলবার্ট বি 2 গিলস
সূত্র
0

Kotlin , 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
]
— গ্যালেন ইভানভ
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.