introduction

Un acronyme récursif est un acronyme qui contient ou se réfère à lui-même, par exemple: Fishpourrait être un acronyme récursif pour Fish is shiny hero, notez comment il contient également l'acronyme lui-même. Un autre exemple est Hi-> Hi igloo. Ou même ppcg paints->ppcg paints cool galaxies pouring acid into night time stars

Donc, fondamentalement, une phrase est un acronyme récursif si les premières lettres de chacun des mots épelent le ou les premiers mots.

Défi

Créez un programme qui prend une chaîne de 1 ou plusieurs mots séparés par un caractère espace et génère un acronyme récursif ou une chaîne vide si cela est impossible. Il est impossible de faire un acronyme récursif pour une chaîne comme, par exemple, ppcg elephantparce que vous commenceriez par prendre le pfrom ppcgpuis en ajoutant cela à l'acronyme, puis en prenant le efrom elephant. Mais maintenant nous avons une contradiction, puisque l'acronyme définit actuellement "pe ..", ce qui est en conflit avec "pp ..". C'est également le cas, par exemple hi,. Vous prendriez le hde hi, mais la phrase est maintenant terminée et il n'y a plus de lettres à épeler hiet il ne nous reste plus que hce qui ne correspond pashi. (La chaîne a besoin d'un nombre de mots supérieur ou égal au nombre de lettres de l'acronyme)

L'entrée et la sortie ne sont pas sensibles à la casse

Restrictions

• Tout ce qui est entré dans votre programme sera un mot anglais valide. Mais vous devez également vous assurer de générer des mots anglais valides (vous pouvez utiliser une base de données ou simplement stocker un mot pour chacune des 26 lettres)
• Les failles standard et les règles d'E / S par défaut s'appliquent

Cas de test

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

Notation

C'est le code-golf , donc le plus petit code source en octets gagne

Japt , 13 octets

¸
mά
VøUÎ ©V

Essayez-le en ligne!

05AB1E , 16 octets

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

Essayez-le en ligne!

Haskell, 51 48 octets

Edit: -3 octets grâce à @xnor.

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

Trouve l'acronyme.

Essayez-le en ligne!

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

-9 octets grâce à nwellnhof

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

Essayez-le en ligne!

Première option. J'exploite le fait que le ordseul retourne la valeur ordinale de la première lettre d'une chaîne, alors qu'il chrsprend une liste d'ordres et renvoie une chaîne. Ou l'expression rationnelle de la réponse de Moonheart est plus courte :(. Pour référence, la réponse précédente était .words>>.ord.chrsau lieu de[~] m:g/<<./

Explication:

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

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

Essayez-le en ligne! Recherche l'acronyme récursif, le cas échéant. Explication:

^
$'¶

Dupliquez l'entrée.

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

Réduisez les mots de la première ligne à leurs lettres initiales.

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

Insérez des espaces pour faire correspondre les mots d'origine, si possible.

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

Sortez la première ligne si c'est un préfixe de la deuxième ligne.

Perl 6 , 56 octets

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

Essayez-le en ligne!

Auparavant, les regex étaient déroutantes et inutilisables pour moi. Du coup je les comprends parfaitement. Ce qui m'est arrivé: P

Répond au choix 1.

K (ngn / k) , 40 octets

Première option:

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

Essayez-le en ligne!

Rust, 155 ans, essayez-le en ligne!

Sélectionné: Problème 1: Recherche d'un acronyme

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, juste un peu:

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 si nous pouvons supposer que l'entrée est entièrement en minuscules, seulement 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ée , 9 octets

Ḳµ;\fZḢWƊ

Un programme complet imprimant l'abréviation récursive si cela est possible.

Essayez-le en ligne!

Comment?

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

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

Crée une expression régulière pour correspondre. Voir des exemples dans le code.

Tous les cas de test:

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 octets

Première option - trouver un acronyme récursif.
Renvoie le résultat dans la liste.

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

Essayez-le en ligne!

Python 2 , 120 octets

Première option - trouver un acronyme récursif.

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

Essayez-le en ligne!

Javascript, 71 octets

Approche 1

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

Non golfé:

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

• Divisez la chaîne par l'espace.
• Créez une nouvelle chaîne en prenant le premier caractère de chaque mot.
• Comparez-le avec le premier mot.

Rubis -apl , 57 octets

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

Essayez-le en ligne!

Python 2 , 109 octets

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]

Essayez-le en ligne!

Scala, 76 octets

Solution pour cas simple (acronymes sans espaces blancs)

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

Scala, 144 octets 100 octets (voir la solution en ASCII uniquement dans les commentaires)

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

Test 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