মোড-ভারসাম্যযুক্ত তালিকা

14

ভূমিকা

ধরুন আমার কাছে পূর্ণসংখ্যার একটি তালিকা রয়েছে, এল = [-1,2,2,1,2,7,1,4] বলুন । আমি আমার জীবনে ভারসাম্য বজায় রাখতে পছন্দ করি, তাই এতে এমনকি উপাদানগুলির মতো অনেকগুলি বিজোড় উপাদান রয়েছে দেখে আমি আনন্দিত। আরও কি, এটি 3 এর সমস্ত মডুলো শ্রেণিতেও সমান সংখ্যক উপাদান রয়েছে যার এতে উপাদান রয়েছে:

         [-1,2,2,1,2,7,1,4]
0 mod 3:
1 mod 3:         1   7 1 4
2 mod 3:  -1 2 2   2

দুঃখের বিষয়, 4 এর মডুলো ক্লাসগুলির জন্য এটি আর ধরে না। সাধারণভাবে, আমরা বলতে একটি খালি তালিকা মডিউল সুষম এন যদি এটা সব মডিউল শ্রেণীর উপাদানের একটি সমান নম্বর আছে এন , যার জন্য এই নম্বরে 0. উপরে তালিকা নয় এল সুষম মডিউল 2 এবং 3, কিন্তু ভারসাম্যহীন মডিউল 4।

কাজটি

আপনার ইনপুটটি কোনও যুক্তিসঙ্গত বিন্যাসে নেওয়া একটি খালি খালি তালিকা L এর পূর্ণসংখ্যার। আপনার আউটপুট হল সেই পূর্ণসংখ্যার N ≥ 2 এর তালিকা যা এল ভারসাম্যযুক্ত মডুলোর এন , আবার কোনও যুক্তিসঙ্গত বিন্যাসে। আউটপুট ক্রম কিছু যায় আসে না, তবে এটিতে সদৃশ থাকা উচিত নয়।

এটা তোলে নিশ্চিত করা হয় আউটপুট, যার মানে অবিকল যে সমস্ত উপাদান একমাত্র finitely অনেক নম্বর আছে এল তাতে সময়ের একটি সমান সংখ্যা ঘটবে। অবৈধ ইনপুটগুলির উদাহরণগুলি [3] , [1,2] এবং [0,4,4,0,3,3] । লক্ষ্য করুন যে আউটপুটে সর্বাধিক সংখ্যাটি সর্বাধিক সর্বাধিক (এল) - মিনিট (এল) ।

প্রতিটি ভাষার মধ্যে সবচেয়ে কম বাইট গণনা এবং মানক -গল্ফ স্ট্যান্ডার্ড standard বিধি প্রযোজ্য।

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

