สำหรับความท้าทายนี้คุณต้องใช้Abbrevโมดูลของรูบี้ในโค้ดให้น้อยที่สุด

ท้าทาย

• การป้อนข้อมูลจะเป็นสิ่งที่ภาษาของคุณมีเป็นอาร์เรย์ (อาร์เรย์รายการลำดับ ฯลฯ ) ของสตริง คุณอาจเขียนฟังก์ชันหรือคุณอาจยอมรับคำที่คั่นด้วยเครื่องหมายจุลภาคใน STDIN

• จากนั้นคุณต้องคำนวณชุดคำนำหน้าที่ไม่คลุมเครือสำหรับสตริงเหล่านั้น ซึ่งหมายความว่าคุณต้องส่งคืนแฮช (หรือแผนที่วัตถุ ฯลฯ ) ของตัวย่อเป็นสตริงดั้งเดิม

  • "คำนำหน้า" เป็นสตริงย่อยของสตริงต้นฉบับเริ่มต้นที่จุดเริ่มต้นของสตริง ตัวอย่างเช่น "pref" เป็นคำนำหน้าของคำว่า "prefix"

  • โปร่งใสคำนำหน้าเป็นสิ่งหนึ่งที่สามารถหมายถึงหนึ่งคำ ตัวอย่างเช่นถ้าใส่ของคุณเป็นcar,catแล้วcaไม่ได้เป็นคำนำหน้าชัดเจนเพราะมันอาจหมายถึงทั้ง "รถ" หรือ "แมว".

  • ข้อยกเว้นของกฎนี้คือคำนั้นเป็นคำนำหน้าของตัวเองเสมอ ตัวอย่างเช่นถ้าคุณมีการป้อนข้อมูลเช่นcar,carpet, car:carจะต้องอยู่ในการส่งออกของคุณ

• จากนั้นคุณสามารถส่งคืนแฮช / แผนที่ / วัตถุ / ฯลฯ จากการทำงานของคุณ (หรือเทียบเท่าทำในภาษาของคุณ) หรือพิมพ์ออกมาเพื่อ STDOUT ในคู่ในรูปแบบของkey:value f:foo,fo:foo,...(คู่ของคีย์ - ค่าอาจคั่นด้วยช่องว่างหากรหัสของคุณสั้นลง)

กรณีทดสอบ

Input  code,golf,going
Output c:code,co:code,cod:code,code:code,gol:golf,golf:golf,goi:going,goin:going,going:going

Input  pie
Output p:pie,pi:pie,pie:pie

Input  pie,pier,pierre
Output pie:pie,pier:pier,pierr:pierre,pierre:pierre

Input  a,dog
Output a:a,d:dog,do:dog,dog:dog

กฎระเบียบ

• อินพุตจะไม่มีองค์ประกอบที่ซ้ำกัน

• ผลลัพธ์ของคุณอาจอยู่ในลำดับใด ๆ คุณไม่จำเป็นต้องจัดเรียง

• คุณไม่สามารถใช้Abbrevโมดูล / ฟังก์ชั่น / สิ่งในตัวเช่นรูดี้ได้

• นี่คือโค้ดกอล์ฟดังนั้นโค้ดที่สั้นที่สุดเป็นไบต์จะเป็นผู้ชนะ!

APL (46)

(ใช่ชุดอักขระ APL มีขนาดพอดีกับพื้นที่ว่าง)

{↑{∆/⍨2=⍴∆←(⊂⍵),∆/⍨⊃¨⍵∘⍷¨∆}¨∪⊃,/{↑∘⍵¨⍳⍴⍵}¨∆←⍵}

นี่คือฟังก์ชั่นที่รับรายการสตริงและส่งกลับเมทริกซ์ 2 คูณด้วยแต่ละแถวมีคำนำหน้าไม่น่าสงสัยและคำที่มันเป็น:

