समान संख्याओं की प्रत्येक श्रृंखला को इन-प्लेस में सम्मिलित करें

27

सख्ती से सकारात्मक पूर्णांक की एक सूची को देखते हुए, प्रत्येक अलग संख्या के माध्यम से जाएं और इसके सभी घटनाओं को एक नई श्रृंखला के क्रमिक सूचकांकों (शून्य या एक आधारित) के साथ बदलें।

उदाहरण

[]→ []/[]

[42]→ [0]/[1]

[7,7,7]→ [0,1,2]/[1,2,3]

[10,20,30]→ [0,0,0]/[1,1,1]

[5,12,10,12,12,10]→ [0,0,0,1,2,1]/[1,1,1,2,3,2]

[2,7,1,8,2,8,1,8,2,8]→ [0,0,0,0,1,1,1,2,2,3]/[1,1,1,1,2,2,2,3,3,4]

[3,1,4,1,5,9,2,6,5,3,5,9]→ [0,0,0,1,0,0,0,0,1,1,2,1]/[1,1,1,2,1,1,1,1,2,2,3,2]

code-golf  number  integer  sorting  substitution 
— एडम
स्रोत
2
तो मूल रूप से यह अब तक अनुक्रम कितनी बार दिखाई दिया है?
— जो राजा
1
@JoKing हाँ, यह इसे बताने का एक और तरीका है, लेकिन "अब तक" का अर्थ शून्य-आधारित है, और "जब तक और इसमें शामिल है" का अर्थ है एक-आधारित। मैं चुनाव को बनाए रखना चाहता था।
— आदम

जवाबों:

23

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

1 अनुक्रमित।

a=>a.map(o=x=>o[x]=-~o[x])

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

टिप्पणी की गई

a =>                // a[] = input array
  a.map(o =         // assign the callback function of map() to the variable o, so that
                    // we have an object that can be used to store the counters
    x =>            // for each value x in a[]:
      o[x] = -~o[x] //   increment o[x] and yield the result
                    //   the '-~' syntax allows to go from undefined to 1
  )                 // end of map()
— Arnauld
स्रोत
1
मुझे नहीं पता कि यह कैसे काम करता है, लेकिन यह निश्चित रूप से सुरुचिपूर्ण दिखता है।
— आदम
मैंने पहले नहीं देखा है -~- वह एक पूर्ण रत्न है।
— डेवमॉन्गोज
वैकल्पिक रूप से, यह उपयोग करना संभव है aमान संग्रहीत करने के लिए है, लेकिन यह करने के लिए आवश्यक है -/ ~इसलिए कोई बाइट सहेजा जाता है सूचकांक।
— user202729
— user202729
1
@DaveMongoose -~वास्तव +1में कई भाषाओं में आमतौर पर इस्तेमाल किया जाने वाला विकल्प है (क्योंकि इसकी अलग-अलग मिसाल है)
— ASCII-only
10

आर , 27 बाइट्स

function(x)ave(x,x,FUN=seq)

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

स्पष्टीकरण:

ave(x,x,FUN=seq)समूहन कुंजियों के xमानों का उपयोग करके वेक्टर को उप-वैक्टर में विभाजित करता है x। फिर seqफ़ंक्शन को प्रत्येक समूह के लिए कहा जाता है और प्रत्येक परिणाम को मूल समूह स्थिति में वापस व्यवस्थित किया जाता है।

बेहतर एक उदाहरण देखें:

