您输入的内容将为英语句子，短语或单词。它只会包含a-zA-Z' -,.!?。您的任务是获取输入，删除空格，然后重新分配大写字母，以使之前被大写的索引中的字母（并且只有之前被大写的索引中的字母）被大写。

例如，如果输入为A Quick Brown Fox Jumped Over The Lazy Dog，则大写字母的（从0开始）索引为0, 2, 8, 14, 18, 25, 30, 34, 39。接下来，从输入中删除空格：AQuickBrownFoxJumpedOverTheLazyDog。接下来，将所有字母都小写，但在0, 2, 8, 14, 18, 25, 30, 34, 39：处将AqUickbrOwnfoxJumpEdovertHelazYdog其大写。

输入项

您输入的内容将为英语句子，短语或单词。它只能包含小写字母，大写字母，连字符，撇号，逗号，句点，问号，感叹号和空格。

输出量

输入的空格已删除，小写字母d，大写字母d中的字母位于大写字母的索引处。

注意：您的程序不会因IndexOutOfRange或类似错误而崩溃（此类执行终止错误）。

测试用例

Hi! Test!
Hi!tEst!

A Quick Brown Fox Jumped Over The Lazy Dog
AqUickbrOwnfoxJumpEdovertHelazYdog

testing TESTing TeStING testing testing TESTING
testingtESTIngteStInGTEstingtestingtestiNG

TESTING... ... ... success! EUREKA???!!! maybe, don't, NOOOOO
TESTING.........success!eureKA???!!!maybe,don't,nooooo

Enter        PASSWORD ---------
Enterpassword---------

A a B b C c D d E e F f G g H h I i J j K k L l M m N n O o P p Q q R r S s T t U u V v W w X x Z z
AabbCcddEeffGghhIijjKkllMmnnOoppQqrrSsttUuvvWwxxZz

  TEST
teST

果冻，14 13字节

nŒlTɓḲFŒlŒuṛ¦

在线尝试！

怎么运行的

nŒlTɓḲFŒlŒuṛ¦  Main link. Argument: s (string)

 Œl            Convert s to lowercase.
n              Perform character-wise "not equal" comparison.
   T           Get the indices of all truthy elements, i.e., the indices of all
               uppercase letters in s. Let's call the resulting array J.
    ɓ          Begin a dyadic chain with left argument s and right argument J.
     ḲF        Split s at spaces and flatten, removing the spaces.
       Œl      Convert s to lowercase.
            ¦  Sparse application:
         Œu        Convert s to uppercase.
           ṛ       Take the resulting items of the uppercased string at all indices
                   in J, the items of the lowercased string at all others.

C（gcc），82 79 74 72 69 67 66字节

f(c){for(char*s=c,*p=c;c=*s++;c&&putchar(c^(*p++|~c/2)&32))c&=95;}

在线尝试！

Python 2，114字节

x=input()
X=x.replace(' ','')
print''.join([X[i].upper()if x[i].isupper()else X[i].lower()for i in range(len(X))])

在线尝试！

等效地：

Python 2，114字节

lambda x:''.join([[str.lower,str.upper][x[i].isupper()](x.replace(' ','')[i])for i in range(len(x)-x.count(' '))])

在线尝试！

Python 3中，78个 75 72字节

s=input()
for c in s:s=s[c>' '!=print(end=(c+c).title()[s<'@'or'['<s]):]

感谢@xnor打高尔夫球6个字节！

在线尝试！

05AB1E，15 14字节

-1字节感谢Emigna

ðKuvy¹Nè.lil}?

在线尝试！

ðK             # Remove spaces
  u            # Convert to uppercase
   vy          # For each character...
     ¹Nè       #   Get the character at the same index from the original input
        .lil}  #   If it was a lowercase letter change this one to lowercase
             ? # Print without a newline

Haskell，98 95 89 88 81字节

