একটি অ্যারে, ডুপ্লিকেট গোষ্ঠী হিসাবে গণনা করুন

24

এই চ্যালেঞ্জের উদ্দেশ্য হ'ল ইতিবাচক পূর্ণসংখ্যার একটি অ্যারে নেওয়া, এবং সূচকগুলি উপাদানগুলির মতো গোষ্ঠীভুক্ত করা।

কোনও সদৃশ ছাড়াই একটি গণনা কেবল জোড়াগুলির একটি অ্যারে আউটপুট করে সম্পন্ন করা হয় (value, index), উদাহরণস্বরূপ, [3, 4, 13, 9, 2]=> [[3,1],[4,2],[13,3],[9,4],[2,5]]।

তবে প্রদত্ত উপাদানটি যদি দ্বিতীয়বার উপস্থিত হয় তবে এটি তার নিজস্ব জুটি দেওয়া হয় না, পরিবর্তে এটি তার প্রথম উপস্থিতির গোষ্ঠীতে যুক্ত করা হয়। আমাদের উপরোক্ত উদাহরণের যদি আমরা 3 9 প্রতিস্থাপিত, তারপর আউটপুটে আমরা মুছে ফেলা হবে [9,4]এবং প্রতিস্থাপন [3,1]সঙ্গে [3,1,4]।

আউটপুটে, গোষ্ঠীগুলি অবশ্যই তাদের প্রথম উপস্থিতি অনুসারে অর্ডার করতে হবে এবং সূচকগুলি অবশ্যই আরোহণের ক্রমে হবে। সূচকের আগে উপাদানটি অবশ্যই একটি গ্রুপে প্রথম হতে হবে। আউটপুট 0 বা 1 সূচকযুক্ত হতে পারে। আপনি ধরে নিতে পারেন অ্যারের কমপক্ষে একটি উপাদান রয়েছে।

পরীক্ষার কেস:

Input           | Output (One-indexed)
[3, 2, 2, 3]    | [[3, 1, 4], [2, 2, 3]]
[17]            | [[17, 1]]
[1, 1]          | [[1, 1, 2]]
[1, 1, 2]       | [[1, 1, 2], [2, 3]]
[1, 2, 3, 4]    | [[1, 1], [2, 2], [3, 3], [4, 4]]
[1, 1, 1, 1]    | [[1, 1, 2, 3, 4]]

এটি কোড-গল্ফ , সবচেয়ে কম বাইট জয়!

code-golf  array-manipulation 
— পাভেল
সূত্র
ইনডাইডস স্ট্রিং হিসাবে আউটপুট হিসাবে গ্রহণযোগ্য হবে, উদাহরণস্বরূপ [[17,"1"]]? (এখনও জানি না যে আমি কোনও বাইট সেভাবে সংরক্ষণ করতে পারি কিনা, এখনও এটি নিয়ে কাজ করছি!)
— শেগি
@ শেগি নিশ্চিত, ঠিক আছে
— পাভেল
3
— সম্পূর্ণমানুষ
1
আমরা কি এর [[3, [1, 4]], [2, [2, 3]]]পরিবর্তে কিছু আউটপুট করতে পারি ?
— কনর ও'ব্রায়ান
1
@ পাভেল যে কোনও কারণ নেই: পি তবে নিশ্চিত
— কনর ও'ব্রায়ান

উত্তর:

9

ডায়ালগ এপিএল, 5 বাইট

(⊂,)⌸

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

,⌸2 বাইটের জন্য প্রায় কাজ করে তবে এর পিছনে শূন্য রয়েছে: /

— dzaima
সূত্র
পৃথিবীতে ⌸কি করে?
— মিঃ এক্সকোডার
@ মিঃ এক্সকোডার প্রতিটি জিনিসের সূচী পান এবং বাম অপারেটরটিকে সেই জিনিসটি এবং সূচকগুলি উপস্থিত রয়েছে যেখানে এটি উপস্থিত রয়েছে
— জাইমা
যেহেতু ইস্যুটি ,⌸শূন্যগুলি অনুসরণ করছে, এবং শূন্যগুলি কখনই ইনপুটটিতে থাকবে না, তাই কি সমস্ত শূন্যগুলি 3 বাইটের চেয়ে কম রেখে দেওয়া সম্ভব হবে?
— পাভেল
@ পাভেল যে জিরো রয়েছে তার কারণ হ'ল ফলাফলটি একটি ম্যাট্রিক্স, যার সঠিক মাত্রা থাকতে হবে, সুতরাং কোনও বাইট লাভের জন্য শূন্যগুলি ফেলে দেওয়ার জন্য কেবল 1 বাইট রয়েছে। আমি মনে করি এটি যদিও গল্ফযোগ্য হতে পারে।
— dzaima
2
"অভিনব আফস" অ্যারের আউটপুট ফর্ম্যাট: এটি অনলাইনে চেষ্টা করুন!
— আদম
7

