[Question]
  [
# Context
(Feel free to skip, doesn't really matter for the algorithmic explanation of the task)
European Portuguese is a fairly complicated language to learn, mostly because of its grammar. One particular annoying thing is conjugating the verbs correctly:
We have this mechanism that, when we have a verb followed by a noun, we may replace the noun by a pronoun and create a contraction with the verb, by means of a hyphen (-).
This introduces a problem because many verb tenses sound like verb-pronoun contractions and many verb-pronoun contractions sound like verb tenses... And then, (Portuguese!) people want to write Portuguese and they know how it should sound, but they don't know if they should insert a hyphen or not... (Strictly speaking, the two variants have subtle differences in intonation.)
So we are taught a decent method to help us discern if we should use a hyphen or not, that revolves around putting the sentence in the negative form.
When the hyphen belongs there, the negative form makes the contracted pronoun go before the verb. When the hyphen doesn't belong there (and it is really just a verb tense) the verb doesn't change. So you negate the sentence and try placing the suspect pronoun in both places. What sounds right is probably the right choice.
# Task
Given a Portuguese sentence, perform the basic test to help discern if a sentence should use a hyphen in a contraction or not.
## Basic algorithm for the challenge
We are going to simplify things a bit here. Your code should do the following (check below for two worked examples)
1. Look for the only hyphen in the input sentence (the hyphen that we are unsure about), between two words, like so: `verb-pronoun`
2. Output the two following modified sentences:
	* in the place of the `verb-pronoun`, use `"nao" verbpronoun`, i.e. prepend "nao" and drop the hyphen;
	* in the place of the `verb-pronoun`, use `"nao" pronoun verbs` where `verbs` is the verb (with an extra "s" if the verb ended in a vowel "aeiou").
## Worked examples
Let `"sei que apanhas-te um susto"` [~I know you were scared] be the input. We find the hyphen and extract `verb = "apanhas"` and `pronoun = "te"`. The `verb` does not end in a vowel, so there will be no need to add an "s" for the second sentence. The two sentences will be of the form `"sei que _ um susto"`. Indeed, they are:
1. `"sei que nao apanhaste um susto"` [~I know you were not scared]
2. `"sei que nao te apanhas um susto"` [~I know were you not scared]
So clearly we should go with number 1.
Now let us take `"da-me um upvote"` [~give me an upvote]. The hyphen is in `"da-me"` so we take `verb = "da"` and `pronoun = "me"`. The verb ends in a vowel so we will need to use `verbs = "das"` in the second sentence:
1. `"nao dame um upvote"` [~give me an upvote not]
2. `"nao me das um upvote"` [~you don't give me an upvote]
So clearly the right Portuguese sentence would be number 2.
# Input
A string composed of spaces, characters in the range `[a-z]` and a single hyphen surrounded by two words.
The input string can be in any sensible format, like a string, a list of words or a list of characters.
# Output
The two modified sentences, as described above. These can be printed separately, returned in a list, or whatever is sensible in your programming language.
* The two sentences can be interchanged, i.e. order doesn't matter.
* The two sentences can be in a single string, as long as they are separated by a character that is not in `[a-z \-]`.
# Test cases
```
"sei que apanhas-te um susto" -> "sei que nao apanhaste um susto", "sei que nao te apanhas um susto"
"da-me um upvote" -> "nao dame um upvote", "nao me das um upvote"
"conta-me no que estas a pensar" -> "nao contame no que estas a pensar", "nao me contas no que estas a pensar"
"pensei em bater-te" -> "pensei em nao baterte", "pensei em nao te bater"
"isto custa-me a crer" -> "isto nao custame a crer", "isto nao me custas a crer"
"passeia-te pela rua" -> "nao passeiate pela rua", "nao te passeias pela rua"
```
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so shortest submission in bytes, wins! If you liked this challenge, consider upvoting it... And happy golfing!
---
This is the third challenge of the [RGS Golfing Showdown](https://codegolf.meta.stackexchange.com/q/18545/75323). If you want to participate in the competition, you have 96 hours to submit your eligible answers. Remember there is still 350 reputation in prizes! (See 6 of [the rules](https://codegolf.meta.stackexchange.com/q/18545/75323))
Also, as per section 4 of the rules in the [linked meta post](https://codegolf.meta.stackexchange.com/q/18545/75323), the "restricted languages" for this third challenge are *only* [Pyth](https://codegolf.stackexchange.com/a/200301/75323), [MATL](https://codegolf.stackexchange.com/a/200264/75323), [Husk](https://codegolf.stackexchange.com/a/200376/75323) and [CJam](https://codegolf.stackexchange.com/a/200333/75323) so submissions in these languages are not eligible for the final prize. But *they can still be posted!!*
Otherwise, this is still a regular [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") challenge, so enjoy!
  
[Answer]
# [Python 3](https://docs.python.org/3/), 112 bytes
```
(*a,v),(p,*b)=map(str.split,input().split('-'))
a+='nao',
print(*a,v+p,*b)
print(*a,p,v+'s'*(v[-1]in'aeiou'),*b)
```
[Try it online!](https://tio.run/##RYsxDsIwDAD3viKb7TRBQsx9CWIwVSQs0cRKnEq8PkAZGO90py97lHwZAz2HnQJq8HdaNlZsVk9Nn2JBsnZD@hFCBKKJ5wUyFwiTVsl27PMx/4V@FDTwuF/j@SYZOEnpQN9qDGlW3NqbcdySY7fWVN8 "Python 3 – Try It Online")
[Answer]
# [Python 3.8](https://docs.python.org/3.8/), ~~167~~ \$\cdots\$ ~~143~~ 142 bytes
Saved a byte thanks to [Kevin Cruijssen](https://codegolf.stackexchange.com/users/52210/kevin-cruijssen)!!! 
```
lambda p:((n:=(g:=re.match(r'(.*)\b(\w+)-(\w+)(.*)',p).group)(1)+'nao ')+(v:=g(2))+g(3)+g(4),n+g(3)+' '+v+'s'*(v[-1]in'aeiou')+g(4))
import re
```
[Try it online!](https://tio.run/##fVLLbtswELzrKxa6kIwko25yKAQwx3xBbrYPa4m2BVgky4eDwvDX9FP6YS5J0VZdILkQy5nh7OxK@pc7KPn8Q5vrjq@vRxy3PYJuKZUtp/uWG7EY0XUHaghdPLH1lq4/KtakMwKk1myxN8prRpesIhIVEFbRU8v39Dtj1Z4@x@OF1XKqCZDqVBFLnuhp1Sw3gyQoBuXJJGPFMGplHBhxNfz8brxoy06NqqzhDY823OSf3woSdCmcsA440AJoacUAP70A1CgPaBsnwI9gvXXx8czHjFnzKHlQuLvRLGGsjo16bMb00OuTciKZxyc9/gcnNGD9ZJLx7NIp6ZKRVKlpmCTIwvaFtGjupkn2herWI@nsJ7LcMt7CiGKELTphmpx9hqNXoqb4j0TYSOJubkNYCXRhMWkKhM6IKXYiUvZI/svNVEzsc8hE3iKiDS0xfjwtjgjG430VmXukyhwtk3bmkiMrdsqAqwUMEuLf0hZg@Y46VoA2g3R0R8qzu5TQvEJ5tqtvm0t0DdUyVHA2K8u52FzCSrUw2CvCrn8B "Python 3.8 (pre-release) – Try It Online")
Inputs a string and returns a tuple of two strings.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~57~~ ~~55~~ ~~53~~ ~~51~~ ~~41~~ ~~40~~ ~~39~~ 38 bytes
*-3 bytes thanks to @KevinCruijssen*
*-1 byte thanks to @Grimmy*
```
#ʒa_}н©¡D®'-¡Âðý¤žMså's×«sJ‚vy"nao ÿ"ý
```
[Try it online!](https://tio.run/##AVYAqf9vc2FiaWX//yPKkmFffdC9wqnCoUTCrictwqHDgsOww73CpMW@TXPDpSdzw5fCq3NK4oCadnkibmFvIMO/IsO9//9pc3RvIGN1c3RhLW1lIGEgY3Jlcg "05AB1E – Try It Online")
---
### Explanation
```
#                                           - split input on spaces
 ʒ'-¢}н©                                    - get the hyphenated word
        ¡D                                  - split the input on this word (removing it)          
          ®'-¡                              - split the hyphenated word into its two parts
              Âðý                           - Swap and join with space 
                                            - (e.g. custa-me -> me custa)  
                 ¤žMså's×«                  - if the last char is a vowel add an 's' 
                            sJ              - swap and join the other hyphenated word
                                            - (e.g. custa-me -> custame)
                              ‚             - put these in an array so ["custame","me custa"]
                               vy"nao ÿ"    - for each of these add nao in front
                                        ý   - then join the split input with them
           
          
```
---
[Answer]
# [V (vim)](https://github.com/DJMcMayhem/V), ~~38~~ 37 bytes
My first ever V answer I believe ...props to the inventor, [James](https://codegolf.stackexchange.com/users/31716/james) A.K.A. DJMcMayhem!
```
ÄÎf-binao 
ó¨[aeiou]©-/±s-
f-dbeá pí-
```
**[Try it online!](https://tio.run/##AUQAu/92///DhMOOZi1iaW5hbyAKw7PCqFthZWlvdV3CqS0vwrFzLQpmLWRiZcOhIHDDrS3//3BlbnNlaSBlbSBiYXRlci10ZQ "V (vim) – Try It Online")**
### How?
```
ÄÎf-binao <CR>ó¨[aeiou]©-/±s-<CR>f-dbeá pí- | implicit read from STDIN
Ä                                           | copy line, paste below
 Î        <CR>                              | for all lines:
  f-                                        |   find "-"
    b                                       |   back one word
     i                                      |   enter insert mode
      naoS                                  |   "nao "
                                            |   (<CR>: implicit exit from insert mode)
              ó          /   <CR>           | single substitution on line:
                                            |    pattern.../:
               ¨       ©                    |      group (1):
                [     ]                     |        any of:
                 aeiou                      |          "aeiou"
                        -                   |      + "-"
                                            |    /...replacement:
                          ±                 |      group (1)
                           s-               |      + "s-"
                                 f-         | find "-"
                                   db       | cut back a word
                                     e      | move to end of word
                                      áS    | insert a space character
                                        p   | paste
                                         í  | single substitution on every line:
                                            |   pattern.../:
                                          - |     "-"
                                            |   /...replacement: (implicit)
                                            |     ""
                                            | implicit print to STDOUT
```
[Answer]
# Java 8, ~~107~~ ~~121~~ ~~119~~ 107 bytes
```
s->s.replaceAll("(.*?)(\\w+)-(\\w+)(.*)","$1nao $2$3$4;$1nao $3 $2"+(s.matches(".*[aeiou]-.*")?"s$4":"$4"))
```
+14 bytes for a bugfix (thanks to *@ovs* for mentioning it)  
-12 bytes thanks to *@Arnauld*. Now we're back to the initial -bugged- byte-count again. xD
Outputs with `;` delimiter between the two sentences.
[Try it online.](https://tio.run/##dVHBTsMwDL3zFVbUQ7LRSLCdNsHEkQPjwHHbwcsCy2jTUCdDCO3bi9sVpA24JLHfi9@zvcM95rvNa2MKJIIHdP7zAsD5aOtnNBbmbQjwFGvnX8DI/kFqyvnDBR8UMToDc/BwAw3lt6RrGwr@fFcUUkg9mCm5XL4PVX68OKPEpciuPFaQXWejbDztgxHHYihJlxjN1pIUerBA66q0yvVAqJmgbCwmgg@lmmkrH9K6YPnexb5yGyi5i97oYgWoji1ES1EKsg7ekgUM6LdIebSQSqBEsRJdT9/EDeZlh6Wwr6I9BU3lY4f7qqvGSSRACNYT1qfcNseitoQ18lTz81qOpcGwga4ggqnteQVejXXYeg22QKgTil/z7zrv@D8r6lf3QdGWukpRBwZi4aW49yHFCYNiSL3UX7THFJlHE6Z5bSSp/7m9n0PzBQ)
**Explanation:**
```
s->               // Method with String as both parameter and return-type
  s.replaceAll(   //  Replace in the input-String:
   "(.*?)(\\w+)-(\\w+)(.*)",
                  //   This regex match
   "$1nao $2$3$4;$1nao $3 $2"
                  //   With this replacement,
     +(           //   which is appended with:
       s.matches(".*[aeiou]-.*")?
                  //    If the input-String matches this regex fully:
         "s$4"    //     Append "s$4" to the replacement
        :         //    Else:
         "$4"))   //     Append "$4" to the replacement instead
```
*Regex explanation:*
```
(.*?)(\\w+)-(\\w+)(.*)        # MATCH:
(   )                         #  Capture group 1:
 .*                           #   Any amount of (optional) leading characters
   ?                          #   Which are optional (to lower their priority in comparison
                              #                       to the next groups)
     (   )                    #  Followed by capture group 2:
      \w+                     #   Any amount of alphanumeric characters
          -                   #  Followed by a literal "-"
            (   )             #  Followed by capture group 3:
             \w+              #   Any amount of alphanumeric characters
                 (  )         #  Followed by capture group 4:
                  .*          #   Any amount of (optional) leading characters
$1nao $2$3$4;$1nao $3 $2s$4   # REPLACEMENT:
$1                            #  Content of capture group 1
  nao                         #  Followed by a literal "nao "
      $2$3$4                  #  Followed by the contents of capture groups 2, 3, and 4
            ;                 #  Followed by a literal ";" as separator
             $1               #  Followed by the content of capture group 1
               nao            #  and a literal "nao " again
                   $3         #  Followed by the content of capture group 3
                              #  Followed by a literal " "
                      $2      #  Followed by the content of capture groups 2
                        s     #  Followed by a literal "s", iff the match below is truthy
                         $4   #  Followed by the content of capture group 4
 .*[aeiou]-.*                 # Check if the string matches this string:
^            $                #  It tries to match the ENTIRE string (which is done
                              #  implicitly by the `String#matches` method)
 .*                           #  Any amount of leading characters
   [aeiou]                    #  Followed by a single vowel character
          -                   #  Followed by a literal "-"
           .*                 #  Followed by any amount of trailing characters
 
```
[Answer]
# [Bash](https://www.gnu.org/software/bash/) + Core utilities, ~~85~~ ~~84~~ ~~82~~ ~~75~~ ~~72~~ 71 bytes
```
p=";s/(\w*)-(\w*)/nao "
sed -E "h$p\1\2/p;g;s/([aeiou])-/\1s-/$p\2 \1/"
```
[Try it online!](https://tio.run/##HY0xDsIwDEX3nMKqGAApitq1YuQUhOG3tWglmoQ4geOHNIst2@8/T5C1lHDrRjFn@7tedKvGwVOnhBfSd@rWU7C9HUwYXwf3AG8@Py/a2F60qceBbG@6UoQ3@mQmBLgVohNT3kmyJK8W6L2NOXx9YjV7l9rK@ZZhSRACBXaCqI5WbbzThMSxqtRWNTRXWYuB5siVg1QOx6vAb1DM@AM "Bash – Try It Online")
---
1 byte shorter, thanks to @user41805: Using the `p` flag in the first substitution permits one `;` to be omitted.
---
Down to 72 bytes now: Added the `-E` option to sed for extended regexes, eliminating the need to escape the various parentheses.
---
*Thanks to @Neil for shaving off 7 bytes, leaving 75 bytes!*
Improvements: (1) Eliminating the `\<` and `\>`, which are unnecessary because of sed's greedy regex matching. (2) Appending the `s` (if needed) before reversing the order of the verb and the pronoun, which eliminates the need for adding the identifying `%` character and later deleting it.
---
Input is on stdin, and output is on stdout.
**How it works:**
1. The value of `p` is essentially the beginning of a sed substitute
command that finds the verb-pronoun combination and replaces it with
a string starting with `nao` (the command is incomplete -- it will
need to filled in with the rest of the desired substitute and then a
final `/`). At the very beginning of `p`, preceding the command, is
a `;`, which will separate it from the previous sed command. (`p` will be used twice -- once for each output string.)
2. The sed command starts by reading one line of input (one Portuguese sentence) into sed's pattern space. (This is automatic with sed.)
3. The first sed command, `h`, copies the pattern space into the hold space, so we've saved a copy of the input string for use later to compute the 2nd output.
4. Next comes `$p\1\2/`, which expands to `;s/(\w*)-(\w*)/nao \1\2`. The command after the sed command separator (`;`) inserts the `nao` in the right place and removes the `-`.
5. The sed command `p` prints the pattern space. That's the first output string.
6. The sed command `g` copies the hold space to the pattern space. Now the pattern space contains the original input string again.
7. The next sed command, `s/([aeiou])-/\1s-/` appends an `s` to the verb if the verb ends with a vowel.
8. Next comes `$p\2 \1`, which expands to a sed command that inserts `nao`, reverses the order of the verb and the pronoun, and replaces the hyphen with a space.
9. Finally, the pattern space is printed (no command needed -- by default, sed does this automatically at the end). That's the second output string.
Note that the sed command is run on each input line separately, so you can process as many sentences as you want in a single run of the program. 
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), 47 bytes
```
(\w*?([aeiou])?)-(\w+)
nao $1$3$"nao $3 $1$#2*s
```
[Try it online!](https://tio.run/##K0otycxLNPz/XyOmXMteIzoxNTO/NFbTXlMXKKCtyZWXmK@gYqhirKIEZhmDOMpGWsX//6ck6uamKpTmKpQWlOWXpAIA "Retina – Try It Online")
The verb consists of some characters `\w*?` and an optional vowel `([aeiou])?`. The pronoun is just some characters `\w+` after the hyphen.
`VERB-PRONOUN` gets replaced by `nao VERBPRONOUN` (`nao $1$3`), `POST_MATCH NEWLINE PRE_MATCH` (`$"`), `nao PRONOUN VERB` (`nao $3 $1`) and, if `([aeiou])?` had a match, a trailing `s` (`$#2*s`).
[Answer]
# [SNOBOL4 (CSNOBOL4)](http://www.snobol4.org/csnobol4/), 145 bytes
```
	W =SPAN(&LCASE)
	INPUT ARB . L W . V '-' W . P REM . R
	L =L 'nao '
	OUTPUT =L V P R
	V ANY('aeiou') . E RPOS(0) =E 's'
	OUTPUT =L P ' ' V R
END
```
[Try it online!](https://tio.run/##VYuxCsIwGITn5Clu8m@HioNrh6gZhJiGtE1xrJhBsI1Q4@vH1E0O7o7jvmUOt/Dcp8QG1K0Rutioo2hlydlZm76DsAdsoTBkd6CKfs3AyktOy5lCrUDzGECcNX23Qnlx64czB6GvBY3@ESKVmZCwpmmLXYlagpY/xoCyXOakPqV0H6vJI06Ir094@y8 "SNOBOL4 (CSNOBOL4) – Try It Online")
Explanation:
```
	W =SPAN(&LCASE)				;* Alias for SPAN(&LCASE), which matches at least one character from &LCASE,
						;* the lowercase letters, so I guess it's [a-z]+
	INPUT ARB . L W . V '-' W . P REM . R	;* match the input against the following pattern:
		;* ARBitrary match, save as L, the Left part of the sentence
		;* SPAN(&LCASE) save as V, the verb
		;* hyphen
		;* SPAN(&LCASE) save as P, the pronoun
		;* REMainder of the match, save as R, the Right part of the sentence
	L =L 'nao '				;* concatenate 'nao ' to the end of L
	OUTPUT =L V P R				;* print L V P R
	V ANY('aeiou') . E RPOS(0) =E 's'	;* if V ends (RPOS(0)) in aeiou, add S to the end
	OUTPUT =L P ' ' V R			;* and output the new sentence.
END
```
[Answer]
# Excel, 311 Bytes
```
B2 <- Input
B3 =LEN(B2)
B4 nao <- Required trailing space
B5 aeiou
B6  <- Cell contains a single space
C3 -
C4 '<- Single results in empty (text formatted) cell
C5 :
D2 =TEXTJOIN(B6,,IF(ISERR(SEARCH(C3,D3#:C3)),D3#:C3,D4#:D5#:C5))<- Output
D3 =TRIM(MID(SUBSTITUTE(B2,B6,REPT(B6,B3)),(SEQUENCE(,B3-LEN(SUBSTITUTE(B2,B6,))+1)-1)*B3+1,B3))
D4 =B4&SUBSTITUTE(D3#,C3,)
D5 =D6#&IF(ISERR(SEARCH(RIGHT(D6#,1),B5)),"","s")
D6 =B4&RIGHT(D3#,LEN(D3#)-D7#)&B6&LEFT(D3#,D7#-1)
```
This answer would be so much shorter if SUBSTITUTE was renamed to SUBS (Microsoft pls fix)
### Sample Image
[![sample image](https://i.stack.imgur.com/KHc5D.png)](https://i.stack.imgur.com/KHc5D.png)
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 37 bytes
```
e€ØẹṪ”sxṭ
ṚKÇ,ṭ€“nao ”
ṣÇ¥Wċ?€”-ŒpK€Y
```
[Try it online!](https://tio.run/##HY0xTgMxEEV7n2IKSvYEkcgBcgBEOSwjJdGubXZsRLpAswUdFUKkQjQIGoRWGKQUaziI9yJm4mr@/P/nzZqaZpMzTbdv8SF9hxRep@2Or1N4Vyk8LmJ/LFLSafuk0YCE4j/Hfnw5/b2bl2BX/d3bhciznL4@UtjPpAzVyThINhMr9kcq/XzGXjrr6WY/DuOQM9MKLj0BWtRL5MoR@BbYszPqAqu2rN5eGUeqNtoVS5tyQ@yQAcGSZuzUYQiNWjhHR52g1EowUAusnCHUHUkPWXp4eGWpQeg8/gM "Jelly – Try It Online")
A full program that takes a list of words and prints a the output separated by newlines.
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 41 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
2ÆË=q-)ÊÉ?X?DÔ¸r"%v$""$&s":Dq)i"nao ":D}S
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=MsbLPXEtKcrJP1g/RNS4ciIldiQiIiQmcyI6RHEpaSJuYW8gIjpEfVM&input=ImRhLW1lIHVtIHVwdm90ZSI)
Alternative, with output being list of words:
# [Japt](https://github.com/ETHproductions/japt) [`-R`](https://codegolf.meta.stackexchange.com/a/14339/), 40 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
2ÆË=q-)ÊÉ?X?DÔ¸r"%v$"_+'s:Dq)i"nao " ¸:D
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LVI&header=cVM&code=MsbLPXEtKcrJP1g/RNS4ciIldiQiXysnczpEcSlpIm5hbyAiILg6RA&input=ImRhLW1lIHVtIHVwdm90ZSI)
[Answer]
# JavaScript (ES6), ~~81 80~~ 79 bytes
Returns a single string with the two sentences separated by a `/`.
```
s=>s.replace(/(\w+)-(\w+)/,"nao $1$2$'/$`nao $2 $"+(/[aeiou]-/.test(s)?'1s':1))
```
[Try it online!](https://tio.run/##dZLRboMwDEXf9xUWQgJUIGofJ3X7kG3SPHA3JkpYnHSfzxJDC6VrHpBiH/nkWnzjCbkyTW@LTtc0HPYD75@4NNS3WFGq0tffTVbIV@VRhxribbyLExW/y2UHcbRJ1QtSo91boUpLbFPOnpMtJ4/bLBsq3bFuqWz1Z3pII6YGfhwB9th9IReWwB2BHVsdZRmEoxRcsCCZ0CWZXxP2Mm9GHlbiGoujTHD9SVs6y5YniMO4Gq/IfKz6Wj0Kpvra4K9WJJ2Wl/lNeB6hp47RiPBsEPQuOQuF4zvY2h/Kfil0hA@0ZIp/Qgb/jAWJoGPI64bfqfRuNI3fLlR@x5IVoTJkVqKgEUyyBnQm80UrJHRTKGneREL2T8Lwl/TUIhiH60znlU7okpz2GEpjk@fe8Ac "JavaScript (Node.js) – Try It Online")
### Commented
```
s =>                       // s = input string
  s.replace(               // replace in s
    /(\w+)-(\w+)/,         //   (verb)-(pronoun) with
    "nao $1$2$'" +         //   1st sentence:
                           //     implicit left context
                           //     + "nao verbPronoun"
                           //     + explicit right context ($')
    "/" +                  //   append our separator
    "$`nao $2 $" + (       //   2nd sentence:
                           //     explicit left context ($`)
                           //     + "nao pronoun verb",
                           //     where 'verb' is built as follows:
      /[aeiou]-/.test(s) ? //       if there's a vowel before the '-' in s,
                           //       i.e. if the verb ends with a vowel:
        '1s'               //         append '1s' (which gives "$1s")
      :                    //       else:
        1                  //         just append '1' (which gives "$1")
    )                      //     + implicit right context
  )                        // end of replace()
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~94 87 83~~ 81 bytes
```
->s{['\1\2','\2 \1'+"#{s=~/[aeiou]-/&&?s}"].map{|r|s.sub /(\w+)-(\w+)/,'nao '+r}}
```
[Try it online!](https://tio.run/##NY7RasMwDEV/RXhQbyRuaN/bfkicByVVWWCxXcvaOpLs11PXsBchLudcKUr/u91Omznz3Gp7sEdda3sEe9CVepv59Ne0SKOXzjS73YVX1e0nDPMSF96z9NC825/qw5TZ1NqhB13Fdd2CJIZWMY1wFwIM6D6RTSKQCVg4eVWrK5qpBBK@faKcDN6lEjpfPOKEDAiBHGPMwGvJnTRBj4miKdaY62DIpUVFGCIVFjmz@Doa6AshCv7//1hu7aNbtyc "Ruby – Try It Online")
[Answer]
# [Julia 1.0](http://julialang.org/), ~~121~~ ~~118~~ 116 bytes
```
s->((x=(r=match(r"(.*)\b(\w+)-(\w+)(.*)",s))[1]*"nao ")*(y=r[2])*r[3]*r[4],x*r[3]*" "*y*"s"^(y[end]∈"aeiou")*r[4])
```
[Try it online!](https://tio.run/##fVLLboMwELzzFSufbAqV0vZK1Y/ojVBpA05DFAz1o03@IN/ZH6H24oRQqeVg2TPj2fGye3docXUct8Vo8mfOjwXXRYe23nHN@H0q1hu@/roTOa0BYJkRolxVKVPYAxMpPxW6fKhEqsvHyi9PVXac9gxYekqZYW/8VErVVN/nM0PZ9o4JEooxsdJYAwXwBDgzsoUPJwEHVDs0uZXgOjDO2J5lN3yoHDVLyUJhr0azRIgsFGow7@iiGz57K8k8XGnwF0yox5rJJOLRpe6VJSPVU1H/FC9DGKQyqK@mJPtHdalBOvOHLJYMJ/9E2cEGrdR5zD7DwYuoKf6S8B0h7uLW@pZA7RtDr0CotZxiE0HZA3nLzVRI7GJIIi8R0fiSGH7eIA8I2uG1FZFbUixGi6SZOXIUiTOteodX35Fk22uw0CqguUnAfy9hC1tu/VAKKAqwfhoTP27jDw "Julia 1.0 – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/) `-p`, ~~67~~ 58 bytes
```
s%(\w*)-(\w+)%"nao $1$2$'
$`nao $2 $1"=~s/[aeiou]\K$/s/r%e
```
[Try it online!](https://tio.run/##K0gtyjH9/79YVSOmXEtTF0hqa6oq5SXmK6gYqhipqHOpJIA5RkC@km1dsX50YmpmfmlsjLeKfrF@kWrq//8pibq5qQqluQqlBWX5Jan/8gtKMvPziv/r@prqGRga/NctAAA "Perl 5 – Try It Online")
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 42 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
2Ær7î"%w+-" _X?Zq- Ô¸r"%v$"_+'s:Zr-)i"nao 
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=MsZyN%2b4iJXcrLSIgX1g/WnEtINS4ciIldiQiXysnczpaci0paSJuYW8g&input=ImRhLW1lIHVtIHVwdm90ZSIKLVI)
[Answer]
# [Python 3](https://docs.python.org/3/), 111 bytes
```
(*a,v),(p,*b)=map(str.split,input().split('-'))
for c in[v+p,p+' '+v+'s'*(v[-1]in'aeiou')]:print(*a,"nao",c,*b)
```
[Try it online!](https://tio.run/##Jc1NCsMgEEDhfU8h2YzjT6F0V@hJQhZWLB1odNBRyOktocu3@R4f8in5Pqc2wQ10mp154XMPrJvUa@MviaPMXTT@S4MHxMu7VBUV5XVYdmxBgR0WGhg9Vn/bKENIVDrg9uBKWU5/yaEsLp6HOalJUbE3CX5PKqhYU/0B "Python 3 – Try It Online")
Method of taking input thanks to @ovs. I felt that this is a big enough change to warrant its own answer, however.
[Answer]
# [R](https://www.r-project.org/), 111 bytes
```
cat(sub(r<-"(\\w+)-(\\w+)","nao \\1\\2",s<-scan(,"")),1,sub(r,paste0("nao \\2 \\1","s"[grep("[aeiou]-",s)]),s))
```
[Try it online!](https://tio.run/##LcsxDoMwDIXhq0SebNWRCjM3wQwuRFUHSBQn7fFDWrq8t/xfbm3VglYfmCcPKPK5kb8OGA6NTmQQGYFt8rbqgQxAxAP/DCe1Eu74L8dv3Z3B/MwhIcwaXrEuvnNaqA@1Tf0eXN1dTe9YQjsB "R – Try It Online")
I am pretty bad at regexing, so there is probably inspiration for something better to be found in other answers.
Note that `scan(,"")` splits words on spaces, making it easier to manipulate the strings. In the output, the two sentences are separated by a `1`.
More readable : 
```
r <- "(\\w+)-(\\w+)"                       # regex to match the word with a dash
s <- scan(, "")                            # stdin
cat(sub(r, "nao \\1\\2", s),              
    1,
    sub(r, paste0("nao \\2 \\1",
                 "s"[grep("[aeiou]-", s)]) # add an s or NULL, depending on whether the letter before the dash is a vowel or not
        , s))
```
[Answer]
# [sed 4.2.2](https://www.gnu.org/software/sed/) `-E`, 72 bytes
```
h;s/(\w*)-(\w*)/nao \1\2/p;g;s/([aeiou])-/\1s-/;s/(\w*)-(\w*)/nao \2 \1/
```
Port of [Mitchell Spector](https://codegolf.stackexchange.com/users/59825/mitchell-spector)'s [Bash answer](https://codegolf.stackexchange.com/a/200490/89298).
[Try it online!](https://tio.run/##bYsxDoMwDAC/4hEqWRZZM/MK0sESVslAnMqJ@ntMYWa55e5MVvctGg3p9xrxJhVWSFMKVOPnUgtL1v4ekdJkSE91@A/kbpLh2wW4ctnYsAn0Haxb00Nry1rMcT4B "sed 4.2.2 – Try It Online")
[Answer]
# [PHP](https://php.net/), 159 bytes
```
for($t=2;$t--;)echo preg_replace_callback('#(\w+?)([aeiou]?)-(\w+)#',fn($m)=>'nao '.$m[$t*2+1].($t?' ':'').$m[2-$t].$m[3-$t].($t&&$m[3-$t]?'s':''),$argn),"\n";
```
[Try it online!](https://tio.run/##NY3LTsMwEEX3@YpRa9UxjSsRdoSSHT/RRtXUnTYRiW38gL8n2JbYzOPOvWfsaNe33qZ6N65m4dh2LEjZCVKjAevocXFkZ1R0UTjPV1SfNd/W5599L@oT0mTi0AuZBbHlzV3XbBHHd67RAD@w5cTCU7t/Hg6J3XPgr5yLLLeShSEPL2VI193uf@u5L76GoXto0WzOetOtq6cJviIBWtQjehkI4gI@@mCqG8qlrNF@m0CVMjoUSZuSIR/QA4Il7dFVuSUaLXDFQC6hqilhQCVYiSEoR8mHPvkwv7I0I7iIv8aGyWi/yo8/ "PHP – Try It Online")
The array numbering is messy, there's more juice to be squeezed there.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 50 bytes
```
≔⊟Φ⪪θ №ι-η≔⪪η-ζＥ⟦⪫ζω⁺⪫⮌ζ ×s№aeiou§§ζ⁰±¹⟧⪫⪪θη⁺nao ι
```
[Try it online!](https://tio.run/##PU5Li8IwEL77K4acJpCCnj2JsLALSlFv4iHoYAfSpDZJlf75OD66cxnme865sf05WFfKKka@eqxDhz/sEvW47xwnvBlQoLSBdcg@IctZKa0FaPRy9nV9pM2HMzAKU/cs8o3t8PgX2ONo4C5U7XLEN7CjgfpIOOqp4cAtRVRRTWXKEocs5yr9@gs9cNoSNhfDlq42ES70a04G3rn/bzdTnfI2gKTwS7Ys5WKrliC3kLshJJqVanBP "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
≔⊟Φ⪪θ №ι-η
```
Split the input on spaces and extract the word that contains a `-`.
```
≔⪪η-ζ
```
Split that word on its `-`.
```
  ⪫ζω
```
Join the parts together.
```
⁺⪫⮌ζ ×s№aeiou§§ζ⁰±¹
```
Reverse the parts and join them with a space, then append as many `s`s as there are vowels in the last letter of the first word.
```
Ｅ⟦...⟧⪫⪪θη⁺nao ι
```
Prefix `nao` to each of the two above values and substitute them for the original word.
[Answer]
# Pure [Bash](https://www.gnu.org/software/bash/), ~~118~~ 117 bytes
```
a=${1%-*}
b=${1#*-}
v=${a##* }
u=${v#${v%[aeiou]}}
h=${a%$v}nao
p=${b%% *}
t=${b#$p}
echo $h $v$p$t,$h $p $v${u:+s}$t
```
[Try it online!](https://tio.run/##HY1NbsQgDEb3PoU1wCZtFrMdqSepunASS0SaAMVARxpx9tRkgfw@/zwWEn/@@f3JmJk2fMEWQbjgzb5uJ33Z993NU4dlkJnmDk2JjJmwQ1VsRp/7Jt5j/ekd/Bg723qgCEnD4hyqoAw0NnXg1Ue0Hm2zyZbPQWmEd318SLfl3GLgU3jH38pIiYInmQtjPVCqlAgbzccVa2qxMKwxlKsV4nXDUkiQMHEQyjCK2vjAhQpnVcGuGlxVdp0Rrpl1j0T3aHyV@EmYK/0D "Bash – Try It Online")
I decided to see what I could do with pure bash (no Unix utilities), and this is what I came up with. It can probably be golfed some more.
Input is passed as an argument.
The output is a comma-separated string containing the two desired results.
[Answer]
## Batch, 265 bytes
```
@echo off
set m=
set n=
for %%w in (%*) do set w=%%w&call:w
echo%m%
echo%n%
exit/b
:w
if %w:-=%==%w% set m=%m% %w%&set n=%n% %w%&exit/b
set m=%m% nao %w:-=%
set v=%w:-=^&rem %
set n=%n% nao %w:*-=% %v%
for %%v in (a e i o u)do if %n:~-1%==%%v set n=%n%s
```
Takes input as command-line parameters. Explanation: The main work is done by the `:w` subroutine, which receives each word in turn passed in a variable so that substitutions can be performed on it. The first substitution is simply deleting the `-`; if this doesn't change the word then we're not interested in the word and we just concatenate it to the outputs. Otherwise, for the first output, we just add `nao` and the substituted word. For the second output things get a little more complicated. Although we can substitute all characters up to and including the `-` with the empty string to give us the pronoun, the verb is a bit tricker. Fortunately due to a quirk of Batch processing we effectively get to `exec` the result of the substitution, turning the pronoun into a comment. (This behaviour also eats the leading space in the output when we `echo` it.) It then remains to see whether the verb ended in a vowel and if so suffix an `s`. Example:
```
set m= nao dame             `m` becomes ` nao dame`
set v=da^&rem me            `v` becomes `da&rem me`
set n= nao me da&rem me     `n` becomes ` nao me da`,
                            as the `rem me` is now a comment.
```
[Answer]
# [GolfScript](http://www.golfscript.com/golfscript/), 62 bytes
```
"-"/~2/(:f;:e;" ":s/.)" nao ":w\f\s\e++++\s*\+p~w\f e++++s\++p
```
*Boy* do I hate string parsing.
This is nowhere near optimised and can very easily be brought down below 50 bytes, I just don't have the bother right now.
Ugh.
TLDR of the process
Split along the hyphen. Remove the next two letters on the right side. Split the left half by spaces and duplicate it. Shove the "nao" and the two letters where they belong and print.
[Try it online!](https://tio.run/##HYixDoQgEAV/ZbOVSpTkSvyVbYhZ1OQU7h7Ezl9H4lQzs8ZvwPLfU64M3elXlHzy5@YxZqVyEApy5Moj2/tjOxdmpzMTO9ipZzp9bH5JEIiahmAQk@526G2IManWBw "GolfScript – Try It Online")
[Answer]
## vi, 48 bytes
```
yyPf-xbinao ␛bj.:s/\([aeiou]\)-/\1s-/e␍f-r ldbwP
```
`␍` means the Enter key and `␛` means the Escape key. Explanation:
```
yyP
```
Duplicate the input line.
```
f-x
```
Delete the `-` on the first line.
```
binao ␛bj.
```
Insert the `nao` on both lines.
```
:s/\([aeiou]\)-/\1s-/e␍
```
Append an `s` to the vowel if necessary.
```
f-r l
```
Change the `-` to a space.
```
dbwP
```
Swap the verb and pronoun.
[Answer]
# T-SQL, 304 bytes
I added some linebreaks to make it readable
```
SELECT 
stuff(replace(@,d+w,iif('eioua'like'%'+right(w,1)+'%',w,p)),z,0,f),
stuff(replace(@,d+w,iif(substring(@,q-2,1)=p,'',p)),z,0,f+w+y)FROM(
SELECT substring(@,q,charindex(y,@+y,q-1)-q)w,len(@)
-charindex(y,s,charindex(d,s)+1)+2z,*
FROM(SELECT-~charindex('-', @)q,'nao 'f,' 'y,'-'d,'s'p,reverse(' '+@)S)Q)L
```
**[Try it online](https://data.stackexchange.com/stackoverflow/query/1205983/help-me-write-portuguese)**(ungolfed)
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~41 38 37~~ 36 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
ṚKµe€ØẹṪ”sxṭÑ
“nao ”;
ṣ”-⁹Ŀ¹Ḋ?¥þ2K€Y
```
A full program accepting a single argument, a list of words, which prints to STDOUT.
**[Try it online!](https://tio.run/##y0rNyan8///hzlneh7amPmpac3jGw107H@5c9ahhbnHFw51rD0/ketQwJy8xXwEoYs31cOdiIK37qHHnkf2Hdj7c0WV/aOnhfUbeQJ2R////j1bPLC7JV9dRUE8uLS5J1M1NBbETwQJFqUXqsQA "Jelly – Try It Online")**
### How?
```
ṚKµe€ØẹṪ”sxṭÑ - Link 1: list of lists of characters, Parts
Ṛ             - reverse
 K            - join with space characters, call this R
  µ           - start a new monadic chain
     Øẹ       - lower-case vowels
    €         - for each character, C, in R:
   e          -   (C) exists in (vowels)?
       Ṫ      - tail (i.e. is the last character a vowel?)
        ”s    - 's' character
          x   - times (i.e. X = ['s'] or [])
           ṭ  - tack (X) to (R)
            Ñ - call the next link (Link 2) as a monad
“nao ”; - Link 2: list, V
“nao ”  - list of characters "nao "
      ; - concatenate ("nao " with V)
ṣ”-⁹Ŀ¹Ḋ?¥þ2K€Y - Main Link: list of lists of characters, words
          2    - literal two
         þ     - outer-product (W in words)*(N in implicit range of 2 = [1,2]) with:
        ¥      -   last two links as a dyad  - i.e. f(W, N):
ṣ              -     split (W) at any:
 ”-            -       hyphen character
       ?       -     if...
      Ḋ        -     ...condition: dequeue (empty is falsey)
    Ŀ          -     ...then: call Link at line number:
   ⁹           -           chain's right argument (N)
     ¹         -     ...else: identity - do nothing
           K€  - join each with space characters
             Y - join with newline characters
               - implicit print
```
]