मौलिकता द्वारा समूह इंटेगर

Question

परिचय:

मैं गंदी पहेलियां इकट्ठा करता हूं। चीनी कंपनियों द्वारा ज्यादातर ट्विस्टी पहेलियां बनाई और बेची जाती हैं। अधिकांश प्रसिद्ध कंपनियां पहेली डिजाइनरों से अनुमति देती हैं कि वे अपने डिजाइन का निर्माण करें और बाजार पर एक उत्पाद की दिशा में एक साथ काम करें। इस मामले में, पहेली डिजाइनर निश्चित रूप से बहुत खुश और गर्वित हैं कि उनकी पहेली में से एक ने बाजार को हिट किया।

हालाँकि, चीनी कंपनियां भी हैं जो नॉक-ऑफ पज़ल बनाती हैं। ये नॉक-ऑफ या तो मूल निर्माता से अनुमति के बिना उपयोग किए जाने वाले डिज़ाइन हैं, या पहले से मौजूद पहेली की सर्वथा सस्ती निम्न गुणवत्ता वाली प्रतियां हैं।

चुनौती:

हम संख्या रहे हैं कि एक विशेष क्रम में 'जारी किया' (बाएं से दाएं की मौलिकता का निर्धारण करने के लिए जा रहे हैं ^† )।
पूर्णांक, समूह की सूची को देखते हुए और उनकी मौलिकता के आधार पर उनका उत्पादन करते हैं।

संख्याओं की मौलिकता कैसे निर्धारित की जाती है?

• क्या एक संख्या पहले की संख्या का एक सटीक डुप्लिकेट है? समूह (सबसे कम मूल), जहां समूह अन्य सभी समूहों के बाद पीछे चल रहा है।$X+1$$X+1$
• क्या कोई संख्या पहले वाली संख्या का डुप्लिकेट है, लेकिन इसके बजाय इसका नकारात्मक (यानी मूल संख्या , लेकिन अब , या इसके विपरीत)? समूह ।$n$$-n$$X$
• क्या एक या एक से अधिक पूर्व निरपेक्ष संख्या को समाप्‍त करके संख्‍या का निरपेक्ष मान बनाया जा सकता है, और क्या यह पहले उल्लेखित समूहों या हिस्सा नहीं है ? समूह , जहां (और ) में उपयोग किए जाने वाले अलग-अलग नंबरों की राशि है ।$X+1$$X$$X-N$$N$$N\geq1$
• क्या उपरोक्त किसी भी समूह में संख्या फिट नहीं है, इसलिए इस प्रकार पूरी तरह से अद्वितीय है? समूह (सबसे मूल), जो अन्य सभी समूहों से पहले अग्रणी है।$1$

यह बहुत अस्पष्ट लग सकता है, इसलिए यहां एक कदम-दर-चरण उदाहरण दिया गया है :

इनपुट-सूची: [34,9,4,-34,19,-199,34,-213,94,1934499,213,3,21,-2134,44449,44]

• 34पहली संख्या है, जो हमेशा मूल और समूह । इस प्रकार उत्पादन अब तक:$1$[[34]]
• 9 मूल भी है: [[34,9]]
• 4 मूल भी है: [[34,9,4]]
• -34पहले की संख्या का ऋणात्मक है 34, इसलिए यह समूह :$X$[[34,9,4],[-34]]
• 19 मूल है: [[34,9,4,19],[-34]]
• -199पहले के दो नंबरों से बन सकता है 19और 9इसलिए यह समूह :$X-2$[[34,9,4,19],[-199],[-34]]
• 34एक पूर्व संख्या की एक सटीक प्रति है, इसलिए यह समूह :$X+1$[[34,9,4,19],[-199],[-34],[34]]
• -213 मूल है: [[34,9,4,19,-213],[-199],[-34],[34]]
• 94पहले के दो नंबरों से बन सकता है 9और 4इसलिए यह समूह :$X-2$[[34,9,4,19,-213],[-199,94],[-34],[34]]
• 1934499चार पहले नंबर के द्वारा गठित किया जा सकता 19, 34, 4, और दो बार 9, तो यह समूह में है :$X-4$[[34,9,4,19,-213],[19499],[-199,94],[-34],[34]]
• 213पहले की संख्या का ऋणात्मक है -213, इसलिए यह समूह :$X$[[34,9,4,19,-213],[1934499],[-199,94],[-34,213],[34]]
• 3 मूल है: [[34,9,4,19,-213,3],[1934499],[-199,94],[-34,213],[34]]
• 21 मूल है: [[34,9,4,19,-213,3,21],[1934499],[-199,94],[-34,213],[34]]
• -2134पहले के दो नंबरों 213और 4(या तीन पहले के नंबरों 21, 3और 4, लेकिन हम हमेशा समरूपता निर्धारित करने के लिए कम से कम मात्रा का उपयोग करते हैं), इसलिए यह समूह :$X-2$[[34,9,4,19,-213,3,21],[1934499],[-199,94,-2134],[-34,213],[34]]
• 44449पहले के दो नंबरों से चार बार बनाया जा सकता है 4और 9इसलिए यह समूह :$X-2$[[34,9,4,19,-213,3,21],[1934499],[-199,94,-2134,44449],[-34,213],[34]]
• 44एक ही पूर्व संख्या के आधार पर 4दो बार दोहराया जा सकता है , इसलिए यह समूह : $X-1$[[34,9,4,19,-213,3,21],[1934499],[-199,94,-2134,44449],[44],[-34,213],[34]]

