এক জায়গায় প্রতিটি অভিন্ন সংখ্যার সিরিজ গণনা করুন

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
@ জোকিং হ্যাঁ, এটি বর্ণনা করার অন্য একটি উপায়, তবে "এখনও অবধি" শূন্য-ভিত্তিক বোঝায়, এবং "যতক্ষণ না এটি অন্তর্ভুক্ত করা হয়" এক-ভিত্তিক বোঝায়। আমি পছন্দ রাখতে চাই।
— আদম

উত্তর:

23

জাভাস্ক্রিপ্ট (ES6), 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মানগুলি সংরক্ষণ করার জন্য এটি ব্যবহার করা সম্ভব তবে এটি -/ ~সূচীকরণের প্রয়োজন যাতে কোনও বাইট সংরক্ষণ করা যায় না।
— ব্যবহারকারী 202729
— ব্যবহারকারী 202729
1
@ ডেভমঙ্গুজ -~আসলে +1অনেক ভাষায় (যেহেতু এর আলাদা নজির রয়েছে) এর একটি সাধারণত ব্যবহৃত বিকল্প
— এএসসিআই-কেবল
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আগে কখনও দেখা হয়নি ।
— জিউসেপ
আমি সম্মানিত, অনেক অনেক ধন্যবাদ! :)
— digEmAl
6

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

&=Rs

এই সমাধানটি 1-ভিত্তিক

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

ব্যাখ্যা

[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 সমাধান আছে একটি অক্ষর আলাদা!
— জিউসেপ
5

এপিএল (ডায়ালগ ইউনিকোড) , 7 বাইট

এটি, ডিবাগিং এবং সংশোধন করতে তাদের সমস্ত সহায়তার জন্য এইচ.পি.উইজ, অ্যাডাম এবং ডিজাইমাকে অনেক অনেক ধন্যবাদ।

+/¨⊢=,\

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

ব্যাখ্যা

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

স্পষ্ট সংস্করণ তিনটি জিনিস করে

  • প্রথমত, এটা দৃষ্টান্ত সরিয়ে ফেলা ⍵ব্যবহৃত ,\⍵যেমন ,\নিজে ডান পরোক্ষভাবে জিনিসটা করতে পারে এটা সঠিক যুক্তি কাজ অনুমিত এর উপর।
  • দ্বিতীয়ত, এর জন্য ⍵=আমরা এর ⍵সাথে প্রতিস্থাপন করি ⊢যা সঠিক যুক্তির জন্য দাঁড়িয়েছে
  • তৃতীয়ত, এখন আমাদের কোনও স্পষ্ট যুক্তি নেই (এই ক্ষেত্রে, ⍵), আমরা {}ব্রেসগুলি সরিয়ে ফেলতে পারি কারণ স্পষ্ট ফাংশনগুলি সেগুলি ব্যবহার না করে we
— Sherlock9
সূত্র
5

এডাব্লুকে , ১৪

  • 1 বাইট @ নাহুয়েলফিউইলুলকে ধন্যবাদ রক্ষা করেছে
{print++a[$1]}

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

উপরেরটি এক-ভিত্তিক সূচক করে। আপনি যদি শূন্য-ভিত্তিক সূচক পছন্দ করেন তবে এটির অতিরিক্ত বাইট:

{print a[$1]++}

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

— ডিজিটাল ট্রমা
সূত্র
1
নোট করুন যে দ্বিতীয়টি {print++a[$1]}স্থান ছাড়াই একটি বাইট সংরক্ষণ করতে পারে বলে মনে হচ্ছে
— নাহুয়েল ফিউইলুল
@ নাহুয়েলফৌইল ধন্যবাদ!
— ডিজিটাল ট্রমা
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 বাইট

-1 বাইট ধন্যবাদ এনএনজি!

{+/'x=,\x}

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

— গ্যালেন ইভানভ
সূত্র
1
হেই, আপনি খুশি যে আমি ডেটা কঠোরভাবে ইতিবাচক করে
— তুলেছি
@ অ্যাডম হ্যাঁ, অন্যথায় আমার উপসর্গটি বক্স করা দরকার :)
— গ্যালেন ইভানভ
1
ইন কে: ='->=
— এনজিএন
3

সি # (ভিজ্যুয়াল সি # ইন্টারেক্টিভ সংকলক) , 44 বাইট

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

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

— Dana
সূত্র
— লিফড ওয়েইন
আপনার এখনই চ্যালেঞ্জের বিপরীতে আছে .. [7,7,7]আউটপুট করা উচিত [0,1,2], এবং না [0,0,0]।
— কেভিন ক্রুইজসেন
1
@ কেভিন ক্রুজসেন - ধন্যবাদ :) দেখে মনে হচ্ছে যে আমি জিনিসগুলি ভুলভাবে লিখেছি, এটি এখনই ঠিক করা উচিত।
— দানা
2

জেলি , 4 বাইট

ċṪ$Ƥ

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

ইনপুট তালিকার প্রতিটি উপসর্গের জন্য, এটি নিজের মধ্যে এটির শেষ উপাদানটির সংখ্যার সংখ্যা গণনা করে।