জে , 12 বাইট

~.,&.><@I.@=

শূন্য-ইন্ডেক্স।

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

আমি বাক্সগুলি দিয়ে যা করছি তার সমস্ত কাজ আপনি যদি সরিয়ে ফেলতে পারেন তবে আপনি সম্ভবত বাইকাউন্টটি কিছুটা কমিয়ে আনতে পারেন। আমি এটি দেখতে পাচ্ছি কিনা তা দেখতে যাচ্ছি।

ব্যাখ্যা

এটি সম্ভবত ব্যাখ্যা করা খুব তাড়াতাড়ি (আরও গল্ফ হওয়া উচিত)।

~. ,&.> <@I.@=
             =  Self-classify (comparison of each unique element to array)
            @   Composed with
          I.    Indices of ones (where it's equal)
         @      Composed with
        <       Boxed (how we deal with arrays of unequal length)
   ,&.>         Joined with
      >          Unbox each
   ,             Concatenate
    &.           Box again
~.              Unique elements
— কপি
সূত্র
2
সেই অ্যারের আউটপুট ফর্ম্যাটটি অভিনব
— আফগান পাভেল
@Pavel এটি অনেকটা Π.Π বাইট নিচ্ছে
— কোল
5

সংযুক্তি , 15 বাইট

Flat=>Positions

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

এটি =>অপারেটর ফর্মের একটি আকর্ষণীয় ঘটনা Map। যখন দুটি কার্যকরী আর্গুমেন্ট দেওয়া হয় fএবং g, Mapএকটি ফাংশন ফেরত f => g[x]দেয় x। অর্থাৎ, আরএইচএস ইনপুটটিতে প্রয়োগ করা হয়, তারপরে এলএইচএস ম্যাপ করা হয়।

অন্তর্নির্মিত Positionsসূচকগুলি দ্বারা প্রবেশের গোষ্ঠীকরণের প্রতিনিধিত্ব করে এমন একটি অ্যারে উত্পন্ন করে। ডিফল্টরূপে, যখন দ্বিতীয় আর্গুমেন্ট সরবরাহ করা হয় না, Positionsপ্রথম যুক্তি ব্যবহার করবে। Flatতারপরে প্রতিটি আইটেমের উপরে ম্যাপ করা হয়, যেমন প্রশ্নটি প্রয়োজন।

বিকল্প সমাধান

31 বাইট

MapArgs[Concat#~Indices,Unique]

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

একটি সুন্দর সংক্ষিপ্ত, বিল্টিন-কম বিকল্প less এটির MapArgsমতো একটি ফাংশন Map, আপনি এটিতে অতিরিক্ত যুক্তি খাওয়াতে ব্যতীত উদাহরণস্বরূপ, MapArgs[{_1 + _2}, 1..3, 3]হয় [4, 5, 6]। ভালো লেগেছে Map, এটা দুটি কার্মিক আর্গুমেন্ট সহ সরবরাহকৃত curried হয়ে যায়। ফাংশনটি ম্যাপ করা হবে Concat#~Indicesযা একটি কাঁটাচামচ। এই কাঁটাচামচটি ইনপুটটির Uniqueআইটেমগুলিতে এবং ইনপুট নিজেই প্রয়োগ করা হয়। এটি Concat[_, Indices[_2, _]]( Indicesঅদলবদল হওয়া যুক্তিগুলির সাথে ~) অনুবাদ করে, যা ইনপুট অ্যারেতে উল্লিখিত _উপাদানগুলির সূচকের সাথে উপাদানটি ম্যাপ করা হচ্ছে ( ) _যা _2জুড়ে দেওয়া হয় ( যা মাধ্যমে প্রবাহিত হয় MapArgs)।

43 বাইট

{Flat=>Zip[Unique[_],Indices[_,Unique[_]]]}

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

এটি # 1 এবং # 2 সমাধানগুলির সংশ্লেষ মাত্র একটি আরও ভার্বোজ (তবুও আরও বেশি পঠনযোগ্য) combination

— কনর ও ব্রায়ান
সূত্র
4

জেলি , 6 বাইট

Q;"ĠṢ$

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

ব্যাখ্যা:

Q;"ĠṢ$
Q      Keep the first occurrence of each element
     $ Last two links as a monad
   Ġ    Group indices of equal elements, then sort the resulting list of groups by the element they point to
    Ṣ   Sort; used to re-order the list of groups based on first occurrence instead
  "    Vectorize link between two arguments (the first occurrences and the group list)
 ;      Concatenate
— এরিক দ্য আউটগল্ফার
সূত্র
শেষ পরীক্ষার ক্ষেত্রে কাজ করে না । অ্যারেটি অন্য স্তরে নেস্ট করা উচিত, আউটপুটটি সর্বদাই দ্বিমাত্রিক।
— পাভেল
@ পাভেল হ্যাঁ এটি করে , আমি কেবল একটি ফুটার যুক্ত করতে ভুলে গেছি (উত্তরটি একটি ফাংশন)
— এরিক দ্য আউটগল্ফার
ঠিক আছে, তাহলে দুর্দান্ত। তাড়াতাড়ি ব্যাখ্যা, হ্যাঁ? : পি
— পাভেল
@ পাভেল ব্যাখ্যা যুক্ত করেছেন
— এরিক আউটগল্ফার
4

পাইথ , 7 বাইট

0-ইন্ডেক্স।

{+VQxRQ

এখানে চেষ্টা করুন! বিকল্প।

কিভাবে?

{+ ভিকিউএসআরকিউ - সম্পূর্ণ প্রোগ্রাম।

     আরকিউ - প্রতিটি উপাদান জন্য ...
    এক্স - এর সমস্ত সূচক পান।
 + ভি - এবং ভেক্টরাইজড কনটেনটেশন প্রয়োগ করুন।
   প্রশ্ন - ইনপুট সহ।
{- অনুলিপি।
— মিঃ এক্সকোডার
সূত্র
4

এমএটিএল , 8 বাইট

u"@tG=fh

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

ব্যাখ্যা

        # Implicitly get the input
u       # Compute the unique values
"       # For each unique value, N
  @     # Push the value N to the stack
  t     # Duplicate N
  G     # Grab the input
  =f    # Get the 1-based indices of the elements that equal N
  h     # Horizontally concatenate N with the indices
        # Implicitly display the result
— Suever
সূত্র
ওহোহু যে চালাক! আমার কাছে 18 টি বাইট ব্যবহার করার চেষ্টা ছিল &fতবে এটি কখনই কাজে লাগেনি ।
— জিউসেপ
3

আসলে , 24 বাইট

;;╗⌠╝╜r⌠╜E╛=⌡░⌡M@Z⌠♂i⌡M╔

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

ব্যাখ্যা:

;;╗⌠╝╜r⌠╜E╛=⌡░⌡M@Z⌠♂i⌡M╔
;;                        make two copies of input
  ╗                       save a copy to register 0
   ⌠╝╜r⌠╜E╛=⌡░⌡M          map over input:
    ╝                       save the element in register 1
     ╜r                     indices for input
       ⌠╜E╛=⌡░              filter:
        ╜E                    element in input at index
          ╛=                  equals element for outer map (from register 1)
                @Z        swap, zip input with map result
                  ⌠♂i⌡M   flatten each element in zipped list
                       ╔  uniquify
— ঐ মেগো
সূত্র
3

আর , 56 বাইট

function(x)lapply(unique(x),function(y)c(y,which(x==y)))

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

কোডগল্ফে এটি আমার প্রথম প্রচেষ্টা, সুতরাং কোনও প্রতিক্রিয়া স্বাগত!

— ফ্লোরিয়ান
সূত্র
3
পিপিসিজিতে আপনাকে স্বাগতম! ভাল উত্তর।
— পাভেল
1
ওহে ওখানে ফ্লোরিয়ান! খুব সুন্দর উত্তর। এটি আসলে কোনও প্রোগ্রাম বা ফাংশনের পরিবর্তে একটি স্নিপেট - এটি ধরে নেয় যে ইনপুটটি হার্ডকোডযুক্ত x, তবে ইনপুট পড়ার একটি উপায় থাকতে হবে - সাধারণত আমরা scanকোনও ফাংশন ব্যবহার করি বা সংজ্ঞায়িত করি। অতিরিক্তভাবে, এটির আউটপুট করতে হবে, তাই এটিকে একটি printবা একটিতে আবৃত করতে হবে cat।
— জিউসেপ
1
দেখতে এই প্রশ্নের আরো কুশলী আর golfing ঠাট জন্য :)
— : Giuseppe
1
ধন্যবাদ বন্ধুরা! আর আর টিপসের লিঙ্কটি অবশ্যই কার্যকর!
— ফ্লোরিয়ান
2
@ ফ্লোরিয়ান আর এতটা খারাপ নয় যতটা আপনি মনে করেন (স্ট্রিং চ্যালেঞ্জ বাদে ...) যতক্ষণ না আপনি মনে রাখবেন যে আপনি অন্য আর গল্ফারদের বিপক্ষে খেলছেন! আপনার যদি প্রশ্ন থাকে তবে নির্দ্বিধায় আমাকে আড্ডায় বেড়াতে দিন। সেখানে বেশ কয়েকজন আর গল্ফার রয়েছেন যারা সক্রিয় আছেন এবং তারা অবশ্যই পরামর্শগুলি দেবেন, এবং আপনার প্রশংসাও করবেন! গল্ফিংয়ে আপনাকে স্বাগতম :)
— জিউসেপ
3

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

মার্টিন ইন্ডারকে একটি বাইট ধন্যবাদ সংরক্ষণ করা।

KeyValueMap[{#,##&@@#2}&]@*PositionIndex

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

— alephalpha
সূত্র
কিভাবে @*PositionIndexকাজ করে?
— পাভেল
@ পাভেল @*হ'ল ফাংশনগুলির সংমিশ্রণ। PositionIndexমূলত সমস্ত কাজ করে তবে তালিকার পরিবর্তে একটি সমিতি প্রদান করে।
— আলেফাল্ফ
1
{#,##&@@#2}&একটি বাইট সংরক্ষণ করে।
— মার্টিন ইন্ডার
3

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

0 সূচকযুক্ত

a=>a.map((v,i)=>a[-v]?a[-v].push(i):a[-v]=[v,i]).filter(x=>x[0])

দ্রষ্টব্য, এই অনুমান হয় যে ইনপুট সংখ্যাগুলি ইতিবাচক হচ্ছে, সুতরাং v> 0

পরীক্ষার কেসগুলির সাথে মেলে টেস্টটি সামান্য পরিবর্তিত (1 ইনডেক্সড) 

var F=
a=>a.map((v,i)=>a[-v]?a[-v].push(i+1):a[-v]=[v,i+1]).filter(x=>x[0])

test = [ // output 1 indexed
  [3, 2, 2, 3],//    | [[3, 1, 4], [2, 2, 3]]
  [17], //           | [[17, 1]]
  [1, 1], //         | [[1, 1, 2]]
  [1, 1, 2], //      | [[1, 1, 2], [2, 3]]
  [1, 2, 3, 4], //   | [[1, 1], [2, 2], [3, 3], [4, 4]]
  [1, 1, 1, 1] //    | [[1, 1, 2, 3, 4]] 
]

test.forEach(t => {
  x = F(t)
  console.log(JSON.stringify(t)+ ' -> ' + JSON.stringify(x))
})
স্নিপেট প্রসারিত করুন

— edc65
সূত্র
3

এপিএল NARS, 24 বাইট, 12 টি অক্ষর

{∪⍵,¨⍸¨⍵=⊂⍵}

-4 বাইটস অ্যাডাম পরীক্ষার জন্য ধন্যবাদ:

  f←{∪⍵,¨⍸¨⍵=⊂⍵}

  ⎕fmt f 3 2 2 3
┌2────────────────┐
│┌3─────┐ ┌3─────┐│
││ 3 1 4│ │ 2 2 3││
│└~─────┘ └~─────┘2
└∊────────────────┘
  ⎕fmt f 17
┌1──────┐
│┌2────┐│
││ 17 1││
│└~────┘2
└∊──────┘
  ⎕fmt f 1 1
┌1───────┐
│┌3─────┐│
││ 1 1 2││
│└~─────┘2
└∊───────┘
  ⎕fmt f 1 2 3 4
┌4──────────────────────────┐
│┌2───┐ ┌2───┐ ┌2───┐ ┌2───┐│
││ 1 1│ │ 2 2│ │ 3 3│ │ 4 4││
│└~───┘ └~───┘ └~───┘ └~───┘2
└∊──────────────────────────┘
  ⎕fmt f 1 1 1 1
┌1───────────┐
│┌5─────────┐│
││ 1 1 2 3 4││
│└~─────────┘2
└∊───────────┘
— RosLuP
সূত্র
একটি 4 বাইট / 2 অক্ষর শেভ করুন:{∪⍵,¨⍸¨⍵=⊂⍵}
— অ্যাডাম
3

এসডাব্লুআই-প্রোলগ , 165 117 বাইট

-৪৪ বাইট প্রোলগ গল্ফিং টিপসকে ধন্যবাদ ।

h(I):-I+[]-1.
[H|T]+R-N:-(select([H|A],R,[H|L],S),!,append(A,[N],L);append(R,[[H,N]],S)),O is N+1,(T+S-O,!;write(S)).

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

ব্যাখ্যা

% The predicate that prints the grouped duplicates. It's a wrapper because we
% need some extra arguments to keep state:
enumerate_duplicates(Input) :- enumerate(Input, [], 1).

% In the golfed code, operators are used to represent this predicate.
% See /codegolf//a/153160
% Go through the input, build up the result on the way and print it.
enumerate([Head|Tail], Result, Index) :-
    (
        % If our current Result already contains a list that starts with the
        % current first element in our input, Head, NewIndexes will become the
        % new "tail" of that list in our next result list:
        select([Head|OldIndexes], Result, [Head|NewIndexes], NextResult),
        % Don't backtrack before this if goals below this fail:
        !,
        % The as-yet-unknown NewIndexes above should in fact be the same as
        % OldIndexes with our current Index appended:
        append(OldIndexes, [Index], NewIndexes)
    % Use ; instead of separate predicate rules.
    % See /codegolf//a/67032
    ;
        % If our current Result did not already contain Head, append a new list
        % for it with the current index:
        append(Result, [[Head, Index]], NextResult)
    ),
    % Increment our index counter:
    NextIndex is Index + 1,
    (
        % And continue with the rest of our input:
        enumerate(Tail, NextResult, NextIndex),
        % Don't backtrack if the above succeeded:
        !
    ;
        % If Tail is no longer a multi-element list, we're done. Print:
        write(NextResult)
    ).
— Mercator
সূত্র
3

কে (ওকে) , 10 বাইট

সমাধান:

(!x),'.x:=

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

উদাহরণ:

(!x),'.x:=,17
,17 0
(!x),'.x:=1 1
,1 1 2
(!x),'.x:=1 0 1
(1 1 2
2 3)
(!x),'.x:=1 2 3 4
(1 0
2 1
3 2
4 3)

ব্যাখ্যা:

মূল্যায়ন ডান থেকে বামে সঞ্চালিত হয়। আমি এখনও মনে করি এটি আরও গল্ফ-সক্ষম ...

(!x),'.x:= / the solution
         = / group input into dictionary, item!indices
       x:  / save as variable x
      .    / value of x (the indices)
    ,'     / concatenate (,) each-both (') with
(  )       / do this together
 !x        / the key of x (i.e. the items)

নোট:

  • 14 বাইট ঘোষণা না করে x, (,/)'+(!;.)@'=এই পদ্ধতির সাথে ছেড়ে দিলেন ...
— streetster
সূত্র
1
আপনি 0-সূচীত ফলাফলটি ফিরে আসতে পারেন, তাই আমি মনে করি আপনি এড়িয়ে যেতে পারেন 1+।
— অ্যাডাম
2

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

0-ইন্ডেক্স।

a=>a.map(p=(x,i)=>1/p[x]?b[p[x]].push(i):b.push([x,p[x]=i]),b=[])&&b

পরীক্ষার মামলা

কোড স্নিপেট দেখান

— Arnauld
সূত্র
ইনপুট নম্বরগুলি
— হ'ল
2

পিএইচপি 4.1, 88 বাইট

হ্যাঁ, এটি বেশ দীর্ঘ।

এটি একটি ডিফল্ট php.ini ফাইল ( short_open_tag = Onএবং register_globals = On) ধরে নেয় ।

<?foreach($A as$k=>$v){!$b[$v]&&$b[$v]=array($v);$b[$v][]=$k;}print_r(array_values($b));

এটি মানব-পঠনযোগ্য উপায়ে অ্যারে উপস্থাপন করে।
মানগুলি POST, GET এবং COOKIE দ্বারা কী "এ" এর অভ্যন্তরে প্রবেশ করা যায়।

আধুনিক সংস্করণের জন্য, কেউ (90 বাইট) ব্যবহার করতে পারেন:

<?foreach($_GET[A]as$k=>$v){if(!$b[$v])$b[$v]=[$v];$b[$v][]=$k;}print_r(array_values($b));

ফলাফলটি একই রকম, ব্যতীত সমস্ত মানগুলি কী "এ" এর মধ্যে জিইটি পরামিতিগুলির মধ্য দিয়ে যেতে হবে।

— ইসমাইল মিগুয়েল
সূত্র
2

পার্ল 6 ,  63  61 বাইট

*.pairs.classify(*.value).map({.key,|.value».key}).sort(*.[1])

এটি পরীক্ষা করুন (0-ভিত্তিক)

{sort *.[1],map {.key,|.value».key},classify *.value,.pairs}

এটি পরীক্ষা করুন (0 ভিত্তিক একই অ্যালগোরিদম)

সম্প্রসারিত:

# WhateverCode lambda (this is the parameter) 
*\                                            # [3,2,2,3]

# get a list of Pairs (zero based index => value)
.pairs                                        # (0=>3,1=>2,2=>2,3=>3)

# classify based on the values (unordered result)
.classify(*.value)                            # {2=>[1=>2,2=>2],3=>[0=>3,3=>3]}

# simplify the structure
.map({
  .key,         # the value
  |.value».key  # slip in the indexes
})                                            # ((3,0,3),(2,1,2))

# sort based on first index
.sort(*.[1])
— ব্র্যাড গিলবার্ট বি 2 গিলস
সূত্র
2

পিএইচপি 7.4+ , 71 বাইট

* $_GETকীটি উদ্ধৃত করতে এবং সতর্কতা এড়াতে 73 বাইট ।

স্নিপেট: ( ডেমো )

<?foreach($_GET[A]as$k=>$v){$b[$v][0]=$v;$b[$v][]=$k;}print_r([...$b]);

প্রতিনিধির উপর ভিত্তি করে, আমি ধরে নিই যে ইসমাইল মিগুয়েল এই সম্প্রদায়ে পিএইচপি কোড পোস্ট করার সবচেয়ে ভাল উপায় জানেন তাই আমি তার ভিত্তি থেকে তৈরি করছি । আমার স্নিপেটে অন্তর্ভুক্ত / গণনা করা উচিত কিনা <?তা আমার কাছে পরিষ্কার নয় । এটি আমার প্রথম পোস্ট হিসাবে যেহেতু কোনও অপ্রয়োজনীয় বাক্য গঠন আছে কিনা তা ব্যাখ্যা করতে আমি যেহেতু খুশি। PS আমি পিএইচপি-তে গল্ফ করার টিপসও পড়েছি যা মেটায় স্থানান্তরিত করার জন্য ভয়ঙ্কর প্রার্থীর মতো বলে মনে হয় ।

ইসমাইল স্নিপেটে উন্নতিগুলি হ'ল:

  1. প্রতিটি সুবারে প্রথম উপাদানটির শর্তযুক্ত অ্যাসাইনমেন্ট (মান ওভাররাইটিং)
  2. আউটপুটটিকে পুনরায় সূচি দেওয়ার পরিবর্তেarray_values() স্প্ল্যাটপ্যাকিং।
— mickmackusa
সূত্র
1

কোটলিন , 83 বাইট

{it.mapIndexed{i,c->c to i}.groupBy({(a,b)->a},{(a,b)->b}).map{(a,b)->listOf(a)+b}}

শোভিত

{
    it.mapIndexed { i, c -> c to i }
        .groupBy({ (a, b) -> a }, { (a, b) -> b })
        .map { (a, b) -> listOf(a) + b }
}

পরীক্ষা

var f: (List<Int>) -> List<List<Int>> =
{it.mapIndexed{i,c->c to i}.groupBy({(a,b)->a},{(a,b)->b}).map{(a,b)->listOf(a)+b}}

data class Test(val input: List<Int>, val output: List<List<Int>>)

val tests = listOf(
        Test(listOf(3, 2, 2, 3), listOf(listOf(3, 0, 3), listOf(2, 1, 2))),
        Test(listOf(17), listOf(listOf(17, 0))),
        Test(listOf(1, 1), listOf(listOf(1, 0, 1))),
        Test(listOf(1, 1, 2), listOf(listOf(1, 0, 1), listOf(2, 2))),
        Test(listOf(1, 2, 3, 4), listOf(listOf(1, 0), listOf(2, 1), listOf(3, 2), listOf(4, 3))),
        Test(listOf(1, 1, 1, 1), listOf(listOf(1, 0, 1, 2, 3)))
)

fun main(args: Array<String>) {
    for (c in tests) {
        val o = f(c.input)
        if (o != c.output) {
            throw AssertionError("${c.input} -> $o != ${c.output}")
        }
    }
}

Tio

TryItOnline

— jrtapsell
সূত্র
এই সমাধানটি একটি স্নিপেট, সম্পূর্ণ ফাংশন বা প্রোগ্রাম নয়। এর পরিবর্তনশীলটিকে iপূর্বনির্ধারিত করা দরকার। আপনি প্যারামিটার লাগে এমন একটি ল্যাম্বডায় রূপান্তর করে এটি বৈধ করতে পারেন i।
— পাভেল
@ পাভেল উত্থাপিত ইস্যু সমাধানের জন্য পুনরায় কাজ করেছেন
— jrtapsell
1

সুইফট 4, 107 বাইট

... হায়।

{a in Dictionary(grouping:a.enumerated()){$0.1}.sorted{$0.1.first!.0<$1.1.first!.0}.map{[$0]+$1.flatMap{$0.0}}}

Ungolfed:

let f = { (input: [Int]) -> [[Int]] in
    return Dictionary(grouping: input.enumerated(), by: { $0.element })
        .sorted { pairA, pairB in // Sort by order of first appearence (lowest offset)
            return pairA.value.first!.offset < pairB.value.first!.offset
        }.map { element, pairs in
            return [element] + pairs.map{ $0.offset /* +1 */} // add 1 here for 1 based indexing
        }
}

এটি খুব খারাপ যে অভিধানটি অর্ডার হারায়, আমাকে আবার সাজানোর ক্ষেত্রে অনেকগুলি অক্ষর নষ্ট করতে বাধ্য করে। অন্তর্নিহিত অবসান আর্গুমেন্ট অপব্যবহার (এই ধরনের $0, $1এবং অন্তর্নিহিত tuple সদস্য, ...) ( .0, .1, ...) সুন্দর না uhhhhh হয়।

— আলেকজান্ডার - মনিকা পুনরায় স্থাপন করুন
সূত্র
1

রুবি , 54 52 বাইট

->a{a.map{|i|[i]+(0..a.size).select{|j|a[j]==i}}|[]}

এই সংস্করণ শূন্য (53 বাইট) অনুমতি দেয়:

->a{a.map{|i|[i]+(0...a.size).select{|j|a[j]==i}}|[]}

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

— আসোন তুহিদ
সূত্র
চ্যালেঞ্জটি অ্যারেটি কেবল ধনাত্মক পূর্ণসংখ্যার সমন্বয়ে নির্দিষ্ট করে এবং কমপক্ষে একটি উপাদান থাকবে। nilধনাত্মক পূর্ণসংখ্যা নয়।
— পাভেল
@ পাভেল ধন্যবাদ, আমি পরীক্ষা করে দেখেছি তবে এটি কোনওভাবেই মিস করেছি
— অসোন তুহিদ
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.