[1,1,2] -> []
[1,1,5] -> [2,4]
[1,1,24] -> [23]
[1,2,3,2] -> [2]
[12,12,-4,20] -> [2,3,4,6,8,12,24]
[1,1,12,12,-3,7] -> [3,10]
[-1,2,2,1,2,7,1,4] -> [2,3]
[4,-17,-14,-18,-18,3,5,8] -> []
[-18,0,-6,20,-13,-13,-19,13] -> [2,4,19]
[-11,-19,-19,3,10,-17,13,7,-5,16,-20,20] -> []
[3,0,1,5,3,-6,-16,-20,10,-6,-11,11] -> [2,4]
[-18,-20,14,13,12,-3,14,6,7,-19,17,19] -> [2,3]
[-16,-9,6,13,0,-17,-5,1,-12,-4,-16,-4] -> [3,9]
[-97,-144,3,53,73,23,37,81,-104,41,-125,70,0,111,-88,-2,25,-112,54,-76,136,-39,-138,22,56,-137,-40,41,-141,-126] -> [2,3,6]
code-golf  arithmetic  array-manipulation 
— Zgarb
সূত্র
কিছু ভাষা যা স্বয়ংক্রিয়ভাবে উপরের সীমানা গণনা করে (সম্ভবত
— ব্র্যাচল্যাজ

উত্তর:

4

05 এ বি 1 ই , 11 বাইট

ÄOL¦ʒ%{γ€gË

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

ÄOL¦ʒ%{γ€gË  | Full program.

Ä            | Absolute value (element-wise).
 O           | Sum.
  L          | 1-based inclusive range.
   ¦         | Remove the first element (generates the range [2 ... ^^]).
    ʒ        | Filter / Select.
     %       | Modulo of the input with the current integer (element-wise).
      {      | Sort.
       γ     | Group into runs of adjacent elements.
        €g   | Get the length of each.
          Ë  | Are all equal?
— মিঃ এক্সকোডার
সূত্র
4

ওল্ফ্রাম ভাষা (ম্যাথমেটিকা) , 56 52 বাইট 56

4 টি বাইট সংরক্ষণের জন্য একটি গাছের জন্য ধন্যবাদ

Cases[Range[2,#.#],n_/;Equal@@Last/@Tally[#~Mod~n]]&

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

মূল গল্ফিং ট্রিকটি হ'ল পরম মানগুলির যোগফল (বা 1-আদর্শ) এর সাথে বর্ধিত মান হিসাবে নিজের সাথে একটি বিন্দু পণ্য হিসাবে গণনা করা স্কোয়ার মানগুলির যোগফল Max@#-Min@#। অন্যথায়, এটি কেবল স্পষ্টভাবে আক্ষরিক প্রয়োগ করে।

— মার্টিন ইন্ডার
সূত্র
3

পার্ল 6 ,  52  48 বাইট

{grep {[==] .classify(*X%$^a).values},2.. .max-.min}

এটা পরীক্ষা করো

{grep {[==] bag($_ X%$^a).values},2.. .max-.min}

এটা পরীক্ষা করো

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

{  # bare block lambda with implicit parameter ｢$_｣

  grep

    {  # bare block lambda with placeholder parameter ｢$a｣

      [==]           # reduce with &infix:«==» (are the counts equal to each other)

        bag(         # group moduluses together

          $_ X% $^a  # find all the moduluses using the current divisor ｢$a｣

        ).values     # the count of each of the moduluses
    },

    2 .. .max - .min # all possible divisors
}
— ব্র্যাড গিলবার্ট বি 2 গিলস
সূত্র
3

হাস্কেল , 85 84 বাইট

f l=[n|n<-[2..sum$abs<$>l],all.(==)=<<head$[r|m<-[0..n],_:r<-[[0|x<-l,mod x n==m]]]]

এটি অনলাইন চেষ্টা করুন! মার্টিন এেন্ডারের উত্তর থেকে সর্বোচ্চ হিসাবে নিখুঁত মানগুলির যোগফল ব্যবহার করে ।

সম্পাদনা: -1 বাইট ধন্যবাদ Ørjan জোহানসেনকে।

ব্যাখ্যা:

f l=                             -- Given a list of numbers l,
  [n|n<-                       ] -- return a list of all numbers n of the range
    [2..sum$abs<$>l],            -- from 2 to the sum of the absolute values of l
      all.(==)=<<head$           -- for which all elements of the following list are equal:
        [r|m<-[0..n],         ]  -- A list r for each number m from 0 to n, where
          _:r<-[             ]   -- r is the tail of a list (to filter out empty lists)
          [0|x<-l,mod x n==m]    -- of as many zeros as elements of l mod n equal m.
— Laikoni
সূত্র
2

আর , 75 72 বাইট

function(L){for(x in 2:(max(L)-min(L)))F=c(F,!sd(table(L%%x)))
which(F)}

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

ব্যবহার tableপ্রতিটি পূর্ণসংখ্যা মডিউল এর গন্য গনা x। sdসংখ্যার সংখ্যার মানক বিচ্যুতি যদি শূন্য হয় তবে তারা সমস্ত সমান এবং অন্যথায় ইতিবাচক। অত: পর !sd(table(L%%x))হয় TRUEযেখানেই থাকুন না কেন Lগেলিক ভাষার-সুষম লেখার জন্য xএবং মিথ্যা অন্যথায়। এই মানগুলি তখন একত্রিত হয় F।

whichতারপরে ফাংশন থেকে সত্য মানগুলির সূচকগুলি প্রদান করে। যেহেতু আরআর 1-ভিত্তিক সূচক ব্যবহার করে এবং Fপ্রাথমিকভাবে মান সহ একটি দৈর্ঘ্য-ভেক্টর FALSE, এটি সঠিকভাবে শুরু হওয়া মানগুলি ফিরিয়ে দেবে2 ।

কেউ বিল্টিন ফাংশনটি কোনও ডেটাসেটের পরিসীমাrange গণনা করার আশা করতে পারে , অর্থাত্‍ , তবে দুঃখের বিষয় এটি ভেক্টরকে গণনা করে এবং ফেরত দেয় ।max(D)-min(D)c(min(D), max(D))

— : Giuseppe
সূত্র
2

পরিষ্কার , 121 বাইট

মার্টিন ইন্ডারের উত্তর থেকে সমষ্টি সম্পর্কে অবৈধ কৌশল ব্যবহার করুন।

Golfed:

import StdEnv   
f l=[n\\n<-[2..sum(map abs l)]|length(removeDup[length[m\\m<-[(e rem n+n)rem n\\e<-l]|m==c]\\c<-[0..n]])<3]

রিডেবল:

import StdEnv
maximum_modulus l = sum (map abs l)
// mod, then add the base, then mod again (to fix issues with negative numbers)
list_modulus l n = [((el rem n) + n) rem n \\ el <- l]
// count the number of elements with each mod equivalency
equiv_class_count l n = [length [m \\ m <- list_modulus l n | m == c] \\ c <- [0..n]]
// for every modulus, take where there are only two quantities of mod class members
f l=[n \\ n <- [2..maximum_modulus l] | length (removeDup (equiv_class_count l n)) < 3]

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

— Οurous
সূত্র
1

জেলি , 12 বাইট

⁹%LƙE
ASḊçÐf

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

বাইট বাঁচানোর জন্য ব্যবহারকারীর জন্য ধন্যবাদ 202729 এবং বাইট সংরক্ষণের জন্য মার্টিন ইন্ডারকে (পরোক্ষভাবে)

কিভাবে এটা কাজ করে

⁹%LƙE ~ Helper link. Let's call the argument N.

⁹%    ~ Modulo the input by N (element-wise).
  Lƙ  ~ Map with length over groups formed by consecutive elements.
    E ~ All equal?

ASḊçÐf ~ Main link.

AS     ~ Absolute value of each, sum.
  Ḋ    ~ Dequeue (create the range [2 ... ^]).
   çÐf ~ Filter by the last link called dyadically.

একটি ওয়ানলাইনারের বিকল্প 12-বাইটার অনলাইনে চেষ্টা করা যেতে পারে !

— মিঃ এক্সকোডার
সূত্র
আমি আমার উত্তরটি মুছে ফেলছি কারণ এটি এখন অপ্রয়োজনীয়। মার্টিনকেও ধন্যবাদ AS( বিসোলিউটের Sউম A) জন্য।
— ব্যবহারকারী 202729
1
ভবিষ্যতের পাঠকদের জন্য একটি রেফারেন্স হিসাবে, আমি স্পষ্ট করেছিলাম কেন চ্যাটেরḟ0 প্রয়োজন হয় না ।
— মিঃ এক্সকোডার
1

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

লুই মেন্ডো -4 বাইট ধন্যবাদ !

S5L)d:Q"G@\8#uZs~?@

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

আমার উত্তর বন্দরে আর ।

Suppose we have input [12,12,-4,20]
         # (implicit input), stack: [12,12,-4,20]
S        # sort the list, stack: [-4, 12, 12, 20]
5L       # push [1 0], stack: [[-4, 12, 12, 20]; [1 0]]
)        # 1-based modular index, stack: [-4, 20]
d        # successive differences, stack: [24]
:        # generate 1:(max(data)-min(data)), stack: [[1...24]]
Q        # increment to start at 2, stack: [[2...25]]
"        # for each element in [2...25]
 G       # push input, stack: [[12,12,-4,20]]
 @       # push loop index, stack: [[12,12,-4,20], 2]
 \       # compute modulo, stack: [[0,0,0,0]]
 8#      # use alternate output spec, unique has 4 outputs, so 8 keeps only the 4th
 u       # unique. 4th output is the counts of each unique value, stack: [4]
 Zs      # compute standard deviation, stack: [0]
 ~       # logical negate, stack: [T]
 ?       # if true,
  @      # push loop index
         # (implicit end of if)
         # (implicit end of for loop)
         # (implicit output of stack as column vector

— : Giuseppe
সূত্র
আপনি তার S5L)dপরিবর্তে X>GX<-এবং এর 8#uপরিবর্তে কিছুটা ছোট করতে পারেনFFFT#u
— লুইস মেন্ডো
@ লুইস মেন্দো আমি কীভাবে ধাক্কা দিতে [1 0]পারি তা বুঝতে পারি না (তবে আমি জানতাম যে এটি সম্ভব ছিল) তাই 5Lসুবিধাজনক, এবং আমি *still* really need to go and properly read the docs for # `:( তবে আপনাকে ধন্যবাদ!
— জিউসেপ্পে
কারণ #, আউটপুটগুলির সর্বাধিক সংখ্যার চেয়ে বেশি সংখ্যক নির্দিষ্ট করে কেবল পৃথক আউটপুট নির্বাচন করে। ফাংশন uসর্বোচ্চ 4, তাই 5#uহয় T#u, 6#uহয় FT#uইত্যাদি
— লুইস Mendo
0

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

মানগুলির একটি স্থান-বিভাজিত তালিকা আউটপুট দেয়।

a=>(g=m=>a.map(n=>x[k=(z|=m/2<n|m/2<-n,n%m+m)%m]=-~x[k],y=z=0,x=[])|z?(x.some(x=>x-(y?y:y=x))?'':m+' ')+g(m+1):'')(2)

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

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

— Arnauld
সূত্র
0

ক্লোজার, 91 বাইট

#(for[i(range 2(apply +(map * % %))):when(apply =(vals(frequencies(for[j %](mod j i)))))]i)

frequenciesকোড গল্ফ ব্যবহার করা আদর্শ নয়।

— NikoNyrh
সূত্র
0

জে, 38 বাইট

[:}.@I.([:i.1#.|)(1=1#.[:~:|#/.])"0 1]

পরম মান কৌতুকের যোগফলের জন্য ক্রেডিট মিঃ এক্সকডারকে যায়।

আপনি চাইলে টিআইও লিঙ্কে সম্পাদনা করুন - আমি তাড়াহুড়ো করে কিছুটা গল্ফ করেছি।

ব্যাখ্যা এবং টিআইও লিঙ্কটি শীঘ্রই আসছে (ইস)।

— কপি
সূত্র
0

এপিএল (ডায়ালগ) , 43 41 38 30 বাইট

কোডের গুলি পুরো গল্পটি বলে।

8 অ্যাডমকে ধন্যবাদ 8 বাইট সংরক্ষণ করা হয়েছে

∊x⊆⍨1=⊂(≢∘∪1⊥|∘.=|)¨⍨x←1+∘⍳1⊥|

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

— ঊরীয়েল
সূত্র
ট্রেন + গভীরতা → র‌্যাঙ্ক, 30 বাইট:∊x⊆⍨1=⊂(≢∘∪1⊥|∘.=|)¨⍨x←1+∘⍳1⊥|
— অ্যাডাম
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.