感谢@ name，@ nimi，@ Zgarb和@Laikoni帮助削减了总共14个字节

import Data.Char
\s->zipWith(\p->last$toLower:[toUpper|isUpper p])s$filter(>' ')s

取消高尔夫：

import Data.Char
\sentence -> zipWith (\oldChar newChar ->
                        if isUpper oldChar
                        then toUpper newChar
                        else toLower newChar)
                     sentence
                     (filter (/= ' ') sentence)

V，24字节

ÄVuÓó
ejlDò/¥2lõ
vuk~òGd

在线尝试！

这些挑战正是V所为的。:)

说明：

Ä           " Duplicate this line
 Vu         " Convert it to lowercase
   Óó       " Remove all spaces
e           " Move to the end of this line
 j          " Move down a line (to the original)
  l         " Move one char to the right
   D        " And delete the end of this line
    ò       " Recursively:
     /      "   Search for:
         õ  "     An uppercase character
      ¥2l   "     On line 2
            "     (This will break the loop when there are no uppercase characters left)
vu          "   Convert it to lowercase
  k         "   Move up a line
   ~        "   Convert this to uppercase also
    ò       " Endwhile
     G      " Move to the last line
      d     " And delete it

Python 2，100字节

s=input()
print"".join([c.lower(),c.upper()][s[i].isupper()]for i,c in enumerate(s.replace(" ","")))

爱丽丝，32字节

/..- ~l+u~mSloy
\ia''-y.'Qa.+a@/

在线尝试！

说明

这是完全在顺序模式下运行的程序的标准模板。展开后，程序如下：

i.' -l.uQm.lay.a-'~y+'~aS+o@

i       take input as string
.       duplicate
' -     remove spaces from copy
l.u     create all-lowercase and all-uppercase versions
Q       reverse stack, so original string is on top
m       truncate original string to length of spaces-removed string
.lay    convert everything except uppercase characters to \n
.a-'~y  convert everything except \n (i.e., convert uppercase characters) to ~
+       superimpose with lowercase string
        \n becomes the corresponding lowercase character, and ~ remains as is
'~aS    convert ~ to \n
+       superimpose with uppercase string
        lowercase in existing string stays as is because it has a higher code point
        \n becomes corresponding uppercase character
o       output
@       terminate

JavaScript（ES6），94 91 85字节

s=>s.replace(/./g,c=>c==" "?"":c[`to${"@"<s[x]&s[x++]<"["?"Upp":"Low"}erCase`](),x=0)

• 在ETHproductions和Arnauld的帮助下节省了6个字节。

试试吧

o.innerText=(f=

s=>s.replace(/./g,c=>c==" "?"":c[`to${"@"<s[x]&s[x++]<"["?"Upp":"Low"}erCase`](),x=0)

)(i.value="Hi! Test!");oninput=_=>o.innerText=f(i.value)

<input id=i><pre id=o>

视网膜，77 71字节

.+
$&¶$&
T`L `l_`.+$
+`((.)*)[A-Z].*(¶(?<-2>.)*)
$1$3 
.+¶