— মিঃ এক্সকোডার
সূত্র
বিকল্পভাবে পুরাতন ;\ċ"
— স্কুলটিও
2

আর , 41 বাইট

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

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

অদ্ভুতভাবে, শূন্য-ভিত্তিক সূচকটি ফেরানো আর-তে সংক্ষিপ্ত is

— : Giuseppe
সূত্র
আবার জিউসেপ্প, আপনার আর এর উচ্চতর জ্ঞান আমাকে মারধর করেছে। আমার কাছে 60 বাইটে একটি শালীন পদ্ধতি ছিল, তবে হায়, এটি যথেষ্ট ছিল না!
— Sumner18
@ Sumner18 এটি পোস্ট করুন! আমি সর্বদা অন্যান্য লোকের পদ্ধতির কাছ থেকে অনেক কিছু শিখি এবং প্রতিক্রিয়া পাওয়া শিখার দ্রুততম উপায়!
— জিউসেপ
অনুপ্রেরণার জন্য ধন্যবাদ! আমি এখনই আমার পোস্ট করেছি এবং উন্নতির জন্য পরামর্শের জন্য সর্বদা উন্মুক্ত!
— Sumner18
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) ভবিষ্যতের রেফারেন্সের জন্য প্রতিটি সংখ্যা প্রদর্শিত হওয়ার সংখ্যা গণনা করে এবং এটি r এ সঞ্চয় করে

names() সারণীতে প্রতিটি অনন্য প্রবেশের মান পায় এবং আমরা লুপের জন্য এই নামগুলি দিয়ে পুনরাবৃত্তি করি।

বাকী অংশটি পরীক্ষা করে যে কোন এন্ট্রিগুলি পুনরাবৃত্তির সমান এবং মানগুলির ক্রম সংরক্ষণ করে (1 থেকে পুনরাবৃত্তির প্রবেশের সংখ্যা পর্যন্ত)

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

— Sumner18
সূত্র
আপনি which()7 বাইট সংরক্ষণ করতে অপসারণ করতে পারেন ।
— জিউসেপ
আপনার ব্যবহার 1:r[i]আমাকে table()পুরোপুরি সরাতে ধারণা দিয়েছে : x=z=scan();for(i in x)z[y]=1:sum(y<-x==i);zএটি 43 বাইট! এটি একটি দুর্দান্ত পদ্ধতির!
— জিউসেপ
দেখে মনে হচ্ছে আমরা উভয়েই ডিগএএমএল'র আর জ্ঞানের সাথে প্রতিযোগিতা করতে পারি না !
— জিউসেপ
আমি এটি দেখেছি এবং একেবারে হতবাক!
— Sumner 18
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 এটি অনলাইনে চেষ্টা করুন!
— লাইকনি
@ লাইকোনি: আপনি কীভাবে এটিকে সামনে এনেছিলেন, আপনার এটি সম্পূর্ণ পোস্ট করা উচিত!
— ბიმო
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ফলন করে :1xy0

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

জাভা (জেডিকে) , 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
-২ বাইট এ পরিবর্তন 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;।
— কেভিন ক্রুইজসেন
1

রুবি , 34 বাইট

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

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

— গিগাবাইট
সূত্র
আমি বিশ্বাস করতে পারি না যে আমি চেষ্টা করেছিলাম ->a{i=-1;a.map{|v|a[0..i+=1].count v}}এবং কেবল নতুন অ্যারে তৈরির কথা ভাবিনি, হ্যাঁ। চমৎকার কাজ.
— ডেভমঙ্গুজ
1

bash, 37 24 বাইট

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

Tio

যদি বৈধ হয়, ডিজিটালট্রামার পরামর্শ অনুসারে এই প্রকরণটিও রয়েছে

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

Tio

— নাহুয়েল ফৌইলুল
সূত্র
1
কমান্ড লাইন আর্গ হিসাবে তালিকাটি পাস করুন - tio.run/##S0oszvj/Py2/SKHCuporNTkjX0ElOjG6IlZbO5ar9v///8b/… - মাত্র 24 বাইট
— ডিজিটাল ট্রমা
@ ডিজিটালট্রামা, ধন্যবাদ তবে আমি জানি না এটি নিয়ম ভঙ্গ করেছে কিনা। এছাড়াও তালিকাটি প্রতিস্থাপন করতে বলা হয়েছিল এবং সম্ভবত tio.run/… এর
— নাহুয়েল ফিউইলুল
2
@ নাহুয়েলফিউলুল এটি ঠিক আছে, সম্পূর্ণ প্রোগ্রামগুলিও অনুমোদিত, এবং এটি একটি তালিকা (আইএমও) ইনপুট / আউটপুট দেওয়ার একটি বৈধ পদ্ধতি
— এএসসিআইআই-
1

পার্ল 5, 11 বাইট

$_=$h{$_}++

Tio