{↑{∆/⍨2=⍴∆←(⊂⍵),∆/⍨⊃¨⍵∘⍷¨∆}¨∪⊃,/{↑∘⍵¨⍳⍴⍵}¨∆←⍵}'code' 'golf' 'going'
 c      code  
 co     code  
 cod    code  
 code   code   
 gol    golf  
 golf   golf  
 goi    going 
 goin   going 
 going  going 

คำอธิบาย:

• ∆←⍵: ∆เก็บอาร์กิวเมนต์ที่ถูกต้องใน
• {↑∘⍵¨⍳⍴⍵}¨∆: สำหรับแต่ละองค์ประกอบของ∆รับส่วนนำหน้าที่เป็นไปได้ขององค์ประกอบนั้น:
  • ⍳⍴⍵: รับรายการจาก1ความยาวของ⍵
  • ↑∘⍵¨: ⍵สำหรับแต่ละตัวเลขเหล่านั้นได้รับที่องค์ประกอบหลายอย่างจาก
• ∪⊃,/: เชื่อมต่อรายการเข้าด้วยกันและนำค่าที่ไม่ซ้ำกัน
• {... }¨: สำหรับแต่ละคำนำหน้าไม่ซ้ำกัน:
  • ∆/⍨⊃¨⍵∘⍷¨∆: เลือกคำที่ขึ้นต้นด้วยคำนำหน้านั้น
  • (⊂⍵),: ใส่คำนำหน้าและต่อเชื่อม
  • ∆/⍨2=⍴∆←: กลับรายการเท่านั้นหากมีสององค์ประกอบ (คำนำหน้าและคำที่ตรงกันหนึ่งคำ)
• ↑: เปลี่ยนรายการของสิ่งอันดับเป็นเมทริกซ์

Python 2.7 - 146 141 ไบต์

l=raw_input().split(',')
for w in l:
 for a in range(len(w)):
    e=w[:a+1]
    if e==w or len(filter(lambda b:b.startswith(e),l))==1:print e+':'+w

โปรดสังเกตว่าการเยื้องในบรรทัด 4 และ 5 ไม่ใช่ 4 ช่องว่างนั่นคือผลข้างเคียงของล่ามมาร์กอัปของ SE นั่นเป็นอักขระแท็บตัวอักษรดังนั้นจึงมีเพียงหนึ่งไบต์

นี่ไม่ใช่เทคนิคตามมาตรฐาน แต่ฉันจะเปลี่ยนถ้า Doorknob ชี้แจง มันใช้ขึ้นบรรทัดใหม่แทนเครื่องหมายจุลภาคเพื่อแยกเอาท์พุท ตัวอย่างเช่น:

$ python2 abbreviations.py <<< code,golf,golfing
c:code
co:code
cod:code
code:code
golf:golf
golfi:golfing
golfin:golfing
golfing:golfing

ใหม่:ฉันก็สามารถที่จะกำจัดของ 5 eตัวอักษรโดยการกำหนดสตริงที่ผมตรวจสอบให้กับตัวแปร ซึ่งหมายความว่าฉันต้องพิมพ์eแทนw[:a]สามครั้งเท่านั้น แต่ยังหมายถึงฉันบันทึกตัวอักษรด้วยการทำe=w[:a+1]และการเปลี่ยนแปลงไป...range(1,len(w)+1)range(len(w))

คำอธิบาย:

l=raw_input().split(',') # Gets a line of input from stdin and splits it at every ',' to make a list
for w in l: # For each word in that list...

 for a in range(1,len(w)+1): # For each number a from 1 to the length of that word...

    if (w[:a]==w # w[:a] gets the string w up to the ath index. For example, 'aeiou'[:3] == 'aei'.
                 # We're testing every possible w[:a] to see if it's a unique abbreviation.
                 # However, a word is always its own abbreviation, so we hardcode that in by testing
                 # if w[:a] is the same as w.

or len(filter( # filter takes a function and an iterable as an argument, and returns a list of every
               # element of that iterable where that_function(that_element) returns a True-y value

lambda b:b.startswith(w[:a]),l) # We define an anonymous function that returns True for any string
                                # that begins with our current w[:a]. We filter for words that return
                                # True.

)==1): # If exactly one word returns True for this, it's a unique abbreviation!

     print w[:a]+':'+w # Print the abbreviation, a colon, and the full word.

