[Question]
  [
Oh, No!  
the sentences are out of balance.  
Quick! balance them.
---
A word is defined as follows:
> 
> A sequence of letters [A-Za-z] separated by **any** non-letter character ([0-9] ~+- etc.)
> 
> 
> 
A word is BaLanCeD if its capitalization is the same forwards as it is backwards.
Given a sentence with words, balance each word by capitalizing a letter on the right-hand side for each uppercase letter on the left-hand side, and the other way around. Do not make uppercase letters lowercase.
## Rules
* For each letter `n` chars from the beginning of a word, it and the letter `n` chars from the end of the word should both be made uppercase if either of them is upper case.
* All input will be printable ASCII (codepoints 32  to 126 `~`).
**No need to balance if:**
* The capital is in the middle of a term (word) (equal amount of letters on each side)
* No capitals are present in the term
**Example:**
```
eeeeE → EeeeE  
eEeee → eEeEe
eeEee → eeEee
Eeee. → EeeE.
{EEee}1EEeEEEeeeeee → {EEEE}1EEeEEEEEEeEE
```
**TesT CaSeS:**
```
It was the first new century. →
IT was the first new century.
IiIIiiIIiiiI Ii iI iiiI iiii iIi. →
IiIIIIIIIIiI II II IiiI iiii iIi.
I sueD the airport for misplacing my Luggage. – I lost my Case. →
I SueD the airport for misplacing my LuggagE. – I lost my CasE.
The Policemen  CraCked THE CaSE of the lost cocaIne. →
ThE PolicemeN  CraCkeD THE CASE of the lost coCaIne.
JUST IN CASE. →
JUST IN CASE.
If(!1){ /\hElloBinOLIngo}elsE{ print( 'bOn aPPetit')} →
IF(!1){ /\hElLOBinOLInGo}ElsE{ print( 'bOn aPPeTIt')}
xK/TH"E7k['VyO%t>2`&{B9X.8^$GWc=!+@ 3Us}]JFM)jbuI,-:alPw*Qvpq5zi\Z(_n1dC~?<;fDAm0SR|eYg6#rN4Lho →
XK/TH"E7k['VyO%t>2`&{B9X.8^$GWC=!+@ 3US}]JFM)JbuI,-:aLPw*QvpQ5zi\Z(_n1DC~?<;fDAm0SR|eYg6#RN4LhO
Foo_bar →
FoO_bar
```
(the " →" will not be included in the input)
This is codegolf, so attempt to achieve least amount of bytes
  
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), ~~76~~ 72 bytes
*Saved 2 bytes thanks to @tsh*
```
s=>s.replace(/[a-z]+/gi,w=>Buffer(w).map((c,i,a)=>c&=a[w.length+~i]|95))
```
[Try it online!](https://tio.run/##HVDtdhIxEP3PU0xRSyKwtNWqVRctdGlTsaBL/QKsIWSXtCHZJtmulNLjO/iGvgim/Jh7ZubMvXdmLukNtcyIzNWVnvJ1Eq5t2LSB4ZmkjKPGkNZvx9VGKmpF2GzlScINKnAwpxlCrCZqFIdNth3SYRFIrlI3q96L8d3BPsZrw69zYTiqJLaCvSKddoTk8UIxtIMDp2NnhEoRDmwmhUPlkSrjINEmomyGLIRNYFpZLXkgdYoSZLEXJQ4KasHNOCTCWAeKF8C4crlZBCUiCBGbEASIAI@b1MNDIfwE2JwfbfhUmEwbB94S5sI@HOz3gfkCunma0pQH8O/PXyAgtffx7Ta1PCgNPLWvpWB8zhVA29D2FZ/C4CTyA3EEOtmob0hMM0qUJ52exwMgZ9A@jCO/RIK2dvESGqNZJKVuCdXrEpXqFZc2WkLm/@IQVCY9BbTf5064Cl6Vfn9oDE7K0curYeXLovfENfd@bS9bB9@CVz8fH39l4Vb1PTw7t6vxaecjvpzkpFZ/TWW/ePrpJrvevxWjH@hC7U7b9@/evkmODuc78ec7/j198cicPe/OdKmj9cWEmv8 "JavaScript (Node.js) – Try It Online")
### Commented
```
s =>                     // s = input string
s.replace(               // replace in s:
  /[a-z]+/gi,            //   match all words in a case-insensitive way
  w =>                   //   for each word w:
    Buffer(w)            //     turn it into a Buffer
    .map((c, i, a) =>    //     for each character c at position i in this array a[]:
      c &=               //       bitwise AND of c with:
        a[w.length + ~i] //         the counterpart character taken from the end of
                         //         the word
        | 95             //         OR 0b1011111
                         ///        (all letter bits except the lowercase bit)
    )                    //     end of map()
                         //     implicit coercion of the Buffer to a string
)                        // end of replace()
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 18 [bytes](https://github.com/DennisMitchell/jelly)
```
=ŒsŒgṁ@µŒu=ŒuṚTƲ¦)
```
A full program that takes a string argument and prints the result.
**[Try it online!](https://tio.run/##HU5NSsNAFN73FJ@rNpuKBxDUGHCk2EDizs0YJ9Onk5kwM6GEUtArxJ0H8ACCi24L9R7tReIki/fxvsf3816FUm3fXx46d@jkcfdxtf89dE3gzXH3lf/97L@jvu@Zx5o7@JVASdZ5aLFGIbRvbDufTBgxRuMQAyMEHNcAA6FBAteI2zGBk62N9SiNRUWuVrwgLVG1WDRScinmOL1/gkGZ0BTOMXciROTBmxpFhaiEBmLL4zfxgvwuCYosgSnH@NFVmIIzPbjuH7Mc7AHxdZYMf5Szs4tog/OnVaKUuSG9XDAtzVYol2xQW9J@hunzUoOnqfDkp9H2Hw "Jelly – Try It Online")**
### How?
```
=ŒsŒgṁ@µŒu=ŒuṚTƲ¦) - Main Link: list of characters (S)
 Œs                - swap-case (only affects alphabetic characters)
=                  - (S) equals (that); vectorises
   Œg              - group runs of equal elements
     ṁ@            - (S) mould-like (that) -> list of "words"
                       (any single non-alphabetic character is now a word)
       µ         ) - for each (word in that):
                ¦  -   sparse application...
               Ʋ   -   ...to indices: last four links as a monad:
           Œu      -       upper-case (word)
          =        -       (word) equals (that); vectorises
             Ṛ     -       reverse
              T    -       truthy indices
        Œu         -   ...action: upper-case (the character at the index)
                   - implicit, smashing print (just prints the characters in the list of lists)
```
Seems a bit long to me:
* The partitioning atoms (`œṖ`, `œṗ`, `œP`, and `œp`) don't seem to help much here even though it seems like they should.
* Perhaps there is a way to shorten code by zipping (`"`) a dyadic function with the reverse of each (`U`)?
[Answer]
# [Perl 5](https://www.perl.org/) `-p`, 60 bytes
```
s|\pL+|$i=0;join'',map$F[--$i]=~/[A-Z]/?uc:$_,@F=$&=~/./g|ge
```
[Try it online!](https://tio.run/##FcgxCsIwFADQ3VP8IdjBpnVxUYqKUih0crSWEkuMX9L@kKSDUMQ7eEMPYtQ3PiOtXoTgxpMpZyPDbL66EfZRFHfCsLzinGGdPdJqy491uh7aJWviTZ6x6S@TVI1KhlCAG@Qe/FWCQGvIeriQhQ6d0aLFXkF3h3JQSiiZwPv5ggI0Of/vnXAymeREzVkcPmQ8Uu8CN/oL "Perl 5 – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~132~~ \$\cdots\$ ~~115~~ 114 bytes
Saved ~~3~~ 11 bytes thanks to [AZTECCO](https://codegolf.stackexchange.com/users/84844/aztecco)!!!
```
f(s,e)char*s,*e;{for(;!isalpha(*s);++s);for(e=s;isalpha(*++e););for(*e&&f(e);s<e;++s)*--e&*s&32||(*s&=95,*e&=95);}
```
[Try it online!](https://tio.run/##jZP/VtMwFMf/5ykuVUbbbfwUFctQ6AoUJxtsKEoHZlnaRbq2NpnbGPX4Dr6hD@JMf2xO2eHQ06TJzf3em@aTi4sOxuOxLbMCUXAHhSorqEQb2X4oa4uUITfoIFllipbPiy42kxLTpgv5PFG01K6SXM6WxZTtkMRbLRZJTmW5zY27OxEiV9reErHjj6JFY@px6CLqycrCaAHEk2QHThhnl00owUgyOfQRA94hYNOQcfBIHzDxeC8crkgFkExqmjRp1ASTguiToejiCU2dgPVIOYmCaBj4IQexXehSFrgIU8@B7hAqPcdBDlmBXz9@ggmuL7IJs44YSYI0hLrmuxSTLvEA9BDpN6QNjSND@NQN8O0kQaLDPkaml@qOz@sNME9A36sb6W5seXFdGcGqZXUM1/X3qVetmJ7jR8RlxgiCUByMDMutqgeoViOc8mUlipWDt6uNI0syXtxcLr8fVpf47sbn3Gh/@2Ll5dXTww@4tJh/A5vnLGoeH7xTvrR6ZqH4Crm1vnr6Lfi6dUst65N87a239e@vdzS7vNddq5/dkY/O8yfhybNKx4@THPj@dQuFUqTNMCGDgGBO2hMsjUdgSZ8YS/rOwVJ/LBZjDhYjw2JMsZxMsJRTLHv3sOgPYDmYxVKpZlgO/ciYi6VhTrBcPIxFz7DUUyzHGZZKiuX0L5byfSxnMZZqiqV6HwvuEHxDwoyKNTA2rMG2LtpWLJmZb0508QHLceFRr00GQramZcMdYPSW@KJ@M9bKamZQpxYN8vnEW4G0YmeqVsRKKzdxaGrT9TibK1YZD13iyVzR/pFCq2fbl@6MQDjiYCjH9gLMutuJ7T@9uJwi@PSCzsseIMbSDeBukMUlCpTiv586JnxtWbKkJWZJUNyFbCQ6TxwnL0CqnBx6HLWZbSZaiMa/se0ih42L/T8 "C (gcc) – Try It Online")
Modifies the input string to have in-word balanced capitalisation.
### Explanation
```
f(s,e)char*s,*e;                           // function taking a string   
{                                          // parameter s and also declares   
                                           // e as a string pointer
  for(;!isalpha(*s);++s);                  // loop until s pointes to the   
                                           // beginning of the next word   
  for(e=s;isalpha(*++e););                 // loop until e pointes to one  
                                           // past the end of that word   
  for(                                     // loop over this word   
      *e&&f(e);                            // while e points to one past
                                           // the current word     
                                           // recursively handle the next 
                                           // word if we're not at the end    
               s<e;                        // loop while s is before e  
                   ++s)*--e                // bump s and e towards the middle   
                   ++s)                    // bump s forwards at the end of  
                                           // each loop  
                       *--e                // bump e backwards at the   
                                           // beginning of each loop 
                       *--e&*s&32||        // if both characters aren't  
                                   (       // both lower case then   
                                    *s&=95 // make the first character upper             
                                   ,       // case regardless of its case    
                                    *e&=95 // and also make the second    
                                           // character upper case    
                                   );      // regardless of its case   
}                                          //       
```
[Answer]
# [Husk](https://github.com/barbuz/Husk), ~~16~~ 13 bytes
```
ṁṠzo?aID↔ġo¬√
```
[Try it online!](https://tio.run/##yygtzv7//@HOxoc7F1Tl2yd6ujxqm3JkYf6hNY86Zv3//99Tobg01UWhJCNVITGzqCC/qEQhLb9IITezuCAnMTkzL10ht1LBpzQ9PTE9VU/hUcNkBU@FnPziEpCwc2Jxqh4A "Husk – Try It Online")
```
            ġo¬√    # first ġroup the input into sublists (words) according to whether the elements are/aren't letters
ṁ                   # now map across this list of words and concatenate the results into a string, with the function
 Sz        ↔        # zip together each word and its reverse using
   μ      )         # 2-argument lambda function:
    ?  D⁰           # if arg 1 is uppercase
     a   ²          # return uppercase of arg 2
      I             # otherwise return arg 2 unchanged
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~73~~ 72 bytes
```
->s{s.gsub(/[A-Z]+/i){|a|r=0;w='';a.bytes{|b|w<<(a[r-=1]>?Z?b:b&95)};w}}
```
[Try it online!](https://tio.run/##JY7tdpNAEIb/exVTP7JgG9JYq7YJiSlFu21sokn9SIi60IWshQV3l1IEPN6Dd@iNREp@zJyZOe/zviNSN9/45qY9kIU0Apm6Wmc5ai9Wux2mFyUphbnfy0yEesRwc0VlUbpl1u9rZCnaZnc1GC6G7rHbOjrUq15WVZskVRKWCCvIiAS1puAzIRVwmoFHuUpFbqC9BwgzjFlTDANmUPdmrNv9wrYikCk9bVwIE0ksFPixgIjJJCQe4wFEOYzTICABNeDfn7@AIYzrtPpsEUkbk3lNT@OQeTSiHMASxLqh1zA/s2vNzIbYbwIazos9gvmWO7@azQFfgjWa2dtvfG2nqxfQcdZ2GMYnjE/GmAdxRUNpF5AIxpUGDnInHMh0ShVTDtKre/TuojM/e2i/vFk66GM@eaIGz763ipOjz8arr4/ffvLMnd3XcHAlq9X5m3f6DzfFe@1jEk6zp@9vk5@Hv5iz0L7x7rX1e9jv@aejaH/2oaRfghePxOXz8Tp2EFoZEUm0lq9v/gM "Ruby – Try It Online")
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 62 bytes
```
T`l`L`.(?=([A-Za-z])*)(?<=(?=(?>(?<-1>.)*)[A-Z])(?>[A-Za-z]+))
```
[Try it online!](https://tio.run/##NVDbUsIwEH3nKxZvtChFvN8AoRYJIqDUG4oQSlqiJcE0iIA4/oN/6I9g6IwPe2b37Dm7OyuIpAzP53bbb5fbhpZNa4@5RAMnJk09rmvZk/SCymZUlkhlDMUt2k3Vyfzr1nV9PkcSRjgA2SPgUhFIYGQEDmFyKMZGBFGEaBgUAaKgMEwVLAqqFBAMyVnox1QMuJDgcgF9Ggx87FDmQX8M5aHnYY8Y8Pv9Awh8rvYo2sQBMSK2sta4Tx3SJwzAFNh8JV2wi5YS1C3gbjg9NDncwYgpU@mmbgOqgJmrW@oIV4um9Ckkn3qW7/M8ZdUyYh6fET@wpjAQlEkNYp0qA1yrqc/JmD6LfFwk7eKStf/6GLsdV1dlZqu9Ns0f3hsHzyvnd046un4K2zfBrFkqXOovnSHaSBxhvzaKX70P3nYn9KmhtViqa35lT47ds1x/s379SR68vWVR2Sn3eKTAeauDxR8 "Retina 0.8.2 – Try It Online") Explanation:
```
.(?=([A-Za-z])*)
```
Count the number of letters following the match.
```
(?<=(?=)(?>[A-Za-z]+))
```
Skip back to the beginning of the word, and then...
```
(?>(?<-1>.)*)
```
... match the same number of characters, ...
```
[A-Z]
```
... followed by an uppercase letter.
```
T`l`L`
```
Uppercase matching letters.
[Answer]
# [Stax](https://github.com/tomtheisen/stax), ~~19~~ 16 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
Å;√∩b₧Aµ╗∞q«J,╕*
```
[Run and debug it](https://staxlang.xyz/#p=8f3bfbef629e41e6bbec71ae4a2cb82a&i=It+was+the+first+new+century.%0A%0AIiIIiiIIiiiI+Ii+iI+iiiI+iiii+iIi.%0A%0AI+sueD+the+airport+for+misplacing+my+Luggage.+%E2%80%93+I+lost+my+Case.%0A%0AThe+Policemen++CraCked+THE+CaSE+of+the+lost+cocaIne.%0A%0AJUST+IN+CASE.%0A%0AIf%28%211%29%7B+%2F%5ChElloBinOLIngo%7DelsE%7B+print%28+%27bOn+aPPetit%27%29%7D%0A%0AxK%2FTH%22E7k%5B%27VyO%25t%3E2%60%26%7BB9X.8%5E%24GWc%3D%21%2B%40+3Us%7D%5DJFM%29jbuI,-%3AalPw*Qvpq5zi%5CZ%28_n1dC%7E%3F%3C%3BfDAm0SR%7CeYg6%23rN4Lho%0A%0AFoo_bar%0A&m=1)
Replaces each match of `[A-Za-z]+` using the ruleset.
-3, borrowing the untruth idea from Jonathan Allan's answer.
## Explanation
```
V^{c{96<mr:1{]^}&}R implicit input of string
V^                  regex: "[A-Za-z]+"
  {c{96<mr:1{]^}&}R replace each occurrence with the following regex:
   c                copy the match
    {96<m           boolean array for uppercase letters
         r:1        reverse and take truthy indices
            {]^}&   uppercase the match at those indices
```
[Answer]
# [Red](http://www.red-lang.org), ~~155~~ 152 bytes
```
func[s][a: charset[#"A"-#"Z"#"a"-#"z"]parse s[any[change copy w some a(repeat
i d: length? w[if w/:i < #"["[n: d - i + 1 w/:n: w/:n and 95]]w)| skip]]s]
```
[Try it online!](https://tio.run/##PVH9dtIwFP9bnuK3oAJOQNSpq3OTsc514sDB/FjWzdCmbaRNalOsjOHxHXxDXwQDTnJO7rk39/dxz03G/cUp96lbCiwsgon0qHYps@BFLNM8p2XSJvUyOSdlwpbJNXHTZQeaMjmlBiZDDk@lUxTQKuFg1YynnOUlAd9CzGWYR3soqAhQNC2BHZQJJVRa8FGHwCZay4aplxFM@tject2idgM9FqnrancRqIwzL4IGLcEc4uQomEYecQQi0zkkL@BxmU@yaYPcYoTjiNUVDhwBE1epCctCrHHQE36w0mIiS1WWw/ghETqNmSdkiGSK7iQMWcgb@PPrNxzEynia5w7T/L/O0Aj0VSw8nnAJdDLWGXMfwyPbwAY2VLDyWFE95TFHrqnHZ4MhnBN02gN7PVZQ3WjVZmheRHYcq30he11HhmrOY23PkGZC5lVURj2zs36f5yKv1Oa33B9vm8OjS2I/H9PKh2nvXr77@Mv92f72p8aLy7tvPnqvNjZf48mZnrvHh@9qX0cT52HdYnG/ePD@e/pt61pcnFevZMvv/NzbeRkctJNHg9Mb/jl8Vs5OnnYjdWtzqNTViGWk5NJ/84CazSXmm0h9lyCAdt07i78 "Red – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/) (-p), 32 bytes
```
s/\pL+/$&&~reverse~$&&$"x"@+"/ge
```
The trick, to uppercase, is to AND characters with the negation of space.
How it works
For each sequence of letters
bitwise NOT
bitwise AND with space character repeated (at least the size of the match, here majorant is the position after match @+)
Reverse
bitwise negate
bitwise AND with matched.
[Try it online!](https://tio.run/##FcixCsIwEADQ3a84QulSbCZ3QREKnZwFiXLGQNo77lLRpfgP/qEf4qnb4zFKXpmpP3Df@KquZ8EbiuL8c@Xubt04H9GsA51wC@WKEJIwSYELCQxJOYdzGiMMD@inGEPEFt7PF3SQScu/N0GxXeyIjqew/xCXRKPakvMX "Perl 5 – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), ~~236~~ ~~230~~ 217 bytes
My first answer in Code Golf!
Edit: *-6 bytes thanks to @movatica*
*-6 bytes thanks to @Danis*
*-7 bytes thanks to @Alex bries*
```
s=input()+'_'
o=''
i=0
for j in range(len(s)):
 p=s[j]
 if p<'A'or'a'<p<'Z'or p>'z':u=[c<'a'for c in s[i:j]];b=[x|y for(x,y)in zip(u,u[::-1])];o+=''.join([c,c.upper()][x]for(c,x)in zip(s[i:j],b))+p;i=j+1
print(o[:-1])
```
[Try it online!](https://tio.run/##NY/9etIwFMb/71Wc@ZVWum44PwudMta5ThwozI91FUOWlnQliWkrFIaP9@AdeiMYusc/cp73nJzfmzeyKqaCH2w2uce4LAvTaqAxMoSHkMG8fSMWClJgHBTmCTUzys3cslwDpJeHaWQAi0G2UQcJhTBqa3mpJchDtERu6YWkrcdbE7I1yUPmplHUmnjh4rYCPTcXdmXpmyWTZmmXoevuNiMraomGTuCkgnEzJDZxSimpMq0oXERbitiL/9Sdpz2xrIZsMS9tNA2pGC9MEdZem01QwBznUEwpxEzlBXA6B0J5UarKMQIWBKw@LICAga611GXbML0BeUmPax4zJYUqtslhxnKZYcJ4ArMKemWS4IQ68Pf3HwggE/odPe7inDrGSKMDkTFCZ5QDdBXu3tBrGJ36emHog4hr9xoiguCAa@jsYjiC4By6naGvQ8TmTtNawd7V1M8yccR4vxfwRKxplvsruPsyoEmfAx4MaMEKZK2Nxbu90ek9/8VNiD5V/YfF4ZPvj1ZHr744L789ePuZeDuNN3Bwka@js5P3VjopA3vXxdlg/vjDT/nj2ZJdXZpj3rzu/nrdbsXHndn@8OMt/Zo8v6/On/amwjgRYjzB6h8 "Python 3 – Try It Online")
Commented code (*original*):
```
import re
```
...import the regex module to find non letter characters
```
s=input()+'_'
```
...take the imput from the console, and append a non letter character to complete the last iteration in the loop
```
o=''
```
...initialize the output string
```
i=0
```
...initialize the index to find the start of each new identified word
```
for j in range(len(s)):
```
...loop on the characters of the input
```
 if re.match('[^A-Za-z]',s[j]):
```
...identify a non letter character that separates words
```
u=[ord(c)<97for c in s[i:j]];
```
...list of boolean values corresponding to the letters in the word: True if uppercase
```
b=[x|y for(x,y)in zip(u,u[::-1])];
```
...reverse the list of boolean values, and apply `or` elementwise to obtain the symmetric list of uppercase characters
```
o+=''.join([[c,c.upper()][x]for(c,x)in zip(s[i:j],b)])+s[j];
```
...builds the output string: convert to uppercase according to the symmetric list built before; add the non letter character
```
i=j+1
```
...update the starting index of the next word.
```
print(o[:-1])
```
...prints the output balanced string (discarding the added last character)!
[Answer]
# [Julia](http://julialang.org/), 76 bytes
```
n->replace(n,r"[a-zA-Z]+"=>x->(L=length(x)+1;map(c->c-32(x[L-=1]<'['<c),x)))
```
[Try it online!](https://tio.run/##fVBbdtowEP33Kib0gV0wKUnfAVowJog4QALkASGpMLIRyJIj28FA6ekeusNuhBrylY9E58ycmTtz78xoGjGK8/HGKW64XpLEZ9gmKs/K1ADry7LeH2ZSxVKsl1SryAh3w4kaa5n8kYd91dZLtn54oMYDSy/mh4X0IF2wtWysadrGERJCEoRAOUiCx4xyEqiaAsnzJeUh4@q2/hRxHrGnoKYQPt6gEOY4gHBCwKEyEeZkDjbhYSQXOQVRhOjOKAJEIfG7MHHbhCYdEESkuuNjKn0hQ9ju6NFgezLlLngLsCLXxS7Jwb8/fwEBE8mcBDZwQHJKN6G2BaM28QgHMCQ2ZmQM3bqZNHRMEM5OfUeyhY0RT0iNXqcLqAlGuWMmSzjqXl5bwf7NxGRMVChvWYi7Yk1YYK4eL1YhPWpxwO02CWmY1tZKfLLfrafMz7NB@mLRehOWDn6@XVW@XuW@3L4@vrSLe5kfcNgL1sNG7VSbjiKU1b9h1p6/O3vw7z8u6U1fveP5sfH7e@HIqZa9953zX@Ta/fRKNj9YE6HUhLgbYangkT0mjjuh0xnzuPDvk2@OHubxYlmuGFWzdlxHjRPrtNlqn513ur2Ly6vrvvJ86Xm5Fya9oPcf "Julia 1.0 – Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 29 bytes
```
Ｆ⁺Ｓψ¿№α↥ι⊞υι«⭆⮌⮌υ⎇№α⊟υ↥κκ¿℅ιι
```
[Try it online!](https://tio.run/##RVBbdtMwEP1uVjENlMiQppQ3hFfrulQlbUzt8KpLURzZVqNIRpYSTAiHPbBDNmJk53D6oZFGM/femRtnRMWS8KpKpALkc1MgLHKjA62YSJHThdJxgCWAXGmERqQLozynKiYFRcyxNd8UGTJdYE6/RXlBYdna8C1YozXHCcnRGZ1TZQH/b@NY4pAqQVR5TezLfF25VpjabGpV@q2NeoahmjBBeC0Ma41adVVV5@12G2tYkAJ0RiFhqtAg6AJiKrRRZS9SmGHMmsMwYAY2Nk8b6oTVLVAYetAwEKZyqTTUtsxYkXMS211gVsLApClJaQ/@/v4DGLi0SvbbteNaitBifclZTGdUALiKuFM6gfDIsx2BBzJp6BtULGOCRY06HgUh4FNw9wKvniNBm7vOEnaizONc7jMxHGCRypX111tC3mwOnfFQAPF9qpnuOKtIfX@7Ex61vcfT8877crilX977emu5//Rj78mXm28@xC8277yG@6NidXF8eOJcjQ3ubj8j3F/cfjfPvz38waLP6FLsTtxfr573k4O92d3g7Cf9lD66oU4fDDIZqUMpL8dEWa8vqu05/wc "Charcoal – Try It Online") Link is to verbose version of code. Link includes test suite. Explanation:
```
Ｆ⁺Ｓψ
```
Loop over the input with a null terminator.
```
¿№α↥ι
```
If the current character is a letter, ...
```
⊞υι«
```
... push it to the predefined empty list, otherwise:
```
⭆⮌⮌υ⎇№α⊟υ↥κκ
```
Loop over a copy of the saved letters, retrieving them in reverse order each time, and uppercasing the copy if the reverse order letter is uppercase.
```
¿℅ιι
```
Print the non-letter unless it's the null terminator.
[Answer]
# Java, 320 Bytes
```
s->java.util.regex.Pattern.compile("[a-zA-Z]+").matcher(s).replaceAll(m->java.util.stream.IntStream.range(0,m.group().length()).mapToObj(i->(Character.isUpperCase(m.group().charAt(m.group().length()-1-i))?Character.toUpperCase(m.group().charAt(i)):m.group().charAt(i))+"").collect(java.util.stream.Collectors.joining()))
```
[Try it online!](https://tio.run/##fVFNSwMxEL37K4Y9JegGvVqtlKViD6LQelF6mKbTbbbZJCSzYhV/e03dQgXFXGaY95HMS4OvWDbLzS50C2s0aIspwT0aBx8nAHAYJ0bO5dWbJbQZFFOOxtUvc8BYJ/lN3Z8m26mOjVWrzmk23qnbQ3PVS86gr0NYXe9SOTwqItX0ph6RmaJT2rfBWBLFC5bvo/J5flpI1SLrNUWRZGYHi5pG1or2p0viSNiqieNp30V0NYnzs1bV0XdBSGXJ1bwWcu8XZv5h0QhTDkW1xog6X65MegqBYoWJxFGmMz5i8dunvCiNlDdHPft/9Jl6@dfwtMgLam8taRa/9ql6wMekGm9cDjC/X@4Gh9z7/KfbxNQq37EKOWO2TqwUhmC3opitCR59/ktqyQFUEasNLWF2N4YKp2PwK@BMsT4xaK9x4kgVUg72zp8nn7sv)
## Explanation
```
s->java.util.regex.Pattern.compile("[a-zA-Z]+").matcher(s)//match words
  .replaceAll(m->//replace each word, m is MatchResult, m.group() is current word
     java.util.stream.IntStream.range(0,m.group().length())//iterate over indexes of word
       .mapToObj(i->(Character.isUpperCase(m.group().charAt(m.group().length()-1-i))
       //check if character at reflected index is uppercase
    ? 
  Character.toUpperCase(m.group().charAt(i))//make uppercase
  :m.group().charAt(i)) //do not modify
   + "" //concatenate with empty string to force result to be a String
  ).collect(java.util.stream.Collectors.joining()))//collect as single String
```
[Answer]
# [J](http://jsoftware.com/), 60 bytes
```
[:;]<@((+.&(91>3&u:)|.)`(,:toupper)});.1~1,2|@-/\e.&Alpha_j_
```
[Try it online!](https://tio.run/##jZDdTsJAEIXveYqjF2wbYRG9sqhBsZhNmkCUOzFYybYdUrpNuw0hUOM7@Ia@SC0/iibEMNlJJrvfOXOyk@KYMw9XFhhqOIVVdp2j8@B0iyer9XzZNowTXjUumtfn1cwyl9x8MWqWVlkcy8TMzRZvvjVrZ8t2vTGUvHoTxoE7mowKs1KR40DBAxMaMzeFDiQ8SlKNSM4wlpHOkjlnG4yxLc/E4D8adetgS0FiWyQgNofKkcoCCdq5lSCtewWu3kB/wW9HPGbybr3WpSRWiYanEkwpjUN3TJGP6RxO5vuub3N8vn9AIFRlvPK646b2biPSQ43kHiO5S9Q1jprmAo1hYIdO75ainiOie5XbYWovECcUaaP83ddeBLfflwOhGTPznxzeL3motnJf5XK/XNNGXnwB "J – Try It Online")
Well this is shockingly verbose for J. Surely I am missing some better alternatives, but this is what I have for now...
[Answer]
# [Python 3](https://docs.python.org/3/), ~~153~~, ~~149~~, ~~148~~, 110 bytes
*Using `re.sub` is even more elegant than re.finditer...*
```
lambda s:re.sub('[a-zA-Z]+',lambda w:''.join([c,c.upper()][d<'a']for c,d in zip(w[0],w[0][::-1])),s)
import re
```
[Try it online!](https://tio.run/##jZLBjtMwEIbP5CmGvTgWbmDFLaJIpU3BqNpWSriQjZCbOqkhsSPbUdVdVeIdeENepMROF7FihbDi0cT@v38m0XRHu1fy9bma3p4b1m53DEyseWT6bYhyNrmbTT4XLxC53B1ihKKvSsgwL0kZ9V3HdYiLfPcGMVRUSkNJdiAk3IkuPOSvCuJCHseT6wJjYnAg2k5pC5qfLTfWwBTC4FmIqIUDM2D3HCqhjQXJD1ByaXt9jBABRLN/CTDxJoJS4begQAUM0adDcC9iNBoE43Ki8XksupiB6fnCF2RC@6bd97XCdA0rhayhPcKqr2tW8wh@fv8BFBo1NDYcz5nhYzFI/9ckecIkeWgmGww2qhElb7kEmGs2/8Z3kH1IBlmagKp8DY@WqmRUjvWzffKbu3ngFiM3@4ubj9xY8uOnNAN643Xe6/GBF@krWoXPr/E9vLzdJ02j3gm5XlFZqxNvTHIPnRbShoC2awlss@FWWIRPVwQGcvkHuVpfyPfqlDxJZtSTY29Lpb5smXZdLdXap@4CB4H7u4IoN4J@vuIAoBuGrAoFdql3zdFyRlfJIkYEbWZp6rIiV9NpVxBB0OQtIh0@/wI "Python 3 – Try It Online")
[Answer]
# [AWK](https://www.gnu.org/software/gawk/manual/gawk.html), 113 bytes 141 bytes
```
{for(b=1+split($0,l,"[ ]");--b;$b=e){a=split(toupper(m=l[b]),c,d=e=x);for(split(m,f,d);a;a--){if(f[++d]==c[d])f[a]=c[a];}for(;d;)e=f[d--]e}}1
```
[Try it online!](https://tio.run/##JYwxC4MwFIT/SpAOBpNS5/AmEdqtULeQ4Zm8UDEaUUsL4m@3ijcdd98dftttW3wc0xrybBpCM6eXmwgi0cwkXElZq0sNxBeEs53jZxhoTDsIujZcWOGA4MfVcXIinfDCcYUKpeRL41Ovs8wZAKud4V6j2R0atR4T5RQn8NpJaWhd822r3sSeMTSWOurZoWLEoiXHqnvJCnyVLPojnncwxGlmzEaLj56ufw "AWK – Try It Online")
*The code got longer to address a bug related to whitespace parsing as noted by Dominic van Essen.*
This isn't all that short, but AWK isn't well suited to this challenge (as far as I can tell) so I think it's worth posted anyway.
Here's how it works...
The first `for` loop processes each commandline argument in reverse order. First it has to break the arguments into words explicitly, since TIO doesn't provide a way to set `RS` and `ORS` variables easily.
```
b=1+split($0,l,"[ ]")
```
which sets variable `b` to the number of space delimited words found, and stores the array of words (some of which might be empty strings) in variable `l`. The `1+` is necessary to keep the code from skipping the last word.
then at the top of each loop,
```
--b
```
the code decrements `b`. The words in the array are processed in reverse order to avoid having to use another variable.
The body of the loop consists of three statements, the first one is:
```
a=split(toupper(m=l[b]),c,d=e=x)
```
which does a couple of things.
* converts the current argument `l[b]` to upper case
* splits that word into a character array, assigns that to variable `c`
* sets variables `d` and `e` to an empty string
* set variable `a` to the number of characters in the argument
* stores the untranslated value of the current argument in variable `m`
The second statement is another loop, checking character by character and translating to uppercase as needed. It does that by initializing the loop with:
```
split(m,f,d)
```
which converts the current commandline argument to a character array, stored in variable `f`. At this point `f` has the original characters, and `c` has the same characters translated to uppercase.
The loop condition and "end of loop" action cause the code to iterate `a` times, which is the number of characters in the current argument.
The body of this second loop is single statement:
```
if(f[++d]==c[d])f[a]=c[a]
```
which translates the paired character to uppercase if the character we're checking is already uppercase. The loop decrements `a` and increments `d` each iterations, which keeps the pairing in sync.
The third statement in the body of the outer loop, is essentially a "join" operation concatenating the characters in the translated character array.
```
for(;d;)e=f[d--]e
```
The only trick here is using the `d` variable as the iteration control, since it was incremented up to the length of the commandline argument in the previous loop. Also working backwards means we can use `f[d--]e` without having to use a space between them since the closing bracket separates the variables.
Then the "end of loop" action on the outer loop assigns the re-assembled string to the current commandline argument.
```
$b=e
```
And all that's left to do is add a "truthy" test without any action to print everything.
```
1
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~15~~ 13 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
-1 thanks to [Makonede](https://codegolf.stackexchange.com/users/94066/makonede)! (Duplicate-TOS and then reverse-TOS has a one-byte built-in, `Â`.)  
-1 thanks to [Kevin Cruijssen](https://codegolf.stackexchange.com/users/52210/kevin-cruijssen)! (Take a list of characters.)
```
.γa}εÂ.uÅÏu]˜
```
**[Try it online!](https://tio.run/##yy9OTMpM/R/8X@/c5sTac1sPN@mVHm493F8ae3rOf6//nmkaioaa1Qr6MRmuOTn5Tpl5/j6eeen5tak5xa7VCgVFmXklGgrqSf55CokBAaklmSXqmrUA "05AB1E – Try It Online")**
### How?
```
.γa}εÂ.uÅÏu]˜ - (accepts a list of characters)
.γ }          - group by:
  a           -   is alphabetic?
    ε         - for each:
     Â        -   push a copy and then push a reversed copy
      .u      -   is upper-case? (vectorises)
        ÅÏ    -   apply at truthy indices (of that, to the forward copy):
          u   -     upper-case
           ]  - } } (close all loops)
            ~ - flatten
```
[Answer]
# [Java (JDK)](http://jdk.java.net/), 130 bytes
```
a->{for(int i=0,l=a.length,c,s,e;i<l;i++){for(s=i;i<l&&(c=a[i]&95)>64&c<91;i++);for(e=i;s<e;a[e]&=c)a[s]&=c=a[s++]^a[--e]^32|95;}}
```
[Try it online!](https://tio.run/##ZVLrUtpAFP6fpzj2golAFG8tDaFVjDUWlRbsDVGXZRMWk126uwEpptN36Bv2RegmouNMdybn@n0nZ8@eEZqg8mhws6DxmAsFI@3biaKRveYY/8WChGFFOcuS46QfUQw4QlLCCaIM5gbAMioVUlpNOB1ArHNmWwnKwm4PkAillSEBGpzJJCaihodIdHt1CNwFKtfnARcmZQqou1GKXGRHhIVqWMIlWSIOrUUOLRatHCVdmgUKBRO7qEt7heqOVd/dLuBatZKjnAxFNErWiIO6pFdwsYW6MtOaIYvF3iXqlsukd7m1eVfdcdJ04eTNKTEDc4IESIwYIwJcYGQK7XvPbM@kIrFNmWXB/W0ApkMaETCXBHuI5Cm5VU3KiPkEBZBVza4sdc0HMHtE2oo3dHJPCDQzLeeRFdgIYzJWZk59kli2whNlj/WQVcTMvNN84kv0Izw1HmRqpAuij2cQTyuDZMrITNuYe1qnFS29zMqO4SuYIglqSCCgQqp8HJgwlYiZbfjU92n@UR98ClrmphaZQzUCZEIOcj6iIl8s/TgQUzmOENatQjyDZhKGKCQ2/P39B3yIuP6PDjeQ1F11NLXF9XqRmDC9PgI1bsgAOkeeBrQ94EFePSdhjpHPNOn4vN0B/xQae21PNxGYKxVrDusXQy@K@D5lZ02fhTwlkfTmkM/PhNX@GQPUahFF1aqVGrcf1jtHz7xXN93Vz7Ozl6q@eV2Y71e/2q8vX7z/gt2V4jvYOpdp7/jwxBr1E79UfoOi1nTt42T8Y@cnvfhuXrHKoPHrbc0JDvbijfanO/It3H0uTrebQ24ccn7VR@If "Java (JDK) – Try It Online")
## Credits
* -3 bytes thanks to [ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat).
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 30 bytes
```
òÈ+Y è"%L"
®íZmr"%a" ÔÏ?Xu:XÃc
```
[Try it online!](https://tio.run/##y0osKPn///Cmwx3akQqHVyip@ihxHVp3eG1UbpGSaqKSwuEph/vtI0qtIg43J///H63kqaSjlAbEGkCsCMSGQKwJxNVArADE@kAcA8QZQOwKxDlQnA/ETkCcCcR5QOwPxD5A7Anlp0PV1AJxKlRPMdQMmNkFQFyEZEYJ1B0gOXUgToKamwcVSwTiAChOharPhNLqUHfXKsUCAA "Japt – Try It Online")
I'm not happy with this, but I haven't actually been able to find something better. Inputs and outputs as an array of characters.
Explanation:
```
òÈ+Y è"%L"    
ò                      # Partition the input between pairs of characters where truthy:
 È+Y                   #  Join the two characters into a string
     è"%L"             #  Count how many are not in [A-Za-Z]
                       # Implicitly store as U
®íZmr"%a" ÔÏ?Xu:XÃc    #
®                      # For each word:
  Zmr"%a"              #  Replace lowercase letters with ""
          Ô            #  Reverse it
 í         Ï     Ã     #  Pair each with the original letter at that index
            ?          #  If the modified array has anything other than "":
             Xu        #   Replace the original letter with upper-case
               :X      #  Otherwise leave it unchanged
                  c    # Flatten all the words back into a single array of chars
```
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~91~~ 82 bytes
```
$args-replace'[a-z]+',{-join(&{($w="$_")|% t*y|%{[char]($w[--$i]-bor95-band$_)}})}
```
[Try it online!](https://tio.run/##jVPtVtMwGP6/q3iZHW1hHaKiIk6BLoPipIMNRccYXUm7QNeMtHOMrh7vwTv0RmaatiAHjtrT5k2ePB9pk47oBLNggD1vLjnVaC5ZzA00hkeeZWO5Y2k33WW5HGkXlPjKYqRIk2pR6hXVWQnCpemsFHXsgcW6HO9omkS6Wp@y9TWtb/nnUk@NYzWex4XCplIoKzLmF5LLMhJVFVDS5xCvCGdQgiWQqAJKSJVUiCocSrAI8VG8yluU9LDwKQAkEwjlE0iUTGKEMLECCAcYHMKCEHw8ARv74ZhNK6nYaP@NktkQwyDiIQYYBHgrurxJBiS34pT0SmjpfZ@W2UEwxjURaRE2oiwEhzIYkiDZA@K7MJxCY@y6losr8OvHTzDAo3xpHNatAOdx0PpfG/SIze13bXODJvWIjYfYB9CZpV/ic2jvIk5rIaCOyBBSm9qW4ecraA/QrXI/V9ZS5dYDpZ4q09C9o1YbjH3By9zuQ4JWNBxlYVWNYOVkgDyPbhPfbBi@S2PsBSiCESN@qIDcN32wmk0cklBW42JiVzTqf0gbZibdoTF6VNo2hDSNvf6w0t49K6JXlx3509Qshe@enS1G2@vHldenZ9LOZ7u6sLwJz4@CuLtX/6he9MdGWXtjec3J0sG30dXaDTn5qvT81XP9@/u3G05ta/i0dTjDX9yXT9j@i8aApks8/keMnsW00pi9LKaRxhzcxtQexhwmMWb6OnKd0l7fYvx/qlNT9NSCCjMoQcSXASAF/Lxj38ZlkPD1CNsh3/8qSL10luFg7IUcWJScO66Y6zRb@jgI6dDsX3BZdzPih9K2cRAk@kyo2fjqzngDDnO/nBAX4vlv "PowerShell – Try It Online")
where:
* `&{` creates a new context each contains `$i=0`
* `-bor` is bitwise `or`, `-band` is bitwise `and` have inspired by the [Arnauld's answer](https://codegolf.stackexchange.com/a/219704/80745)
]