Trova un acronimo ricorsivo

10

introduzione

Un acronimo ricorsivo è un acronimo che contiene o si riferisce a se stesso, ad esempio: Fishpotrebbe essere un acronimo ricorsivo per Fish is shiny hero, notare come questo contenga anche l'acronimo stesso. Un altro esempio è Hi-> Hi igloo. O anche ppcg paints->ppcg paints cool galaxies pouring acid into night time stars

Quindi, in sostanza, una frase è un acronimo ricorsivo se le prime lettere di ciascuna delle parole spiegano la prima o le prime parole.

Sfida

Crea un programma che accetta una stringa di 1 o più parole separate da un carattere spazio e genera un acronimo ricorsivo o una stringa vuota se è impossibile. È impossibile creare un acronimo ricorsivo per una stringa come, ad esempio, ppcg elephantperché inizieresti prendendo il pda ppcgpoi aggiungendolo all'acronimo, quindi prendendo il eda elephant. Ma ora abbiamo una contraddizione, poiché l'acronimo attualmente indica "pe ..", che è in conflitto con "pp ..". Questo è anche il caso, ad esempio, di hi. Prenderesti il hda hi, ma la frase ora è finita e non ci sono più lettere da precisare hie ci resta solo hche non corrispondahi. (La stringa richiede una quantità di parole maggiore o uguale alla quantità di lettere nell'acronimo)

Input e output non fanno distinzione tra maiuscole e minuscole

restrizioni

  • Tutto ciò che viene inserito nel tuo programma sarà una parola inglese valida. Ma devi assicurarti di produrre anche parole inglesi valide (puoi usare un database o semplicemente memorizzare una parola per ognuna delle 26 lettere)
  • Si applicano scappatoie standard e regole IO predefinite

Casi 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

punteggio

Questo è code-golf , quindi vince il codice sorgente più piccolo in byte

code-golf  string 
— FireCubez
fonte
1
Q, q [kyoo] sostantivo, Q o Qs plurale, q o qs. la diciassettesima lettera dell'alfabeto inglese, una consonante. qualsiasi suono parlato rappresentato dalla lettera Q o q, come in quick, assolit o Iraq. qualcosa che ha la forma di una Q.
— l4m2
3
Inoltre, non credo che ppcg sia una parola nel dizionario
— l4m2,
1
Va bene, uno di quei casi di test non è andato come mi aspettavo. Solo per assicurarsi che nessuno di noi stia commettendo un errore ppcg paints cool galaxies pouring acid into night timesarebbe "ppcgpaint" se trasformato in un acronimo, ma l'output dovrebbe essere ppcganche se è solo una corrispondenza parziale?
— Kamil Drakari,
1
Poiché tutte le soluzioni attuali stanno prendendo la prima opzione ("trova acronimo") e l'opzione "trova frase" è molto più complicata (quindi non c'è modo di essere competitivi con la prima - per iniziare è necessario un elenco di parole), Suggerirei di rimuoverlo da questa sfida e di farne una sua domanda.
— Paŭlo Ebermann,
2
@ PaŭloEbermann Bene, l'ho rimosso
— FireCubez,

Risposte:

5

Japt , 13 byte

¸
mά
VøUÎ ©V

Provalo online!

— Luis Felipe De Jesus Munoz
fonte
— Shaggy,
1
Questo fallisce nel ppcg paints cool galaxies pouring acid into night time starscaso di test
— Kamil Drakari,
ecco una versione che funziona per quel test, ma non è
— giocata a
La mia precedente soluzione da 13 byte era corretta Dx \
— Luis felipe De jesus Munoz il
La versione attuale verifica che l'acronimo contenga la prima parola, il che si traduce in alcuni nuovi numeri
— Kamil Drakari,
5

05AB1E , 16 byte

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

Provalo online!

— Emigna
fonte
1
Perché è cambiato ð¡invece che #nell'ultima modifica? Alcuni casi di test speciali non sto prendendo in considerazione?
— Kevin Cruijssen,
@KevinCruijssen: Perché #fallirebbe per l'input di una sola parola che emette l'input invece di una stringa vuota.
— Emigna,
Ah sì, era quello. Ricordo di aver chiesto qualcosa di simile prima. Penso ancora che #dovrebbe comportarsi come ð¡.. C'è un caso d'uso a cui puoi pensare dove vuoi dividere una stringa su spazi, ma se non contiene uno spazio, dovrebbe rimanere la stringa (anziché la stringa racchiuso in un elenco)? Altre persone leggono questo; Cordiali saluti: L'uso di #(diviso nello spazio) su una stringa senza spazi provoca la stringa così com'è (cioè "test" -> "test"). L'uso di ð¡(diviso nello spazio) su una stringa senza spazi comporta la stringa racchiusa in un elenco (ad es "test" -> ["test"].).
— Kevin Cruijssen,
@KevinCruijssen: penso che sia principalmente dovuto al #fatto di essere usato come quit if true(che è la sua funzione principale). Se #restituito falso, probabilmente non vorrai che il valore controllato sia racchiuso in un elenco, lasciato nello stack.
— Emigna,
1
@KamilDrakari: funziona ora però.
— Emigna,
2

