El objetivo aquí es simplemente invertir una cadena, con un solo giro:
mantener la capitalización en los mismos lugares.

Ejemplo de entrada 1: Hello, Midnightas
Ejemplo de salida 1:SathginDim ,olleh

Ejemplo de entrada 2: .Q
Salida de ejemplo 2:q.

reglas :

• Salida a STDOUT, entrada de STDIN
• El ganador será elegido el 13 de julio en GMT + 3 12:00 (una semana)
• La entrada solo puede consistir en símbolos ASCII, lo que facilita los programas que no utilizan ninguna codificación que contenga caracteres no ASCII.
• Cualquier puntuación que termine en una posición donde haya una letra mayúscula debe ser ignorada.

TCC - 4 bytes

<>ci

Pruébalo en línea!

Explicación:

     - output is implicit in TCC
<>   - reverse string
  c  - preserve capitalization
   i - get input

Python, 71 bytes

lambda s:''.join((z*2).title()[c.isupper()-1]for c,z in zip(s,s[::-1]))

Pruébalo en línea

-3 bytes de Ruud, más la inspiración para 2 más.

-4 bytes más de FryAmTheEggman

Python 2, 73 bytes

Como las reglas especifican que la entrada es ascii:

lambda s:''.join([z.lower,z.upper]['@'<c<'[']()for c,z in zip(s,s[::-1]))

Sin embargo, todo el crédito va a @Mego, pero no tenía la reputación de solo comentar su respuesta.

Perl, 31 + 2 ( -lp) = 33 bytes

Esta solución es de @Ton Hospel (13 bytes más corta que la mía).

s%.%(lc$&gt$&?u:l)."c chop"%eeg

Pero necesitará ly se penciende. Para ejecutarlo:

perl -lpe 's%.%(lc$&gt$&?u:l)."c chop"%eeg'

Pyth, 13 11 10 9 bytes

Gracias a @FryAmTheEggman por recordarme Vy a @LeakyNun por otro byte.

srV_Qm!/G

Pruébalo en línea! _{ahora en el móvil, actualizando el enlace en un momento}

Python, 66 bytes

f=lambda s,i=0:s[i:]and(s[~i]*2).title()[~('@'<s[i]<'[')]+f(s,i+1)

