In Dyalog APL Extended di @Adám , l' operatore (sotto) significa coniugazione: applica una funzione, quindi una seconda funzione, quindi l'inverso della prima. È divertente pensare alle azioni della vita reale in termini di coniugazione:⍢

Un problema viene trasformato da g in un altro dominio in cui viene risolto più facilmente da f, quindi trasformato nuovamente nel dominio originale. Un esempio della vita reale è "sotto anestetici":

apply anesthetics
    perform surgery
wake up from anesthetics

Sfida

L'inverso di una linea gè "un" anteposto a g, e viceversa. Definisci qualsiasi linea tra se il suo inverso, in quell'ordine, come "sotto" s. Per ogni riga fin input nell'ordine:

• Se fe il suo inverso si verificano entrambi, non fare nulla
• Se fnon è "sotto" qualsiasi altra azione, stampaf
• Se fè "sotto" una linea g, stampa f + " under " + gdove si +trova la concatenazione.

Ingresso

Una stringa multilinea non vuota, o un elenco di stringhe, ecc., Costituito da spazi e lettere minuscole (è possibile utilizzare invece lettere maiuscole). Esattamente una riga inizierà con "un"; e sarà l'inverso di qualche altra linea. Nessuna riga sarà vuota.

Produzione

Output nello stesso formato in cui è stato immesso, o come consentito dall'I / O standard.

Casi test:

Input:
apply anesthetics
perform surgery
unapply anesthetics

Output:
perform surgery under apply anesthetics


Input:
unite asia
establish the silk road
ite asia

Output:
establish the silk road under unite asia


Input:
desire a book
walk to store
take the book
pay for the book
unwalk to store
read the book

Output:
desire a book
take the book under walk to store
pay for the book under walk to store
read the book


Input:
drink excessively
undrink excessively

Output:
[empty string]

Brachylog , 90 byte

;Ṡ{hhH↰₂gB&hb~c[A,B,C]&tT;C↔↰U∧" under ",H,T;A↔↰,U|tT&hh,TgJ&hb;T↰Q∧J,Q|h}
~↰₃|↰₃
∧"un";?c

L'ho fatto pur avendo l'impressione che questo potesse essere ricorsivo e che più sottostanti potevano essere impilati. Probabilmente non ottimizzato. Inoltre, poiché si tratta di bracylog, l'idraulica richiede alcuni byte.

Provalo online!

Retina , 82 byte

m{A`^(un)?(.+)¶(?(1)|un)\2$
^((un)?(.+)¶)(.+)¶((.+¶)*(?(2)|un)\3)$
$4 under $1$1$5

Provalo online!Il link include casi di test. Spiegazione:

m{

Esegui l'intero programma in modalità multilinea (in modo che ^e$ abbinare l'inizio e la fine delle singole linee) e ripetere fino a quando non ci sono cambiamenti.

A`^(un)?(.+)¶(?(1)|un)\2$

Cerca le linee che potrebbero iniziare con une sono seguite da una linea che inizia conun solo se la linea precedente non fa mentre il resto della linea è la stessa ed elimina entrambe le linee. (Questo è un cambiamento di comportamento rispetto a Retina 0.8.2, che divide le linee prima di provare ad abbinare e quindi non può mai eliminare le linee se l'incontro deve estendersi su più di una linea alla volta.)

^((un)?(.+)¶)(.+)¶((.+¶)*(?(2)|un)\3)$

Cerca le linee che potrebbero iniziare un, seguite da almeno una linea, seguite da una linea che inizia conun solo se la linea originale non funziona mentre il resto della linea è lo stesso.

$4 under $1$1$5

Spostare la linea originale in basso di una riga e aggiungerla anche underalla linea appena attraversata. (Le righe aggiuntive saranno gestite dalla ripetizione.)

Python 2 , 106 byte

s=input()
x=''
l=[]
for i in s:
 if'un'==i[:2]or'un'+i in s:x=(' under '+i)*(not x)
 else:l+=[i+x]
print l

Provalo online!

Se l'input può essere un elenco da STDIN e l'output è separato da una nuova riga, allora abbiamo questa soluzione a 94 byte:

s=input()
x=''
for i in s:
 if'un'==i[:2]or'un'+i in s:x=(' under '+i)*(not x)
 else:print i+x

JavaScript (nodo Babele) , 91 byte

Accetta l'input come una matrice di stringhe in minuscolo. Restituisce un altro array di stringhe.

a=>a.flatMap(s=>s==r|'un'+s==r?(u=u?'':' under '+s,[]):s+u,u='',r=a.find(s=>/^un/.test(s)))

Provalo online!

Commentate

a =>                     // a[] = input array
  a.flatMap(s =>         // for each string s in a[]:
    s == r |             //   if s matches the reference string
    'un' + s == r ? (    //   or its opposite:
      u =                //     update u:
        u ?              //       if u is not an empty string:
          ''             //         turn it to an empty string
        :                //       else:
          ' under ' + s, //         set it to s with the ' under ' prefix
      []                 //     yield an empty array so that this entry is removed
    ) :                  //   else:
      s + u,             //     yield s followed by u
    u = '',              //   initialize u to an empty string
    r = a.find(s =>      //   initialize r ...
      /^un/.test(s)      //     ... to the string beginning with 'un'
    )                    //
  )                      // end of flatMap()

Pulito , 147 byte

import StdEnv,Data.List
a=inits;b=tails
$l=hd[w++[e++[' under ':u]\\e<-z]++y\\i<-a l&t<-b l,w<-a i&u<-i,z<-a t&[x:y]<-b t|u==['un':x]||x==['un':u]]

Provalo online!