Đối với thử thách này, bạn phải triển khai Abbrevmô-đun của Ruby với càng ít mã càng tốt.

Thử thách

• Đầu vào sẽ là bất cứ thứ gì ngôn ngữ của bạn có dưới dạng một mảng (mảng, danh sách, chuỗi, v.v.) của chuỗi. Bạn có thể viết một hàm hoặc bạn có thể chấp nhận các từ được phân tách bằng dấu phẩy trên STDIN.

• Sau đó, bạn phải tính toán tập hợp các tiền tố rõ ràng cho các chuỗi đó. Điều này có nghĩa là bạn phải trả lại một hàm băm (hoặc bản đồ, đối tượng, v.v.) cho các chuỗi gốc của chúng.

  • "Tiền tố" là một chuỗi con của chuỗi gốc bắt đầu từ đầu chuỗi. Ví dụ: "pref" là tiền tố của từ "tiền tố."

  • Một tiền tố rõ ràng là một tiền tố chỉ có thể có nghĩa là một từ. Ví dụ: nếu đầu vào của bạn là car,cat, thì đó cakhông phải là tiền tố rõ ràng bởi vì nó có thể có nghĩa là "xe hơi" hoặc "con mèo".

  • Ngoại lệ cho quy tắc này là một từ luôn luôn là tiền tố của chính nó. Ví dụ: nếu bạn có đầu vào như car,carpet, car:carphải nằm trong đầu ra của bạn.

• Sau đó, bạn có thể trả về hàm băm / bản đồ / đối tượng / v.v. từ chức năng của bạn (hoặc thực hiện tương đương trong ngôn ngữ của bạn) hoặc in nó ra STDOUT key:valuetheo cặp dưới dạng f:foo,fo:foo,.... (Các cặp khóa-giá trị cũng có thể được phân tách bằng khoảng trắng nếu nó làm cho mã của bạn ngắn hơn.)

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

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

Quy tắc

• Đầu vào sẽ không chứa các yếu tố trùng lặp.

• Đầu ra của bạn có thể theo thứ tự bất kỳ; bạn không phải sắp xếp nó

• Bạn không được sử dụng Abbrevmô-đun / chức năng / thứ tích hợp như của Ruby.

• Đây là mã golf , vì vậy mã ngắn nhất tính bằng byte sẽ giành chiến thắng!

APL (46)

(Có, bộ ký tự APL không vừa trong một byte, có chỗ trống.)

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

Đây là một hàm lấy danh sách các chuỗi và trả về ma trận 2-by-N, trong đó mỗi hàng chứa một tiền tố rõ ràng và từ đó thuộc về:

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

Giải trình:

• ∆←⍵: lưu trữ đối số đúng trong ∆ .
• {↑∘⍵¨⍳⍴⍵}¨∆: cho mỗi phần tử của ∆ , lấy các tiền tố có thể có của phần tử đó:
  • ⍳⍴⍵: lấy danh sách từ 1 chiều dài của⍵
  • ↑∘⍵¨: cho mỗi số đó, lấy nhiều phần tử từ đó ⍵.
• ∪⊃,/: nối các danh sách lại với nhau và lấy các giá trị duy nhất.
• {...}¨ : cho mỗi tiền tố duy nhất:
  • ∆/⍨⊃¨⍵∘⍷¨∆: chọn các từ bắt đầu bằng tiền tố đó
  • (⊂⍵),: cũng kèm theo tiền tố và nối
  • ∆/⍨2=⍴∆←: chỉ trả về danh sách nếu có hai thành phần (tiền tố và một từ phù hợp)
• ↑: biến danh sách các bộ dữ liệu thành một ma trận

Python 2.7 - 146 141 byte

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

Lưu ý rằng vết lõm trên dòng 4 và 5 không phải là 4 khoảng trắng, đó là tác dụng phụ của trình thông dịch đánh dấu SE. Đó là một ký tự tab theo nghĩa đen, vì vậy chỉ có một byte.

