Introducción

Un acrónimo recursivo es un acrónimo que contiene o se refiere a sí mismo, por ejemplo: Fishpodría ser un acrónimo recursivo para Fish is shiny hero, observe cómo también contiene el acrónimo. Otro ejemplo es Hi-> Hi igloo. O incluso ppcg paints->ppcg paints cool galaxies pouring acid into night time stars

Básicamente, una oración es un acrónimo recursivo si las primeras letras de cada una de las palabras deletrean la primera palabra o palabras.

Desafío

Cree un programa que tome una cadena de 1 o más palabras separadas por un carácter de espacio y genere un acrónimo recursivo o una cadena vacía si es imposible. Es imposible hacer un acrónimo recursivo para una cadena como, por ejemplo, ppcg elephantporque comenzaría tomando el pde ppcgluego agregando eso al acrónimo, luego tomando el ede elephant. Pero ahora tenemos una contradicción, ya que el acrónimo actualmente deletrea "pe ..", que entra en conflicto con "pp ..". Ese es también el caso con, por ejemplo hi,. Tomarías el hde hi, pero la oración ha terminado y no hay más letras para deletrear hiy solo nos queda hlo que no coincidehi. (La cadena necesita una cantidad de palabras mayor o igual que la cantidad de letras en el acrónimo)

La entrada y la salida no distinguen entre mayúsculas y minúsculas

Restricciones

• Todo lo que ingrese en su programa será palabras válidas en inglés. Pero también debe asegurarse de escribir palabras en inglés válidas (puede usar una base de datos o simplemente almacenar una palabra para cada una de las 26 letras)
• Se aplican las lagunas estándar y las reglas de E / S predeterminadas

Casos de prueba

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

Puntuación

Este es el código de golf , por lo que gana el código fuente más pequeño en bytes

Japt , 13 bytes

¸
mά
VøUÎ ©V

Pruébalo en línea!

05AB1E , 16 bytes

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

Pruébalo en línea!

Haskell, 51 48 bytes

Editar: -3 bytes gracias a @xnor.

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

Encuentra acrónimo.

Pruébalo en línea!

\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 gracias a nwellnhof

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

Pruébalo en línea!

Primera opción. Estoy explotando el hecho de que ordsolo devuelve el valor ordinal de la primera letra de una cadena, mientras que chrstoma una lista de ords y devuelve una cadena. O la expresión regular de la respuesta de moonheart es más corta :(. Como referencia, la respuesta anterior fue en .words>>.ord.chrslugar de[~] m:g/<<./

Explicación:

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

Pruébalo en línea! Encuentra el acrónimo recursivo, si lo hay. Explicación:

^
$'¶

Duplicar la entrada.

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

Reduzca las palabras en la primera línea a sus letras iniciales.

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

Inserte espacios para que coincidan con las palabras originales, si es posible.

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

Salida de la primera línea si es un prefijo de la segunda línea.

Perl 6 , 56 bytes

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

Pruébalo en línea!

Anteriormente, las expresiones regulares eran confusas e inutilizables para mí. De repente los entiendo perfectamente. Lo que me pasó a mí: P

Cumple con la elección 1.

K (ngn / k) , 40 bytes

Primera opción:

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

Pruébalo en línea!

Rust, 155, ¡ pruébalo en línea!

Seleccionado: Problema 1: Encontrar siglas

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, solo un poco:

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

O si podemos suponer que la entrada está en minúsculas, solo 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()}}

Jalea , 9 bytes

Ḳµ;\fZḢWƊ

Un programa completo que imprime la abreviatura recursiva si es posible.

Pruébalo en línea!

¿Cómo?

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

Crea una expresión regular para que coincida. Ver ejemplos en el código.

Todos los casos de prueba:

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

Primera opción: encontrar siglas recursivas.
Devuelve el resultado en la 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]))]

Pruébalo en línea!

Python 2 , 120 bytes

Primera opción: encontrar siglas recursivas.

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

Pruébalo en línea!

Javascript, 71 bytes

Enfoque 1

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

Sin golf:

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

• Divide la cuerda por espacio.
• Crea una nueva cadena tomando el primer carácter de cada palabra.
• Compárelo con la primera palabra.

Ruby -apl , 57 bytes

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

Pruébalo en línea!

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]

Pruébalo en línea!

Scala, 76 bytes

Solución para caso simple (acrónimos sin espacios en blanco)

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

Scala, 144 bytes 100 bytes (ver solución por ASCII solo en los comentarios)

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

Prueba en 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