মন্তব্য নিম্নলিখিত ব্যাখ্যা

  • $_ইনপুট ( -pবা -nস্যুইচগুলি) লুপ করার সময় পার্লের বিশেষ ভেরিয়েবলটি বর্তমান লাইন যুক্ত করে
  • $h{$_}++মানচিত্রটি অটোভিভাইফাই করে %hএবং কী $_এবং ইনক্রিমেন্ট সহ একটি এন্ট্রি তৈরি করে এবং ইনক্রিমেন্টের আগে মান দেয়
  • বিশেষ ভেরিয়েবলটি -pস্যুইচ হওয়ার কারণে মুদ্রিত হয় , -lসুইচ ইনপুটটিতে লাইনের শেষটি সরিয়ে দেয় এবং আউটপুটটিতে লাইনের শেষ যোগ করে
— নাহুয়েল ফৌইলুল
সূত্র
দারুণ লাগছে। বোঝাতে কি যত্ন?
— আদম
@ অ্যাডাম, আপনার মতামতের জন্য ধন্যবাদ, নিশ্চিত
— হয়েছি
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 বাইটস কেবলমাত্র এসসিআইআই-কে ধন্যবাদ

এটি খুব সোজা মনে হয়েছিল, তবে আমি আলাদা পদ্ধতির সাথে কোনও সংক্ষিপ্ততর পেতে পারি না।

— attinat
সূত্র
63
— ASCII-
@ এএসসিআইআই-এটি কি বৈধ উত্তর? কোনও শিরোনাম অন্তর্ভুক্ত নেই, কোনও ঘোষণা নেই, এটি একটি স্নিপেট প্লাস অনেক সতর্কতা যদিও এটি আউটপুট করে।
— আজটেকো
@ আজটেকোর সতর্কতাগুলি ঠিক আছে (স্টাডার উপেক্ষা করা হবে), যতক্ষণ না এটি গ্রহণযোগ্য হওয়া উচিত should নোট করুন যে এটি একটি ফাংশন ঘোষণা, এবং কিছু পরিবর্তনশীল ঘোষণা - আপনি এটি শীর্ষ স্তরের এক্সপ্রেশন হিসাবে যে কোনও জায়গায় রাখতে পারেন এবং এটি সূক্ষ্ম সংকলন করবে। গ উত্তর (এবং কম কঠোর বাক্য গঠন সঙ্গে ভাষায় যারা) অনেকটা না সাধারণত কারণ bytesaves যে ভাল কোড শৈলী নয়, সেগুলো বেশ কিছু সতর্কবার্তা আছে
— হওয়া ASCII শুধুমাত্র
ঠিক আছে আমি বুঝতে পারি, তবে এখনও আমার কাছে সঠিক কিছু নেই। আমরা যদি অন্য কোনও সেট (আকারে) দিয়ে পরীক্ষা করতে চান তবে আমাদের কোডটি এমনকি মুদ্রিত লুপেও সংশোধন করতে হবে, এবং ইনপুটটি কেবল তার আকার নয়, সেট হওয়া উচিত "" কঠোর ইতিবাচক পূর্ণসংখ্যার একটি তালিকা দেওয়া ... "সুতরাং আমি মনে করি ইনপুট কেবল তালিকা হওয়া উচিত।
— আজটেকো
@ আজটেককো নিশ্চিত নন যে এই আলোচনাটি এই উত্তরের মন্তব্যে অন্তর্ভুক্ত করা উচিত, তবে আপনি মেটা - বিশেষত I / O এবং উত্তর ফর্ম্যাটগুলিতে একবার দেখে নিতে পারেন।
— এ্যাটিন্যাট
1

কে (এনএনজি / কে) , 18 বাইট

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

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

পুরানো প্রচার

কে (এনএনজি / কে) , 27 23 22 বাইট

{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-ইন্ডেক্স। ব্যাখ্যা: রেজেক্সের প্রথম অংশটি তালিকার প্রতিটি পূর্ণসংখ্যার সাথে মিলে যায়। লুকইহিন্ডের গোষ্ঠীটি সেই লাইনে থাকা পূর্ণসংখ্যার প্রতিটি ঘটনার সাথে বর্তমান সংখ্যার সাথে মেলে এবং matches পূর্ণসংখ্যার পরে ম্যাচের সংখ্যার সাথে প্রতিস্থাপিত হয়।

— নিল
সূত্র
0

ব্যাচ, 61 বাইট

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

1-ইন্ডেক্স। যেহেতু পরিবর্তনশীল প্রতিস্থাপন পার্সিংয়ের আগে ঘটে থাকে, set/aকমান্ডটি cতালিকা থেকে পূর্ণসংখ্যার সাথে চিঠিটি সংক্ষিপ্ত করে প্রদত্ত পরিবর্তনশীল নামটি বাড়িয়ে তোলে (সংখ্যার ভেরিয়েবলগুলি ডিফল্টে শূন্যে ব্যাচ করে)। ফলাফলটি আউটপুট সহজ করার জন্য অন্য সংখ্যায় অনুলিপি করা হয় (আরও স্পষ্টতই, এটি একটি বাইট সংরক্ষণ করে)।

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