Recurre a través de los índices i, tomando el personaje s[~i]desde atrás y el caso s[i]desde el frente. Ser capital se verifica como si estuviera en el rango contiguo @ABC...XYZ[. Gracias a FryAmTheEggman por el (_*2).title()truco.

Retina , 75 67 65 bytes

El recuento de bytes asume la codificación ISO 8859-1.

$
±·$`
O$^`\G[^·]

s{T`L`l`±.
T01`l`L`±.*·[A-Z]
±·

±(.)
$1±
·.
·

Pruébalo en línea! (La primera línea habilita un conjunto de pruebas con múltiples casos de prueba separados por salto de línea).

JavaScript (ES6), 95 83 bytes

s=>[...t=s.toLowerCase()].reverse().map((c,i)=>s[i]==t[i]?c:c.toUpperCase()).join``

Editar: ahorró 12 bytes masivos gracias a @ edc65.

Pyke, 11 10 9 bytes

_FQo@UhAl

Pruébalo aquí!

_         -   reversed(input)
 F        -  for i in ^
   o      -      o+=1
  Q @     -     input[^]
     Uh   -    ^.is_upper()+1
       Al -   [len, str.lower, str.upper, ...][^](i)
          - "".join(^)

05AB1E , 19 16 15 13 bytes

¡Gracias a Emigna por guardar 3 bytes!

Probablemente sea golpeado por Jelly ... Código:

Âuvy¹Nè.lil}?

Utiliza la codificación CP-1252 . Pruébalo en línea! .

MATL , 13 bytes

PktGtk<)Xk5M(

Pruébalo en línea!

Pk      % Implicit inpput. Flip, lowercase
t       % Duplicate
Gtk<    % Logical index of uppercase letters in the input string
)       % Get letters at those positions in the flipped string
Xk      % Make them uppercase
5M(     % Assign them to the indicated positions. Implicit display

J , 30 bytes

(={"_1 toupper@]|.@,.])tolower

No es compatible con no ASCII

Brachylog , 28 bytes

@lr:?z:1ac.
h@u.,@A@um~t?|h.

Explicación

• Predicado principal:

  @lr                 Reverse the lowercase version of the Input
     :?z              Zip that reversed string with the Input
        :1a           Apply predicate 1 to each couple [char i of reverse, char i of Input]
           c.         Output is the concatenation of the result
  

• Predicado 1:

  h@u.,               Output is the uppercase version of the first char of Input
       @A@um~t?       The second char of Input is an uppercase letter
               |      Or
                h.    Output is the first char of Input
  

TSQL, 175 bytes

Golfizado:

DECLARE @ varchar(99)='Hello, Midnightas'

,@o varchar(99)='',@i INT=0WHILE @i<LEN(@)SELECT
@i+=1,@o+=IIF(ascii(x)=ascii(lower(x)),lower(y),upper(y))FROM(SELECT
SUBSTRING(@,@i+1,1)x,SUBSTRING(@,len(@)-@i,1)y)z
PRINT @o

Sin golf

DECLARE @ varchar(99)='Hello, Midnightas'

,@o varchar(99)=''
,@i INT=0

WHILE @i<LEN(@)
  SELECT @i+=1,@o+=IIF(ascii(x)=ascii(lower(x)),lower(y),upper(y))
  FROM
    (SELECT SUBSTRING(@,@i+1,1)x,SUBSTRING(@,len(@)-@i,1)y)z

PRINT @o

Violín

En realidad, 25 bytes

;`úíuY"ùû"E£`M@ùRZ`i@ƒ`MΣ

Pruébalo en línea!

Explicación:

;`úíuY"ùû"E£`M@ùRZ`i@ƒ`MΣ
;                          create a copy of the input
 `úíuY"ùû"E£`M             for each character in input:
  úíuY                       0-based index in lowercase English letters, or -1 if not found, increment, boolean negate (1 if uppercase else 0)
      "ùû"E£                 `û` if the character is lowercase else `ù` (str.lower vs str.upper)
              @ùRZ         make the other copy of the input lowercase, reverse it, and zip it with the map result
                  `i@ƒ`M   for each (string, function) pair:
                   i@ƒ       flatten, swap, apply (apply the function to the string)
                        Σ  concatenate the strings

Haskell, 83 80 75 71 bytes

La forma más directa que se me ocurrió.

import Data.Char
f a|isUpper a=toUpper|1>0=toLower
zipWith f<*>reverse

PowerShell, 154 , 152 , 99 , 86 bytes

Gracias @TimmyD por ahorrarme la friolera de 47 bytes (también guardé 6 adicionales)

Gracias @TessellatingHeckler por guardar 13 bytes adicionales.

Último:

param($a)-join($a[$a.length..0]|%{("$_".ToLower(),"$_".ToUpper())[$a[$i++]-in65..90]})

Original:

param($a);$x=0;(($a[-1..-$a.length])|%{$_=$_.tostring().tolower();if([regex]::matches($a,"[A-Z]").index-contains$x){$_.toupper()}else{$_};$x++})-join''

Formato normal:

Lo último (se ve mejor como dos líneas en mi opinión):

param($a)
-join($a[$a.length..0] | %{("$_".ToLower(), "$_".ToUpper())[$a[$i++] -in 65..90]})

Explicación:

param($a)-join($a[$a.length..0]|%{("$_".ToLower(),"$_".ToUpper())[$a[$i++]-in65..90]})
param($a)
# Sets the first passed parameter to variable $a
         -join(                                                                      )
# Converts a char array to a string
               $a[$a.length..0]
# Reverses $a as a char array
                               |%{                                                  }
# Shorthand pipe to foreach loop
                                  ("$_".ToLower(),"$_".ToUpper())
# Creates an array of the looped char in lower and upper cases
                                                                 [$a[$i++]-in65..90]
# Resolves to 1 if the current index of $a is upper, which would output "$_".ToUpper() which is index 1 of the previous array

Original:

param($a)
$x = 0
(($a[-1..-$a.length]) | %{
    $_ = $_.tostring().tolower()
    if([regex]::matches($a,"[A-Z]").index -contains $x){
            $_.toupper()
        }else{
            $_
        }
        $x++
    }
) -join ''

El póster por primera vez aquí, estaba motivado porque rara vez veo PowerShell, pero con 154 152 bytes en este ... ¡Puedo ver por qué! Cualquier sugerencia apreciada.

¡He aprendido que debo cambiar completamente mi forma de pensar al golf en código y es divertido!

Dyalog APL , 12 bytes

⌽f¨⍨⊢≠f←819⌶

819⌶ es la función de plegado del estuche

f←porque su nombre es largo, lo asignamos a f

⊢≠f Booleano donde el texto difiere del texto en minúsculas

f¨⍨ use eso (1 significa mayúscula, 0 significa minúscula) para doblar cada letra ...

⌽ ... del texto invertido

Maneja no ASCII de acuerdo con las reglas del Consorcio Unicode.

CJam, 22 bytes

q_W%.{el\'[,65>&{eu}&}

Pruébalo aquí.

Raqueta, 146 bytes

(λ(s)(build-string(string-length s)(λ(n)((if(char-upper-case?(string-ref s n))char-upcase char-downcase)(list-ref(reverse(string->list s))n)))))

La raqueta es mala en todo este asunto del "golf".

Encogimiento de hombros Como siempre, cualquier ayuda con este acortamiento sería muy apreciada.

Jolf, 21 bytes

Pruébalo aquí!

Μid?&γ._pXiS=pxHHpxγγ

Explicación

Μid?&γ._pXiS=pxHHpxγγ
Μid                   (Μ)ap (i)nput with (d)is fucntion:
   ?        =pxHH     (H is current element) if H = lowercase(H)
    &γ._pXiS          and set γ to the uppercase entity in the reversed string
                 pxγ  lowercase γ
                    γ else, return γ

Perl 6 , 29 bytes

$_=get;put .flip.samecase($_)

C #, 86 85 bytes

s=>string.Concat(s.Reverse().Select((c,i)=>s[i]>96?char.ToLower(c):char.ToUpper(c)));

AC # lambda donde la entrada y la salida son una cadena. Puedes probarlo en .NetFiddle .

Estoy luchando para entender por qué no puedo logro convertir char.ToLower(c)a c+32. ¡Espero arreglarlo!

12 bytes guardados gracias a @PeterTaylor ( c|32para agregar 32 al valor ascii de cy c&~32restar 32). El resultado sería 72 bytes (pero puede fallar en caracteres no alfa).

s=>string.Join("",s.Reverse().Select((c,i)=>(char)(s[i]>96?c|32:c&~32)));

PHP, 128 bytes

$s=$argv[1];$l=strrev($s);for($i=0;$i<strlen($s);++$i){echo(strtolower($s[$i])!==$s[$i]?strtoupper($l[$i]):strtolower($l[$i]));}

Puedo intentar optimizar esto aún más, pero lo dejaré como está por ahora.

Octava, 51 50 bytes

@(s)merge(isupper(s),b=flip(toupper(s)),tolower(b))

@(s)merge(s>64&s<91,b=flip(toupper(s)),tolower(b))

VIM, 46 bytes

Serían tres bytes g~Gsi no necesitáramos leer desde stdin o escribir en stdout, pero bueno ...

vim -es '+normal! g~G' '+%print|q!' /dev/stdin

Para probar esto, ejecuta

echo "testString" | vim -es '+normal! g~G' '+%print|q!' /dev/stdin

Esta es mi primera presentación aquí, no estoy seguro si este tipo de presentación es aceptable.

Javascript (usando una biblioteca externa) (224 bytes)

(s)=>{t=_.From(s);var cnt=t.Count();var caps=t.Select(x=>{return x.toUpperCase()===x&&x.toLowerCase()!==x}).ToArray(),i=-1;return t.AggregateRight((a,b)=>{i++;var c=caps[i];return c?a+b.toUpperCase():a+b.toLowerCase()},"");}

Descargo de responsabilidad: utilizando una biblioteca que escribí para traer LINQ de C # a Javascript

Sed, 113 + 1 = 114 bytes

¿Por qué? Porque es divertido usar la herramienta incorrecta para hacer cosas: P

Uso: Ejecutar sed -rf file, ingresar texto y presionar Ctrl+ D(enviar EOF).

Golfizado:

s/[A-Z]/\a\l&/g;s/^.*$/\f&\v/;:x;s/\f\a/\a\f/;s/\a\v/\v\a/;s/\f(.)(.*)(.)\v/\3\f\2\v\1/;tx;s/\f|\v//g;s/\a./\U&/g

Sin golf:

s/[A-Z]/\a\l&/g #Prepend all upper-case letters with a 
                #BEL ASCII character and make them lowercase
s/^.*$/\f&\v/   #Wrap text between a from feed (\f) and a vertical tab (\v)
                #These are used as markers

:x #Define a label named x

s/\f\a/\a\f/;s/\a\v/\v\a/ #Move BEL characters outside of the boundary, so they're not moved later
s/\f(.)(.*)(.)\v/\3\2\1/  #This part does the switching itself
                          #It grabs a character preceded by a form feed and another 
                          #one followed by a vertical tab and swaps them, while keeping the text in-between
                          #and replaces the marker \f and \v

tx             #Conditional jump (t) to label x
               #Jumps to the label x if the last substitution (s command) was successful 
s/\f|\v//g     #Delete markers
s/\a(.)/\u\1/g #Make letters preceded by a BEL upper-case

Java 7, 221 217 180 bytes

void c(char[]s){int x=0,y=s.length-1;for(char t;x<y;s[x]=s(t,s[y]),s[y]=s(s[y],t),x++,y--)t=s[x];}char s(char a,char b){return(char)(64<a&a<91?96<b&b<123?b-32:b:64<b&b<91?b+32:b);}

Un montón de bytes guardados gracias al enfoque de @LeakuNun .

Sin golf y casos de prueba:

Pruébalo aquí

class Main{
  void c(char[] s){
    int x = 0,
        y = s.length-1;
    for(char t; x < y; s[x] = s(t, s[y]),
                       s[y] = s(s[y], t),
                       x++,
                       y--){
       t = s[x];
    }
  }

  char s(char a, char b){
    return (char)(64 < a & a < 91
                    ? 96 < b & b < 123
                        ? b-32
                        : b
                    : 64 < b & b < 91
                        ? b+32
                        : b);
  }

  public static void main(String[] a){
    print("Hello, Midnightas");
    print("TEST");
    print("test");
    print("Test");
    print(".,..,,!@");
    print("ABCDefgHijklMNOPqrsTuVWxyz");
    print("AbCdEfGHIJKlmnop123");
  }

  static void print(String s){
    char[] t = s.toCharArray();
    c(t);
    System.out.println(t);
  }
}

Salida:

SathginDim ,olleh
q.
TSET
tset
Tset
@!,,..,.
ZYXWvutSrqpoNMLKjihGfEDcba
321pOnMLKJIhgfedcba

do

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char *argv[])
{
  char *a,*b,*c;

  a=c=strdup(argv[1]);
  b=&argv[1][strlen(a)-1];
  for(;*a;a++,b--){
    *a=(*a>='A'&&*a<='Z')?((*b>='a'&&*b<='z')?*b-32:*b):((*b>='A'&&*b<='Z')?*b+32:*b);
  }
  puts(c);
  free(c);
  return 0;
}