Einführung

Ein rekursives Akronym ist ein Akronym, das sich selbst enthält oder auf sich selbst verweist, zum Beispiel: Fishkönnte ein rekursives Akronym sein für Fish is shiny hero, beachten Sie, wie das auch das Akronym selbst enthält. Ein anderes Beispiel ist Hi-> Hi igloo. Oder sogar ppcg paints->ppcg paints cool galaxies pouring acid into night time stars

Im Grunde genommen ist ein Satz ein rekursives Akronym, wenn die ersten Buchstaben jedes der Wörter das erste Wort oder die ersten Wörter buchstabieren.

Herausforderung

Erstellen Sie ein Programm, das eine Zeichenfolge aus einem oder mehreren durch ein Leerzeichen getrennten Wörtern verwendet und ein rekursives Akronym oder eine leere Zeichenfolge ausgibt, wenn dies nicht möglich ist. Es ist unmöglich , ein rekursive Akronym für eine Zeichenfolge wie zum Beispiel zu machen, ppcg elephantweil man das , indem man beginnen würde pvon ppcgdann fügen hinzu , dass auf das Akronym, dann nehmen die eaus elephant. Aber jetzt haben wir einen Widerspruch, da das Akronym derzeit "pe .." bedeutet, was mit "pp .." in Konflikt steht. Dies ist beispielsweise auch der Fall hi. Sie würden das hvon nehmen hi, aber der Satz ist jetzt vorbei und es gibt keine Buchstaben mehr zu buchstabieren hiund wir bleiben nur mit hdenen, die nicht übereinstimmenhi. (Die Zeichenfolge benötigt eine Anzahl von Wörtern, die größer oder gleich der Anzahl der Buchstaben im Akronym ist.)

Bei der Eingabe und Ausgabe wird nicht zwischen Groß- und Kleinschreibung unterschieden

Beschränkungen

• Alles, was in Ihr Programm eingegeben wird, sind gültige englische Wörter. Sie müssen jedoch sicherstellen, dass auch gültige englische Wörter ausgegeben werden (Sie können eine Datenbank verwenden oder einfach ein Wort für jeden der 26 Buchstaben speichern).
• Es gelten Standardlücken und Standard-E / A-Regeln

Testfälle

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

Wertung

Dies ist Code-Golf , also gewinnt der kleinste Quellcode in Bytes

Japt , 13 Bytes

¸
mά
VøUÎ ©V

Probieren Sie es online aus!

05AB1E , 16 Bytes

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

Probieren Sie es online aus!

Haskell, 51 48 Bytes

Bearbeiten: -3 Bytes dank @xnor.

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

Findet Akronym.

Probieren Sie es online aus!

\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 dank nwellnhof

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

Probieren Sie es online aus!

Erste Wahl. Ich nutze die Tatsache, dass ordnur der Ordnungswert des ersten Buchstabens einer Zeichenfolge zurückgegeben wird, während chrseine Liste von Ordnungen erstellt und eine Zeichenfolge zurückgegeben wird. Oder der reguläre Ausdruck aus der Antwort von Mondherz ist kürzer :(. Als Referenz war die vorherige Antwort .words>>.ord.chrsanstelle von[~] m:g/<<./

Erläuterung:

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

Probieren Sie es online aus! Findet das rekursive Akronym, falls vorhanden. Erläuterung:

^
$'¶

Duplizieren Sie die Eingabe.

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

Reduzieren Sie die Wörter in der ersten Zeile auf ihre Anfangsbuchstaben.

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

Fügen Sie nach Möglichkeit Leerzeichen ein, die mit den ursprünglichen Wörtern übereinstimmen.

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

Geben Sie die erste Zeile aus, wenn es sich um ein Präfix der zweiten Zeile handelt.

Perl 6 , 56 Bytes

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

Probieren Sie es online aus!

Bisher waren Regexe für mich verwirrend und unbrauchbar. Plötzlich verstehe ich sie perfekt. Was ist mit mir passiert: P.

Erfüllt Auswahl 1.

K (ngn / k) , 40 Bytes

Erste Wahl:

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

Probieren Sie es online aus!

Rust, 155, probieren Sie es online!

Ausgewählt: Problem 1: Akronym finden

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, nur ein bisschen:

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

Oder wenn wir davon ausgehen können, dass die Eingabe nur in Kleinbuchstaben geschrieben ist, nur 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()}}

Gelee , 9 Bytes

Ḳµ;\fZḢWƊ

Ein Vollprogramm, das die rekursive Abkürzung druckt, wenn es möglich ist.

Probieren Sie es online aus!

Wie?

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

Erstellt einen regulären Ausdruck, der übereinstimmt. Siehe Beispiele im Code.

Alle Testfälle:

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

Erste Option - Rekursives Akronym finden.
Gibt das Ergebnis in der Liste zurück.

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

Probieren Sie es online aus!

Python 2 , 120 Bytes

Erste Option - Rekursives Akronym finden.

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

Probieren Sie es online aus!

Javascript, 71 Bytes

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

• Teilen Sie die Zeichenfolge durch Leerzeichen.
• Erstellen Sie eine neue Zeichenfolge, indem Sie aus jedem Wort das erste Zeichen nehmen.
• Vergleichen Sie es mit dem ersten Wort.

Ruby -apl , 57 Bytes

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

Probieren Sie es online aus!

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]

Probieren Sie es online aus!

Scala, 76 Bytes

Lösung für den einfachen Fall (Akronyme ohne Leerzeichen)

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

Scala, 144 Bytes 100 Bytes (siehe Lösung nur durch ASCII in den Kommentaren)

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

Test in 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