J - 47 ตัวอักษร

(,.~~.@,~[:(#~1-1({.\e."_1]\.){."1)@;(<\,.<)&.>)

J เห็นสตริงเป็นเพียงเวกเตอร์ของตัวละครซึ่งหมายความว่าเมื่อมันพยายามที่จะสร้างรายการของสตริงมันจริง ๆ แล้วจบลงด้วยการสร้างตารางของตัวละครดังนั้นจุดสิ้นสุดจึงมีช่องว่าง คำตอบของเจนี้เรียกว่ากล่องดังนั้นฟังก์ชั่นนี้ใช้เป็นอาร์กิวเมนต์ของกล่องข้อความเพื่อรักษาความยาว

   'code';'golf';'going'
+----+----+-----+
|code|golf|going|
+----+----+-----+

นอกจากนี้ J ขาดประเภทแฮชดังนั้นสิ่งที่ใกล้เคียงที่สุดคือรายการตารางสองคอลัมน์เช่นสตริงที่มีกล่องเป็นต้น หากนั่นเป็นสิ่งที่ยอมรับไม่ได้และฉันต้องตั้งค่าเริ่มต้นให้เป็นรูปแบบคีย์ - ค่าฉันสามารถฟอร์แมตเอาต์พุตไปยังแบบฟอร์มนี้ด้วยความยาวรวม67 ตัวอักษร :

;@|.@,@((<&>',:'),."1,.~~.@,[:(#~1-1({.\e."_1]\.){:"1)@;(<,.<\)&.>)

คำอธิบายจากการระเบิด:

(,.~~.@,[:(#~1-1({.\e."_1]\.){."1)@;(<\,.<)&.>) NB. unambiguous prefixes
                                    (     )&.>  NB. for each string:
                                     <\         NB.   take all prefixes
                                       ,.<      NB.   pair each with string
        [:                         ;            NB. gather up "partial" hashes
          (#~1-                  )@             NB. remove those rows where:
               1({.\        ){."1               NB.   each key
                    e."_1                       NB.   is an element of
               1(        ]\.){."1               NB.   the rest of the keys
 ,.~                                            NB. hash each word to itself
       ,                                        NB. add these rows to hash
    ~.@                                         NB. remove duplicate rows

ตัวอย่าง:

   (,.~~.@,[:(#~1-1({.\e."_1]\.){."1)@;(<\,.<)&.>) 'pie';'pier';'pierre'
+------+------+
|pie   |pie   |
+------+------+
|pier  |pier  |
+------+------+
|pierre|pierre|
+------+------+
|pierr |pierre|
+------+------+
   NB. 1-char words have to be made into lists with ,
   (,.~~.@,[:(#~1-1({.\e."_1]\.){."1)@;(<\,.<)&.>) (,'a');'dog'
+---+---+
|a  |a  |
+---+---+
|dog|dog|
+---+---+
|d  |dog|
+---+---+
|do |dog|
+---+---+
   NB. "key:value," format, reversed order to save chars
   ;@|.@,@((<&>',:'),."1,.~~.@,[:(#~1-1({.\e."_1]\.){:"1)@;(<,.<\)&.>) 'code';'golf';'going'
goin:going,goi:going,gol:golf,cod:code,co:code,c:code,going:going,golf:golf,code:code,

Haskell 96 87

import Data.List
i=inits
f a=a>>= \x->[(y,x)|y<-i x,y/="",y`notElem`(a>>=i)\\i x||y==x]

เวอร์ชันที่ไม่ถูกปรับแต่ง:

 import Data.List
 f a = concatMap (\x ->
     [(y, x) |
      y <- inits x,
      y /= "",
      y `notElem` concatMap inits a \\ inits x || y == x]
     ) a

ตัวอย่าง:

> f ["pi","pier","pierre"]
[("pi","pi"),("pier","pier"),("pierr","pierre"),("pierre","pierre")]

ฉันใช้initsฟังก์ชันซึ่งค้นหาคำนำหน้าทั้งหมดของรายการ / สตริง มันนับว่าเป็นการโกงหรือไม่?

Python 3 (97)

c=','
S=c+input()
for w in S.split(c):
 e=w
 while e:e<w<w*S.count(c+e)or print(e+':'+w);e=e[:-1]

เราวนซ้ำคำนำหน้าของแต่ละคำในอินพุตโดยพิมพ์คู่นำหน้า / คำที่ตรงกันหากปรากฏขึ้นหนึ่งครั้งหรือทั้งคำ เราใช้ประโยชน์จากพฤติกรรมการลัดวงจรของor(และprintเป็นฟังก์ชัน) เพื่อพิมพ์เฉพาะเมื่อตรงตามเงื่อนไขข้อใดข้อหนึ่งเหล่านี้

การwhileวนซ้ำจะตัดอักขระตัวสุดท้ายออกซ้ำ ๆ เพื่อสร้างคำนำหน้าที่สั้นลงและสั้นลงโดยยกเลิกเมื่อสตริงว่างยังคงอยู่ นี่เป็นครั้งเดียวที่เราจัดทำดัชนีหรือแบ่งเป็นอะไรก็ได้

เรานับการเกิดขึ้นของคำนำหน้าeในการป้อนข้อมูลโดยการค้นหาสายป้อนคั่นด้วยเครื่องหมายจุลภาคเดิมสำหรับสตริงS ','+eเราเติมเครื่องหมายจุลภาคให้กับสตริงอินพุตก่อนหน้า การเพิ่มนี้ทำให้องค์ประกอบสตริงว่างพิเศษเมื่อเราsplitแต่สิ่งนี้ไม่มีผลเพราะมันไม่มีสตริงย่อยที่ไม่ว่างเปล่า

ในการตรวจสอบกรณีและปัญหาเมื่อสตริงย่อยeเป็นทั้งคำwเราจะทำการเปรียบเทียบโดยใช้ตัวดำเนินการเปรียบเทียบสตริง สิ่งนี้เปรียบเทียบพจนานุกรมด้วยคำนำหน้าคำนำหน้าจึงสั้นลงจึงเล็กลง การเปรียบเทียบคู่ล้มเหลวถ้าอย่างใดอย่างหนึ่งหรือe==wS.count(c+e)<2

หากe,wอนุญาตให้พิมพ์ผลงานในรูปแบบได้ฉันจะบันทึกอักขระด้วยการเขียนe+c+wแทน

ให้เครดิตกับundergroundmonorailจากคำตอบที่ฉันใช้โครงสร้างรหัสโดยรวมของฉัน

ทับทิม, 114

def f(l);h={};l.each{|w|w.size.times{|i|k=w[0..i];h[k]=h[k]&&0||w}};h.delete_if{|k,v|v==0};l.each{|w|h[w]=w};h end

Ungolfed:

def f(list)
  hash = {}
  list.each do |word|
    word.size.times do |i|
      key = word[0..i]
      h[key] = (hash[key] && 0) || word
    end
  end
  hash.delete_if{|key, value| v==0}
  list.each{|word| hash[word] = word}
  hash 
end

k4 (70)

ไม่กอล์ฟโดยเฉพาะอย่างยิ่ง; ฉันแน่ใจว่ามันอาจจะสั้นกว่านี้

ค่อนข้างคล้ายกับ J impl ด้านบนฉันคิดว่า - เพียงแค่รวบรวมคำนำหน้า (ที่เหมาะสม) ทั้งหมดเอาคำออกจากคำนำหน้าอีกครั้ง (เพื่อจัดการกับ"car"/ "carpet"กรณี) จัดกลุ่มคำเหล่านั้นเป็นคลาสที่เท่าเทียมกันเลือกคลาสที่มีองค์ประกอบเดียวเท่านั้น สตริงและเพิ่มในแผนที่จากสตริงเพื่อตัวเอง

f:{(x!x),*:'{(&1=#:'x)#x}{x@=y@:&~y in x}.,/'+{1_'(c#,x;(!c:#x)#\:x)}'x}

บางกรณีทดสอบ

โปรดทราบว่าในk/ q, สตริงเป็นรายการของตัวละครดังนั้นสตริงที่มีเพียงตัวเดียวจะต้องมีการทำเครื่องหมายเป็นเช่นนี้โดยใช้,ฟังก์ชั่นยูนารี; & mmwrt รายการสตริงที่มีเพียงสตริงเดียว

เหล่านี้ใช้งานqของshowฟังก์ชั่นที่มีในตัวจัดรูปแบบโครงสร้างข้อมูลบางอย่างที่จะทำให้ผลการอ่านเพิ่มเติมได้ที่:

  .q.show f("code";"golf";"going")
"code" | "code"
"golf" | "golf"
"going"| "going"
,"c"   | "code"
"co"   | "code"
"cod"  | "code"
"gol"  | "golf"
"goi"  | "going"
"goin" | "going"
  .q.show f@,"pie"
"pie"| "pie"
,"p" | "pie"
"pi" | "pie"
  .q.show f("pie";"pier";"pierre")
"pie"   | "pie"
"pier"  | "pier"
"pierre"| "pierre"
"pierr" | "pierre"
  .q.show f(,"a";"dog")
,"a" | ,"a"
"dog"| "dog"
,"d" | "dog"
"do" | "dog"
  .q.show f("car";"carpet")
"car"   | "car"
"carpet"| "carpet"
"carp"  | "carpet"
"carpe" | "carpet"

JavaScript - 212

w=prompt(o=[]).split(",");w.map(function(k,l){for(i=0;++i<k.length;){p=k.slice(0,i);if(w.filter(function(r,t){return t!=l}).every(function(r){return r.indexOf(p)}))o.push(p+":"+k)}o.push(k+":"+k)});console.log(o)

เริ่มต้นกอล์ฟ

การป้อนข้อมูล:

code,golf,going

เอาท์พุท:

["c:code", "co:code", "cod:code", "code:code", "gol:golf", "golf:golf", "goi:going", "goin:going", "going:going"]

Perl, 93 77

ด้วยการขึ้นบรรทัดใหม่และการเยื้องเพื่อให้อ่านง่าย:

sub f{
    (map{
        $h{$x}=[($x=$`.$&,$_)x!$h{$x}]while/./g;
        $_,$_
    }@_),map@$_,values%h
}

สายเกินไปและยาวไปหน่อย แต่ฉันดีใจที่ในที่สุดมันมีน้อยกว่า 100 ฟังก์ชันส่งคืนรายการที่สามารถกำหนดให้กับตัวแปรแฮช:

%h = f(qw/code golf going pie pier pierre/);
print "$_ $h{$_}\n" for sort keys %h;

และ

perl prefix.pl
c code
co code
cod code
code code
goi going
goin going
going going
gol golf
golf golf
pie pie
pier pier
pierr pierre
pierre pierre

ที่จริงแล้วรายการที่ส่งคืนจะยังไม่ถูกกรอง - การสร้างแฮชจะแล้วเสร็จในขณะที่มอบหมายเช่นฟังก์ชันภายนอก ถ้ามันไม่สะอาด / ยุติธรรมเพียงพอให้เพิ่ม 3 เพื่อนับและใส่เนื้อหาของฟังก์ชั่นลงในเครื่องหมายปีกกาแบบเตรียมล่วงหน้า+- จากนั้นฟังก์ชันจะส่งคืนการอ้างอิงแฮช 'จริง'

Q: 44 ไบต์

{x!p@'(?0,&:)'p in\:&1=#:'=,/p:`$(-1_)\'$x}

หมายเหตุ

• ภาษา Q มีแกนในชื่อ K4 ภายใน (ใช้ในคำตอบนี้และอีกคำตอบก่อนหน้านี้สำหรับคำถามนี้)

• หากต้องการทดสอบโค้ดให้ดาวน์โหลดล่าม (kx.com ฟรีสำหรับการใช้งานที่ไม่ใช่เชิงพาณิชย์รองรับ Windows, Linux, Mac)

ล่ามยอมรับสองไวยากรณ์:

• verbose (ชื่อที่อ่านได้มากขึ้นชื่อที่แตกต่างกันสำหรับ moands และ diads, ไลบรารีเพิ่มเติม, ... ) โหลดซอร์สไฟล์ที่มีส่วนขยาย q หรือล่ามแบบโต้ตอบ

• กะทัดรัด (แกนในการทำงานผู้ปฏิบัติงานตัวอักษรหนึ่งตัวอักษรตัวเดียวกันสำหรับทั้งสองใช้ monad / diad, ... ) โหลดซอร์สไฟล์ที่มีนามสกุล k หรือล่ามแบบโต้ตอบในโหมด k (พร้อมท์เขียน \ at) รหัสจะต้องทดสอบในโหมดนี้

รหัสกำหนดแลมบ์ดา (ฟังก์ชั่นที่ไม่ระบุชื่อ) เพื่อให้ชื่อกับฟังก์ชั่นที่เราต้องการชื่อคำนำหน้า: (เช่น f: {.. }) ดังนั้นจึงต้อง 46 ไบต์

ทดสอบ

(สมมติว่าชื่อฟังก์ชั่น: มิฉะนั้นแทนที่ f สำหรับรหัส)

f `code`golf`going

`code`golf`going!(`code`cod`co`c;`golf`gol;`going`goin`goi)

ส่งคืนพจนานุกรม (คีย์ไวยากรณ์! ค่า) Keys คือรายการสัญลักษณ์ (`symb`symb .. ) และให้ความสำคัญกับรายการรายการสัญลักษณ์ หากเราดำเนินการ Sentente ที่ล่ามแบบโต้ตอบเรามีการนำเสนอที่สะดวกกว่า (แต่ละคีย์และค่าเชื่อมโยงที่บรรทัดอื่น)

code | `code`cod`co`c
golf | `golf`gol
going| `going`goin`goi

คำอธิบาย

x เป็นข้อโต้แย้งโดยปริยายของแลมบ์ดา

$x แปลงรายการสัญลักษณ์เป็นรายการสตริง

(-1_)\ วนซ้ำทุกองค์ประกอบของรายการสัญลักษณ์

(อ่านสำหรับแต่ละสตริงคำนวณคำนำหน้า (ที่ eat iteration ลดอักขระตัวสุดท้ายของสตริง (-1_) จนกระทั่งสตริงว่าง)

$ เปลี่ยนเป็นรายการสัญลักษณ์อีกครั้ง (รายการคำนำหน้าทั้งหมด)

p: และมอบหมายให้ p

,/ ทำลายทั้งหมด (เชื่อมต่อกันและสร้างโครงสร้างระดับเดียว)

= classify -> สำหรับคำนำหน้าแต่ละคำที่ไม่ซ้ำกันให้เชื่อมโยงคำที่เกี่ยวข้อง

#:' คำนวณความยาว (จำนวนคำที่เกี่ยวข้องกับแต่ละคำนำหน้า)

1= true ถ้า length = 1 (unigiguous), false เป็นอย่างอื่น

& โดยที่ -> ดัชนีขององค์ประกอบที่แท้จริง

p in\: กำหนดสำหรับคำนำหน้าทั้งหมดหากอยู่ในส่วนนำหน้าอย่างชัดเจน

(..)' ใช้ (.. ) กับแต่ละค่าทางด้านขวา (คำนำหน้าชัดเจน)

?0,&: -> 0 ที่แตกต่างกันตัดแบ่งที่ไหน

p@ แปลงดัชนีเป็นสัญลักษณ์

x!.. สร้างพจนานุกรมที่มี x (คำ) เป็นคีย์และ .. เป็นค่า

อ่านเป็น:

• สร้างและส่งคืนพจนานุกรมที่มีคำว่าคีย์และค่า ..

• ... ค่าของดัชนีที่ตำแหน่งที่ต่างกัน 0 (ทุกคำ) และโดยที่คำนำหน้าไม่ชัดเจน

• ... การคำนวณที่ชัดเจนเป็นคำนำหน้าซึ่งปรากฏที่คำเดียว (คำที่เกี่ยวข้องกับแต่ละสัญลักษณ์มีความยาวหนึ่งคำ)

• ... รายการที่เกิดจากการจำแนกสัญลักษณ์ที่ไม่ซ้ำกันทั้งหมดด้วยคำที่เกี่ยวข้อง

• ... คำนำหน้าคำนวณโดยการลดตัวอักษรสุดท้ายของแต่ละคำซ้ำ

PHP 7.0, 67 ไบต์ (ลงวันที่ท้าทาย)

for(;a&$c=$s[++$k]??($s=$argv[++$i])[$k=+$t=!1];)echo$t.=$c,":$s,";

รับอินพุตจากอาร์กิวเมนต์บรรทัดรับคำสั่ง พิมพ์เครื่องหมายจุลภาคต่อท้าย; -nrทำงานด้วย

สำหรับรุ่นใหม่ PHPเพิ่มหนึ่งไบต์: แทนที่ด้วย&a""<

สำหรับ PHP รุ่นเก่าใช้ 70 ไบต์เหล่านี้:

PHP, 70 ไบต์

for(;a&$s=$argv[++$i];)for($k=+$t="";a&$c=$s[$k++];)echo$t.=$c,":$s,";

Brachylogขนาด 23 ไบต์

∋Xa₀Y;?↔⟨∋a₀⟩ᶜ1∧Y;X|∋gj

ลองออนไลน์!

รับอินพุตเป็นรายการผ่านตัวแปรอินพุตและสร้างรายการ[key, value]คู่ผ่านตัวแปรเอาต์พุต สายป้อนใด ๆ ที่ไม่ได้เป็นคำนำหน้าของสตริงป้อนข้อมูลอื่นจะถูกสร้างเป็นคำนำหน้าของตัวเองเป็นครั้งที่สองแม้ว่าส่วนหัวใน TIO ซ่อนนี้โดยใช้การขอรับรายการเต็มรูปแบบแทนᵘᶠ

 X                         X
∋                          is an element of
                           the input variable
    Y                      and Y
  a₀                       is a prefix of
 X                         X.
             ᶜ             The number of ways in which
        ⟨∋  ⟩              an element can be selected from
     ;?↔⟨   ⟩              the input variable
    Y; ↔⟨ a₀⟩              such that it has Y as a prefix
              1            is equal to 1.
               ∧Y          Y is not necessarily 1,
                   |       and the output variable
                Y;X        is the list [Y, X].
                   |       If every choice from the first rule has been taken already,
                           the output variable is
                    ∋      an element of
                   |       the input variable
                     gj    paired with itself.

Perl 5 -a , 76 ไบต์

map{say"$, $a"if($,=substr$a,0,$_)eq$a||2>grep/^$,/,@F}1..length($a=$_)for@F

ลองออนไลน์!

APL (Dyalog Classic) , 38 ไบต์

ขอบคุณ Erik the Outgolfer ที่เตือนให้ฉันใช้การเข้ารหัสอักขระไบต์เดียว

{⊃,/⍵{b,¨⍨(⊂¨⍵~⊃,/a~⊂⍵)∪b←⊂⊂⍺}¨a←,\¨⍵}

ลองออนไลน์!

Python (127)

ดังนั้นฉันไม่สามารถแสดงความคิดเห็น @undergroundmonorail ได้ แต่ฉันคิดว่าการใช้วิธีพจนานุกรมจะดีกว่าหรือไม่ ฉันแน่ใจว่ามีบางรายการ / ความเข้าใจในพจนานุกรมที่สามารถลดลงอย่างมากเช่นกัน แต่ไม่สามารถทำงานกับการ popping จาก dict

i=raw_input().split(",")
d = {}
for x in i:
    for c in range(1,len(x)+1):
        if x[:c] in d:
            del d[x[:c]]
        else:
            d[x[:c]]=x
print d

การพิมพ์จะส่งออกพจนานุกรมไม่ได้เรียงลำดับ

แก้ไข: Ahh ฉันพลาดรถ: รถยนต์ / รถยนต์: เกณฑ์พรม อาจจะตรวจสอบความยาว?

Groovy - 212 ตัวอักษร

แข็งแรงเล่นกอล์ฟ:

c="collectEntries";f="findAll";def g={def h=[:].withDefault{[]};it.each{def w->w.size().times{ h[w[0..it]] << w}};(h."$f"{k,v->v.size()==1}."$c"{k,v->[k,v[0]]}).plus(h."$f"{k,v->v.contains(k)}."$c"{k,v->[k,k]})}

เอาท์พุทตัวอย่าง:

println g(["code","golf","going"])

[c:code, co:code, cod:code, code:code, gol:golf, golf:golf, goi:going, goin:going, going:going]

Ungolfed:

def g = { def list ->
    def hash = [:].withDefault{[]}
    list.each {
        def word -> word.size().times{ hash[word[0..it]] << word }
    }

    def map = hash.findAll{ k,v -> v.size() == 1 }.collectEntries{ k,v -> [k,v[0]] }
    map.plus(hash.findAll{ k,v -> v.contains(k) }.collectEntries{ k,v -> [k,k] }
    map
}

JavaScript (Node.js) , 88 ไบต์

L=>L.map(s=>[...s].map(c=>L.filter(t=>t>S&t<S+'~',S+=c)[1]&&s>S||(R[S]=s),S=''),R={})&&R

ลองออนไลน์!

Zsh , 95 ไบต์

local -A m
for w;{m[$w]=$w;x=
for c (${(s::)w})x+=$c&&[ ${(M)@:#$x*} = $w ]&&m[$x]=$w
}
local m

ลองออนไลน์!

วิธีเดียวที่จะ "คืนค่า" อาเรย์แบบเชื่อมโยงใน Bash / Zsh คือการประกาศโดยไม่มีlocalคีย์เวิร์ดจากนั้นเข้าถึงในขอบเขตพาเรนต์ นี่จะช่วยประหยัดหนึ่งไบต์ อย่างไรก็ตามโดยทั่วไปแล้ว I / O ผ่านตัวแปรจะถูกดึงออกมาดังนั้นเราจึงพิมพ์คำนิยามอาร์เรย์แทน

local -A m                          # declare m as associative
                                    # "local" is shorter than "typeset"/"declare"
for w;{                             # for each word
    m[$w]=$w                        # the word is a prefix of itself
    x=                              # ensure x is empty
    for c (${(s::)w})               # for each character in the word
        x+=$c &&                    # append to x (building a prefix
          [ ${(M)@:#$x*} = $w ] &&  # if the only match is the word itself:
          m[$x]=$w                  # ... then x is a prefix of w
}
local m                             # print m

Ruby , 84 ไบต์

เพิ่งสังเกตเห็นว่ามีวิธีแก้ปัญหาทับทิมอยู่แล้วใช่แล้ว สิ่งนี้จะปรับปรุงในโซลูชันเก่าโดยการเลือกคำนำหน้าอย่างชาญฉลาด (ไม่จำเป็นต้องเพิ่มแต่ละคำเป็น "คำนำหน้า" ในตอนท้าย) และนับคำนำหน้าเพื่อตรวจสอบเอกลักษณ์ก่อนที่จะเพิ่มลงในแฮชแทนที่จะเขียนทับค่าด้วย หลอกตาหากมีซ้ำกันแล้วลบรายการ

->w{h={};w.map{|e|(1..e.size).map{|i|w.count{|d|d[0,i]==e[0,i]}<2?h[e[0,i]]=e:0}};h}

ลองออนไลน์!