परिचय

मान लीजिए कि मेरे पास पूर्णांकों की एक सूची है, तो L = [-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 के modulo वर्गों के लिए यह अब नहीं है। सामान्य तौर पर, हम कहते हैं एक गैर खाली सूची है सापेक्ष संतुलित एन अगर यह के सभी सापेक्ष कक्षाओं में तत्वों की संख्या बराबर है एन जिसके लिए इस नंबर 0. नहीं है उपरोक्त सूची एल संतुलित सापेक्ष 2 और 3 है, लेकिन असंतुलित सापेक्ष 4।

काम

आपका इनपुट किसी भी उचित प्रारूप में ली गई पूर्णांकों की गैर-रिक्त सूची L है। आपका आउटपुट उन पूर्णांकों N that 2 की सूची है, जैसे L संतुलित मोड्यूलो N , फिर से किसी भी उचित प्रारूप में है। आउटपुट का क्रम मायने नहीं रखता है, लेकिन इसमें डुप्लिकेट नहीं होना चाहिए।

यह गारंटी है कि आउटपुट में केवल बहुत कम संख्याएं हैं, जिसका अर्थ है कि एल के सभी तत्व समान संख्या में बार नहीं होते हैं। अमान्य इनपुट के उदाहरण हैं [3] , [1,2] और [0,4,4,0,3,3] । ध्यान दें कि आउटपुट में सबसे बड़ी संख्या अधिकतम (L) - मिनट (L) पर है ।

प्रत्येक भाषा में सबसे कम बाइट गिनती जीतती है, और मानक कोड-गोल्फ नियम लागू होते हैं।

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

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

कुछ भाषाएँ जो स्वतः ऊपरी सीमा की गणना करती हैं (शायद Brachylog?) का एक फायदा होगा ...

— user202729

4

05AB1E , 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 बाइट्स

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
}

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

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]]]]

इसे ऑनलाइन आज़माएं! मार्टिन एंडर के उत्तर से अधिकतम के रूप में पूर्ण मूल्यों के योग का उपयोग करता है ।

संपादित करें: ० अर्जन जोहान्सन को धन्यवाद।

स्पष्टीकरण:

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

भूसी , 13 बाइट्स

f₅⁰…2ṁa⁰
Λ≈k%

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

— H.PWiz
स्रोत

2

आर , 75 72 बाइट्स

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

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

tableप्रत्येक पूर्णांक modulo की गणना करने के लिए उपयोग करता है x। sdसंख्याओं के एक सेट का मानक विचलन शून्य है यदि वे सभी समान हैं, और अन्यथा सकारात्मक। इसलिए !sd(table(L%%x))है TRUEजहाँ भी Lआधुनिक संतुलित आधुनिक है xऔर झूठे अन्यथा। इन मूल्यों को फिर समाप्‍त कर दिया जाता है F।

whichफिर फ़ंक्शन से सही मानों के सूचकांकों को लौटाता है। चूंकि आर 1-आधारित इंडेक्सिंग का उपयोग करता है और Fशुरू में मूल्य के साथ एक लंबाई-एक वेक्टर है FALSE, यह सही ढंग से शुरू होने वाले मूल्यों को वापस करेगा 2।

एक builtin समारोह उम्मीद कर सकते हैं rangeगणना करने के लिए एक डाटासेट की सीमा , यानी, max(D)-min(D), लेकिन दुर्भाग्य से यह गणना करता है और रिटर्न वेक्टर c(min(D), max(D))।

— ग्यूसेप
स्रोत

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

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

एक बाइट को बचाने के लिए और बाइट बचाने के लिए मार्टिन एंडर (अप्रत्यक्ष रूप से) के लिए user202729 का धन्यवाद ।

यह काम किस प्रकार करता है

⁹%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( bsolutes के Sउम A) भी।

— user202729

1

भविष्य के पाठकों के लिए एक संदर्भ के रूप में, मैंने स्पष्ट किया कि चैट कीḟ0 आवश्यकता क्यों नहीं है ।

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

