介绍

一个递归的缩写，是一个包含或引用本身，例如首字母缩写： Fish可能是递归的缩写Fish is shiny hero，通知怎么也包含缩写本身。另一个例子是Hi-> Hi igloo。甚至ppcg paints->ppcg paints cool galaxies pouring acid into night time stars

因此，基本上，如果每个单词的第一个字母拼写出第一个单词或多个单词，那么句子就是递归首字母缩写词。

挑战

编写一个程序，该程序接受由1个或多个单词组成的字符串，并用空格字符分隔，然后输出一个递归首字母缩写词；如果不可能，则输出一个空字符串。例如，不可能为字符串创建递归首字母缩写词，ppcg elephant因为您首先要使用pfrom，ppcg然后将其添加到首字母缩写词，然后使用efrom elephant。但是现在我们有了矛盾，因为首字母缩写词目前拼写为“ pe ..”，与“ pp ..”冲突。例如，也是如此hi。您可以使用hfrom hi，但是句子现在结束了，没有更多字母可以拼出hi，我们只剩下h不匹配的字母hi。（字符串需要的单词数量大于或等于首字母缩写词中的字母数量）

输入和输出不区分大小写

限制条件

• 输入到程序中的任何内容都将是有效的英语单词。但是，您还必须确保输出有效的英语单词（可以使用数据库，也可以只为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

计分

这是代码高尔夫，因此以字节为单位的最小源代码获胜

Japt，13个字节

¸
mά
VøUÎ ©V

在线尝试！

05AB1E，16个字节

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

在线尝试！

Haskell，51 48字节

编辑：-3字节感谢@xnor。

(\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

Perl 6的，50个42 58 49字节

-9字节归功于nwellnhof

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

在线尝试！

第一选择。我正在利用这样一个事实，即ord唯一返回字符串的第一个字母的序数值，而chrs接收一个ords列表并返回一个字符串。或来自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 )

如果它是第二行的前缀，则输出第一行。

Perl 6、56字节

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

在线尝试！

以前的正则表达式令我困惑，无法使用。突然我完全理解它们。我怎么了：P

完成选择1。

K（ngn / k），40个字节

第一种选择：

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

在线尝试！

Rust，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

JavaScript [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'

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

在线尝试！

Python 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

在线尝试！

Javascript，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 : '';
}

• 按空格分割字符串。
• 通过从每个单词中获取第一个字符来创建新字符串。
• 将其与第一个单词进行比较。

Ruby -apl，57个字节

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

在线尝试！

Python 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]

在线尝试！

Scala，76个字节

简单案例的解决方案（不带空格的缩写）

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

Scala，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