이 문제를 해결하려면 Abbrev가능한 적은 코드로 Ruby 모듈을 구현해야 합니다.

도전

• 입력은 언어의 배열 (배열, 목록, 순서 등)로 사용하는 언어가 무엇이든됩니다. 함수를 작성하거나 STDIN에서 쉼표로 구분 된 단어를 승인 할 수 있습니다.

• 그런 다음 해당 문자열에 대한 명확한 접두사 세트를 계산해야합니다. 즉, 약어의 해시 (또는 맵, 객체 등)를 원래 문자열로 반환해야합니다.

  • "접두사"는 문자열의 시작 부분에서 시작하는 원래 문자열의 부분 문자열입니다. 예를 들어 "pref"는 "prefix"라는 단어의 접두사입니다.

  • 명확한 접두사는 단 하나 개의 단어를 의미 할 것입니다. 예를 들어, 입력이 car,cat인 ca경우 "car"또는 "cat"을 의미 할 수 있으므로 명확한 접두사가 아닙니다.

  • 이 규칙의 예외는 단어가 항상 자신의 접두사라는 것입니다. 이 같은 입력 등이있는 경우 예를 들어 car,carpet, car:car귀하의 출력에 있어야합니다.

• 그런 다음 해시 / 맵 / 오브젝트 등을 반환 할 수 있습니다. 함수에서 (또는 귀하의 언어로 동등한 작업을 수행하십시오) 또는 key:value형식으로 STDOUT에 쌍으로 인쇄하십시오 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모듈 / 기능 / 루비와 같은 것을 사용할 수 없습니다 .

• 이것은 code-golf 이므로 바이트 단위의 가장 짧은 코드가 이길 것입니다!

APL (46)

(예, APL 문자 세트는 여유 공간이있는 바이트 단위로 맞습니다.)

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

문자열 목록을 가져 와서 2xN 행렬을 반환하는 함수입니다. 각 행에는 명확한 접두사와 해당 단어가 포함됩니다.

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

설명:

• ∆←⍵:에 올바른 인수를 저장하십시오 ∆.
• {↑∘⍵¨⍳⍴⍵}¨∆:의 각 요소에 대해 해당 요소의 ∆가능한 접두사를 가져옵니다.
  • ⍳⍴⍵: 1에서 길이 까지 목록을 얻습니다.⍵
  • ↑∘⍵¨: 각 숫자에 대해에서 많은 요소를 가져옵니다 ⍵.
• ∪⊃,/: 목록을 연결하고 고유 한 값을 가져옵니다.
• {... }¨: 고유 한 접두사 각각에 대해 :
  • ∆/⍨⊃¨⍵∘⍷¨∆: 해당 접두어로 시작하는 단어를 선택하십시오.
  • (⊂⍵),: 접두사를 묶고 연결
  • ∆/⍨2=⍴∆←: 두 요소 (접두사와 일치하는 단어)가있는 경우에만 목록을 리턴합니다.
• ↑: 튜플 목록을 행렬로 변환

파이썬 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의 마크 다운 인터프리터의 부작용입니다. 문자 그대로의 탭 문자이므로 1 바이트 만 가능합니다.

이것은 기술적으로 사양이 아니지만 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는 문자열을 문자의 벡터로 간주합니다. 즉, 문자열 목록을 만들려고 할 때 실제로 문자 테이블을 만들므로 끝이 공백으로 채워집니다. 이것에 대한 J의 솔루션을 box 라고 부르며 ,이 함수는 길이를 보존하기 위해 박스 화 된 문자열리스트를 인수로받습니다.

   '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대신 쓰면 문자를 저장합니다 .

전체 코드 구조를 기반으로 한 답변 에서 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

언 골프 드 :

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"

자바 스크립트-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 확장자 또는 대화식 인터프리터가있는 소스 파일로드

• 콤팩트 (기능적 내부 코어, 하나의 문자 연산자, 모두 동일한 문자는 모나드 / diad를 사용합니다.) 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: 그리고 p에 할당

,/ 모두 모으기 (1 레벨 구조를 연결하고 만듭니다)

= classify-> 고유 한 접두사마다 해당 단어를 연관시킵니다.

#:' 길이 (각 접두사와 관련된 단어 수)를 계산합니다.

1= 길이가 1 (모호하지 않은)이면 true, 그렇지 않으면 false

& 여기서-> 실제 요소의 색인

p in\: 명확한 접두사 인 경우 모든 접두사를 결정합니다.

(..)' 오른쪽의 각 값에 (..) 적용 (명확한 접두사)

?0,&: -> distinct 0이 연결된 위치 (단어 자체를 접두어로 사용)

p@ 인덱스를 기호로 변환

x!.. x (단어)를 키로 사용하고 ..를 값으로 사용하여 사전을 구성합니다.

다음과 같이 읽으십시오 :

• 단어를 키와 값으로하여 사전을 구성하고 반환합니다.

• ... 개별 위치 0 (모든 단어) 및 명확한 접두사에서 인덱스 값

• ... 한 단어에만 나타나는 접두사로 명확하게 계산됩니다 (각 기호에 연결된 단어 목록의 길이는 1입니다)

• ... 모든 고유 기호를 해당 단어로 분류 한 결과를 나열합니다.

• ... 각 단어의 마지막 문자 삭제를 반복하여 계산 된 접두사

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.

펄 5 -a , 76 바이트

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

온라인으로 사용해보십시오!

APL (Dyalog Classic) , 38 바이트

1 바이트 문자 인코딩을 사용하도록 상기시켜 준 Outgolfer Erik에게 감사합니다.

{⊃,/⍵{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

인쇄물은 사전을 순서없이 출력합니다.

편집 : 아 자동차 : 자동차 / 자동차 : 카펫 기준을 놓쳤다. 아마도 길이 확인?

그루비-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
}

자바 스크립트 (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키워드 없이 선언 한 다음 상위 범위에서 액세스하는 것입니다. 이것은 1 바이트를 절약 할 수 있습니다. 그러나 변수를 통한 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

루비 , 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}

온라인으로 사용해보십시오!