Celem jest tutaj odwrócenie łańcucha za pomocą jednego zwrotu:
Utrzymuj wielkie litery w tych samych miejscach.

Przykład danych wejściowych 1: Hello, Midnightas
Przykład danych wyjściowych 1:SathginDim ,olleh

Przykład danych wejściowych 2: Przykład danych .Q
wyjściowych 2:q.

Zasady :

• Wyjście do STDOUT, wejście z STDIN
• Zwycięzca zostanie wybrany 13 lipca w GMT + 3 12:00 (jeden tydzień)
• Dane wejściowe mogą składać się tylko z symboli ASCII, co ułatwia programom, które nie używają żadnego kodowania zawierającego znaki inne niż ASCII.
• Wszelkie znaki interpunkcyjne, które kończą się w miejscu, w którym była wielka litera, należy zignorować.

TCC - 4 bajty

<>ci

Wypróbuj online!

Wyjaśnienie:

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

Python, 71 bajtów

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

Wypróbuj online

-3 bajty od Ruuda oraz inspiracja dla 2 kolejnych.

-4 dodatkowe bajty od FryAmTheEggman

Python 2, 73 bajty

Ponieważ reguły określają dane wejściowe to ascii:

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

Wszystkie zasługi należą się @Mego, ale nie miałem reputacji, aby komentować jego odpowiedź.

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

To rozwiązanie pochodzi z @Ton Hospel (13 bajtów krótszych niż moje).

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

Ale będziesz potrzebować li się pwłączy. Aby uruchomić:

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

Pyth, 13 11 10 9 bajtów

Dzięki @FryAmTheEggman za przypomnienie mi Vi @LeakyNun o kolejny bajt.

srV_Qm!/G

Wypróbuj online! _{teraz na telefonie komórkowym, trochę aktualizuję link}

Python, 66 bajtów

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

Powtarza się przez indeksy i, biorąc postać s[~i]z tyłu i przypadek s[i]z przodu. Bycie kapitałem jest sprawdzane jako leżące w ciągłym zakresie @ABC...XYZ[. Podziękowania dla FryAmTheEggman za (_*2).title()lewę.

Siatkówka , 75 67 65 bajtów

Liczba bajtów zakłada kodowanie ISO 8859-1.

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

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

±(.)
$1±
·.
·

Wypróbuj online! (Pierwszy wiersz włącza zestaw testów z wieloma przypadkami testowymi oddzielonymi od linii).

JavaScript (ES6), 95 83 bajtów

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

Edycja: Zaoszczędzono ogromne 12 bajtów dzięki @ edc65.

Pyke, 11 10 9 bajtów

_FQo@UhAl

Wypróbuj tutaj!

_         -   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 bajtów

Dzięki Emigna za uratowanie 3 bajtów!

Prawdopodobnie zostanie pokonany przez Jelly ... Kod:

Âuvy¹Nè.lil}?

Wykorzystuje kodowanie CP-1252 . Wypróbuj online! .

MATL , 13 bajtów

PktGtk<)Xk5M(

Wypróbuj 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 bajtów

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

Nie obsługuje innych niż ASCII

Brachylog , 28 bajtów

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

Wyjaśnienie

• Główny predykat:

  @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
  

• Predykat 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 bajtów

Gra w golfa:

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

Nie golfił

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

Skrzypce

Właściwie 25 bajtów

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

Wypróbuj online!

Wyjaśnienie:

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

Najprostszy sposób, jaki mogłem wymyślić.

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

PowerShell, 154 , 152 , 99 , 86 bajtów

Dziękuję @ TimmyD za uratowanie mnie aż 47 bajtów (zapisałem również dodatkowe 6)

Dziękujemy @TessellatingHeckler za zapisanie dodatkowych 13 bajtów.

Najnowszy:

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

Oryginalny:

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

Normalne formatowanie:

Najnowsze (moim zdaniem najlepiej jak dwie linie):

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

Wyjaśnienie:

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

Oryginalny:

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

Pierwszy plakat tutaj był motywowany, ponieważ rzadko widzę PowerShell, ale przy 154 152 bajtach na tym ... Rozumiem dlaczego! Wszelkie sugestie mile widziane.

Nauczyłem się, że muszę całkowicie zmienić sposób myślenia na golfa w kodzie i jego zabawie!

Dyalog APL , 12 bajtów

⌽f¨⍨⊢≠f←819⌶

819⌶ to funkcja składania skrzynek

f←ponieważ jego nazwa jest długa, przypisujemy ją do f

⊢≠f Boolean, w którym tekst różni się od tekstu pisanego małymi literami

f¨⍨ użyj tego (1 oznacza wielkie litery, 0 oznacza małe litery), aby złożyć każdą literę ...

⌽ ... odwróconego tekstu

Obsługuje non-ASCII zgodnie z zasadami konsorcjum Unicode.

CJam, 22 bajty

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

Sprawdź to tutaj.

Rakieta, 146 bajtów

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

Rakieta jest zła w tej całej grze w golfa.

Wzruszenie Jak zawsze każda pomoc w skróceniu tego będzie mile widziana.

Jolf, 21 bajtów

Wypróbuj tutaj!

Μid?&γ._pXiS=pxHHpxγγ

Wyjaśnienie

Μ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 bajtów

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

C #, 86 85 bajtów

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

AC # lambda, gdzie wejście i wyjście jest ciągiem. Możesz spróbować na .NetFiddle .

Jestem stara się zrozumieć, dlaczego nie mogę osiągnąć konwertować char.ToLower(c)do c+32. Mam nadzieję to naprawić!

12 bajtów zapisanych dzięki @PeterTaylor ( c|32aby dodać 32 do wartości ascii ci c&~32odjąć 32). Wynik wynosiłby 72 bajty (ale może się nie powieść w przypadku znaków innych niż alfa).

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

PHP, 128 bajtów

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

Mogę spróbować dalej to zoptymalizować, ale zostawię to na razie.

Oktawa, 51 50 bajtów

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

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

VIM, 46 bajtów

Byłyby trzy bajty g~G, gdybyśmy nie musieli czytać ze standardowego wejścia ani pisać na standardowe wyjście, ale cóż ...

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

Aby to przetestować, uruchom

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

To jest moje pierwsze zgłoszenie tutaj, nie jestem pewien, czy tego rodzaju zgłoszenie jest dopuszczalne.

JavaScript (przy użyciu zewnętrznej biblioteki) (224 bajty)

(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()},"");}

Oświadczenie: Używając biblioteki, którą napisałem, aby przenieść LINQ C # do Javascript

Sed, 113 + 1 = 114 bajtów

Czemu? Ponieważ fajnie jest używać niewłaściwego narzędzia do robienia różnych rzeczy: P

Sposób użycia: Uruchom sed -rf file, wprowadź tekst i naciśnij Ctrl+ D(wyślij EOF).

Gra w golfa:

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

Nie golfowany:

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 bajtów

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

Mnóstwo bajtów zaoszczędzonych dzięki podejściu @LeakuNun .

Przypadki bez golfa i testy:

Wypróbuj tutaj.

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

Wydajność:

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