Haskell, 51 48 byte

Modifica: -3 byte grazie a @xnor.

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

Trova l'acronimo.

Provalo 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
— Nome del modello
fonte
Dal momento che non stai usando x, la composizione (\w-> ...).wordssarebbe più breve.
— xnor
2

Perl 6 , 50 42 58 49 byte

-9 byte grazie a nwellnhof

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

Provalo online!

Prima opzione. Sto sfruttando il fatto ordche restituisce solo il valore ordinale della prima lettera di una stringa, mentre chrsprende un elenco di ordini e restituisce una stringa. O la regex della risposta di moonheart è più breve :(. Per riferimento, la risposta precedente era .words>>.ord.chrsinvece di[~] m:g/<<./

Spiegazione:

{~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
— Jo King
fonte
Non è necessario generare "IMPOSSIBLE" ora
— FireCubez,
@Jo King Posso fare regex, ma per la vita di me non riesco a pensare con tutti gli operatori. Continuo a dimenticare che esiste l'operatore x, ad esempio: P
— moonheart08,
1

Retina 0.8.2 , 60 byte

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

Provalo online! Trova l'eventuale acronimo ricorsivo. Spiegazione:

^
$'¶

Duplica l'input.

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

Riduci le parole della prima riga alle lettere iniziali.

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

Inserisci spazi per abbinare le parole originali, se possibile.

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

Emette la prima riga se è un prefisso della seconda riga.

— Neil
fonte
Per le vernici ppcg, l'output non è valido, non dovrebbe produrre nulla dal momento ppche incantesimi solo una parte della prima parola, invece di tutto ciò
— FireCubez,
@FireCubez Siamo spiacenti, stavo lavorando su una versione precedente della domanda.
— Neil,
1

Perl 6 , 56 byte

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

Provalo online!

Precedentemente le regex erano confuse e inutilizzabili per me. Improvvisamente li capisco perfettamente. Cosa mi è successo: P

Soddisfa la scelta 1.

— moonheart08
fonte
Purtroppo, sono ancora allo stadio in cui le regex sono semplicemente follia. Sfortunatamente, questo fallisce il ppcgpaintstest, altrimenti avrei suggerito qualcosa di simile $!∈.wordsper la condizione if
— Jo King,
1

Rust, 155, provalo online!

Selezionato: Problema 1: trovare l'acronimo

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 po ':

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 se possiamo supporre che l'input sia tutto minuscolo, 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()}}
— Hannes Karppila
fonte
Quale delle 2 scelte fa questo programma?
— FireCubez,
@FireCubez Aggiornato.
— Hannes Karppila,
1

Gelatina , 9 byte

Ḳµ;\fZḢWƊ

Un programma completo che stampa l'abbreviazione ricorsiva se è possibile.

Provalo online!

Come?

Ḳµ;\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
— Jonathan Allan
fonte
Cosa intendi con "stampa la prima parola"? Deve trovare l'acronimo se ne esiste uno, lo fa?
— FireCubez,
Non riesce a "ppcg dipinge galassie fredde che versano acido non nel cielo", dovrebbe stampare "vernici ppcg" o "ppcgpaints"
— FireCubez,
Oh, ho perso il requisito delle parole adiacenti :(
— Jonathan Allan il
Risolto il problema per soddisfare questo requisito.
— Jonathan Allan,
1

JavaScript [ES6], 74 byte

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

Crea un'espressione regolare da abbinare. Vedi esempi nel codice.

Tutti i casi di 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'
Espandi frammento

— Rick Hitchcock
fonte
Fail onincrease i
— l4m2
@ l4m2, ora risolto.
— Rick Hitchcock,
0

Python 2 , 106 byte

Prima opzione: trovare l'acronimo ricorsivo.
Restituisce il risultato nell'elenco.

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

Provalo online!

Python 2 , 120 byte

Prima opzione: trovare l'acronimo ricorsivo.

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

Provalo online!

— Dead Possum
fonte
Non è richiesto di produrre "IMPOSSIBILE" secondo la richiesta di @JoKing, che potrebbe ridurre il conteggio dei byte
— FireCubez,
Lettere singole come "I" non funzionano, dovrebbe generare quella singola lettera
— FireCubez,
@FireCubez risolto
— Dead Possum il
0

Javascript, 71 byte

Approccio 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 : '';
}
  • Dividi la stringa per spazio.
  • Crea una nuova stringa prendendo il primo carattere di ogni parola.
  • Confronta con la prima parola.
— Alpheus
fonte
0

Scala, 76 byte

Soluzione per un caso semplice (acronimi senza spazi bianchi)

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

Scala, 144 byte 100 byte (vedere la soluzione solo ASCII nei commenti)

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
— Dr Y Wit
fonte
— solo ASCII il
Può :::essere sostituito con ++? Inoltre, List[String]-> Seq[Any]?
— ASCII il
1
— ASCII il
@ Solo ASCII, fantastico! Questa soluzione batte Python. :)
— Dr Y Wit,
Ti dispiace aggiungere il codice qualche volta? IMO è un po 'strano vedere il bytecount senza vedere la soluzione
— solo ASCII il
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.