Sua entrada será uma frase, frase ou palavra em inglês. Ele conterá apenas a-zA-Z' -,.!?. Sua tarefa é pegar a entrada, remover espaços e redistribuir letras maiúsculas para que letras em índices que foram colocadas em maiúsculas antes (e somente letras em índices que foram colocadas em maiúscula antes) sejam colocadas em maiúsculas.

Por exemplo, se a entrada for A Quick Brown Fox Jumped Over The Lazy Dog, os índices (com base em 0) das letras maiúsculas são 0, 2, 8, 14, 18, 25, 30, 34, 39. Em seguida, remova os espaços a partir da entrada: AQuickBrownFoxJumpedOverTheLazyDog. Em seguida, minúsculas todas as letras, mas maiúsculas aqueles em 0, 2, 8, 14, 18, 25, 30, 34, 39: AqUickbrOwnfoxJumpEdovertHelazYdog, que é sua saída.

Entrada

Sua entrada será uma frase, frase ou palavra em inglês. Ele pode conter apenas letras minúsculas, maiúsculas, hífens, apóstrofos, vírgulas, pontos, pontos de interrogação, pontos de exclamação e espaços.

Saída

A entrada com espaços removidos, em minúsculas-d, com letras no índice de letras maiúsculas na entrada em maiúsculas-d.

NOTA: O seu programa não pode falhar (erro que termina com a execução) com um IndexOutOfRange ou erro semelhante.

Casos de teste

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

Geléia , 14 13 bytes

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

Experimente online!

Como funciona

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 bytes

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

Experimente online!

Python 2 , 114 bytes

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

Experimente online!

Equivalentemente:

Python 2 , 114 bytes

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

Experimente online!

Python 3 , 78 75 72 bytes

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

Graças a @xnor por jogar fora 6 bytes!

Experimente online!

05AB1E , 15 14 bytes

-1 byte graças a Emigna

ðKuvy¹Nè.lil}?

Experimente online!

ð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 bytes

Agradecemos a @name, @nimi, @Zgarb e @Laikoni por ajudar a remover 14 bytes no total

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

Ungolfed:

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

V , 24 bytes

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

Experimente online!

Esse tipo de desafio é exatamente para o que V foi criado. :)

Explicação:

Ä           " 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 bytes

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

Alice , 32 bytes

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

Experimente online!

Explicação

Este é um modelo padrão para programas que funcionam inteiramente no modo ordinal. Desembrulhado, o programa é o seguinte:

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 bytes

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

• 6 bytes salvos com assistência da ETHproductions & Arnauld.

Tente

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>

Retina , 77 71 bytes

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

