Introdução

Um acrônimo recursivo é um acrônimo que contém ou se refere a si mesmo, por exemplo: Fishpoderia ser um acrônimo recursivo para Fish is shiny hero, observe como isso também contém o próprio acrônimo. Outro exemplo é Hi-> Hi igloo. Ou até ppcg paints->ppcg paints cool galaxies pouring acid into night time stars

Então, basicamente, uma frase é um acrônimo recursivo se as primeiras letras de cada uma das palavras soletrarem a primeira palavra ou palavras.

Desafio

Crie um programa que use uma sequência de 1 ou mais palavras separadas por um caractere de espaço e produza um acrônimo recursivo ou uma sequência vazia, se for impossível. É impossível criar um acrônimo recursivo para uma sequência como, por exemplo, ppcg elephantporque você começaria com o pfrom ppcge o adicionaria ao acrônimo, depois com o efrom elephant. Mas agora temos uma contradição, já que atualmente o acrônimo indica "pe ..", que entra em conflito com "pp ..". Esse também é o caso, por exemplo hi. Você pegaria o hfrom hi, mas a frase agora acabou e não há mais letras para soletrar hie ficamos apenas com o hque não correspondehi. (A sequência precisa de uma quantidade de palavras maior ou igual à quantidade de letras na sigla)

Entrada e saída não diferenciam maiúsculas de minúsculas

Restrições

• Qualquer coisa inserida no seu programa será válida em inglês. Mas você também deve fornecer palavras em inglês válidas (você pode usar um banco de dados ou apenas armazenar uma palavra para cada uma das 26 letras)
• Aplicam-se brechas padrão e regras de E / S padrão

Casos de teste

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

Pontuação

Isso é código-golfe , então o menor código-fonte em bytes vence

Japonês , 13 bytes

¸
mά
VøUÎ ©V

Experimente online!

05AB1E , 16 bytes

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

Experimente online!

Haskell, 51 48 bytes

Edit: -3 bytes graças a @xnor.

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

Localiza a sigla.

Experimente online!

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

-9 bytes graças a nwellnhof

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

Experimente online!

Primeira opção. Estou explorando o fato de que o ordúnico retorna o valor ordinal da primeira letra de uma string, enquanto chrspega uma lista de ords e retorna uma string. Ou o regex da resposta do moonheart é mais curto :(. Para referência, a resposta anterior foi em .words>>.ord.chrsvez de[~] m:g/<<./

Explicação:

{~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

Retina 0.8.2 , 60 bytes

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

Experimente online! Localiza a sigla recursiva, se houver. Explicação:

^
$'¶

Duplique a entrada.

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

Reduza as palavras da primeira linha para as letras iniciais.

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

Insira espaços para corresponder às palavras originais, se possível.

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

Emita a primeira linha se for um prefixo da segunda linha.

Perl 6 , 56 bytes

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

Experimente online!

Regexes anteriores eram confusos e inutilizáveis ​​para mim. De repente eu os entendo perfeitamente. O que aconteceu comigo: P

Cumpre a escolha 1.

K (ngn / k) , 40 bytes

Primeira opção:

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

Experimente online!

Ferrugem, 155, experimente online!

Selecionado: Problema 1: Localizando Acrônimo

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

Ungolfed, apenas um pouco:

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

Ou, se pudermos supor que a entrada esteja em minúscula, apenas 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()}}

Geléia , 9 bytes

Ḳµ;\fZḢWƊ

Um programa completo imprimindo a abreviação recursiva, se possível.

Experimente online!

Como?

Ḳµ;\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 bytes

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

Cria uma expressão regular para combinar. Veja exemplos no código.

Todos os casos de teste:

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 bytes

Primeira opção - encontrar acrônimo recursivo.
Retorna o resultado na lista.

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

Experimente online!

Python 2 , 120 bytes

Primeira opção - encontrar acrônimo recursivo.

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

Experimente online!

Javascript, 71 bytes

Abordagem 1

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

Ungolfed:

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

• Divida a string pelo espaço.
• Crie uma nova string usando o primeiro caractere de cada palavra.
• Compare com a primeira palavra.

Ruby -apl , 57 bytes

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

Experimente online!

Python 2 , 109 bytes

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]

Experimente online!

Scala, 76 bytes

Solução para casos simples (acrônimos sem espaços em branco)

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

Scala, 144 bytes 100 bytes (consulte a solução somente por ASCII nos comentários)

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

Teste no 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