Giới thiệu:

Tôi thu thập các câu đố xoắn. Hầu hết các câu đố xoắn được sản xuất và bán bởi các công ty Trung Quốc. Hầu hết các công ty nổi tiếng đều xin phép các nhà thiết kế câu đố để sản xuất các thiết kế của họ và cùng nhau hướng tới một sản phẩm trên thị trường. Trong trường hợp này, các nhà thiết kế câu đố tất nhiên rất vui mừng và tự hào rằng một trong những câu đố của họ được tung ra thị trường.

Tuy nhiên, cũng có những công ty Trung Quốc thực hiện các câu đố loại trực tiếp. Những tiếng gõ cửa này là những thiết kế được sử dụng mà không có sự cho phép của người tạo ban đầu, hoặc là những bản sao chất lượng thấp hơn rẻ hơn của các câu đố đã tồn tại.

Thử thách:

Chúng ta sẽ xác định tính độc đáo của con số mà được 'thả' theo một thứ tự cụ thể (từ trái sang phải ^† ).
Đưa ra một danh sách các số nguyên, nhóm và xuất chúng theo tính nguyên bản của chúng.

Làm thế nào là độc đáo của các số được xác định?

• Là một số trùng lặp chính xác của một số trước đó? Nhóm (ít nhất là bản gốc), trong đó nhóm đang theo sau, sau tất cả các nhóm khác.$X+1$$X+1$
• Là một số trùng lặp với một số trước đó, nhưng thay vào đó là số âm (tức là số ban đầu là , nhưng bây giờ ; hoặc ngược lại)? Nhóm .$n$$-n$$X$
• Giá trị tuyệt đối của số có thể được hình thành bằng cách ghép một hoặc nhiều số tuyệt đối sớm hơn và nó không phải là một phần của các nhóm được đề cập trước đó hoặc ? Nhóm , trong đó là số lượng các số riêng biệt được sử dụng trong phép nối (và ).$X+1$$X$$X-N$$N$$N\geq1$
• Con số không phù hợp với bất kỳ nhóm nào ở trên, vì vậy là hoàn toàn duy nhất cho đến nay? Nhóm (hầu hết nguyên bản), đang dẫn đầu trước tất cả các nhóm khác.$1$

Điều này nghe có vẻ khá mơ hồ, vì vậy đây là một ví dụ từng bước :

Danh sách đầu vào: [34,9,4,-34,19,-199,34,-213,94,1934499,213,3,21,-2134,44449,44]

• 34là số đầu tiên, luôn luôn là bản gốc và trong nhóm . Đầu ra cho đến nay:$1$[[34]]
• 9 cũng là bản gốc: [[34,9]]
• 4 cũng là bản gốc: [[34,9,4]]
• -34là số âm của số trước đó 34, vì vậy nó thuộc nhóm :$X$[[34,9,4],[-34]]
• 19 là bản gốc: [[34,9,4,19],[-34]]
• -199có thể được hình thành bởi hai số trước đó 19và 9do đó, nó thuộc nhóm :$X-2$[[34,9,4,19],[-199],[-34]]
• 34là bản sao chính xác của một số trước đó, vì vậy nó thuộc nhóm :$X+1$[[34,9,4,19],[-199],[-34],[34]]
• -213 là bản gốc: [[34,9,4,19,-213],[-199],[-34],[34]]
• 94có thể được hình thành bởi hai số trước đó 9và 4do đó, nó thuộc nhóm :$X-2$[[34,9,4,19,-213],[-199,94],[-34],[34]]
• 1934499có thể được hình thành bởi bốn con số trước đó 19, 34, 4, và hai lần 9, vì vậy trong nhóm :$X-4$[[34,9,4,19,-213],[19499],[-199,94],[-34],[34]]
• 213là số âm của số trước đó -213, vì vậy nó thuộc nhóm :$X$[[34,9,4,19,-213],[1934499],[-199,94],[-34,213],[34]]
• 3 là bản gốc: [[34,9,4,19,-213,3],[1934499],[-199,94],[-34,213],[34]]
• 21 là bản gốc: [[34,9,4,19,-213,3,21],[1934499],[-199,94],[-34,213],[34]]
• -2134có thể được hình thành bởi hai số trước đó 213và 4(hoặc ba con số trước đó 21, 3và 4, nhưng chúng tôi luôn luôn sử dụng số tiền ít nhất của concatenating số để xác định sự độc đáo), vì vậy nó là trong nhóm :$X-2$[[34,9,4,19,-213,3,21],[1934499],[-199,94,-2134],[-34,213],[34]]
• 44449có thể được hình thành bởi hai số trước đó bốn lần 4và 9vì vậy nó thuộc nhóm :$X-2$[[34,9,4,19,-213,3,21],[1934499],[-199,94,-2134,44449],[-34,213],[34]]
• 44có thể được hình thành bởi một số trước đó 4, lặp lại hai lần, vì vậy nó thuộc nhóm : $X-1$[[34,9,4,19,-213,3,21],[1934499],[-199,94,-2134,44449],[44],[-34,213],[34]]