इसलिए इनपुट के [34,9,4,-34,19,-199,34,-213,94,1934499,213,3,21,-2134,44449,44]लिए आउटपुट है [[34,9,4,19,-213,3,21],[1934499],[-199,94,-2134,44449],[44],[-34,213],[34]]।

चुनौती नियम:

• I / O लचीला है। आप किसी सूची / सरणी / पूर्णांक या स्ट्रीम की धारा के रूप में इनपुट कर सकते हैं, उन्हें एक-एक करके STDIN, आदि के माध्यम से इनपुट कर सकते हैं। आउटपुट कुंजी के रूप में समूहों के साथ एक मानचित्र हो सकता है, इस चुनौती में उदाहरण और परीक्षण मामलों के रूप में एक नेस्टेड सूची, मुद्रित न्यूलाइन अलग, आदि।
• आपको इनपुट-सूची को उल्टे क्रम में लेने की अनुमति है (शायद स्टैक-आधारित भाषाओं के लिए उपयोगी)। ^Of किस मामले में उल्लिखित बाएं-से-दाएं निश्चित रूप से दाएं-बाएं है।
• आप पूर्णांक के लिए उदाहरण में देख सकते हैं -2134, हम हमेशा समूह एक संख्या के रूप कुछ संभव के रूप में के साथ अन्य संख्या का एक संयोजन है कि (द्वारा गठित 213और 4- दो नंबर, और से नहीं 21, 3और 4- तीन नंबर)।
• जैसा कि आप पूर्णांक के उदाहरण पर देख सकते हैं 1934499, आप 9कई बार (इस मामले में) एक पूर्व संख्या ( 44449चार 4एस और 9उदाहरण में उपयोग के साथ समान) का उपयोग कर सकते हैं । हालाँकि समूह को निर्धारित करने के लिए उन्हें केवल एक बार गिना जाता है।
• आपको खाली समूहों के लिए आउटपुट में रिक्त आंतरिक सूची रखने की अनुमति नहीं है। इसलिए परीक्षण के मामले [1,58,85,-8,5,8585,5885,518]में परिणाम नहीं हो सकता है [[1,58,85,8,5],[518],[5885],[8585],[],[]], जहां खाली समूह और , और ऊपर दिए गए उदाहरण के परिणामस्वरूप परिणाम नहीं हो सकता है , जहां खाली समूह ।$X$$X-1$एक्स - 3[[34,9,4,19,-213,3,21],[1934499],[],[-199,94,-2134,44449],[44],[-34,213],[34]]$X-3$
• समूहों का क्रम सख्त है (जब तक कि आप एक मानचित्र का उपयोग नहीं करते हैं, क्योंकि तब तक समूह कुंजियों से काटा जा सकता है), लेकिन समूह के भीतर संख्याओं का क्रम किसी भी क्रम में हो सकता है। तो उपरोक्त उदाहरण में [34,9,4,19,-213,3,21]समूह के लिए भी या हो सकता है ।$1$[21,3,-213,19,4,9,34][-213,4,34,19,9,21,3]
• आपको गारंटी दी जाती है कि कभी भी कोई संख्या नहीं होगी जो कि पिछले नौ से अधिक संख्याओं से बन सकती है। इसलिए आपके पास कभी भी समूह नहीं होंगे, और संभव समूहों की सबसे बड़ी राशि 12 है:$X-10$$[1,X-9,X-8,...,X-2,X-1,X,X+1]$
• आप मान सकते हैं कि पूर्णांक अधिकतम सीमा में 32 बिट्स होंगे, इसलिए सीमा के भीतर [−2147483648,2147483647]।