1

पायथन 3, 120 102 बाइट्स

बहुत गोल्फ नहीं है।

-18 बाइट्स मिस्टर एक्सकोडर की बदौलत ।

f=lambda a,i=2:[]if i>max(a)-min(a)else(len({*map([k%i for k in a].count,range(i)),0})<3)*[i]+f(a,i+1)

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

— कोलेरा सु
स्रोत

1

MATL , 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

— ग्यूसेप
स्रोत

आप एक छोटे का उपयोग कर छोटा कर सकते हैं S5L)dके बजाय X>GX<-और 8#uके बजायFFFT#u

— लुइस Mendo

@LuisMendo मैं समझ नहीं पा [1 0]रहा था कि कैसे धकेलूं (लेकिन मुझे पता था कि यह संभव है) तो 5Lयह आसान है, और मैं *still* really need to go and properly read the docs for # `:( लेकिन धन्यवाद!

— Giuseppe

#अधिकतम संख्या आउटपुट से अधिक संख्या निर्दिष्ट करने के लिए , केवल व्यक्तिगत आउटपुट का चयन करता है। समारोह के साथ uअधिक से अधिक है 4, तो 5#uहै T#u, 6#uहै FT#uआदि

— लुइस Mendo

0

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

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

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

let f =

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)

console.log(f([1,1,2])) // []
console.log(f([1,1,5])) // [2,4]
console.log(f([1,1,24])) // [23]
console.log(f([1,2,3,2])) // [2]
console.log(f([12,12,-4,20])) // [2,3,4,6,8,12,24]
console.log(f([1,1,12,12,-3,7])) // [3,10]
console.log(f([-1,2,2,1,2,7,1,4])) // [2,3]
console.log(f([4,-17,-14,-18,-18,3,5,8])) // []
console.log(f([-18,0,-6,20,-13,-13,-19,13])) // [2,4,19]
console.log(f([-11,-19,-19,3,10,-17,13,7,-5,16,-20,20])) // []
console.log(f([3,0,1,5,3,-6,-16,-20,10,-6,-11,11])) // [2,4]
console.log(f([-18,-20,14,13,12,-3,14,6,7,-19,17,19])) // [2,3]
console.log(f([-16,-9,6,13,0,-17,-5,1,-12,-4,-16,-4])) // [3,9]
console.log(f([-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]

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

— 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]

पूर्ण मान चाल के योग के लिए श्रेय श्री एक्सकोडर को जाता है।

यदि आप चाहते हैं तो एक TIO लिंक में संपादित करें - मैंने इसे थोड़ी जल्दी में तैयार किया है।

स्पष्टीकरण और TIO लिंक जल्द ही (ish) आ रहा है।

— गोभी
स्रोत

0

एपीएल (डायलॉग) , 43 41 38 30 बाइट्स

कोड में thes पूरी कहानी बताता है।

8 बाइट्स @ Adám की बदौलत बच गईं

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

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

— Uriel
स्रोत

ट्रेन + डेप्थ → रैंक, 30 बाइट्स:∊x⊆⍨1=⊂(≢∘∪1⊥|∘.=|)¨⍨x←1+∘⍳1⊥|

— एडम डे

मॉड-संतुलित सूची

परिचय

काम

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

05AB1E , 11 बाइट्स

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 56 52 बाइट्स

पर्ल 6 , 52 48 बाइट्स

विस्तारित:

हास्केल , 85 84 बाइट्स

भूसी , 13 बाइट्स

आर , 75 72 बाइट्स

क्लीन , 121 बाइट्स

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

यह काम किस प्रकार करता है

पायथन 3, 120 102 बाइट्स

MATL , 19 बाइट्स

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

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

क्लोजर, 91 बाइट्स

जे, 38 बाइट्स

एपीएल (डायलॉग) , 43 41 38 30 बाइट्स