前書き：

ツイスティパズルを収集します。ほとんどのツイスティパズルは、中国企業によって製造および販売されています。ほとんどの有名企業は、パズルデザイナーにデザインを作成し、市場の製品に向けて協力する許可を求めています。この場合、パズルデザイナーはもちろん、パズルの1つが市場に出回ったことを非常に喜んで誇りに思っています。

しかし、模造パズルを作成する中国企業もあります。これらの模造品は、元の作成者の許可なしに使用されたデザイン、または既存のパズルのまったく安価で低品質のコピーです。

チャレンジ：

特定の順序（左から右へ^†）で「リリース」された番号の独創性を判断します。
整数のリストが与えられたら、それらをオリジナリティでグループ化して出力します。

数字の独創性はどのように決定されますか？

• 番号は以前の番号とまったく同じですか？グループ$X+1$（オリジナルが最も少ない）。グループ$X+1$は、他のすべてのグループの後に続きます。
• 番号は、以前の番号の重複ですが、その負のではなく（つまり、元の数だった$n$が、今$-n$、またはその逆）？グループ$X$。
• 数値の絶対値は、1つ以上の以前の絶対数を連結することで形成できますか？また、前述のグループ$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は、前の2つの数字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は、以前の2つの数字9と4で形成できるため、グループます。$X-2$[[34,9,4,19,-213],[-199,94],[-34],[34]]
• 19344994つの以前の数値を用いて形成することができる19、34、4、および2回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]]
• -213421342134$X-2$[[34,9,4,19,-213,3,21],[1934499],[-199,94,-2134],[-34,213],[34]]
• 4444949$X-2$[[34,9,4,19,-213,3,21],[1934499],[-199,94,-2134,44449],[-34,213],[34]]
• 444$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などを介して1つずつ入力したりできます。出力はグループをキーとしてマップ、ネストされたリストを例として、このチャレンジのテストケースを印刷できます改行区切りなど
• 入力リストを逆の順序で使用できます（スタックベースの言語に役立つ可能性があります）。^†その場合、前述の左から右はもちろん右から左です。
• あなたは、整数のための例でもわかるように-2134、私たちは常にグループできるだけ少ないようで、他の数字の連結である数（によって形成された213と4-二つの数、およびしないことにより21、3および4- 3つの数字）。
• integerの例で1934499わかるように、以前の数値（9この場合）を複数回使用できます（例で444494つ4のsとa を使用するのと同様9）。ただし、グループを決定するために一度だけカウントされます。
• [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$[21,3,-213,19,4,9,34][-213,4,34,19,9,21,3]
• $X-10$$[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秒の制限内で実行されるわけではありません。

オンラインでお試しください！

おかげARBOに、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

Pythonの2、406の 379 374 373 372 368 355バイト

同じアプローチですが、いくつかのゴルフのトリックのために短くなりましたPython 3はもうサポートしていません。おかげARBOバックポート用とに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バイト

この答えには、最も些細なテストケース以外の解決策はありません。TIOのリンクでは、s*11置き換えられていs*2高速のためのいくつかのケースでは正確さを犠牲に、ERの実行時間が、私の知る限り、この記事ではバージョンは、常に理論的には、正しい答えが得られます。

説明

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を使用します。

Python 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`。

JavaScript（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のグループがあるという仮定を使用します。

JavaScriptの（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ます。