24

इस चुनौती का उद्देश्य सकारात्मक पूर्णांकों की एक सरणी लेना है, और तत्वों की तरह समूहीकरण करते हुए, अपने सूचकांकों की गणना करना है।

किसी डुप्लिकेट के बिना एक गणना केवल जोड़े की एक सरणी का उत्पादन करके किया जाता है (value, index), उदाहरण के लिए, [3, 4, 13, 9, 2]=> [[3,1],[4,2],[13,3],[9,4],[2,5]]।

हालाँकि, यदि कोई दिया गया तत्व दूसरी बार दिखाई देता है, तो उसे अपनी जोड़ी नहीं दी जाती है, बल्कि इसकी पहली घटना के समूह में जोड़ा जाता है। यदि हमारे उपरोक्त उदाहरण में हमने 9 को 3 के साथ बदल दिया है, तो आउटपुट में हम हटा देंगे [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

@Pavel इसका कोई कारण नहीं है: p लेकिन निश्चित है

— कॉनर ओ'ब्रायन

9

Dyalog एपीएल, 5 बाइट्स

(⊂,)⌸

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

,⌸2 बाइट्स के लिए लगभग काम करता है, लेकिन अनुगामी शून्य है: /

— dzaima
स्रोत

दुनिया में क्या करता ⌸है?

— श्री एक्सकोडर

@ Mr.Xcoder को प्रत्येक चीज़ का इंडेक्स मिलता है और बाएं ऑपरेटर को उस चीज़ और सूचक के साथ कॉल करता है जहां यह मौजूद है

— dzaima

चूंकि isue के साथ ,⌸शून्य चल रहा है, और शून्य इनपुट में कभी नहीं होगा, क्या 3 शून्य से कम में सभी शून्य को गिराना संभव होगा?

— पावेल

@ कारण यह है कि वहाँ शून्य हैं परिणाम एक मैट्रिक्स है, जिसमें सटीक आयाम हैं, इसलिए किसी भी बाइट लाभ के लिए शून्य को छोड़ने के लिए केवल 1 बाइट है। मुझे लगता है कि यह भले ही गोल्फ हो सकता है।

— द्विजिमा

2

"फैंसी af" सरणी आउटपुट स्वरूप: इसे ऑनलाइन आज़माएं!

— आदम

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

यह सरणी आउटपुट फॉर्मेट फैंसी है

— पावेल

@ फावल यह भी बहुत सारे बाइट्स ले रहा है Jan. '

— कोल

5

05AB1E , 10 बाइट्स

ÙεDIQƶ0K)˜

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

व्याख्या

Ù             # remove duplicates
 ε            # apply to each element
  D           # duplicate
   IQ         # compare for equality with input
     ƶ        # multiply each element by its index (1-based)
      0K      # remove zeroes
        )˜    # wrap in a flattened list

— Emigna
स्रोत

5

पायथन 3 , 83 82 बाइट्स

^{मीगो को -1 बाइट}

lambda x:[[n]+[j for j,m in enumerate(x)if m==n]for n in sorted({*x},key=x.index)]

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

— छड़ी
स्रोत

1

j+1-> j(सूचकांक शून्य-अनुक्रमित हो सकता है)

— मेगो

5

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

import Data.List
f l=nub[k:elemIndices k l|k<-l]

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

— totallyhuman
स्रोत

5

अटैची , 15 बाइट्स

Flat=>Positions

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

यह एक दिलचस्प मामला है =>, ऑपरेटर के रूप का Map। जब दो कार्यात्मक तर्क दिए जाते हैं fऔर g, Mapएक फ़ंक्शन f => g[x]को वापस कर देता हैx । यही है, आरएचएस इनपुट पर लागू होता है, फिर एलएचएस मैप किया जाता है।

बिलिन Positionsसूचकांकों द्वारा प्रविष्टियों के समूहन का प्रतिनिधित्व करने वाला एक सरणी उत्पन्न करता है। डिफ़ॉल्ट रूप से, जब दूसरे तर्क के साथ आपूर्ति नहीं की जाती है, Positionsतो पहले तर्क का उपयोग करेंगे। Flatतब प्रत्येक आइटम पर मैप किया जाता है, क्योंकि प्रश्न की आवश्यकता होती है।

वैकल्पिक समाधान

31 बाइट्स