Đây không phải là kỹ thuật tùy thuộc vào thông số kỹ thuật, nhưng tôi sẽ thay đổi nó nếu Doorknob làm rõ. Nó sử dụng dòng mới thay vì dấu phẩy để phân tách đầu ra. Ví dụ:

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

Mới: Tôi đã có thể loại bỏ 5 ký tự bằng cách gán chuỗi mà tôi đang kiểm tra cho một biến e. Điều này có nghĩa là tôi chỉ phải gõ ethay vì w[:a]ba lần. Nó cũng có nghĩa là tôi lưu các nhân vật bằng cách làm e=w[:a+1]và thay đổi ...range(1,len(w)+1)thành range(len(w)).

Giải trình:

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 char

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

J xem các chuỗi chỉ là các vectơ của các ký tự, có nghĩa là khi nó cố gắng tạo một danh sách các chuỗi, nó thực sự kết thúc việc tạo một bảng các ký tự, vì vậy các đầu được đệm bằng các khoảng trắng. Giải pháp của J cho cái này được gọi là hộp , vì vậy hàm này lấy làm đối số một danh sách các chuỗi được đóng hộp, để duy trì độ dài.

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

Ngoài ra, J thiếu một kiểu băm, do đó, gần nhất với nó là một bảng gồm hai cột của các mục, ví dụ như các chuỗi được đóng hộp. Nếu điều đó không được chấp nhận và tôi phải mặc định ở dạng khóa-giá trị, tôi có thể định dạng lại đầu ra thành dạng này trong tổng số 67 ký tự :

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

Giải thích bằng vụ nổ:

(,.~~.@,[:(#~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

Ví dụ:

   (,.~~.@,[:(#~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]

Phiên bản bị đánh cắp:

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

Thí dụ:

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

Tôi đã sử dụng initshàm tìm thấy tất cả các tiền tố của danh sách / chuỗi. Liệu nó được tính là gian lận?

Con trăn 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]

Chúng tôi lặp lại các tiền tố của mỗi từ trong đầu vào, in cặp tiền tố / từ tương ứng nếu nó xuất hiện chính xác một lần hoặc là toàn bộ từ. Chúng tôi tận dụng hành vi ngắn mạch của or(và printlà một chức năng) để chỉ in nếu một trong những điều kiện này được đáp ứng.

Các while vòng lặp liên tục cắt ký tự cuối cùng để tạo ra các tiền tố ngắn hơn và ngắn hơn, chấm dứt khi phần còn lại chuỗi rỗng. Đây là lần duy nhất chúng tôi lập chỉ mục hoặc cắt thành bất cứ điều gì.

Chúng tôi đếm số lần xuất hiện của tiền tố etrong đầu vào bằng cách tìm kiếm chuỗi đầu vào được phân tách bằng dấu phẩy ban đầu Sđể tìm chuỗi con ','+e. Chúng tôi thêm dấu phẩy vào chuỗi đầu vào. Sự bổ sung này gây ra một phần tử chuỗi rỗng thêm khi chúng ta split, nhưng điều này không có hiệu lực vì nó không có các chuỗi con không trống.

Để kiểm tra trường hợp khi chuỗi con elà toàn bộ từ w, chúng ta so sánh chúng bằng toán tử so sánh chuỗi. Điều này so sánh về mặt từ vựng, vì vậy các tiền tố ngắn hơn nhỏ hơn. Việc so sánh đôi thất bại nếu một trong hai e==whoặc S.count(c+e)<2.

Nếu e,wcho phép in kết quả đầu ra ở dạng , tôi sẽ lưu một ký tự bằng cách viết e+c+w.

Tín dụng cho công cụ ngầm từ câu trả lời của tôi dựa trên cấu trúc mã tổng thể của tôi.

Ruby, 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

Ung dung:

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)

không đặc biệt chơi golf; tôi chắc rằng nó có thể ngắn hơn

khá giống với J impl. ở trên, tôi nghĩ - về cơ bản chỉ cần thu thập tất cả các tiền tố (thích hợp), loại bỏ các từ khỏi tiền tố một lần nữa (để xử lý "car"/ "carpet"case), nhóm chúng thành các lớp tương đương, chọn các lớp chỉ có một phần tử, giảm chúng khỏi danh sách chuỗi và thêm vào bản đồ từ chuỗi đến chính họ.

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

một số trường hợp thử nghiệm

lưu ý rằng trong k/ q, một chuỗi là danh sách các ký tự, vì vậy một chuỗi chỉ chứa một ký tự duy nhất cần được đánh dấu như vậy bằng cách sử dụng ,hàm unary ; & mmwrt một danh sách các chuỗi chỉ chứa một chuỗi

những sử dụng qcủa showchức năng, trong đó đã xây dựng-in định dạng cho một số cấu trúc dữ liệu, để làm cho các kết quả dễ đọc hơn:

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

Sân golf ban đầu.

Đầu vào:

code,golf,going

Đầu ra:

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

Perl, 93 77

Với dòng mới và thụt lề cho dễ đọc:

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

Một chút quá muộn và quá lâu, nhưng tôi rất vui vì cuối cùng nó cũng có dưới 100. Hàm trả về một danh sách có thể được gán cho biến băm:

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

và

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

Trên thực tế, danh sách trả về chưa được lọc - xây dựng hàm băm được hoàn thành tại thời điểm gán của nó, tức là chức năng bên ngoài. NẾU nó không đủ sạch / công bằng, hãy thêm 3 để đếm và đưa nội dung hàm vào dấu ngoặc nhọn, chuẩn bị trước +- sau đó hàm trả về tham chiếu băm 'true'.

Q: 44 byte

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

GHI CHÚ

• Ngôn ngữ Q có lõi bên trong có tên K4 bên trong (được sử dụng trong câu trả lời này và một câu trả lời khác trước đây cho câu hỏi này)

• Để kiểm tra mã, tải xuống trình thông dịch (kx.com, miễn phí cho sử dụng không giao dịch, hỗ trợ cho Windows, Linux, Mac)

Thông dịch viên thừa nhận hai cú pháp:

• dài dòng (tên dễ đọc hơn, tên riêng biệt cho moands và diads, nhiều thư viện hơn, ...). Tải tệp nguồn với phần mở rộng q hoặc trình thông dịch tương tác

• nhỏ gọn (lõi bên trong chức năng, toán tử một chữ cái, cùng một chữ cái cho cả hai sử dụng monad / diad, ...). Tải tệp nguồn có phần mở rộng k hoặc trình thông dịch tương tác ở chế độ k (ghi \ tại dấu nhắc). Mã phải được kiểm tra trong chế độ này

Mã định nghĩa một lambda (hàm ẩn danh). Để đặt tên cho hàm, chúng ta cần tên tiền tố: (ex f: {..}), vì vậy cần 46 Byte

KIỂM TRA

(hàm giả định tên: nếu không thay thế f cho mã)

f `code`golf`going

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

trả về một từ điển (các phím cú pháp! giá trị). Các khóa là một danh sách các ký hiệu (`symb`ymb ..) và giá trị một danh sách các danh sách các ký hiệu. Nếu chúng tôi thực hiện lệnh được gửi tại trình thông dịch tương tác, chúng tôi sẽ có bản trình bày thuận tiện hơn (mỗi khóa và các giá trị liên kết ở một dòng khác nhau)

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

GIẢI TRÌNH

x là đối số ngầm cho lambda

$x chuyển đổi danh sách ký hiệu thành danh sách chuỗi

(-1_)\ lặp đi lặp lại qua từng elem của danh sách biểu tượng

(đọc như đối với mỗi chuỗi tính toán các tiền tố (tại lần lặp ăn nhỏ giọt char cuối cùng của chuỗi (-1_), cho đến khi chuỗi trống)

$ chuyển đổi thành danh sách ký hiệu một lần nữa (danh sách tất cả các tiền tố)

p: và gán cho p

,/ san bằng tất cả (nối và tạo cấu trúc một cấp)

= phân loại -> cho mỗi tiền tố duy nhất, liên kết các từ tương ứng

#:' tính toán độ dài (số lượng từ liên quan đến mỗi tiền tố)

1= đúng nếu độ dài = 1 (không rõ ràng), sai khác

& trong đó -> chỉ số của các phần tử thực

p in\: xác định cho tất cả tiền tố nếu chúng ở tiền tố rõ ràng

(..)' áp dụng (..) cho từng giá trị ở bên phải (tiền tố không rõ ràng)

?0,&: -> phân biệt 0 được ghép nối ở đâu (để đối phó các từ làm tiền tố của chính nó)

p@ biến đổi chỉ mục thành biểu tượng

x!.. xây dựng một từ điển với x (từ) làm khóa và .. làm giá trị

Đọc như:

• Xây dựng và trả về một từ điển với các từ là khóa và giá trị ..

• ... Giá trị của các chỉ mục ở các vị trí khác nhau 0 (tất cả từ) và trong đó tiền tố không rõ ràng

• ... không rõ ràng được tính là tiền tố chỉ xuất hiện ở một từ (danh sách từ liên kết với mỗi ký hiệu có độ dài một)

• ... danh sách kết quả của việc phân loại tất cả các biểu tượng duy nhất với các từ tương ứng

• ... tiền tố được tính bằng cách lặp lại thả char cuối cùng của mỗi từ

PHP 7.0, 67 byte (hoãn thử thách)

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

lấy đầu vào từ các đối số dòng lệnh; in dấu phẩy; chạy với -nr.

đối với PHP mới hơn , thêm một byte: Thay thế &abằng ""<.

đối với PHP cũ hơn, hãy sử dụng 70 byte này:

PHP, 70 byte

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

Brachylog , 23 byte

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

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

Đưa đầu vào dưới dạng danh sách thông qua biến đầu vào và tạo danh sách các [key, value]cặp thông qua biến đầu ra. Bất kỳ chuỗi đầu vào nào không phải là tiền tố của một chuỗi đầu vào khác sẽ được tạo thành tiền tố của chính nó hai lần, mặc dù tiêu đề trên TIO che giấu điều này bằng cách sử dụng ᵘđể lấy danh sách đầy đủ thay vì ᶠ.

 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 byte

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

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

APL (Dyalog Classic) , 38 byte

cảm ơn Erik Outgolfer đã nhắc tôi sử dụng mã hóa ký tự một byte

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

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

Con trăn (127)

Vì vậy, tôi không thể nhận xét @undergroundmonorail, nhưng tôi nghĩ rằng sử dụng một cách tiếp cận từ điển sẽ tốt hơn? Tôi chắc chắn với một số hiểu danh sách / từ điển, nó cũng có thể bị cắt giảm rất nhiều, nhưng không thể làm cho nó hoạt động với popping từ 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

Bản in sẽ xuất từ ​​điển, không có thứ tự.

EDIT: Ahh Tôi đã lỡ xe: xe / xe: tiêu chí thảm. Có thể kiểm tra chiều dài?

Groovy - 212 ký tự

Chơi gôn

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

đầu ra ví dụ:

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

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

Ung dung:

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 byte

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

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

Zsh , 95 byte

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

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

Cách duy nhất để "trả về" một mảng kết hợp trong Bash / Zsh là khai báo nó mà không cần localtừ khóa và sau đó truy cập nó trong phạm vi cha. Điều này sẽ tiết kiệm một byte. Tuy nhiên, I / O thông qua các biến thường được tán thành, vì vậy chúng tôi in định nghĩa mảng thay thế.

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

Hồng ngọc , 84 byte

Chỉ cần lưu ý rằng đã có một giải pháp Ruby hiện có, ồ tốt. Điều này về cơ bản cải thiện giải pháp cũ bằng cách chọn tiền tố theo cách thông minh hơn (loại bỏ nhu cầu thêm từng từ làm "tiền tố" ở cuối) và đếm tiền tố để kiểm tra tính duy nhất trước khi thêm chúng vào hàm băm, thay vì ghi đè giá trị bằng một hình nộm nếu có một bản sao và sau đó xóa mục.

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

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