x <- c(5,7,5,5,7,6)
ave(x, x, FUN=seq) # returns 1,1,2,3,2


 ┌───┬───┬───┬───┬───┐
 │ 5 │ 7 │ 5 │ 5 │ 7 │
 └───┴───┴───┴───┴───┘            
   |   |   |    |  |     
   ▼   |   ▼    ▼  |
 GROUP A : seq(c(5,5,5)) = c(1,2,3)
   |   |   |    |  |     
   ▼   |   ▼    ▼  |
 ┌───┐ | ┌───┬───┐ |
 │ 1 │ | │ 2 │ 3 │ |
 └───┘ | └───┴───┘ |
       ▼           ▼
 GROUP B : seq(c(7,7)) = c(1,2)
       |           |
       ▼           ▼
     ┌───┐       ┌───┐
     │ 1 │       │ 2 │
     └───┘       └───┘ 

   |   |   |   |   |
   ▼   ▼   ▼   ▼   ▼ 
 ┌───┬───┬───┬───┬───┐
 │ 1 │ 1 │ 2 │ 3 │ 2 │
 └───┴───┴───┴───┴───┘

ध्यान दें :

seq(y)फ़ंक्शन के पास कोई अनुक्रम 1:length(y)होता yहै length(y) > 1, लेकिन 1:y[1]यदि कोई yकेवल एक तत्व होता है , तो वह अनुक्रम लौटाता है ।
यह सौभाग्य से कोई समस्या नहीं है क्योंकि उस मामले में आर - बहुत चेतावनियों के साथ शिकायत करना - केवल पहले मूल्य का चयन करता है जो संयोग से वही है जो हम चाहते हैं :)

— digEmAll
स्रोत
2
प्रतिभाशाली! मैं इसके लिए एक इनाम जोड़ूंगा। aveपहले कभी नहीं देखा ।
— ग्यूसेप
मैं सम्मानित हुआ, बहुत बहुत धन्यवाद! :)
— digEmAll
6

MATL , 4 बाइट्स

&=Rs

यह समाधान 1-आधारित है

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

व्याख्या

[1,2,3,2]उदाहरण के रूप में उपयोग करता है

    # Implicitly grab the input array of length N
    #
    #   [1,2,3,2]
    #
&=  # Create an N x N boolean matrix by performing an element-wise comparison
    # between the original array and its transpose:
    #
    #     1 2 3 2
    #     -------
    # 1 | 1 0 0 0
    # 2 | 0 1 0 1
    # 3 | 0 0 1 0
    # 2 | 0 1 0 1
    #
R   # Take the upper-triangular portion of this matrix (sets below-diagonal to 0)
    #
    #   [1 0 0 0
    #    0 1 0 1
    #    0 0 1 0
    #    0 0 0 1]
    #
s   # Compute the sum down the columns
    #
    #   [1,1,1,2]
    #
    # Implicitly display the result
— Suever
स्रोत
2
आह, मुझे पता था कि एक पुरानी समस्या थी जो मुझे कुछ इसी तरह के बारे में सोचती थी, यह अद्वितीय है सस्ता है, और MATL समाधान एक चरित्र अलग है!
— Giuseppe
5

एपीएल (डायलॉग यूनिकोड) , 7 बाइट्स

कई, H.PWiz, Adám और dzaima के लिए बहुत धन्यवाद उनकी सभी डिबगिंग में मदद करने और इसे ठीक करने के लिए।

+/¨⊢=,\

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

व्याख्या

10-बाइट गैर-टैसिट संस्करण को पहले समझाना आसान होगा

{+/¨⍵=,\⍵}

{         } A user-defined function, a dfn
      ,\⍵  The list of prefixes of our input list ⍵
           (⍵ more generally means the right argument of a dfn)
           \ is 'scan' which both gives us our prefixes 
           and applies ,/ over each prefix, which keeps each prefix as-is
    ⍵=     Checks each element of ⍵ against its corresponding prefix
           This checks each prefix for occurrences of the last element of that prefix
           This gives us several lists of 0s and 1s
 +/¨       This sums over each list of 0s and 1s to give us the enumeration we are looking for