सामान्य नियम:

• यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
  कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव संक्षिप्त उत्तर के साथ आने का प्रयास करें।
• डिफ़ॉल्ट I / O नियमों के साथ आपके उत्तर के लिए मानक नियम लागू होते हैं , इसलिए आपको उचित पैरामीटर और रिटर्न-प्रकार, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति है। तुम्हारा कॉल।
• डिफ़ॉल्ट लूपोल्स वर्जित हैं।
• यदि संभव हो, तो कृपया अपने कोड (यानी TIO ) के लिए एक परीक्षण के साथ एक लिंक जोड़ें ।
• साथ ही, आपके उत्तर के लिए स्पष्टीकरण जोड़ना अत्यधिक अनुशंसित है।

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

Input:  [34,9,4,-34,19,-199,34,-213,94,1934499,213,3,21,-2134,44449,44]
Output: [[34,9,4,19,-213,3,21],[1934499],[-199,94,-2134,44449],[44],[-34,213],[34]]

Input:  [17,21,3,-317,317,2,3,117,14,-4,-232,-43,317]
Output: [[17,21,3,2,117,14,-4],[-317,-232,-43],[317],[3,317]]

Input:  [2,4,8,10,12,-12,-102,488,10824]
Output: [[2,4,8,10,12],[10824],[-102,488],[-12]]

Input:  [0,100,-100,10000,-100,1001000]
Output: [[0,100],[10000,1001000],[-100],[-100]]

Input:  [1,58,85,-8,5,8585,5885,518]
Output: [[1,58,85,-8,5],[518],[5885],[8585]]

Input:  [4,-4,44,5,54]
Output: [[4,5],[54],[44],[-4]]

Comments

तो X + 1सटीक प्रतियों के लिए एक विशेष समूह है, और Xअन्य संख्याओं के लिए एक समूह है जो एक एकल संख्या की प्रतियों से बन सकता है, जैसे कि इसकी उपेक्षा?

— नील

@ArBo मान लें कि पूर्णांक अधिकतम 32 बिट्स हैं, इसलिए । तो आपका उदाहरण वैध इनपुट नहीं है, लेकिन संभव है। $[-2147483648, 2147483647]$[1, 1111111111]

— केविन क्रूज़सेन

खुद कलेक्टर होने के नाते: यह एक बहुत अच्छा संग्रह है जो आपको वहां मिला है, केविन। वाकई बहूत बढिया।

— जे। साले

मैं जादू इकट्ठा करता हूं: इकट्ठा करने वाले कार्ड और सेट, जो अभी भी अंतरिक्ष की एक बड़ी मात्रा में कब्जा कर लेते हैं, भले ही वे काफी छोटे हों।

— जे। साले

@ J.Sallé ओह, मैं भावना को जानता हूं। मैं पोकेमोन टीसीजी कार्ड भी इकट्ठा करता हूं (और वास्तव में दुनिया में दूसरा सबसे बड़ा पिकाचु टीसीजी संग्रह है जिसमें 1200 से अधिक अद्वितीय पिकाचु कार्ड हैं) .. जब आपके पास 9,000 से अधिक कार्ड हैं तो यह वास्तव में काफी जगह लेता है। पहेली के रूप में ज्यादा नहीं है, यद्यपि। 10. के बजाय केवल 1.5 अलमारियों; पी

— केविन क्रूज़सेन

Answer 1

जेली , 36 33 बाइट्स

ADṪŒṖfƑƇƊQ€Ẉ.*;,AṪe$€SƲṀµƤż⁸ṢZ¹ƙ/

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

मुझे यकीन है कि यह अधिक गोल्फ हो सकता है। ग्रिम के 05AB1E उत्तर से कुछ प्रेरणा ली गई है , इसलिए यह सुनिश्चित करना सुनिश्चित करें कि एक भी!

Answer 2

पायथन 3 , 565 564 524 523 500 437 399 394 393 389 385 372 बाइट्स

का उपयोग कर जानवर बल कार्यान्वयन itertools; सभी परीक्षण मामले टीआईओ पर 60 सेकंड की सीमा के भीतर नहीं चलते हैं।

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