T`l `L_` .?

在线尝试！链接包括测试套件。说明：第一阶段复制该行，而第二阶段将其复制为小写并删除其空格。然后，第三阶段从右到左循环浏览每个大写字母，并尝试在第二行的相应字符之前放置一个空格。第一行被删除，空格用于将结果的相关字符大写。编辑：由于@Kobi，节省了6个字节。

Perl，95 94 +1 = 95字节

-n +1个字节的罚款

保存由替换一个字节s/\s//g到s/ //g

$s=$_;s/ //g;$_=lc($_);while(/(.)/gs){$p=$&;$p=uc($p)if(substr($s,$-[0],1)=~/[A-Z]/);print$p;}

在线尝试！

说明：

1. 复制输入字符串。

2. 删除所有空格并将字符串转换为小写。

3. 然后开始循环遍历每个字母。在保存的字符串中的相同位置测试字母为大写。如果较高-将当前字母大写。打印字母。

请注意，perl需要使用“ -n”命令行开关来运行

MATL，18字节

kXz"@GX@)tk<?Xk]&h

与Riley的05AB1E答案相同。

在线尝试！

Python 3，117字节

s=input()
y=list(s.replace(' ','').lower())
i=0
for c in y:
 if s[i].isupper():y[i]=c.upper()
 i+=1
print(''.join(y))

在线尝试！

这几乎是我第一次打高尔夫球，因此可能很糟糕，请从下面的注释中减去帮助！

PS是的，定义和递增可i节省超出范围（len（y））的字节，这是愚蠢的。那好吧。

C＃（.NET Core），108101字节

using System.Linq;s=>s.Replace(" ","").Select((c,i)=>s[i]>64&s[i]<91?char.ToUpper(c):char.ToLower(c))

在线尝试！

• 意识到char该类具有静态ToUpper()和ToLower()方法后，节省了7个字节。

木炭，33字节

Ａ⁰χＦＬθ¿⁼§θι Ａ⁺¹χχ¿№α§θ⁻ιχ↥§θι↧§θι

在线尝试！

由于我仍然不知道如何将带有空格的字符串作为单个输入参数传递到Charcoal代码中，因此我只是在标头中将测试字符串分配给Charcoal变量，该变量代表第一个输入（θ）：

ＡA Quick Brown Fox Jumped Over The Lazy Dogθ

因此，代码具有与将字符串作为第一个输入传递的字节数相同的字节数。

您可以在此处看到该代码的详细版本。

PHP，181字节

我尝试获取较小的字节数，这是我的代码：

<?php
$s=readline();
preg_match_all('/[A-Z]/',$s,$m,PREG_OFFSET_CAPTURE);
$s=strtolower(str_replace(' ','',$s));
while($d=each($m[0]))$s[$d[1][1]]=strtoupper($s[$d[1][1]]);
echo $s;

在线尝试！

Java的8，184个 177 161字节

s->{String r="";for(int i=0,j=i,t,u;i<s.length;){t=s[i++];if(t>32){u=s[j++];r+=(char)(t<65|t>90&t<97|t>122?t:u>64&u<91?t&~32:u>96&u<123|u<33?t|32:t);}}return r;}

绝对可以打更多..-
感谢@OlivierGrégoire通过输入char[]代替@来获得16个字节String。

说明：

在这里尝试。

s->{                           // Method with char-array parameter and String return-type
  String r="";                 //  Result-String
  for(int i=0,j=i,t,u;         //  Some temp integers and indices
      i<s.length;){            //  Loop over the String
    t=s[i++];                  //   Take the next character and save it in `t` (as integer)
                               //   and raise index `i` by 1
    if(t>32){                  //   If `t` is not a space:
     u=s[j++];                 //   Take `u` and raise index `j` by 1
     r+=                       //   Append the result-String with:
      (char)                   //    Integer to char conversion of:
       (t<65|t>90&t<97|t>122?  //     If `t` is not a letter:
        t                      //      Simply use `t` as is
       :u>64&u<91?             //     Else if `u` is uppercase:
        t&~32                  //      Take `t` as uppercase
       :u>96&u<123|u<33?       //     Else if `u` is lowercase or a space:
        t|32                   //      Take `t` as lowercase
       :                       //     Else:
        t);                    //      Take `t` as is
    }
  }                            //  End of loop
  return r;                    //  Return result-String
}                              // End of method

通用Lisp，104个字节

(defun f(s)(map'string(lambda(x y)(if(upper-case-p x)(char-upcase y)(char-downcase y)))s(remove #\  s)))

在线尝试！

罗the的Common Lisp的简称！

简单代码：

(defun f (s)                     ; receive the string as parameter
  (map 'string                   ; map the following function of two arguments
       (lambda (x y)             ; x from the original string, y from the string with removed spaces
         (if (upper-case-p x)    ; if x is uppercase
             (char-upcase y)     ; get y uppercase
             (char-downcase y))) ; else get y lowercase
       s
       (remove #\  s)))

的Java（OpenJDK的8） ，150个 117 113 97字节

s->{for(int i=0,j=0,c;i<s.length;)if((c=s[i++]&95)>0)System.out.printf("%c",c^(s[j++]|~c/2)&32);}

在线尝试！

打高尔夫球的时候，我得到了102个字节：

s->{for(int i=0,j=0,c;i<s.length;)if((c=s[i++]&95)>0)System.out.printf("%c",c<64?c|32:c|s[j]&32,j++);}

在线尝试！

但是我记得这开始看起来像丹尼斯的C答案，所以我只是移植了他的琐事，然后……魔术发生了。港口的最大收获是消除了分支和分支内部的重复。

Google表格，213字节

=ArrayFormula(JOIN("",IF(REGEXMATCH(MID(A1,ROW(OFFSET(A1,0,0,LEN(A1))),1),"[A-Z]"),MID(UPPER(SUBSTITUTE(A1," ","")),ROW(OFFSET(A1,0,0,LEN(A1))),1),MID(LOWER(SUBSTITUTE(A1," ","")),ROW(OFFSET(A1,0,0,LEN(A1))),1))))

输入在单元格中A1，公式分解如下：

• ArrayFormula()让我们ROW()独立评估每个术语
• JOIN() 将所有这些独立结果连接到一个字符串中
• IF(REGEXMATCH(),UPPER(),LOWER() 是什么使它使用大写或小写交替显示，具体取决于输入中该位置的大小写
• ROW(OFFSET())返回值的阵列1，以A1.length可供给到MID()功能，所以我们可以评价依次在每个字符

测试用例的结果：（如果单击较大的版本，则更容易阅读。）

红宝石，80字节

->a{n=a.downcase.delete' '
n.size.times{|i|(?A..?Z)===a[i]&&n[i]=n[i].upcase}
n}

在线尝试！

Perl，92个字节

$p[$i++]=$-[0]while s/[A-Z]/lc($&)/e;s/\s//g;for$c(@p){substr($_,$c,1)=~tr[a-z][A-Z]};print;

说明：

$p[$i++]=$-[0]while s/[A-Z]/lc($&)/e;   #get locations of caps into an array at the same time converting letters to lowercase

s/\s//g;   #delete all spaces

for$c(@p){substr($_,$c,1)=~tr[a-z][A-Z]};   #convert lowercase letters to uppercase where uppercase letters were present

print;   # print (of course) :)

C，103字节

i,j,c;f(char*s){for(i=j=0;c=tolower(s[j++]);)c-32&&putchar(c-32*(s[i]>64&&s[i]<91&&c>96&&c<123))&&++i;}

在线尝试！

Python 3中，125，124个字节

lambda s:''.join(c.upper()if i in(s.find(q)for q in s if q.isupper())else c for i,c in enumerate(s.replace(' ','').lower()))

在线尝试！

Python 2中，106个 105字节

s=input()
print''.join(map(lambda(c,u):[c.lower,c.upper][u](),zip(s.replace(' ',''),map(str.isupper,s))))

编辑：通过print ''.join=> 保存一个字节print''.join。

Lambda格式，99个字节

lambda s:''.join(map(lambda(c,u):[c.lower,c.upper][u](),zip(s.replace(' ',''),map(str.isupper,s))))

SCALA，128个字符，128个字节

var l=s.toLowerCase().filter(x=>x!=32)
for(i<-0 to l.size-1){if(s(i).isUpper)l=l.substring(0,i)+l(i).toUpper+l.substring(i+1)}
l

感谢您的挑战。在线尝试！

q / kdb +，49个字节

解：

{@[a;(&)#:[a:lower x except" "]#x in .Q.A;upper]}

例子：

q){@[a;(&)#:[a:lower x except" "]#x in .Q.A;upper]}"Hi! Test!"
"Hi!tEst!"

q){@[a;(&)#:[a:lower x except" "]#x in .Q.A;upper]}"A Quick Brown Fox Jumped Over The Lazy Dog"
"AqUickbrOwnfoxJumpEdovertHelazYdog"

q){@[a;(&)#:[a:lower x except" "]#x in .Q.A;upper]}"testing TESTing TeStING testing testing TESTING"
"testingtESTIngteStInGTEstingtestingtestiNG"

q){@[a;(&)#:[a:lower x except" "]#x in .Q.A;upper]}"TESTING... ... ... success! EUREKA???!!! maybe, don't, NOOOOO"
"TESTING.........success!eureKA???!!!maybe,don't,nooooo"

q){@[a;(&)#:[a:lower x except" "]#x in .Q.A;upper]}"Enter        PASSWORD ---------"
"Enterpassword---------"

q){@[a;(&)(#:[a:lower x except" "]#x)in .Q.A;upper]}"A a B b C c D d E e F f G g H h I i J j K k L l M m N n O o P p Q q R r S s T t U u V v W w X x Z z"
"AabbCcddEeffGghhIijjKkllMmnnOoppQqrrSsttUuvvWwxxZz"

q){@[a;(&)#:[a:lower x except" "]#x in .Q.A;upper]}"  TEST"
"teST"

说明：

查找输入为大写的索引，然后将函数upper应用于输入字符串的小写，空格删除版本上的那些索引。请注意，我们不能在字符串的长度之外应用该函数，因此请使用take（#）将输入字符串截断为小写的空格删除版本的长度。

{@[a;where count[a:lower x except " "]#x in .Q.A;upper]} / ungolfed
{                                                      } / lambda function
 @[ ;                                           ;     ]  / apply FUNC to VAR at INDICES: @[VAR;INDICES;FUNC]
                                                 upper   / uppercase, upper["abc"] -> "ABC"
                                       x in .Q.A         / boolean list where input is in uppercase alphabet ABC..XYZ
                                      #                  / take this many elements from list on the right (ie truncate)
           count[                    ]                   / returns length of the stuff inside the brackets, count["ABC"] -> 3                                        
                         x except " "                    / remove " " from string
                   lower                                 / lowercase, lower["ABC"] -> "abc"
                 a:                                      / save in variable a
     where                                               / returns indices where true where[101b] -> 0 2
   a                                                     / our lowercased, space-stripped input

奖金：

阅读答案后，以为我会尝试对输入进行迭代的解决方案，到目前为止，我只管理了一个53字节的解决方案：

{a{$[y in .Q.A;upper x;x]}'#:[a:lower x except" "]#x}

Swift 3.0，199字节

var s="AS Ff",i=[String](),p=[Int](),j=0;for c in s.characters{if c>="A"&&c<="Z"{p.append(j)};if c != " "{i.append(String(c).lowercased())};j=j+1};for c in p{i[c]=i[c].uppercased()};print(i.joined())

在线尝试！

Perl 5，40个字节

37个字节的代码+ -F标志。（请注意，在旧版本的Perl上，您可能需要添加-an标志）

print$F[$i++]=~/[A-Z]/?uc:lc for/\S/g

在线尝试！

说明：
感谢-F，@F包含输入的每个字符的列表。
for/\S/g遍历输入的每个非空格字符。我们$i用来计算迭代次数。如果$F[$i++]是大写字符（/[A-Z]/），则打印大写的当前字符（uc），否则，将其打印为小写（lc）。请注意，uc并lc返回参数不变，如果它不是一个字母。

先前版本（少打高尔夫球：47个字节）：

 s/ //g;s%.%$_=$&;$F[$i++]=~/[A-Z]/?uc:lc%ge

在线尝试！