소개:

나는 트위스트 퍼즐을 수집합니다. 대부분의 뒤틀린 퍼즐은 중국 회사에서 생산하고 판매합니다. 대부분의 잘 알려진 회사는 퍼즐 디자이너의 허가를 얻어 디자인을 제작하고 시장에 출시 된 제품을 향해 협력합니다. 이 경우 퍼즐 디자이너는 물론 퍼즐 중 하나가 시장에 출시 된 것을 매우 기쁘게 생각합니다.

그러나 노크 오프 퍼즐을 만드는 중국 회사들도 있습니다. 이러한 넉 오프는 원래 제작자의 허가없이 사용 된 디자인이거나 기존 퍼즐의 품질이 훨씬 저렴한 저품질 사본입니다.

도전:

특정 순서 (왼쪽에서 오른쪽으로 ^† ) 로 '릴리스'된 숫자의 독창성을 결정합니다 .
정수 목록이 주어지면 독창성을 기준으로 그룹화하고 출력하십시오.

숫자의 독창성은 어떻게 결정됩니까?

• 숫자가 이전 숫자와 정확히 중복됩니까? 그룹 $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을 통해 하나씩 입력 할 수 있습니다. 출력은 그룹으로 키, 중첩 된 목록을 예로 들어 맵으로,이 챌린지에서 테스트 케이스로 인쇄 할 수 있습니다. 줄 바꿈 등
• 입력 목록을 역순으로 가져올 수 있습니다 (아마도 스택 기반 언어에 유용 할 수 있음). ^† 이 경우 언급 된 왼쪽에서 오른쪽은 물론 오른쪽에서 왼쪽입니다.
• 당신이 정수의 예에서 볼 수 있듯이 -2134, 우리는 항상 그룹 몇이 가능한 다른 숫자의 연결 한 수 (형성 213및 4- 두 개의 숫자, 그리고하지 않음으로써 21, 3그리고 4- 세 개의 숫자).
• integer의 예제에서 볼 수 있듯이 1934499이전 숫자 ( 9이 경우)를 여러 번 사용할 수 있습니다 ( 44449네 개의 4s 및9 예제에서는 ). 그러나 그룹을 결정하기 위해 한 번만 계산됩니다.
• 빈 그룹의 출력에 빈 내부 목록을 가질 수 없습니다. 따라서 빈 그룹이 X 및 X - 1 인 경우 테스트 사례 [1,58,85,-8,5,8585,5885,518]가 [[1,58,85,8,5],[518],[5885],[8585],[],[]]대신 생성되지 않을 수 있으며 위의 예는$X$$X-1$[[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$ for 는 [21,3,-213,19,4,9,34]또는 일 수도 있습니다 [-213,4,34,19,9,21,3].
• 9 개 이상의 이전 숫자로 구성 할 수있는 숫자는 절대 없을 것입니다. 당신은 상관하지 않습니다 그래서 $X-10$ : 그룹 및 가능한 그룹의 가장 큰 금액을 12 $[1,X-9,X-8,...,X-2,X-1,X,X+1]$
• 정수는 최대 32 비트이므로 범위 내에 있다고 가정 할 수 있습니다 [−2147483648,2147483647].

일반 규칙:

• 이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.
  코드 골프 언어가 코드 골프 언어 이외의 언어로 답변을 게시하지 못하게하십시오. '모든'프로그래밍 언어에 대한 가능한 한 짧은 대답을 생각해보십시오.
• 표준 규칙 은 기본 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]]

젤리 , 36 33 바이트

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

온라인으로 사용해보십시오!

나는 이것이 더 골프 될 수 있다고 확신합니다. Grimy의 05AB1E 답변 에서 영감을 얻었 으므로 그 중 하나를 찬성 해야합니다!

Python 3 , 565 564 524 523 500 437 399 394 393 389 385 372 바이트

itertools;를 사용한 무차별 구현 모든 테스트 사례가 TIO에서 60 초 이내에 실행되는 것은 아닙니다.

온라인으로 사용해보십시오!

덕분에 ARBÖ 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 바이트

동일한 접근법이지만 일부 골프 트릭으로 인해 더 짧습니다 .Python 3는 더 이상 지원하지 않습니다. 덕분에 ARBÖ 백 포트 및 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)

온라인으로 사용해보십시오!

파이썬 (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)

온라인으로 사용해보십시오!

다른 Python 답변에 대한 Squid의 의견 덕분에 -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

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를 사용합니다.

파이썬 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 Python 빌드에서로 교체 '%s-%%s'%a%n하여 2 바이트 단축 할 수 있습니다 `a`+'-'+`n`.

자바 스크립트 (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합니다.