입력 한 내용은 영어 문장, 문구 또는 단어입니다. 이 포함 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;}

온라인으로 사용해보십시오!

파이썬 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))])

온라인으로 사용해보십시오!

동등하게 :

파이썬 2 , 114 바이트

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

온라인으로 사용해보십시오!

파이썬 3 , 78 75 72 바이트

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

6 바이트를 골라 낸 @xnor에게 감사드립니다!

온라인으로 사용해보십시오!

05AB1E , 15 14 바이트

Emigna 덕분에 -1 바이트

ð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

하스켈 , 98 95 89 88 81 바이트

총 14 바이트를 줄이는 데 도움을 준 @name, @nimi, @Zgarb 및 @Laikoni 덕분에

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

파이썬 2, 100 바이트

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

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

자바 스크립트 (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 바이트가 절약되었습니다.

펄, 95 94 + 1 = 95 바이트

-n에 대해 +1 바이트 페널티

에서 s/\s//g를 교체하여 1 바이트를 저장하십시오.s/ //g

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

온라인으로 사용해보십시오!

설명:

1. 입력 문자열을 복사하십시오.

2. 모든 공백을 제거하고 문자열을 소문자로 변환하십시오.

3. 그런 다음 각 문자에 대해 루프를 시작하십시오. 대문자로 저장된 문자열에서 같은 위치에있는 문자를 테스트하십시오. 위와 같으면 현재 문자를 대문자로 만듭니다. 편지를 인쇄하십시오.

"-n"명령 행 스위치를 사용하여 perl을 실행해야합니다.

MATL , 18 바이트

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

Riley의 05AB1E 답변 과 동일한 접근 방식 입니다.

온라인으로 사용해보십시오!

파이썬 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))

온라인으로 사용해보십시오!

이것은 첫 번째 코드 골프와 거의 같으므로 아래 주석의 도움을 빼면 나쁠 것입니다!

추신 : 네, 정의하고 증가시키는 것은 irange (len (y))에 걸쳐 바이트를 절약 하는 바보입니다 . 오 잘

C # (. NET 코어) , 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;

온라인으로 사용해보십시오!

자바 (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
덕분에 16 바이트 대신 입력을 가져옴char[]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

공통 리스프, 104 바이트

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

온라인으로 사용해보십시오!

엄청나게 커먼 리스프의 줄임말!

간단한 코드 :

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

자바 (오픈 JDK 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++);}

온라인으로 사용해보십시오!

그러나 나는 이것이 Dennis '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}

온라인으로 사용해보십시오!

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

온라인으로 사용해보십시오!

파이썬 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()))

온라인으로 사용해보십시오!

파이썬 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=> 를 통해 1 바이트 저장print''.join .

람다 형식, 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}

스위프트 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 bytes

37 bytes of code + -F flag. (note that on old versions of Perl, you might need to add -an flags)

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

Try it online!

Explanations:
Thanks to -F, @F contains a list of every characters of the input.
for/\S/g iterates over every non-space character of the input. We use $i to count at which iteration we are. If $F[$i++] is an uppercase character (/[A-Z]/), then we print the uppercase current character (uc), otherwise, we print it lowercase (lc). Note that uc and lc return their argument unchanged if it isn't a letter.

Previous version (less golfed: 47 bytes):

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

Try it online!