Vì vậy, cho đầu vào [34,9,4,-34,19,-199,34,-213,94,1934499,213,3,21,-2134,44449,44]là đầu ra [[34,9,4,19,-213,3,21],[1934499],[-199,94,-2134,44449],[44],[-34,213],[34]].

Quy tắc thử thách:

• I / O là linh hoạt. Bạn có thể nhập dưới dạng danh sách / mảng / luồng số nguyên hoặc chuỗi, nhập từng cái một qua STDIN, v.v. Đầu ra có thể là bản đồ với các nhóm làm khóa, danh sách lồng nhau làm ví dụ và trường hợp kiểm tra trong thử thách này, được in dòng mới tách, vv
• Bạn được phép lấy danh sách đầu vào theo thứ tự đảo ngược (có lẽ hữu ích cho các ngôn ngữ dựa trên ngăn xếp). ^† Trong trường hợp này, ngay từ trái sang nói là tất nhiên phải sang trái.
• Như bạn có thể nhìn thấy ở ví dụ cho số nguyên -2134, chúng tôi luôn nhóm một con số đó là một nối các con số khác với càng ít càng tốt (được thành lập bởi 213và 4- hai con số; và không bằng 21, 3và 4- ba số).
• Như bạn có thể thấy trong ví dụ về số nguyên 1934499, bạn có thể sử dụng một số trước đó ( 9trong trường hợp này) nhiều lần (tương tự với 44449việc sử dụng bốn 4s và a 9trong ví dụ). Họ chỉ được tính một lần để xác định nhóm tuy nhiên.
• Bạn không được phép có các danh sách bên trong trống trong đầu ra cho các nhóm trống. Vì vậy, trường hợp thử nghiệm [1,58,85,-8,5,8585,5885,518]có thể không dẫn đến [[1,58,85,8,5],[518],[5885],[8585],[],[]]thay vào đó, trong đó các nhóm trống là và , và ví dụ trên có thể không dẫn đến thay vào đó, trong đó nhóm trống là .$X$$X-1$X - 3[[34,9,4,19,-213,3,21],[1934499],[],[-199,94,-2134,44449],[44],[-34,213],[34]]$X-3$
• Thứ tự của các nhóm rất nghiêm ngặt (trừ khi bạn sử dụng bản đồ, vì các nhóm sau đó có thể được khấu trừ khỏi các khóa), nhưng thứ tự của các số trong một nhóm có thể theo bất kỳ thứ tự nào. Vì vậy, [34,9,4,19,-213,3,21]cho nhóm trong ví dụ trên cũng có thể hoặc .$1$[21,3,-213,19,4,9,34][-213,4,34,19,9,21,3]
• Bạn được đảm bảo rằng sẽ không bao giờ có bất kỳ số nào có thể được hình thành bởi hơn chín số trước đó. Vì vậy, bạn sẽ không bao giờ có bất kỳ nhóm và số lượng nhóm lớn nhất có thể là 12:$X-10$$[1,X-9,X-8,...,X-2,X-1,X,X+1]$
• Bạn có thể giả sử các số nguyên sẽ có tối đa 32 bit, do đó trong phạm vi [−2147483648,2147483647].

Quy tắc chung:

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.
  Đừng để ngôn ngữ mã-golf ngăn cản bạn đăng câu trả lời với các ngôn ngữ không mã hóa. Cố gắng đưa ra một câu trả lời càng ngắn càng tốt cho ngôn ngữ lập trình 'bất kỳ'.
