Для цього завдання ви повинні реалізувати Abbrevмодуль Ruby якомога менше коду.

Виклик

• Вхід буде будь-яким у вашій мові як масив (масив, список, послідовність тощо) рядків. Ви можете написати функцію або приймати слова, розділені комами, на STDIN.

• Потім потрібно обчислити набір однозначних префіксів для цих рядків. Це означає, що ви повинні повернути хеш (або карту, об’єкт тощо) абревіатур до їх початкових рядків.

  • "Префікс" - це підрядок початкового рядка, що починається на початку рядка. Наприклад, "pref" - це префікс слова "префікс".

  • Однозначну префікс один , що може означати тільки одне слово. Наприклад, якщо ваш вхід є 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модуль / функцію / таку річ, як Ruby.

• Це код-гольф , тому найкоротший код у байтах виграє!

APL (46)

(Так, гарнітура APL дійсно вкладається в байт, з простором місця.)

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

Це функція, яка займає список рядків і повертає матрицю 2 на N, де кожен рядок містить однозначний префікс і слово, яке належить йому:

{↑{∆/⍨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 char

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

J розглядає рядки як просто вектори символів, це означає, що коли він намагається скласти список рядків, він фактично закінчується складанням таблиці символів, тому кінці забиті пробілами. Рішення 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,

Хаскелл 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функцію, яка знаходить всі префікси списку / рядка. Чи вважається це обманом?

Пітон 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==wабо S.count(c+e)<2.

Якщо друковані виводи у формі e,wбули дозволені, я б зберегла символ, написавши e+c+wзамість цього.

Заслуга метрополітену, з відповіді на який я базував свою загальну структуру коду.

Рубі, 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

Безголівки:

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 імпл. вище, я думаю - в основному просто збирає всі (належні) префікси, знову видаляє слова з префіксів (для обробки "car"/ "carpet"case), групує їх у класи еквівалентності, підбирає класи лише з одним елементом, зменшує їх зі списків до рядків і додає на карті від рядків до себе.

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

деякі тестові випадки

зауважте, що в k/ q, рядок - це список символів, тому рядок, що містить лише один символ, потрібно позначати як такий за допомогою функції unry ,; & 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"]

Перл, 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)

Інтерпретатор допускає два синтаксиси:

• багатослівний (більш читаються імена, чіткі назви для moands та diads, більше бібліотек, ...). Завантажте вихідний файл із розширенням q або інтерактивним перекладачем

• компактний (функціональне внутрішнє ядро, оператори однієї літери, однаковий лист для обох використовує монаду / діад, ...). Завантажте вихідний файл із розширенням k або інтерактивним перекладачем у режимі k (запишіть \ у відповідь). Код повинен бути протестований у цьому режимі

Код визначає лямбда (анонімна функція). Щоб надати ім'я функції, нам потрібна префікса ім'я: (наприклад, f: {..}), тому потрібно 46 байт

ТЕСТ

(припускаючи названу функцію: інакше підмініть f на код)

f `code`golf`going

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

повертає словник (синтаксичні клавіші! значення). Клавіші - це список символів (`symb`symb ..), а значення списку списку символів. Якщо ми виконуємо сентенцію в інтерактивному інтерпретаторі, у нас є більш зручна презентація (кожен ключ і асоціювати значення в іншому рядку)

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

ПОЯСНЕННЯ

x є неявним аргументом лямбда

$x перетворити список символів у список рядків

(-1_)\ повторюється над кожним елемом списку символів

(читається, як для кожного рядка обчислюються префікси (при ітерації їжі падає останній символ рядка (-1_), поки порожній рядок)

$ знову перетворюється на список символів (список усіх префіксів)

p: і призначає на с

,/ підкреслити всіх (об'єднує і створює однорівневу структуру)

= класифікувати -> для кожного унікального префікса, пов'язує відповідні слова

#:' обчислює довжину (кількість слів, пов'язаних з кожним префіксом)

1= вірно, якщо довжина = 1 (однозначно), інакше помилково

& де -> індекс істинних елементів

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,";

Брахілог , 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 байт

дякую Еріку Outgolfer за те, що він нагадав мені використовувати однобайтове кодування символів

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

Спробуйте в Інтернеті!

Пітон (127)

Тому я не міг коментувати @undergroundmonorail, але думав, що краще використовувати підхід до словника? Я впевнений, що з деяким розумінням списку / словника він також може бути надзвичайно скорочений, але я не можу змусити його працювати з вискакуванням з диктату.

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

Друк виведе словник без упорядкування.

РЕДАКЦІЯ: А-а, я пропустив машину: машина / машина: критерії килимів. Може бути, перевірка довжини?

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]

Безголівки:

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ключового слова, а потім отримати доступ до нього в батьківській області. Це врятувало б один байт. Однак, введення / виведення через змінні, як правило, нахмуриться, тому ми друкуємо визначення масиву замість цього.

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

Рубін , 84 байти

Щойно помітив, що вже існує рішення Ruby, ну добре. Це в основному покращується на старому рішенні, вибираючи префікси розумнішим способом (виключаючи необхідність додавати кожне слово як "префікс" в кінці) та рахувати префікси для перевірки унікальності перед додаванням їх у хеш, замість того, щоб перезаписувати значення з манекен, якщо є дублікат, а потім стирається запис.

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

Спробуйте в Інтернеті!