टैसिट संस्करण तीन चीजें करता है

  • सबसे पहले, यह के कहने को हटा ⍵में प्रयोग किया जाता ,\⍵के रूप में ,\अपने आप में सही परोक्ष पता लगा सकते हैं कि यह सही तर्क पर संचालित करने के लिए चाहिए था पर।
  • दूसरा, के लिए ⍵=, हम के ⍵साथ प्रतिस्थापित करते हैं ⊢, जो सही तर्क के लिए खड़ा है
  • तीसरा, अब जब हमारे पास कोई स्पष्ट तर्क नहीं है (इस मामले में ⍵), हम ब्रेस {}को हटा सकते हैं क्योंकि टैसीट फ़ंक्शन इनका उपयोग नहीं करते हैं
— Sherlock9
स्रोत
5

AWK , 14

  • 1 बाइट ने @NahuelFouilleul को धन्यवाद दिया
{print++a[$1]}

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

उपरोक्त एक-आधारित अनुक्रमण करता है। यदि आप शून्य-आधारित अनुक्रमण को प्राथमिकता देते हैं, तो यह एक अतिरिक्त बाइट है:

{print a[$1]++}

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

— डिजिटल आघात
स्रोत
1
ध्यान दें कि दूसरा {print++a[$1]}अंतरिक्ष के बिना एक बाइट को बचा सकता है
— नहुएल फौलीउल
@NahuelFouilleul धन्यवाद!
— डिजिटल ट्रामा
5

जे , 7 बाइट्स

1#.]=]\

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

1 अनुक्रमित।

स्पष्टीकरण:

]\ all the prefixes (filled with zeros, but there won't be any 0s in the input):
   ]\ 5 12 10 12 12 10
5  0  0  0  0  0
5 12  0  0  0  0
5 12 10  0  0  0
5 12 10 12  0  0
5 12 10 12 12  0
5 12 10 12 12 10

]= is each number from the input equal to the prefix:
   (]=]\) 5 12 10 12 12 10
1 0 0 0 0 0
0 1 0 0 0 0
0 0 1 0 0 0
0 1 0 1 0 0
0 1 0 1 1 0
0 0 1 0 0 1

1#. sum each row:
   (1#.]=]\) 5 12 10 12 12 10
1 1 1 2 3 2

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

Ngn के लिए -1 बाइट धन्यवाद!

{+/'x=,\x}

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

— गैलेन इवानोव
स्रोत
1
हे, तुम खुश हो कि मैंने डेटा को सख्ती से सकारात्मक बना दिया है ...
— Adám
@ Adám हां, अन्यथा मुझे उपसर्गों को बॉक्स करने की आवश्यकता होगी :)
— गैलन इवानोव
1
में k: ='->=
— ngn
3

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 44 बाइट्स

x=>x.Select((y,i)=>x.Take(i).Count(z=>z==y))

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

— दाना
स्रोत
— LiefdeWen
आपके पास अभी चुनौती का उलटा है .. [7,7,7]आउटपुट होना चाहिए [0,1,2], और नहीं [0,0,0]।
— केविन क्रूज़सेन
1
@ केविनक्रूजसेन - धन्यवाद :) मुझे लगता है कि मैं गलत चीजों को देखता हूं, इसे अब ठीक किया जाना चाहिए।
— दाना
2

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

ċṪ$Ƥ

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

इनपुट सूची के प्रत्येक उपसर्ग के लिए, यह अपने अंतिम तत्व की घटनाओं की संख्या को स्वयं में गिनता है।

— श्री एक्सकोडर
स्रोत
वैकल्पिक रूप से पुराना स्कूल ;\ċ"भी 4. है
— जोनाथन एलन
2

आर , 41 बाइट्स

function(x)diag(diffinv(outer(x,x,"==")))

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

विचित्र रूप से, शून्य-आधारित इंडेक्स वापस करना आर में छोटा है।

— ग्यूसेप
स्रोत
एक बार फिर Giuseppe, R के आपके बेहतर ज्ञान ने मुझे हरा दिया है। मेरे पास 60 बाइट्स में एक शालीनतापूर्वक सरल तरीका था, लेकिन अफसोस, यह पर्याप्त नहीं था!
— सुमेर १18
@ Sumner18 इसे वैसे भी पोस्ट करें! मैं हमेशा अन्य लोगों के दृष्टिकोण से बहुत कुछ सीखता हूं, और प्रतिक्रिया प्राप्त करना सीखने का सबसे तेज़ तरीका है!
— गिउसेप्पे
प्रोत्साहित करने के लिए धन्यवाद! मैंने अभी अपना पोस्ट किया है और हमेशा सुधार के लिए सुझाव के लिए खुला हूँ!
— सुमेर १18
2

