บทนำ:

ฉันรวบรวมปริศนาคดเคี้ยว ส่วนใหญ่ผลิตและจำหน่ายโดย บริษัท จีน บริษัท ที่มีชื่อเสียงส่วนใหญ่ขออนุญาตจากผู้ออกแบบตัวต่อเพื่อผลิตงานออกแบบและทำงานร่วมกันเพื่อนำไปสู่ผลิตภัณฑ์ในตลาด ในกรณีนี้ผู้ออกแบบเกมปริศนานั้นมีความสุขและภูมิใจมากที่หนึ่งในปริศนาของพวกเขาเข้าสู่ตลาด

อย่างไรก็ตามยังมี บริษัท ของจีนที่สร้างปริศนาเลียนแบบ การลอกเลียนแบบเหล่านี้มีทั้งการออกแบบที่ใช้โดยไม่ได้รับอนุญาตจากผู้สร้างดั้งเดิมหรือเป็นสำเนาที่มีคุณภาพต่ำกว่าของปริศนาที่มีอยู่เดิม

ท้าทาย:

เราจะพิจารณาความสามารถในการสร้างสรรค์ของตัวเลขที่ 'ปล่อย' ตามลำดับเฉพาะ (จากซ้ายไปขวา^† )
รับรายการจำนวนเต็มจัดกลุ่มและส่งออกตามความคิดริเริ่ม

ความคิดริเริ่มของตัวเลขถูกกำหนดอย่างไร?

• ตัวเลขซ้ำซ้อนกับตัวเลขก่อนหน้าหรือไม่ กลุ่ม (ต้นฉบับน้อยที่สุด) โดยที่กลุ่มต่อท้ายอยู่หลังจากกลุ่มอื่น ๆ ทั้งหมด$X+1$$X+1$
• เป็นตัวเลขที่ซ้ำกันของตัวเลขก่อนหน้า แต่เป็นค่าลบแทน (เช่นหมายเลขเดิมคือแต่ตอนนี้ ; หรือกลับกัน) กลุ่มX$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ป่านนี้:$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สาม - ตัวเลข)
• อย่างที่คุณเห็นในตัวอย่างสำหรับจำนวนเต็ม1934499คุณสามารถใช้หมายเลขก่อนหน้า ( 9ในกรณีนี้) หลาย ๆ ครั้ง (คล้ายกับการ44449ใช้สี่4s และ a 9ในตัวอย่าง) พวกเขาจะถูกนับเพียงครั้งเดียวเพื่อพิจารณากลุ่มอย่างไรก็ตาม
• คุณไม่ได้รับอนุญาตให้มีรายการภายในที่ว่างเปล่าในผลลัพธ์สำหรับกลุ่มที่ว่างเปล่า ดังนั้นกรณีทดสอบ[1,58,85,-8,5,8585,5885,518]อาจจะไม่ส่งผลในการ[[1,58,85,8,5],[518],[5885],[8585],[],[]]แทนซึ่งกลุ่มที่ว่างเปล่าเป็นและและตัวอย่างข้างต้นอาจจะไม่ส่งผลในการแทนซึ่งกลุ่มที่ว่างเปล่าเป็นX-3$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]
• คุณรับประกันได้ว่าจะไม่มีตัวเลขใด ๆ ที่สามารถสร้างขึ้นจากตัวเลขก่อนหน้านี้ได้มากกว่าเก้าหมายเลข ดังนั้นคุณจะไม่มีกลุ่มใด ๆและจำนวนกลุ่มที่มากที่สุดที่เป็นไปได้คือ 12:$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¹ƙ/

ลองออนไลน์!

ฉันแน่ใจว่านี่สามารถเล่นกอล์ฟได้มากกว่านี้ แรงบันดาลใจบางส่วนมาจากคำตอบของ 05AB1E ของ Grimyดังนั้นอย่าลืมลงมือทำเช่นนั้นด้วย!

Python 3 , 565 564 524 523 500 437 399 394 393 389 385 382 372 ไบต์

การใช้กำลังดุร้ายโดยใช้itertools; ไม่ใช่ทุกกรณีทดสอบวิ่งภายใน 60 วินาทีใน TIO จำกัด

ลองออนไลน์!

ขอบคุณArBoสำหรับการเล่นกอล์ฟ 101 ไบต์ถึงGalen Ivanovสำหรับการเล่นกอล์ฟ 19 ไบต์ถึงElPedroสำหรับการเล่นกอล์ฟ 5 ไบต์เพื่อmovaticaสำหรับการเล่นกอล์ฟ 17 ไบต์ถึงBlack Owl Kaiสำหรับการเล่นกอล์ฟ 2 ไบต์และปลาหมึกสำหรับการเล่นกอล์ฟ 2 ไบต์และKevin 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สำหรับ 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)

ลองออนไลน์!

Python 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 ไบต์ต้องขอบคุณ Squid's comment ใน Python อีกคำตอบ

คำตอบนี้ไม่มีความหวังในการแก้ปัญหาใด ๆ ยกเว้นกรณีทดสอบเล็กน้อยที่สุด ในการเชื่อมโยง TIO, 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 สำหรับหมายเลขดั้งเดิม 2 ^ -N สำหรับกลุ่ม XN, 1 สำหรับกลุ่ม X, 2 สำหรับกลุ่ม X + 1

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)

มันสามารถจะสั้นลงโดย 2 ไบต์ใน LP64 หลามสร้างโดยการแทนที่ด้วย'%s-%%s'%a%n`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หมายถึงกลุ่ม