MapArgs[Concat#~Indices,Unique]

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

बहुत छोटा, बिलिन-कम वैकल्पिक। MapArgsएक ऐसा कार्य है Map, जिसे छोड़कर आप इसमें अतिरिक्त तर्क दे सकते हैं। उदाहरण के लिए, MapArgs[{_1 + _2}, 1..3, 3]है [4, 5, 6]। जैसे Map, दो क्रियात्मक तर्कों के साथ आपूर्ति किए जाने पर यह रूखा हो जाता है। फ़ंक्शन मैप किया गया है Concat#~Indices, जो एक कांटा है। यह कांटा Uniqueइनपुट के आइटम और इनपुट पर ही लागू होता है। यह इनपुट सरणी में उक्त तत्व के सूचकांकों के साथ जोड़े गए तत्व ( ) के माध्यम Concat[_, Indices[_2, _]]से Indicesअदला-बदली के तर्कों के साथ अनुवाद करता है, जो (के रूप में ffed है)~___2MapArgs )।

43 बाइट्स

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

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

यह वास्तव में समाधान # 1 और # 2 का संयोजन है।

— कोनोर ओ ब्रायन
स्रोत

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

यहाँ कोशिश करो! वैकल्पिक।

कैसे?

{+ VQxRQ - पूर्ण कार्यक्रम।

     RQ - प्रत्येक तत्व के लिए ...
    x - इसके सभी सूचकांक प्राप्त करें।
 + V - और सदिश संघनन लागू करें।
   क्यू - इनपुट के साथ।
{- डेडुप्लिकेट।

— मिस्टर एक्सकोडर
स्रोत

4

MATL , 8 बाइट्स

u"@tG=fh

इसे MATL ऑनलाइन पर आज़माएं

व्याख्या

        # 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
स्रोत

ooooohhh कि चालाक है! मुझे 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

PPCG में आपका स्वागत है! अच्छा पहला जवाब।

— पावेल

1

अरे वहाँ फ्लोरियन! बहुत अच्छा जवाब। यह वास्तव में एक प्रोग्राम या फ़ंक्शन के बजाय एक स्निपेट है - यह मानता है कि इनपुट में हार्डकोड किया गया है x, लेकिन इनपुट पढ़ने का एक तरीका है - आमतौर पर हम scanएक फ़ंक्शन का उपयोग करते हैं या परिभाषित करते हैं। इसके अतिरिक्त, इसे आउटपुट करना है, इसलिए इसे एक printया एक में लपेटना होगा cat।

— ग्यूसेप

1

अधिक आसान आर गोल्फ चाल के लिए इस सवाल को देखें :)

— Giuseppe

1

धन्यवाद दोस्तों! और आर टिप्स का लिंक निश्चित रूप से उपयोगी है!

— फ्लोरियन

2

@Florian R इतना बुरा नहीं है जितना आप सोचते हैं (स्ट्रिंग चुनौतियों को छोड़कर ...) जब तक आपको याद है कि आप अन्य R गोल्फरों के खिलाफ गोल्फ खेल रहे हैं! यदि आपके कोई प्रश्न हों तो मुझे चैट में बेझिझक पिंग करें। आर गोल्फर्स की एक जोड़ी है जो सक्रिय हैं, और वे निश्चित रूप से सुझाव देंगे, और आपकी सराहना करेंगे! गोल्फिंग में आपका स्वागत है :)

— Giuseppe

3

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

मार्टिन एंडर को एक बाइट धन्यवाद दिया।

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

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

— alephalpha
स्रोत

कैसे @*PositionIndexकाम करता है ?

— पावेल

@ फावल @*कार्यों की संरचना है। PositionIndexमूल रूप से सभी काम करता है, लेकिन एक सूची के बजाय एक संघ देता है।

— एलेफाल्फा

1

{#,##&@@#2}&एक बाइट बचाता है।

— मार्टिन एंडर

3

जावास्क्रिप्ट (ईएस 6), 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

एपीएल नार, 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 शेव शेव करें:{∪⍵,¨⍸¨⍵=⊂⍵}

— Adám

3

एसडब्ल्यूआई-प्रोलॉग , 165 117 बाइट्स

-48 बाइट्स प्रोलॉग गोल्फिंग टिप्स के लिए धन्यवाद ।

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)
    ).

— मर्केटर
स्रोत

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

जूलिया ०.६ , 37 बाइट्स

1 बाइट के लिए पावेल को धन्यवाद।

y->[[x;findin(y,[x])]for x=unique(y)]

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

— gggg
स्रोत

-1 बाइट के बीच ]और उसके forलिए जगह निकालें ।

— पावेल

2

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

0 अनुक्रमित।

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

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

कोड स्निपेट दिखाएं

let f =

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

console.log(JSON.stringify(f([3, 4, 13, 9, 2]))) // [[3,0],[4,1],[13,2],[9,3],[2,4]]
console.log(JSON.stringify(f([3, 4, 13, 3, 2]))) // [[3,0,3],[4,1],[13,2],[2,4]]
console.log(JSON.stringify(f([3, 2, 2, 3]    ))) // [[3,0,3],[2,1,2]]
console.log(JSON.stringify(f([17]            ))) // [[17,0]]
console.log(JSON.stringify(f([1, 1]          ))) // [[1,0,1]]
console.log(JSON.stringify(f([1, 1, 2]       ))) // [[1,0,1],[2,2]]
console.log(JSON.stringify(f([1, 2, 3, 4]    ))) // [[1,0],[2,1],[3,2],[4,3]]
console.log(JSON.stringify(f([1, 1, 1, 1]    ))) // [[1,0,1,2,3]]