के लिए धन्यवाद अरबो 101 बाइट्स, करने के लिए गोल्फ के लिए गैलेन इवानोव 19 बाइट्स, करने के लिए गोल्फ के लिए ElPedro 5 बाइट्स गोल्फ, करने के लिए के लिए movatica 17 बाइट्स, करने के लिए गोल्फ के लिए काले उल्लू काई 2 बाइट्स गोल्फ के लिए, करने के लिए विद्रूप 2 बाइट्स गोल्फ के लिए और करने के लिए केविन Cruijssen के लिए गोल्फ 1 बाइट।

from itertools import*
w=permutations
def c(l,x):
 for i in range(9):
  for q in w(map(abs,sum(l,[]))):
   for s in w(q[:i+1]*len(x)):
    z='';s=[*s]
    while x[len(z):]:
     z+=str(s.pop(0))
     if z==x:return 9-i
 return 0
def f(a):
 l=[[]for _ in a*6]
 for x in a:l[(x in sum(l,[]))*11or(-x in sum(l,[]))*10or any(l)and c(l,str(abs(x)))]+=x,
 return[*filter(len,l)]

स्पष्टीकरण:

from itertools import *
w = permutations  # We'll be using this twice

def c  # Helper function to calculate which group a number belongs in according to the concatenation rule; returns 0 (original) if none is found
(l, x):  # First parameter is the list of groups (a list of lists of numbers), second parameter is the number to investigate
 for i in range(9):  # There won't be any concatenations of more than 9 elements
  for q in w(map(abs,sum(l,[]))):  # Flatten l to get a plain list of previous numbers, then generate permutations of their absolute values as lists; for each permutation ...
   for s in w(q[:i+1]*len(x)):  # ... use only the first i + 1 elements; inflate the list with enough copies to compose the target number and permutate; then try to compose the target number from each permutation:
    z = ''  # Start with the empty string
    s = [*s]  # Convert permutation to list
    while x[len(z):]:  # Keep going until the length of the concatenated string equals the length of the target number
     z += str(s.pop(0))  # Concatenate the first element of the current permutation list and remove it
     if z == x:  # If the target number has been synthesized successfully ...
      return 9 - i  # stop searching and return the appropriate group
 return 0  # If no concatenation has been found, consider the number original

def f(a):  # Solution function, takes a list of numbers as argument
 l = [[] for _ in a * 6]  # Populate the result list with at least 12 empty groups if there is more than one number in the input (we'll be using only the first 12 and removing empty ones later); if there is just one, we'll only need one group in the output
 for x in a:  # For each number in order:
  l[(x in sum(l, [])) * 11 or (-x in sum(l, [])) * 10 or any(l) and c(l, str(abs(x)))] += x,  # If x is not the first number, attempt concatenation (if not, c(l, str(abs(x))) would crash due to l not containing any non-empty sublists; use absolute value of the number under investigation; convert to string since we'll be needing the number of digits and comparing it to a string later); if -x has already been seen, put it in Group X; if x has already been seen, put it in Group X + 1
  return [* filter(len, l)]  # Remove empty lists and return the result

पायथन 2 , 406 379 374 373 372 368 355 बाइट्स

एक ही दृष्टिकोण, लेकिन कुछ गोल्फ चाल के कारण कम पायथन 3 किसी भी अधिक का समर्थन नहीं करता है। के लिए धन्यवाद अरबो backport के लिए और 28 बाइट्स, करने के लिए गोल्फ के लिए ElPedro 5 बाइट्स गोल्फ, करने के लिए के लिए movatica 17 बाइट्स गोल्फ के लिए, और करने के लिए व्यंग्य 1 अधिक बाइट गोल्फ के लिए।

from itertools import*
w=permutations
def c(l,x):
 for i in range(9):
  for q in w(map(abs,sum(l,[]))):
	for s in map(list,w(q[:i+1]*len(x))):
	 z=''
	 while x[len(z):]:
		z+=`s.pop(0)`
		if z==x:return 9-i
 return 0
def f(a):
 l=[[]for _ in a*6]
 for x in a:l[(x in sum(l,[]))*11or(-x in sum(l,[]))*10or any(l)and c(l,`abs(x)`)]+=x,
 return filter(len,l)

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

Comments

टिप्पणियाँ विस्तारित चर्चा के लिए नहीं हैं; इस वार्तालाप को बातचीत में स्थानांतरित कर दिया गया है ।

— जेम्स

