Dans Dyalog APL Extended @ Adám , l' opérateur (sous) signifie la conjugaison: appliquer une fonction, puis une deuxième fonction, puis l'inverse de la première. C'est amusant de penser aux actions réelles en termes de conjugaison:⍢

Un problème est transformé par g dans un autre domaine où il est plus facilement résolu par f, puis retransformé dans le domaine d'origine. Un exemple tiré de la vie réelle est «sous anesthésie»:

apply anesthetics
    perform surgery
wake up from anesthetics

Défi

L'inverse d'une ligne gest "non" précédé de g, et vice versa. Définissez une ligne entre set son inverse, dans cet ordre, comme étant "sous" s. Pour chaque ligne fen entrée dans l'ordre:

• Si fet son inverse se produisent, ne faites rien
• Si fn'est "sous" aucune autre action, imprimezf
• Si fest "sous" une ligne g, imprimez f + " under " + goù se +trouve la concaténation.

Contribution

Une chaîne multiligne non vide, ou une liste de chaînes, etc., composée d'espaces et de lettres minuscules (vous pouvez utiliser à la place des majuscules). Exactement une ligne commencera par "un"; et ce sera l'inverse d'une autre ligne. Aucune ligne ne sera vide.

Production

Sortie dans le même format que celui utilisé pour l'entrée, ou comme autorisé par les E / S standard.

Cas de 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 octets

;Ṡ{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

J'ai fait cela tout en étant sous l'impression que cela pouvait être récursif et que plusieurs sous pouvaient être empilés. Probablement pas optimisé. De plus, comme il s'agit de bracylog, la plomberie prend pas mal d'octets.

Essayez-le en ligne!

Rétine , 82 octets

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

Essayez-le en ligne! Le lien inclut des cas de test. Explication:

m{

Exécutez l'ensemble du programme en mode multiligne (de sorte que ^et faire $correspondre le début et la fin des lignes individuelles) et répétez jusqu'à ce qu'il n'y ait aucun changement.

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

Recherchez les lignes qui peuvent commencer par unet qui sont suivies par une ligne qui commence par ununiquement si la ligne précédente ne correspond pas alors que le reste de la ligne est la même, et supprimez les deux lignes. (Il s'agit d'un changement de comportement par rapport à Retina 0.8.2, qui fractionne les lignes avant d'essayer de faire correspondre et ne peut donc jamais supprimer des lignes si la correspondance doit s'étendre sur plusieurs lignes à la fois.)

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

Recherchez les lignes qui peuvent commencer par un, suivies d'au moins une ligne, suivies d'une ligne qui commence par unseulement si la ligne d'origine ne le fait pas alors que le reste de la ligne est identique.

$4 under $1$1$5

Déplacez la ligne d'origine d'une ligne vers le bas et ajoutez-la également underà la ligne que vous venez de parcourir. (Les lignes supplémentaires seront traitées par la répétition.)

Python 2 , 106 octets

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

Essayez-le en ligne!

Si l'entrée peut être une liste de STDIN et la sortie être séparée par des sauts de ligne, nous avons alors cette solution de 94 octets:

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 (nœud Babel) , 91 octets

Prend l'entrée comme un tableau de chaînes en minuscules. Renvoie un autre tableau de chaînes.

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

Essayez-le en ligne!

Commenté

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

Nettoyer , 147 octets

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

Essayez-le en ligne!