Das Ziel hier ist es, einfach eine Zeichenfolge mit einem Dreh umzukehren:
Behalten Sie die Großschreibung an den gleichen Stellen.

Beispiel Eingabe 1: Hello, Midnightas
Beispiel Ausgabe 1:SathginDim ,olleh

Beispiel Eingabe 2: .Q
Beispiel Ausgabe 2:q.

Regeln :

• Ausgabe nach STDOUT, Eingabe von STDIN
• Der Gewinner wird am 13. Juli bei GMT + 3 12:00 (eine Woche) ermittelt.
• Die Eingabe darf nur aus ASCII-Symbolen bestehen. Dies erleichtert Programme, die keine Codierung verwenden, die Nicht-ASCII-Zeichen enthält.
• Interpunktionen, die an einer Stelle landen, an der ein Großbuchstabe vorlag, müssen ignoriert werden.

TCC - 4 Bytes

<>ci

Probieren Sie es online!

Erläuterung:

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

Probieren Sie es online aus

-3 Bytes von Ruud plus die Inspiration für 2 weitere.

-4 weitere Bytes von FryAmTheEggman

Python 2, 73 Bytes

Da die Regeln die Eingabe spezifizieren, ist ascii:

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

Der ganze Kredit geht an @Mego, aber ich hatte nicht den Ruf, nur seine Antwort zu kommentieren.

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

Diese Lösung stammt von @Ton Hospel (13 Bytes kürzer als meine).

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

Aber du wirst brauchen lund peinschalten. Um es auszuführen:

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

Pyth, 13 11 10 9 Bytes

Vielen Dank an @FryAmTheEggman für die Erinnerung Vund @LeakyNun für ein weiteres Byte.

srV_Qm!/G

Probieren Sie es online! _{jetzt auf dem Handy, Update-Link in ein bisschen}

Python, 66 Bytes

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

Durchläuft die Indizes i, wobei der Buchstabe s[~i]von hinten und der Buchstabe von s[i]vorne betrachtet wird. Kapital zu sein wird als im zusammenhängenden Bereich liegend geprüft @ABC...XYZ[. Dank an FryAmTheEggman aus dem (_*2).title()Streich.

Retina , 75 67 65 Bytes

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.

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

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

±(.)
$1±
·.
·

Probieren Sie es online! (Die erste Zeile aktiviert eine Testsuite mit mehreren durch Zeilenvorschub getrennten Testfällen.)

JavaScript (ES6), 95 83 Bytes

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

Bearbeiten: Dank @ edc65 wurden massive 12 Bytes gespeichert.

Pyke, 11 10 9 Bytes

_FQo@UhAl

Probieren Sie es hier aus!

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

Vielen Dank an Emigna für das Speichern von 3 Bytes!

Wahrscheinlich werde ich von Jelly geschlagen ... Code:

Âuvy¹Nè.lil}?

Verwendet die CP-1252- Codierung. Probieren Sie es online! .

MATL , 13 Bytes

PktGtk<)Xk5M(

Probieren Sie es online!

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

Unterstützt kein ASCII

Brachylog , 28 Bytes

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

Erläuterung

• Hauptprädikat:

  @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
  

• Prädikat 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

Golf gespielt:

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

Ungolfed

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

Geige

Eigentlich 25 Bytes

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

Probieren Sie es online!

Erläuterung:

;`úí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

Der einfachste Weg, den ich mir vorstellen konnte.

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

PowerShell, 154 , 152 , 99 , 86 Byte

Vielen Dank an @TimmyD, dass du mir satte 47 Bytes gespart hast (ich habe auch weitere 6 Bytes gespart)

Vielen Dank an @TessellatingHeckler, dass Sie weitere 13 Byte gespeichert haben.

Neueste:

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

Normale Formatierung:

Neueste (sieht meiner Meinung nach am besten aus als zwei Zeilen):

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

Erläuterung:

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

Das erste Mal Poster hier, war motiviert, weil ich selten PowerShell sehe, aber bei 154 152 Bytes auf diesem ... Ich kann verstehen, warum! Anregungen geschätzt.

Ich habe gelernt, dass ich meine Denkweise auf Golf in Code und dessen Spaß komplett umstellen muss!

Dyalog APL , 12 Bytes

⌽f¨⍨⊢≠f←819⌶

819⌶ ist die Fallfaltfunktion

f←weil sein Name lang ist, weisen wir ihn f zu

⊢≠f Boolescher Wert, bei dem sich Text von Kleinbuchstaben unterscheidet

f¨⍨ benutze das (1 bedeutet Großbuchstaben, 0 bedeutet Kleinbuchstaben), um jeden Buchstaben zu falten ...

⌽ ... des umgekehrten Textes

Verarbeitet Nicht-ASCII-Dateien gemäß den Regeln des Unicode-Konsortiums.

CJam, 22 Bytes

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

Teste es hier.

Schläger, 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)))))

Schläger ist schlecht in dieser ganzen "Golf" Sache.

Achselzucken Wie immer wäre jede Hilfe bei der Verkürzung sehr dankbar.

Jolf, 21 Bytes

Probieren Sie es hier aus!

Μid?&γ._pXiS=pxHHpxγγ

Erläuterung

Μ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, wobei die Eingabe und die Ausgabe eine Zeichenfolge ist. Sie können es auf .NetFiddle ausprobieren .

Ich kämpfe , um zu verstehen , warum ich konvertieren kann nicht erreichen char.ToLower(c)zu c+32. Ich hoffe es zu beheben!

Dank @PeterTaylor werden 12 Byte gespeichert ( c|32um 32 zum ASCII-Wert von cund c&~32zu subtrahieren). Das Ergebnis wäre 72 Byte (kann aber auf Nicht-Alpha-Zeichen fehlschlagen).

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]));}

Ich kann versuchen, dies weiter zu optimieren, aber ich lasse es einfach so, wie es ist.

Oktave, 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

Es wären drei Bytes g~G wenn wir nicht von stdin lesen oder nach stdout schreiben müssten, aber na ja ...

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

Um dies zu testen, führen Sie aus

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

Dies ist meine erste Einreichung hier, nicht sicher, ob diese Art der Einreichung akzeptabel ist.

Javascript (mit externer Bibliothek) (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()},"");}

Haftungsausschluss: Mit einer Bibliothek, die ich geschrieben habe, um C # LINQ zu Javascript zu bringen

Sed, 113 + 1 = 114 Bytes

Warum? Weil es Spaß macht, das Falsche zu benutzen Werkzeug zu verwenden, um Dinge zu tun: P

Verwendung: Führen Sie aus sed -rf file, geben Sie Text ein und drücken Sie Ctrl+ D(EOF senden).

Golf gespielt:

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

Ungolfed:

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);}

Dank des @LeakuNun -Ansatzes werden viele Bytes gespart .

Ungolfed & Testfälle:

Probieren Sie es hier aus.

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);
  }
}

Ausgabe:

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

C

#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;
}