소개

재귀 적 약어는 : 포함하거나, 예를 들어, 자신을 참조 약자입니다 Fish에 대한 재귀 적 약어 될 수있다 Fish is shiny hero, 즉 또한 글자 자체를 포함하는 방법에 관한 사항. 다른 예는 Hi-> Hi igloo입니다. 또는 심지어 ppcg paints->ppcg paints cool galaxies pouring acid into night time stars

따라서 기본적으로 문장은 각 단어의 첫 글자가 첫 단어를 철자하는 경우 재귀 약어입니다.

도전

공백 문자로 구분 된 1 개 이상의 단어 문자열을 사용하고 재귀 약어를 출력하거나 불가능한 경우 빈 문자열을 출력하는 프로그램을 만드십시오. 예를 들어, 같은 문자열에 대한 재귀 적 약어를 만드는 것은 불가능하다 ppcg elephant당신이를 복용하여 시작하기 때문 p에서 ppcg다음 글자로 그를 추가, 다음을 복용 e에서 elephant. 그러나 현재 약자에서 "pp .."라는 철자가 있기 때문에 모순이 있습니다. 예를 들어 hi. hfrom 을 가져 hi왔지만 이제 문장이 끝나고 더 이상 철자를 쓸 문자 가 없으며 일치하지 않는 문자가 hi남았습니다.hhi. (문자열에는 약어의 글자 수 이상이 필요합니다)

입력과 출력은 대소 문자를 구분하지 않습니다

제한 사항

• 프로그램에 입력 된 것은 유효한 영어 단어입니다. 그러나 유효한 영어 단어도 출력해야합니다 (데이터베이스를 사용하거나 26 글자마다 단어를 저장할 수 있습니다)
• 표준 허점 및 기본 IO 규칙이 적용됩니다.

테스트 사례

hi igloo -> hi
ppcg paints -> (impossible)
ppcg paints cool giraffes -> ppcg
ppcg paints cool galaxies pouring acid into night time stars -> ppcgpaints
ppcg paints cool galaxies pouring acid into night time -> ppcg
ppcg questions professional pool challengers greatly -> (impossible)
I -> I

채점

이것은 code-golf 이므로 바이트 단위의 가장 작은 소스 코드가 승리합니다.

Japt , 13 바이트

¸
mά
VøUÎ ©V

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

05AB1E , 16 바이트

ð¡©ηʒJ®€нJηså}θJ

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

하스켈, 51 48 바이트

편집 : @xnor 덕분에 -3 바이트.

(\w->[r|p<-scanl1(++)w,map(!!0)w==p,r<-p]).words

약어를 찾습니다.

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

\w->            .words -- let 'w' be the input list split into words
   p<-scanl1(++)w      -- loop 'p' through the list starting with the first word
                       --  and appending the next words one by one, e.g.
                       --  "Fish","is","shiny","hero" -> "Fish","Fishis","Fishisshiny","Fishisshinyhero"
     ,map(!!0)w==p     -- if the word made out of the first characters of the
                       --  words of 'w' equal 'p'
  [r|   r<-p]          -- return the letters of 'p' - if the check before
                       --  never evaluates to True then no letters, i.e. the
                       --  the empty string is returned

펄 6 , 50 42 58 49 바이트

nwellnhof 덕분에 -9 바이트

{~first {m:g/<<./.join~~/^$^a/},[R,] [\~] .words}

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