• Quy tắc chuẩn áp dụng cho câu trả lời của bạn với quy tắc I / O mặc định , vì vậy bạn được phép sử dụng STDIN / STDOUT, các hàm / phương thức với các tham số thích hợp và kiểu trả về, chương trình đầy đủ. Cuộc gọi của bạn.
• Lỗ hổng mặc định bị cấm.
• Nếu có thể, vui lòng thêm một liên kết với một bài kiểm tra cho mã của bạn (ví dụ TIO ).
• Ngoài ra, thêm một lời giải thích cho câu trả lời của bạn rất được khuyến khích.

Các trường hợp thử nghiệm:

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

Thạch , 36 33 byte

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

Hãy thử trực tuyến!

Tôi chắc chắn rằng điều này có thể được chơi golf nhiều hơn. Một số nguồn cảm hứng lấy từ câu trả lời 05AB1E của Grimy , vì vậy hãy chắc chắn cũng nâng cấp nó!

Python 3 , 565 564 524 523 500 437 399 394 393 389 385 372 byte

Thực hiện sử dụng vũ lực itertools; không phải tất cả các trường hợp thử nghiệm đều chạy trong giới hạn 60 giây trên TIO.

Hãy thử trực tuyến!

Nhờ Arbo cho chơi golf 101 byte, để Galen Ivanov cho chơi golf 19 byte, để ElPedro cho chơi golf 5 byte, để movatica cho chơi golf 17 byte, để Đen Owl Kai cho chơi golf 2 byte, để mực cho chơi golf 2 byte và Kevin Cruijssen cho chơi golf 1 byte.

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

Giải trình:

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

Python 2 , 406 379 374 373 372 368 355 byte

Cách tiếp cận tương tự, nhưng ngắn hơn do một số thủ thuật chơi gôn Python 3 không hỗ trợ nữa. Cảm ơn ArBo về backport và chơi golf 28 byte, ElPedro để chơi golf 5 byte, để di chuyển để chơi golf 17 byte và để câu mực để chơi golf thêm 1 byte.

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)

Hãy thử trực tuyến!

Python 2 , 235 234 232 246 245 244 241 240 238 237 236 byte

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)

Hãy thử trực tuyến!

-1 byte nhờ nhận xét của Squid về câu trả lời Python khác

Câu trả lời này không có hy vọng giải quyết bất kỳ trường hợp thử nghiệm tầm thường nào. Trong liên kết TIO, s*11đã được thay thế bởi s*2, hy sinh tính chính xác trong một số trường hợp cho nhanh er thời gian thực hiện, nhưng như xa như tôi có thể thấy, phiên bản trong bài viết này luôn mang lại câu trả lời đúng, về mặt lý thuyết.

Giải trình

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

05AB1E , 43 41 38 35 27 byte

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

Hãy thử trực tuyến!

Giải trình:

.¡                              # 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

Vì số nhóm không phải là một phần của đầu ra, chúng tôi có thể sử dụng bất kỳ số nào chúng tôi muốn, miễn là thứ tự đúng. Điều này sử dụng 0 cho số gốc, 2 ^ -N cho nhóm XN, 1 cho nhóm X, 2 cho nhóm X + 1.

Python 2, 195 byte

Trường hợp thử nghiệm chậm nhất không thể hoàn thành trên TIO , nhưng chỉ mất khoảng 10 giây trên máy của tôi.

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)

Nó có thể được rút ngắn 2 byte trên các bản dựng LP64 Python bằng cách thay thế '%s-%%s'%a%nbằng `a`+'-'+`n`.

JavaScript (Node.js) , 211 205 byte

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)

Hãy thử trực tuyến!

Sử dụng giả định rằng có nhiều nhất là 12 nhóm.

JavaScript (Node.js) , 267 226 221 218 211 byte

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)

Hãy thử trực tuyến!

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

... hoặc 193 byte nếu trả lại từ điển là được:

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

Hãy thử trực tuyến!

Trong trường hợp này, khóa -Infinitycó nghĩa là Nhóm 1 và các khóa khác có nghĩa là Nhóm X+key.