T`l `L_` .?

Experimente online! O link inclui o conjunto de testes. Explicação: O primeiro estágio duplica a linha, enquanto o segundo estágio baixa a duplicata e exclui seus espaços. O terceiro estágio percorre cada letra maiúscula da direita para a esquerda e tenta colocar um espaço antes do caractere correspondente na segunda linha. A primeira linha é excluída e os espaços são usados ​​para colocar em maiúscula os caracteres relevantes do resultado. Editar: salvou 6 bytes graças a @Kobi.

Perl, 95 94 + 1 = 95 bytes

Penalidade de +1 byte para -n

Salve um byte substituindo de s/\s//gparas/ //g

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

Experimente online!

Explicação:

1. Faça uma cópia da sequência de entrada.

2. Remova todos os espaços e transforme a cadeia em minúsculas.

3. Em seguida, inicie o loop sobre cada letra. Letra de teste na mesma posição na sequência salva para maiúsculas. Se for superior - torne a letra atual em maiúscula. Imprimir carta.

Observe que o perl precisa ser executado com a opção de linha de comando "-n"

MATL , 18 bytes

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

Mesma abordagem da resposta 05AB1E de Riley .

Experimente online!

Python 3 , 117 bytes

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

Experimente Online!

Este é praticamente o meu primeiro código de golfe, por isso é provável que seja ruim, menos a ajuda dos comentários abaixo!

PS Sim, é estúpido que definir e incrementar ieconomize bytes acima do intervalo (len (y)). Ah bem.

C # (.NET Core) , 108 101 bytes

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

Experimente online!

• 7 bytes salvos após perceber que a charclasse tem métodos ToUpper()e estáticos ToLower().

Carvão , 33 bytes

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

Experimente online!

Como ainda não sei como passar uma string com espaços em branco como um único parâmetro de entrada no código Charcoal, apenas atribuo no cabeçalho a string de teste à variável Charcoal que representa qual seria a primeira entrada ( θ):

ＡA Quick Brown Fox Jumped Over The Lazy Dogθ

Portanto, o código tem o mesmo número de bytes como se a sequência fosse passada como primeira entrada.

Você pode ver aqui a versão detalhada do código.

PHP, 181 bytes

Eu tento obter o menor número de bytes, este é o meu código:

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

Experimente online!

Java 8, 184 177 161 bytes

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

Definitivamente pode ser jogado um pouco mais ..
- 16 bytes graças a @ OlivierGrégoire pegando a entrada como em char[]vez de String.

Explicação:

Experimente aqui.

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 comum, 104 bytes

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

Experimente online!

Anormalmente curto para o prolixo Lisp comum!

Código simples:

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

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

Experimente online!

Enquanto jogava mais, cheguei a 102 bytes:

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

Experimente online!

Mas eu lembrei que isso estava começando a parecer a resposta de Dennis, então eu simplesmente expressava sua brincadeira e ... mágica aconteceu. O grande ganho do porto é remover os galhos e as repetições dentro deles.

Planilhas Google, 213 bytes

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

A entrada está na célula A1e a fórmula se divide assim:

• ArrayFormula()permite avaliar cada termo de ROW()forma independente
• JOIN() concatena todos os resultados independentes em uma única sequência
• IF(REGEXMATCH(),UPPER(),LOWER() é o que o alterna usando maiúsculas ou minúsculas, dependendo do que o caso estava nessa posição na entrada
• ROW(OFFSET())retorna uma matriz de valores 1para A1.lengthque pode ser alimentado na MID()função de modo que podemos avaliar um de cada vez

Resultados dos casos de teste: (É mais fácil ler se você clicar na versão maior.)

Ruby , 80 bytes

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

Experimente online!

Perl, 92 bytes

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

Explicação:

$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 bytes

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

Experimente online!

Python 3 , 125 , 124 bytes

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

Experimente online!

Python 2, 106 105 bytes

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

Editar: salve um byte via print ''.join=> print''.join.

Formulário Lambda, 99 bytes

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

SCALA, 128 caracteres, 128 bytes

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

Obrigado por este desafio. Experimente online!

q / kdb +, 49 bytes

Solução:

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

Exemplos:

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"

Explicação:

Encontre índices em que a entrada esteja em maiúsculas e aplique a função uppera esses índices em uma versão em minúscula e removida por espaço da sequência de entrada. Observe que não podemos aplicar a função além do comprimento da string, portanto, use take ( #) para truncar a string de entrada ao comprimento da versão em minúscula e removida por espaço.

{@[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

Bônus:

Depois de ler as respostas, pensei em tentar uma solução onde iterasse sobre a entrada, até agora só consegui uma solução de 53 bytes:

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

Swift 3.0, 199 bytes

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

Experimente Online!

Perl 5 , 40 bytes

37 bytes de código + -Fsinalizador. (observe que nas versões antigas do Perl, pode ser necessário adicionar -ansinalizadores)

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

Experimente online!

Explicações:
Graças a -F, @Fcontém uma lista de todos os caracteres da entrada.
for/\S/gitera sobre cada caractere não espacial da entrada. Usamos $ipara contar em que iteração estamos. Se $F[$i++]for um caractere maiúsculo ( /[A-Z]/), imprimimos o caractere atual maiúsculo ( uc), caso contrário, imprimimos em letras minúsculas ( lc). Observe que uce lcretorne o argumento inalterado se não for uma letra.

Versão anterior (menos golfe: 47 bytes):

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

Experimente online!