रूबी, 35 बाइट्स

->a{f=Hash.new 0;a.map{|v|f[v]+=1}}

यह सुंदर सांसारिक है, दुर्भाग्य से - एक हैश का निर्माण करें जो अब तक सामने आई प्रत्येक प्रविष्टि के लिए कुल संग्रहीत करता है।

कुछ अन्य, मजेदार विकल्प जो दुर्भाग्य से काफी कम नहीं थे:

->a{a.dup.map{a.count a.pop}.reverse}   # 37
->a{i=-1;a.map{|v|a[0..i+=1].count v}}  # 38
— DaveMongoose
स्रोत
2

आर , 62 43 बाइट्स

x=z=scan();for(i in x)z[y]=1:sum(y<-x==i);z

-19 बाइट्स, ग्यूसेप के लिए धन्यवाद, जिसे हटाकर, और तालिका, और केवल कार्यान्वयन में मामूली परिवर्तन

मूल

x=z=scan();for(i in names(r<-table(x)))z[which(x==i)]=1:r[i];z

मैं ग्यूसेप के ज्ञान के साथ प्रतिस्पर्धा नहीं कर सकता, इसलिए मेरा प्रस्तुतिकरण उसकी तुलना में कुछ लंबा है, लेकिन अपने मूल ज्ञान का उपयोग करते हुए, मुझे लगा कि यह समाधान बल्कि सरल था।

r<-table(x) प्रत्येक संख्या दिखाई देने वाली संख्या को गिनती है और भविष्य में संदर्भ के लिए इसे संग्रहीत करती है

names() तालिका में प्रत्येक अद्वितीय प्रविष्टि का मान मिलता है, और हम इन नामों को लूप के साथ जोड़ते हैं।

शेष भाग जाँच करता है कि कौन सी प्रविष्टियाँ पुनरावृत्तियों के बराबर हैं और मानों के अनुक्रम को संग्रहीत करती हैं (1 से लेकर पुनरावृत्तियों की प्रविष्टियों की संख्या)

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

— Sumner18
स्रोत
आप which()7 बाइट्स को बचाने के लिए निकाल सकते हैं ।
— Giuseppe
आपके उपयोग 1:r[i]ने मुझे table()पूरी तरह से हटाने का विचार दिया : x=z=scan();for(i in x)z[y]=1:sum(y<-x==i);z43 बाइट्स! यह एक अच्छा तरीका है!
— गिउसेप्पे
ऐसा लगता है कि हम में से कोई भी digEmAll के R ज्ञान के साथ प्रतिस्पर्धा नहीं कर सकता है !
— ग्यूसेप
मैंने देखा कि वह बिल्कुल भड़क गया था!
— सुमेर
2

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

