Viết một hàm hoặc chương trình, khi được đưa ra một danh sách các tên, xuất ra hoặc trả về một danh sách trong đó các bản sao của các tên đã cho có một phiên bản rút gọn duy nhất của họ của chúng.

Đầu vào:

Một danh sách các tên, trong đó một tên được xác định bởi một tên cụ thể và một tên cuối cùng được phân tách bằng một khoảng trắng. Tên là các chuỗi không trống chỉ chứa chữ hoa và chữ thường. Danh sách có thể là một chuỗi các chuỗi hoặc các tên được phân tách bằng một ký tự không phải là không phải alpha, không gian, nhưng đầu ra phải có cùng định dạng với đầu vào.

Đầu ra:

Một danh sách các tên được nhập theo cùng thứ tự và định dạng như đầu vào đã được sửa đổi bởi các quy tắc này:

• Đối với các tên đã cho, chỉ xuất ra tên đã cho
• Đối với các tên có cùng tên đã cho:
  • Cũng như tên họ của họ, hãy thêm phiên bản duy nhất ngắn nhất của họ của họ mà không được chia sẻ bởi một tên khác, theo sau là một khoảng thời gian. Ví dụ: John Clancy, John Smithtrở thành John C.,John S.và James Brown, James Brattetrở thànhJames Bro.,James Bra.
  • Nếu một họ là một tập hợp con khác, chẳng hạn như Julian King,Julian Kingsley, trả lại họ đầy đủ của họ nhỏ hơn mà không có dấu chấm. Ví dụ sẽ trở thànhJulian King,Julian King.
• Về cơ bản, một khoảng thời gian đại diện cho regex .+, trong đó chỉ có một tên phù hợp với nó.
• Bạn có thể cho rằng không ai sẽ chia sẻ cả tên đã cho và cùng họ
• Tên có phân biệt chữ hoa chữ thường

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

• John Clancy,Julie Walker,John Walker,Julie Clancy -> John C.,Julie W.,John W.,Julie C.
• Julian King,Jack Johnson,Julian Kingsley > Julian King,Jack,Julian King.
• Jack Brown,Jack Black,Jack Blue > Jack Br.,Jack Bla.,Jack Blu.
• John Storm,Jon Snow,Johnny Storm > John,Jon,Johnny
• Jill DeSoma,Jill Desmond > Jill DeS.,Jill Des.
• XxXnO sCOppeXxX,XxXNO MERCYXxX > XxXnO,XxXNO

Đây là môn đánh gôn , vì vậy số byte thấp nhất cho mỗi ngôn ngữ sẽ thắng.

Thạch ,  34 33 32  30 byte

;\ċÐf⁶t€⁶;€JṖḊ$$¦”.µ€ċ@ÐṂ€Ẏ$Ḣ€

Một liên kết đơn âm lấy danh sách các danh sách các ký tự (tức là danh sách "chuỗi") và trả về các chữ viết tắt theo cùng định dạng và thứ tự tương đối.

Hãy thử trực tuyến! (một bộ kiểm tra chương trình đầy đủ)

Làm sao?

;\ċÐf⁶t€⁶;€JṖḊ$$¦”.µ€ċ@ÐṂ€Ẏ$Ḣ€ - Link: list of lists    e.g. ["Sam Ng","Sam Li","Sue Ng"]
                   µ€          - monadically for €ach:  e.g. "Sue Ng"
 \                             -   cumulative reduce with:
;                              -     concatenation           ["S","Su","Sue","Sue ","Sue N","Sue Ng"]
     ⁶                         -   literal space character   ' '
   Ðf                          -   filter keep if:
  ċ                            -     count (spaces)          ["Sue ","Sue N","Sue Ng"]
        ⁶                      -   literal space character   ' '
      t€                       -   trim from €ach            ["Sue","Sue N","Sue Ng"]
                 ”.            -   literal period character  '.'
                ¦              -   sparse application...
         ;€                    -   ...of: concatenate €ach (with a period)
                               -   ...only for these indexes:
               $               -     last two links as a monad:
           J                   -       range of length       [1,2,3]
              $                -       last two links as a monad:
            Ṗ                  -         pop                 [1,2]
             Ḋ                 -         dequeue             [2]  (i.e. 2,3,...,length-1)
                               -   ...i.e.:                  ["Sue","Sue N.","Sue Ng"]
                               -                   yielding: [["Sam","Sam N.","Sam Ng"],["Sam","Sam L.","Sam Li"],["Sue","Sue N.","Sue Ng"]]
                           $   - last two links as a monad:
                          Ẏ    -   tighten                   ["Sam","Sam N.","Sam Ng","Sam","Sam L.","Sam Li","Sue","Sue N.","Sue Ng"]
                       ÐṂ€     -   filter keep minimals for €ach: 
                     ċ@        -     count (sw@ping args)    [["Sam N.","Sam Ng"],["Sam L.","Sam Li"],["Sue","Sue N.","Sue Ng"]]
                            Ḣ€ - head €ach                   ["Sam N.","Sam L.","Sue"]

Python 2 , 130 byte

def f(a):n=[[x[:i]+'.'*(' 'in x[:i]<x)for i in range(x.find(' '),len(x)+1)]for x in a];print[min(x,key=sum(n,[]).count)for x in n]

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

Đầu tiên tạo ra tất cả các biệt danh, như sau:

n == [
    ['John', 'John .', 'John C.', 'John Cl.', 'John Cla.', 'John Clan.', 'John Clanc.', 'John Clancy'],
    ['Julie', 'Julie .', 'Julie W.', 'Julie Wa.', 'Julie Wal.', 'Julie Walk.', 'Julie Walke.', 'Julie Walker'],
    ['John', 'John .', 'John W.', 'John Wa.', 'John Wal.', 'John Walk.', 'John Walke.', 'John Walker'],
    ['Julie', 'Julie .', 'Julie C.', 'Julie Cl.', 'Julie Cla.', 'Julie Clan.', 'Julie Clanc.', 'Julie Clancy'],
    ['Jill', 'Jill .', 'Jill D.', 'Jill De.', 'Jill Des.', 'Jill Desm.', 'Jill Desmo.', 'Jill Desmon.', 'Jill Desmond']
]

Sau đó chọn một trong những * đầu tiên từ mỗi danh sách đó là thường xuyên nhất trong sum(n,[]). Đây sẽ luôn là biệt danh độc đáo đầu tiên.

Lưu ý nbao gồm các biệt danh sai 'John .', vv, nhưng chúng sẽ không bao giờ được chọn.

(* minDù sao thì CPython 2.7 cũng vậy. Mã này có thể không di động được !)

Ruby 165 162 161 160 byte

Bao gồm 1 dấu cách nếu chỉ trả lại tên đã cho, vd. "John "

->a,n=0,s=0{a.group_by{|i|i[n]}.values.flat_map{|i|j=i[0];k=j.index' ';i.size<2?j.size>n ?j[0,[n+1,k].max-(s>1?0:1)]+(n>k ??.:''):j:f[i,n+=1,i.count{|l|l[n]}]}}

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

163 byte nếu bạn không muốn dấu cách

->a,n=0,s=0{a.group_by{|i|i[n]}.values.flat_map{|i|j=i[0];k=j.index' ';i.size<2?j.size>n ?j[0..[n,k-1].max-(s>1?0:1)]+(n>k ??.: ''):j:f[i,n+1,i.count{|l|l[n+1]}]}}

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