Su entrada será una oración, frase o palabra en inglés. Solo contendrá a-zA-Z' -,.!?. Su tarea es tomar la entrada, eliminar espacios y luego redistribuir las mayúsculas de manera que las letras en los índices que se capitalizaron antes (y solo las letras en los índices que se capitalizaron antes) se capitalicen.

Por ejemplo, si la entrada es A Quick Brown Fox Jumped Over The Lazy Dog, los índices (basados ​​en 0) de las letras mayúsculas son 0, 2, 8, 14, 18, 25, 30, 34, 39. A continuación, quite los espacios de la entrada: AQuickBrownFoxJumpedOverTheLazyDog. A continuación, minúsculas todas las letras, pero mayúsculas en 0, 2, 8, 14, 18, 25, 30, 34, 39:, AqUickbrOwnfoxJumpEdovertHelazYdogque es su salida.

Entrada

Su entrada será una oración, frase o palabra en inglés. Solo puede contener letras minúsculas, letras mayúsculas, guiones, apóstrofes, comas, puntos, signos de interrogación, signos de exclamación y espacios.

Salida

La entrada con espacios eliminados, minúscula-d, con letras en el índice de mayúsculas en la entrada mayúscula-d.

NOTA: Su programa no puede bloquearse (el error finaliza tal ejecución) con un IndexOutOfRange o un error similar.

Casos de prueba

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

Jalea , 14 13 bytes

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

Pruébalo en línea!

Cómo 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;}

Pruébalo en línea!

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

Pruébalo en línea!

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

Pruébalo en línea!

Python 3 , 78 75 72 bytes

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

¡Gracias a @xnor por jugar 6 bytes!

Pruébalo en línea!

05AB1E , 15 14 bytes

-1 byte gracias a Emigna

ðKuvy¹Nè.lil}?

Pruébalo en línea!

ð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

Gracias a @name, @nimi, @Zgarb y @Laikoni por ayudar a reducir 14 bytes en total

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

Sin golf:

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

Pruébalo en línea!

Este tipo de desafíos son exactamente para lo que V fue creado. :)

Explicación:

Ä           " 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@/

Pruébalo en línea!

Explicación

Esta es una plantilla estándar para programas que funcionan completamente en modo ordinal. Sin envolver, el programa es el siguiente:

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 guardados con asistencia de ETHproductions & Arnauld.