([]#)
x#(y:z)=sum[1|a<-x,a==y]:(y:x)#z
_#e=e

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

व्याख्या

xप्रारंभ में विज़िट किए गए तत्वों की सूची रखते हुए सूची को बाएं से दाएं की ओर ले जाता है []:

एक yगिनती के हर मुठभेड़ के लिए सूची में सभी समान तत्व x।

— ბიმო
स्रोत
1
थोड़ा लंबा लेकिन शायद फिर भी दिलचस्प है: (#(0*));(x:r)#g=g x:r# \y->0^abs(y-x)+g y;e#g=e इसे ऑनलाइन आज़माएं!
— लकोनी 18
@ लाईकोनी: आप भी कैसे आए, आप इसे पूरी तरह से पोस्ट करें!
— ბიმო
1
— लाकोनी
2

हास्केल , 47 46 बाइट्स

(#(*0))
(x:r)#g=g x:r# \y->0^(y-x)^2+g y
e#g=e

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

बीएमओ के उत्तर की तुलना में एक अलग दृष्टिकोण जो थोड़ा लंबा हो गया। (और कृपया अपना अच्छा परीक्षण सूट उधार लें।)

विचार इनपुट सूची पर पुनरावृत्त करना है और किसी फ़ंक्शन को अपडेट करके प्रत्येक तत्व की संख्या का ट्रैक रखना है g। Ungolfed:

f (const 0)
f g (x:r) = g x : f (\ y -> if x==y then 1 + g y else g y) r
f g []    = []

दो दिलचस्प गोल्फिंग अवसर पैदा हुए। पहले मूल्य के लिए g, एक स्थिर कार्य जो अपने तर्क और प्रतिफल की उपेक्षा करता है 0:

const 0  -- the idiomatic way
(\_->0)  -- can be shorter if parenthesis are not needed
min 0    -- only works as inputs are guaranteed to be non-negative
(0*)     -- obvious in hindsight but took me a while to think of

और दूसरा, चर पर एक अभिव्यक्ति xऔर yजो पैदावार देता है 1यदि xबराबर yऔर 0अन्यथा:

if x==y then 1else 0  -- yes you don't need a space after the 1
fromEnum$x==y         -- works because Bool is an instance of Enum
sum[1|x==y]           -- uses that the sum of an empty list is zero
0^abs(x-y)            -- uses that 0^0=1 and 0^x=0 for any positive x
0^(x-y)^2             -- Thanks to  Christian Sievers!

अभी भी छोटे तरीके हो सकते हैं। किसी को एक विचार मिला?

— Laikoni
स्रोत
1
आप उपयोग कर सकते हैं 0^(x-y)^2।
— क्रिश्चियन सेवर्स
1

जावा (JDK) , 76 बाइट्स

a->{for(int l=a.length,i,c;l-->0;a[l]=c)for(c=i=0;i<l;)c+=a[l]==a[i++]?1:0;}

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

क्रेडिट

— ओलिवियर ग्रेजायर
स्रोत
1
-2 बदलकर बाइट्स for(c=0,i=l;i-->0;)c+=a[l]==a[i]?1:0;करने के लिए for(c=i=0;i<l;)c+=a[l]==a[i++]?1:0;।
— केविन क्रूज़सेन 15
1

रूबी , 34 बाइट्स

->a{r=[];a.map{|x|(r<<x).count x}}

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

— जीबी
स्रोत
मुझे विश्वास नहीं हो रहा है कि मैंने कोशिश की ->a{i=-1;a.map{|v|a[0..i+=1].count v}}और सिर्फ एक नई सरणी, योग्य बनाने के बारे में नहीं सोचा। अच्छा काम।
— डेवमानगोज
1

बैश, 37 24 बाइट्स

f()(for x;{ r+=$[a[x]++]\ ;};echo $r)

TIO

यदि मान्य है, तो यह भिन्नता भी है, जैसा कि DigitalTrauma द्वारा सुझाया गया है

for x;{ echo $[a[x]++];}

TIO

— नहुएल फौलीउल
स्रोत
1
कमांड लाइन आर्ग्स के रूप में सूची पास करें - tio.run/##S0oszvj/Py2/SKHCuporNTkjX0ElOjG6IlZbO5ar9v///8b/… - केवल 24 बाइट्स।
— डिजिटल ट्रॉमा
@DigitalTrauma, धन्यवाद हालांकि मुझे नहीं पता कि क्या उसने नियम तोड़े हैं। यह भी कहा गया कि सूची बदलने के लिए कहा गया था और शायद कुछ ऐसा होना चाहिए जैसे कि tio.run/…
— Nahuel Fouilleul
2
@NahuelFouilleul यह ठीक है, पूर्ण कार्यक्रमों की भी अनुमति है, और यह सूची (IMO) इनपुट करने / आउटपुट करने का एक मान्य तरीका है
— ASCII-only
1

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

$_=$h{$_}++

TIO

टिप्पणी के बाद स्पष्टीकरण

  • $_इनपुट ( -pया -nस्विच) पर लूपिंग करते समय पर्ल की विशेष चर, जिसमें वर्तमान लाइन होती है
  • $h{$_}++मानचित्र को स्वचालित करता है %hऔर कुंजी $_और वेतन वृद्धि के साथ एक प्रविष्टि बनाता है और वेतन वृद्धि से पहले मूल्य देता है
  • -pस्विच के कारण विशेष चर मुद्रित किया जाता है , -lस्विच इनपुट पर लाइन के अंत को हटा देता है और आउटपुट पर लाइन का अंत जोड़ता है
— नहुएल फौलीउल
स्रोत
यह अद्भुत लग रहा है। समझाने की परवाह?
— एडम
@ Adám, आपकी प्रतिक्रिया के लिए धन्यवाद, निश्चित रूप से, किया गया
— नहुएल फौलीउल
1

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

{`~&>Zip[_,_[0:#_::0]]}

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

व्याख्या

{`~&>Zip[_,_[0:#_::0]]}
{                     }    _: input (e.g., [5, 12, 10, 12, 12, 10])
             0:#_          range from 0 to length of input (inclusive)
                           e.g., [0, 1, 2, 3, 4, 5, 6]
                 ::0       descending range down to 0 for each element
                           e.g., [[0], [1, 0], [2, 1, 0], [3, 2, 1, 0], [4, 3, 2, 1, 0], [5, 4, 3, 2, 1, 0], [6, 5, 4, 3, 2, 1, 0]]
           _[       ]      get input elements at those indices
                           e.g., [[5], [12, 5], [10, 12, 5], [12, 10, 12, 5], [12, 12, 10, 12, 5], [10, 12, 12, 10, 12, 5], [nil, 10, 12, 12, 10, 12, 5]]
     Zip[_,          ]     concatenate each value with this array
                           e.g., [[5, [5]], [12, [12, 5]], [10, [10, 12, 5]], [12, [12, 10, 12, 5]], [12, [12, 12, 10, 12, 5]], [10, [10, 12, 12, 10, 12, 5]]]
   &>                      using each sub-array spread as arguments...
 `~                            count frequency
                               e.g. [12, [12, 10, 12, 5]] = 12 ~ [12, 10, 12, 5] = 2
— कोनोर ओ ब्रायन
स्रोत
1

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

c,d;f(a,b)int*a;{for(;c=d=b--;a[b]=d)for(;c--;d-=a[c]!=a[b]);}

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

-2 बाइट्स ASCII-only को धन्यवाद

यह बहुत सीधा लगता था, लेकिन मैं अलग दृष्टिकोण के साथ किसी भी छोटे को प्राप्त नहीं कर सकता था।

— attinat
स्रोत
63
— एएससीआईआई-केवल
@ ASCII- केवल यह एक वैध उत्तर है? कोई हेडर शामिल नहीं है, कोई घोषणा नहीं है, यह एक स्निपेट और कई चेतावनी है, हालांकि यह आउटपुट है।
— AZTECCO
@AZTECCO चेतावनियां ठीक हैं (जब तक स्टाडर को नजरअंदाज नहीं किया जाता), तब तक यह वही करता है जो उसे स्वीकार्य होना चाहिए। ध्यान दें कि यह है एक समारोह घोषणा, प्लस कुछ चर घोषणाओं - आप इसे कहीं भी किसी उच्च स्तरीय अभिव्यक्ति के रूप में रख सकते हैं और यह ठीक संकलित कर देगा। ग जवाब (और कम सख्त वाक्य रचना के साथ भाषाओं में उन) का एक बहुत करते हैं आम तौर पर क्योंकि bytesaves कि अच्छा कोड शैली नहीं हैं से काफी कुछ चेतावनियां होती
— ASCII-केवल
ठीक है मैं समझ सकता हूं, लेकिन अभी भी कुछ मेरे लिए ठीक नहीं है। यदि हम एक अलग सेट (आकार में) के साथ परीक्षण करना चाहते हैं, तो हमें कोड को संशोधित करना होगा, यहां तक ​​कि प्रिंट लूप में भी, इनपुट केवल सेट होना चाहिए, इसका आकार नहीं। "कड़ाई से सकारात्मक पूर्णांक की सूची को देखते हुए ... "तो मुझे लगता है कि इनपुट सिर्फ सूची में होना चाहिए।
— AZTECCO
@AZTECCO को यकीन नहीं है कि यह चर्चा इस उत्तर की टिप्पणियों में होनी चाहिए, लेकिन आप मेटा पर विशेष रूप से I / O और उत्तर प्रारूपों पर एक नज़र डालना चाहते हैं ।
— attinat
1

के (ngn / k) , 18 बाइट्स

(,/.!'#'=x)@<,/.=x

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

पुराने चरण

के (ngn / k) , २ 22 २३ २२ बाइट्स

{x[,/.=x]:,/.!'#'=x;x}

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

यह सुंदर नहीं है ... त्वरित और गंदा समाधान, मैं इसे बाद में परिष्कृत करूंगा जब मुझे बेहतर दृष्टिकोण के बारे में सोचने का मौका मिलेगा

स्पष्टीकरण:

  • =xएक निश्चित रिटर्न देता है जहाँ कुंजियाँ x की वस्तुएं हैं और मान उनके सूचक हैं ( 3 1 4 5 9 2 6!(0 9;1 3;,2;4 8 10;5 11;,6;,7))
  • i: तानाशाही करना i
  • #:'प्रत्येक कुंजी के लिए मानों की गणना करें ( 3 1 4 5 9 2 6!2 2 1 3 2 1 1)
  • !:'प्रत्येक मान में गणना करें ( 3 1 4 5 9 2 6!(0 1;0 1;,0;0 1 2;0 1;,0;,0))
  • ,/.:मान निकालें और समतल सूची ( 0 1 0 1 0 0 1 2 0 1 0 0)
  • x[,/.:i]: इन सूचकांकों से आय निकालें, समतल करें, और इन सूचकांकों पर दाईं ओर की सूची से प्रत्येक मान निर्दिष्ट करें

नाराज होकर, सूची अपडेट की गई है लेकिन एक अशक्त मान असाइनमेंट द्वारा लौटाया गया है, इसलिए मुझे अर्धविराम ( ;x) के बाद सूची वापस करने की आवश्यकता है

संपादित करें: निकाले गए कॉलोन को हटा दिया गया

edit2: अनावश्यक असाइनमेंट को हटा दिया गया

— घसीट
स्रोत
0

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

\b(\d+)\b(?<=(\b\1\b.*?)+)
$#2

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। 1 अनुक्रमित। स्पष्टीकरण: रेगेक्स का पहला भाग सूची में प्रत्येक पूर्णांक से मेल खाता है। लुकबाइंड का समूह वर्तमान पूर्णांक तक उस पूर्णांक की प्रत्येक घटना को उस रेखा से जोड़ता है। पूर्णांक को फिर मैचों की संख्या के साथ प्रतिस्थापित किया जाता है।

— नील
स्रोत
0

बैच, 61 बाइट्स

@setlocal
@for %%n in (%*)do @set/ac=c%%n+=1&call echo %%c%%

1 अनुक्रमित। चूँकि चर प्रतिस्थापन पार्स करने से पहले होता है, set/aकमांड अक्षर cको सूची से पूर्णांक के साथ दिए गए चर नाम को बढ़ाने पर समाप्त होता है (बैच में संख्यात्मक चर डिफ़ॉल्ट रूप से)। परिणाम को आउटपुट की आसानी के लिए दूसरे पूर्णांक में कॉपी किया जाता है (अधिक सटीक रूप से, यह एक बाइट बचाता है)।

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