आप str(abs(x))फ़ंक्शन कॉल में (या पायथन 2 में बैकटिक्स के साथ एब्स (x) दोनों को फंक्शन कॉल में बदल सकते हैं और y = str (abs (x)) को हटाने के लिए फ़ंक्शन परिभाषा में x बदल सकते हैं। क्षमा करें, इस समय कार्य करने के लिए TIO नहीं मिल सकता है।

— ElPedro

आप lenएक और बाइट दाढ़ी से दाएं फ़िल्टर कर सकते हैं ?

— स्क्वीड

आप any()कॉल के अंदर सूची सिंटैक्स को हटा सकते हैं, इस प्रकार यह एक सामान्य जनरेटर बना सकता है, जो कि बस काम करता है और आपको 4 और बाइट्स बचाता है :)

— movatica

... और यहां तक ​​कि कम: दोनों (x in sum(l,[]))के any(x in s for s in l)लिए xऔर -x13 बाइट्स बचाता है!

— 20

Answer 3

पायथन 2 , 235 234 232 246 245 244 241 240 238 237 236 बाइट्स

from itertools import*
s=[];r=map(list,[s]*12)
for e in input():r[-(e in s)or max([10*(-e in s)]+[10-len(set(p[:i]))for p in permutations(`abs(x)`for x in s*11)for i in range(len(p))if''.join(p[:i])==`e`])]+=e,;s+=e,
print filter(len,r)

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

अन्य पायथन जवाब पर स्क्विड की टिप्पणी के लिए -1 बाइट

इस उत्तर से किसी भी मामले को सुलझाने की कोई उम्मीद नहीं है लेकिन परीक्षण मामलों का सबसे तुच्छ है। टीआईओ लिंक में, तेजी से एर निष्पादन समय के लिए कुछ मामलों में शुद्धता का त्याग s*11करके प्रतिस्थापित किया गया है , लेकिन जहां तक ​​मैं देख सकता हूं, इस पोस्ट में संस्करण हमेशा सही उत्तर देता है, सिद्धांत रूप में।s*2

व्याख्या

from itertools import*          # So that we can abuse permutations
s=[];                           # s will hold the already classified numbers
r=map(list,[s]*12)              # r will hold these too, but in the form of
                                #  a nested list, sorted by originality
for e in input():               # Here comes the big one; iterate over the input
 r[-(e in s)or                  # If e has already passed, it is not original
   max([10*(-e in s)]+          # Else, we count 10 - the number of seen elements
                                #  needed to make this one, or 0 if it's new,
                                #  or 10 if its inverse has already passed
   [10-len(set(p[:i]))          # The number of distinct elements in...
    for p in permutations(      #  for each permutation of the seen elements,
      `abs(x)`for x in s*11)
                                #  with values occuring up to 10 times (to
                                #  account for 1111111111, for example;
                                #  we need 11 here and not 10, because
                                #  p[:i] doesn't include i)...
    for i in range(len(p))      #  each prefix...
    if''.join(p[:i])            #  only if its concatenation is equal to
      ==`e`])]                  #  the current element
 +=e,;s+=e,                     # Append the element to the relevant lists
print filter(len,r)             # And finally, print the non-empty result lists

Comments

मुझे यह देखकर प्रसन्नता हुई है कि आपने अपना स्वयं का पायथन उत्तर बनाया है :-) और यह छोटा भी है!

— 20

@Oobalance अब, अगर केवल यह मेरे जीवनकाल के भीतर समाप्त हो जाएगा ...

— ArBo

ओह, मैं भूल गया कि विंडोज संस्करण के साथ यह कैसे मूर्खतापूर्ण बात है (यह int64-बिट संस्करण में भी केवल 32 बिट्स का उपयोग करता है )।

— feersum

Answer 4

05AB1E , 43 41 38 35 27 बाइट्स

.¡IN£UÄ.œεgΘ>XÄyÙå;P*}àXyå+

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

स्पष्टीकरण:

.¡                              # group by:
  IN£                           #  first N elements of the input, N being the iteration count
     U                          #  store this as X
  Ä                             #  absolute value of the current number
   .œ                           #  partitions (eg 449 => [[4, 4, 9], [44, 9], [4, 49], [449]])
     ε             }            #  map each partition to:
      gΘ>                       #   2 if length = 1, 1 otherwise
           yÙ                   #   for each unique element in the current partition:
         XÄ  å                  #    1 if it's in the absolute value of X, 0 otherwise
              ;                 #   divide all by 2
               P*               #   product of all these numbers
                  à             #  take the maximum
                   Xyå+         #  add 1 if X contains the current number