Intentalo

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_` .?

Pruébalo en línea! El enlace incluye un conjunto de pruebas. Explicación: La primera etapa duplica la línea, mientras que la segunda pone en minúscula el duplicado y elimina sus espacios. Luego, la tercera etapa recorre cada letra mayúscula de derecha a izquierda e intenta colocar un espacio antes del carácter correspondiente en la segunda línea. La primera línea se elimina y los espacios se utilizan para poner en mayúscula los caracteres relevantes del resultado. Editar: Guardado 6 bytes gracias a @Kobi.

Perl, 95 94 + 1 = 95 bytes

+1 byte de penalización por -n

Guardar un byte por reemplazar de s/\s//gas/ //g

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

Pruébalo en línea!

Explicación:

1. Haga una copia de la cadena de entrada.

2. Elimine todos los espacios y transforme la cadena a minúsculas.

3. Luego comience el ciclo sobre cada letra. Pruebe la letra en la misma posición en la cadena guardada para mayúsculas. Si es superior, haga que la letra actual quede cautivada. Letra impresa

Tenga en cuenta que perl necesita ejecutarse con el interruptor de línea de comando "-n"

MATL , 18 bytes

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

El mismo enfoque que la respuesta 05AB1E de Riley .

Pruébalo en línea!

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

¡Pruébelo en línea!

Este es mi primer código de golf, por lo que es probable que sea malo, ¡menos la ayuda de los comentarios a continuación!

PD Sí, es tonto que definir e incrementar iguarde bytes por encima del rango (len (y)). Oh bien.

C # (.NET Core) , 108101 bytes

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

Pruébalo en línea!

• 7 bytes guardados después de darse cuenta de que la charclase tiene estática ToUpper()y ToLower()métodos.

Carbón , 33 bytes

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

Pruébalo en línea!

Como todavía no sé cómo pasar una cadena con espacios en blanco como un único parámetro de entrada en el código de carbón, simplemente asigno en el encabezado la cadena de prueba a la variable de carbón que representa lo que sería la primera entrada ( θ):

ＡA Quick Brown Fox Jumped Over The Lazy Dogθ

Por lo tanto, el código tiene el mismo número de bytes que si la cadena se pasara como primera entrada.

Puede ver aquí la versión detallada del código.

PHP, 181 bytes

Intento obtener los números menores de bytes, este es mi 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;

Pruébalo en línea!

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 se puede jugar un poco más.
- 16 bytes gracias a @ OlivierGrégoire tomando la entrada como en char[]lugar de String.

Explicación:

Pruébalo aquí

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 común, 104 bytes

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

Pruébalo en línea!

Inusualmente corto para la palabra Common Lisp!

Código directo:

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

Pruébalo en línea!

Mientras jugaba más, llegué 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++);}

Pruébalo en línea!

Pero recordé que esto estaba empezando a parecerse a la respuesta de Dennis 'C, así que simplemente porté su torpeza y ... ocurrió la magia. La gran ganancia del puerto es eliminar las ramas y las repeticiones dentro de ellas.

Hojas de cálculo de 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))))

La entrada está en la celda A1y la fórmula se desglosa así:

• ArrayFormula()nos permite evaluar cada término de forma ROW()independiente
• JOIN() concatena todos esos resultados independientes en una sola cadena
• IF(REGEXMATCH(),UPPER(),LOWER() es lo que lo hace alternativo usando mayúsculas o minúsculas dependiendo de cuál era el caso en esa posición en la entrada
• ROW(OFFSET())Devuelve una matriz de valores 1a A1.lengthque se puede introducir en la MID()función para que podamos evaluar cada carácter a su vez

Resultados de casos de prueba: (Es más fácil de leer si hace clic en la versión más grande).

Rubí , 80 bytes.

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

Pruébalo en línea!

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;

Explicación:

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

Pruébalo en línea!

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

Pruébalo en línea!

Python 2, 106105 bytes

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

Editar: guardar un byte a través de print ''.join=> print''.join.

Formulario 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

Gracias por este reto. Pruébalo en línea!

q / kdb +, 49 bytes

Solución:

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

Ejemplos:

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"

Explicación:

Encuentre índices donde la entrada es mayúscula y luego aplique la función uppera esos índices en una versión en minúsculas, sin espacio, de la cadena de entrada. Tenga en cuenta que no podemos aplicar la función más allá de la longitud de la cadena, por lo tanto, use take ( #) para truncar la cadena de entrada a la longitud de la versión en minúsculas y sin espacio.

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

Prima:

Después de leer las respuestas, pensé en probar una solución donde iteraba sobre la entrada, hasta ahora solo he logrado una solución 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())

Pruébalo en línea!

Perl 5 , 40 bytes

37 bytes de código + -Fbandera. (tenga en cuenta que en versiones anteriores de Perl, es posible que deba agregar -anmarcas)

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

Pruébalo en línea!

Explicaciones:
Gracias a -F, @Fcontiene una lista de todos los caracteres de la entrada.
for/\S/gitera sobre cada carácter no espacial de la entrada. Usamos $ipara contar en qué iteración estamos. Si $F[$i++]es un carácter en mayúscula ( /[A-Z]/), imprimimos el carácter actual en mayúscula ( uc), de lo contrario, lo imprimimos en minúscula ( lc). Tenga en cuenta eso ucy lcdevuelva su argumento sin cambios si no es una carta.

Versión anterior (menos golfizada: 47 bytes):

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

Pruébalo en línea!