स्निपेट का विस्तार करें

— Arnauld
स्रोत

इनपुट नंबर हैं! = 0, जो 1 / x चाल से बचने के लिए उपयोगी हो सकता है

— edc65

2

PHP 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));

यह सरणी को मानव-पठनीय तरीके से प्रस्तुत करता है।
मूल्यों को प्रमुख "ए" के अंदर, पोस्ट, जीईटी और कूकी द्वारा पारित किया जा सकता है।

एक आधुनिक संस्करण के लिए, कोई भी (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])

— ब्रैड गिल्बर्ट b2gills
स्रोत

2

जाप , १४ 9 बाइट्स

0 अनुक्रमित।

â £ð¶X iX

कोशिश करो

â £ð¶X iX
â             :Deduplicate
  £           :Map each X
   ð          :  Get 0-based indices of elements in the input
    ¶X        :    That are equal to X
       iX     :  Prepend X

— झबरा
स्रोत

2

PHP 7.4+ , 71 बाइट्स

* 73 बाइट्स को कोट करने के लिए $_GET कुंजी और चेतावनियों से बचने के लिए।

स्निपेट: ( डेमो )

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

प्रतिनिधि के आधार पर, मुझे लगता है कि इस्माइल मिगेल इस समुदाय में php कोड पोस्ट करने का सबसे अच्छा तरीका जानता है इसलिए मैं उसकी नींव से निर्माण कर रहा हूं । यह मेरे लिए स्पष्ट नहीं है कि क्या <?मेरे स्निपेट में शामिल / गिना जाना है । के रूप में यह मेरी पहली पोस्ट है, मैं किसी को भी समझाने के लिए खुश हूँ अगर कोई अनावश्यक वाक्यविन्यास है। ps मैंने पीएचपी में गोल्फिंग के लिए टिप्स भी पढ़े जो मुझे मेटा में माइग्रेशन के लिए एक शानदार उम्मीदवार की तरह लगते हैं ।

इस्माईल के स्निपेट में किए गए सुधार हैं:

प्रत्येक तत्व में पहले तत्व का बिना शर्त असाइनमेंट (मूल्य अधिलेखित)
array_values()आउटपुट को फिर से जोड़ने के बजाय स्प्लैटपैकिंग ।

— mickmackusa
स्रोत

1

स्वच्छ , 61 60 बाइट्स

import StdEnv,StdLib
$l=removeDup[[e:elemIndices e l]\\e<-l]

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

आउटपुट 0-अनुक्रमित है

— Οurous
स्रोत

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।

— पावेल

@Pavel

— 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और अंतर्निहित टपल के सदस्यों, ...) ( .0, .1, ...) सुंदर नहीं uhhhhh है।

— अलेक्जेंडर - मोनिका को बहाल करें
स्रोत

1

पर्ल 5 , 63 + 1 ( `-a`) = 64 बाइट्स

map$k{$_}.=$".++$i,@F;say$_.$k{$_}for sort{$k{$a}-$k{$b}}keys%k

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

— Xcali
स्रोत

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एक सकारात्मक पूर्णांक नहीं है।

— पावेल

@ फेयर धन्यवाद, मैंने जाँच की लेकिन किसी तरह चूक गया

— आसून तुहिद

डुप्लिकेट को समूहीकृत करते हुए एक सरणी की गणना करें

Dyalog एपीएल, 5 बाइट्स

जे , 12 बाइट्स

व्याख्या

05AB1E , 10 बाइट्स

पायथन 3 , 83 82 बाइट्स

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

अटैची , 15 बाइट्स

वैकल्पिक समाधान

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

अजगर , 7 बाइट्स

कैसे?

MATL , 8 बाइट्स

दरअसल , 24 बाइट्स

आर , 56 बाइट्स

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

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

एपीएल नार, 24 बाइट्स, 12 चार्ट

एसडब्ल्यूआई-प्रोलॉग , 165 117 बाइट्स

व्याख्या

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

जूलिया ०.६ , 37 बाइट्स

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

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

PHP 4.1, 88 बाइट्स

पर्ल 6 , 63 61 बाइट्स

विस्तारित:

जाप , १४ 9 बाइट्स

PHP 7.4+ , 71 बाइट्स

स्वच्छ , 61 60 बाइट्स

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

सजा हुआ

परीक्षा

TIO

स्विफ्ट 4, 107 बाइट्स

पर्ल 5 , 63 + 1 ( -a) = 64 बाइट्स

रूबी , 54 52 बाइट्स

पर्ल 5 , 63 + 1 ( `-a`) = 64 बाइट्स