첫 번째 옵션. 나는 ord문자열의 첫 번째 문자의 서수 값만 반환하는 반면 chrsords 목록 을 가져 와서 문자열을 반환 한다는 사실을 이용하고 있습니다. 또는 moonheart의 답변 에서 정규식 이 더 짧습니다 :(. 참고로, 이전의 대답이었다 .words>>.ord.chrs대신[~] m:g/<<./

설명:

{~first {m:g/<<./.join~~/^$^a/},[R,] [\~] .words}
{                                               } # Anonymous code block
  first  # Find the first 
                                [R,] [\~] .words  # Of the reverse of the triangular joined words
         {                    }  # That matches:
          m:g/   /   # Match all from the original string
              <<.    # Single letters after a word boundary
                  .join    # Joined
                       ~~/^$^a/   # And starts with the given word
 ~  # And stringify Nil to an empty string

레티 나 0.8.2 , 60 바이트

^
$'¶
\G(\w)\w* ?
$1
+`^(.+)(\w.*¶\1 )
$1 $2
!`^(.+)(?=¶\1 )

온라인으로 사용해보십시오! 재귀 약어를 찾습니다 (있는 경우). 설명:

^
$'¶

입력을 복제하십시오.

\G(\w)\w* ?
$1

첫 줄의 단어를 첫 글자로 줄이십시오.

+`^(.+)(\w.*¶\1 )
$1 $2

가능하면 원래 단어와 일치하도록 공백을 삽입하십시오.

!`^(.+)(?=¶\1 )

첫 번째 행이 두 번째 행의 접 두부 인 경우 출력하십시오.

펄 6 , 56 바이트

$!=[~] m:g{<<.};say $! if m:g{<<\w+}.map({$_ eq $!}).any

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

이전에는 정규 표현식이 혼란스럽고 사용할 수 없었습니다. 갑자기 나는 그들을 완벽하게 이해합니다. 나에게 일어난 일 : P

선택 사항을 이행합니다.

K (ngn / k) , 40 바이트

첫 번째 옵션 :

{$[1=#:x;x;$[(*:t)~,/*:'t:" "\x;*:t;`]]}

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

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

선택 : 문제점 1 : 약어 찾기

type S=String;fn f(t:&str)->S{let l=t.to_lowercase();let w=l.split(' ').fold(S::new(),|a,b|a+&b[..1])+" ";if (l+" ").contains(w.as_str()){w}else{S::new()}}

언 골프, 조금 :

fn f(t: &str) -> String {
    let l = t.to_lowercase();
    let w = l.split(' ').fold(String::new(), |a, b| a + &b[0..1]) + " ";
    if (l + " ").contains(w.as_str()) {
        w
    } else {
        String::new()
    }
}

또는 입력이 모두 소문자라고 가정 할 수 있다면 130입니다.

type S=String;fn f(l:S)->S{let w=l.split(' ').fold(S::new(),|a,b|a+&b[..1])+" ";if (l+" ").contains(&w.as_str()){w}else{S::new()}}

젤리 , 9 바이트

Ḳµ;\fZḢWƊ

가능한 경우 재귀 약어를 인쇄하는 전체 프로그램.

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

어떻게?

Ḳµ;\fZḢWƊ - Main Link: list of characters
Ḳ         - split at space (let's call this v)
 µ        - start a new monadic chain (i.e. f(v)):
   \      - cumulative reduce v with:
  ;       -   concatenation -> [v(1), v(1);v(2), v(1);v(2);v(3); ...]
        Ɗ - last three links as a monad (i.e. f(v)):
     Z    -   transpose -> [[v(1)[1], v(2)[1], ...],[v(1)[1],v(2)[2],...],...]
      Ḣ   -   head -> [v(1)[1], v(2)[1], ...] ... i.e. 'the potential abbreviation'
       W  -   wrap in a list -> ['the potential abbreviation']
    f     - filter discard those from the left list that are not in the right list
          - implicit print -- a list of length 0 prints nothing
          -                   while a list of a single item prints that item

자바 스크립트 [ES6], 74 바이트

s=>s.split` `.map(w=>(b+='('+w,e+=')?',t+=w[0]),b=e=t='')&&t.match(b+e)[0]

일치시킬 정규식을 작성합니다. 코드의 예제를 참조하십시오.

모든 테스트 사례 :

let f=

s=>s.split` `.map(w=>(b+='('+w,e+=')?',t+=w[0]),b=e=t='')&&t.match(b+e)[0]

console.log(f('hi igloo'))
// 'hi'.match('(hi(igloo)?)?')[0] == 'hi'

console.log(f('ppcg paints'))
// 'pp'.match('(ppcg(paints)?)?')[0] == ''

console.log(f('ppcg paints cool giraffes'))
// 'ppcg'.match('(ppcg(paints(cool(giraffes)?)?)?)?')[0] == 'ppcg'

console.log(f('ppcg paints cool galaxies pouring acid into night time stars'))
// 'ppcgpaints'.match('(ppcg(paints(cool(galaxies(pouring(acid(into(night(time(stars)?)?)?)?)?)?)?)?)?)?')[0] == 'ppcgpaints'

console.log(f('ppcg paints cool galaxies pouring acid into night time'))
// 'ppcgpaint'.match('(ppcg(paints(cool(galaxies(pouring(acid(into(night(time)?)?)?)?)?)?)?)?)?')[0] == 'ppcg'

console.log(f('ppcg questions professional pool challengers greatly'))
// 'pqppcg'.match('(ppcg(questions(professional(pool(challengers(greatly)?)?)?)?)?)?')[0] == ''

console.log(f('I'))
// 'I'.match('(I)?')[0] == 'I'

console.log(f('increase i'))
// 'ii'.match('(increase(i)?)?')[0] == ''

console.log(f('i increase'))
// 'ii'.match('(i(increase)?)?')[0] == 'i'

파이썬 2 , 106 바이트

첫 번째 옵션-재귀 약어를 찾습니다.
결과를 목록으로 반환합니다.

I=input().split()
print[' '.join(I[:i])for i in range(1,-~len(I))if[j[0]for j in I]==list(''.join(I[:i]))]

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

파이썬 2 , 120 바이트

첫 번째 옵션-재귀 약어를 찾습니다.

def F(I,a=[],r=''):
 for j in I.split():
  a+=j,
  if list(''.join(a))==[i[0]for i in I.split()]:r=' '.join(a)
 return r

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

자바 스크립트, 71 바이트

접근법 1

l=s=>{p=s.split(' ');k=p.reduce((r,x)=>r+x[0],'');return k==p[0]?k:''}

언 골프 드 :

l=s=>{
    p = s.split(' ');
    k = p.reduce((r,x)=>r+x[0],'');
    return k==p[0] ? k : '';
}

• 문자열을 공백으로 나눕니다.
• 각 단어에서 첫 문자를 사용하여 새 문자열을 만듭니다.
• 그것을 첫 단어와 비교하십시오.

루비 -apl , 57 바이트

$_=y="";$F.all?{|w|$F.map(&:chr).join[/^#{y+=w}/]?$_=y:p}

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

파이썬 2 , 109 바이트

def f(s,J=''.join):s=s.split();return[J(s[:i])for i in range(len(s)+1)if J(zip(*s)[0]).find(J(s[:i]))==0][-1]

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

스칼라, 76 바이트

간단한 경우에 대한 솔루션 (공백이없는 약어)

def^(s:String)={val l=s.split(" ");if(l(0)==l.map(_(0)).mkString)l(0)else""} 

스칼라, 144 바이트 100 바이트 (주석에서 ASCII 전용 솔루션 참조)

def^(s:String)={val l=s.split(" ");l.scanLeft(List[String]())(_:::List(_)).find(_.mkString==l.map(_(0)).mkString).map(_.mkString).getOrElse("")}

REPL에서 테스트

scala> def^(s:String)={val l=s.split(" ");if(l(0)==l.map(_(0)).mkString)l(0)else""}
$up: (s: String)String

scala> ^("hi igloo")
res12: String = hi

scala> ^("ppcg paints cool giraffes")
res13: String = ppcg

scala> ^("ppcg paints Xcool giraffes")
res14: String = ""

scala> ^("ppcg paints cool galaxies pouring acid into night time stars")
res15: String = ""

scala>

scala> def^(s:String)={val l=s.split(" ");l.scanLeft(List[String]())(_:::List(_)).find(_.mkString==l.map(_(0)).mkString).map(_.mkString).getOrElse("")}
$up: (s: String)String

scala> ^("hi igloo")
res16: String = hi

scala> ^("ppcg paints cool giraffes")
res17: String = ppcg

scala> ^("ppcg paints Xcool giraffes")
res18: String = ""

scala> ^("ppcg paints cool galaxies pouring acid into night time stars")
res19: String = ppcgpaints