चूंकि समूह संख्याएँ आउटपुट का हिस्सा नहीं हैं, इसलिए जब तक ऑर्डर सही है, हम जितनी भी संख्याएँ चाहें उपयोग करने के लिए स्वतंत्र हैं। यह मूल संख्याओं के लिए 0, समूह XN के लिए 2 ^ -N, समूह X के लिए 1, समूह X + 1 के लिए 2 का उपयोग करता है।

Comments

मैं इस बात का स्पष्टीकरण देखना पसंद करूंगा कि यह कैसे काम करता है क्योंकि मैं 05AB1E नहीं पढ़ सकता।

— OOBalance

@ मैं एक स्पष्टीकरण जोड़ा, उम्मीद है कि यह पर्याप्त स्पष्ट है।

— ग्रैमी

धन्यवाद, यह अच्छी तरह से बताते हैं। अच्छा दृष्टिकोण, मेरा

— अपवित्र है

Answer 5

पायथन 2, 195 बाइट्स

सबसे धीमा परीक्षण मामला TIO पर पूरा नहीं हो सकता है , लेकिन मेरी मशीन पर केवल 10 सेकंड लगते हैं।

import re
a=[()];m=a*99
for n in input():
    i=0;r='-('
    while i<10>re.search(r'(\b.+\b).+'*i+r+')+$','%s-%%s'%a%n):i+=1;r+='|\\'+`i`
    m[48*(n in a)|32*(-n in a)|14-i]+=n,;a+=n,
print filter(len,m)

इसे LP64 पायथन बिल्ड ऑन के '%s-%%s'%a%nसाथ बदलकर 2 बाइट्स से छोटा किया जा सकता है `a`+'-'+`n`।

Answer 6

जावास्क्रिप्ट (Node.js) , 211 205 बाइट्स

a=>a.map(s=>(c[q=(G=(n,r=[],A=Math.abs,N=""+A(s))=>N[L="length"]<n[L]?0:N!=n?Math.max(0,...c.flat().map(x=>G(n+A(x),[...r,x]))):1/r?s-r?11:12:12+~new Set(r).size)``]=c[q]||[]).push(s),c=[])&&c.filter(x=>x)

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

इस धारणा का उपयोग करते हुए कि अधिकांश 12 समूह हैं।

जावास्क्रिप्ट (Node.js) , 267 226 221 218 211 बाइट्स

a=>a.map(s=>(c[q=(G=(n,r=[],A=Math.abs,N=""+A(s))=>N[L]<n[L]?0:N!=n?Math.max(0,...c.flat().map(x=>G(n+A(x),[...r,x]))):1/r?l-(s!=+r):l+~new Set(r).size)``]=c[q]||[]).push(s),c=[],l=a[L="length"])&&c.filter(x=>x)

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

a=>a.map(                       // Iterate through all items:
 s=>(c[q=(
  G=(                           //  Helper function to calculate index (=GroupNo-1):
   n,                           //   Stores different (repeatable) permutations
   r=[],                        //   Stores the elements used
   A=Math.abs,
   N=""+A(s))                   //   Stores the string version of the absolute value
  =>
  N[L="length"]<n[L]?           //   If n is longer then N:
   0                            //    0 (Group 1) - no permutation found to equal the string
  :N!=n?                        //   Else if N!=n:
   Math.max(0,...c.flat().map(  //    Return max of the results of the next recursion
    x=>G(n+A(x),[...r,x])       //    for each of the elements in c
   ))
  :1/r?                         //   Else if r has only 1 item: (=+s/-s)
   s-r?11:12                    //    Return l-1 (Group X) if r=-s, and l (Group X+1) if r=s
  :12+~new Set(r).size          //   Else: return l-r.size-1 (Group X-r.size)
 )``]=c[q]||[]).push(s),        //  Push the element into the corresponding array
 c=[]                           //  Initialize an empty array
)&&c.filter(x=>x)               // Filter out all empty groups

... या 193 बाइट्स अगर एक शब्दकोश वापस करना ठीक है:

a=>a.map(c=s=>(c[q=(G=(n,r=[],A=Math.abs,N=""+A(s))=>N[L="length"]<n[L]?-1/0:N!=n?Math.max(...d.map(x=>G(n+A(x),[...r,x]))):1/r?+!(s-r):-new Set(r).size)``]=c[q]||[]).push(s)&d.push(s),d=[])&&c

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

इस स्थिति में, कुंजी का -Infinityअर्थ है समूह 1 और अन्य कुंजियों का अर्थ है समूह X+key।