Eliminar espacios, manteniendo la capitalización

27

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
code-golf  string 
— Stephen
fuente
— Stephen
'Por ejemplo, si la entrada es "Un zorro marrón rápido saltó sobre el perro perezoso", los índices (basados ​​en 0) de las letras mayúsculas son 0, 2, 8, 14, 18, 23, 27, 32' Ellos son0, 2, 8, 14, 18, 25, 30, 34, 39
— Luke Sawczak
@LukeSawczak gracias, mi mal
— Stephen
¿No se permiten espacios de traling, supongo?
— Luis Mendo
@LuisMendo su suposición es correcta. Este es el código de golf, ¿verdad? : P
— Stephen

Respuestas:

7

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.
— Dennis
fuente
7

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!

— Hiperneutrino
fuente
''.join([(X[i].lower,X[i].upper)[x[i].isupper()]()for i in range(len(X))])para -5 bytes.
— ovs
5

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!

— Dennis
fuente
¿Puedes simplemente comparar en slugar de s[0]?
— xnor
Sí, por supuesto. ¡Gracias!
— Dennis
1
(c*2).title()puede obtener ambos casos, aunque haya cambiado.
— xnor
Otros 3 bytes. ¡Gracias de nuevo!
— Dennis
¡Difícil! Me tomó un tiempo darme cuenta de que c>' '!=f()es equivalente a (c>' ') and (' '!=f()).
— Chas Brown
5

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
— Riley
fuente
Guarda un byte si escribe en mayúscula la cadena de espacio y minúscula en la condición.
— Emigna
5

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)
— Julian Wolf
fuente
En dispositivos móviles, pero parece que puede guardar algunos bytes con filtro (/ = '')
— Henry
Sí, ciertamente puede. Se perdió la parte de la especificación que señalaba que los espacios eran el único espacio en blanco que necesitaba eliminarse.
— Julian Wolf
1
filter(>' ')por un byte menos
— nimi
2
Creo que el cuerpo de la lambda se puede acortar alast(toLower:[toUpper|isUpper p])c
— Zgarb
Cambio de los argumentos de zipWithdebe guardar una más bytes: f s=zipWith(\p->last$toLower:[toUpper|isUpper p])s$filter(>' ')s.
— Laikoni
4

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
— DJMcMayhem
fuente
@DLosc ¡Buenas preguntas! Las nuevas líneas señalan el final de un comando regex, como un comando sustituto (eliminar) o de búsqueda. Más detalles se encuentran en esta página: github.com/DJMcMayhem/V/wiki/Regexes
— DJMcMayhem
4

Python 2, 100 bytes

s=input()
print"".join([c.lower(),c.upper()][s[i].isupper()]for i,c in enumerate(s.replace(" ","")))
— erik
fuente
3
¡Bienvenido a PPCG, y muy buena primera respuesta!
— ETHproductions
3

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
— Nitrodon
fuente
3

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>
Expandir fragmento

— Lanudo
fuente
— Stephen
Podrías hacer '@'<s[i]&s[i]<'['??
— ETHproductions
@StepHen: Aw, hombre, no lo vi anoche mientras estaba trabajando en esto.
— Shaggy
@ETHproductions: Me preguntaba si eso podría ser más corto, pero era demasiado vago para buscar qué caracteres necesitaría usar: D Resulta que sí guarda un byte; Gracias.
— Shaggy
3

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.

— Neil
fuente
Pequeña pregunta: ¿Son los (.?)y $4las piezas necesarias? Parece que tener un grupo opcional al final no hace nada.
— Kobi
@Kobi ¡Nada pequeño sobre esa pregunta! Originalmente había sido parte de un intento de usar las miradas para unir los caracteres que se colocarían en mayúsculas directamente en lugar de tener que traducirlos como un paso separado.
— Neil
3

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"

— Veitcel
fuente
Bienvenido a PPCG! Si lo desea, puede agregar un enlace a Probar en línea: tio.run/# (Lo agregaría, pero no sé si es Perl 5 o Perl 6)
— Stephen
1
Creo que necesitas contar el +1byte para la -nbandera. Aparte de eso, ¡esto se ve bien! Bienvenido al sitio! :)
— DJMcMayhem
@StepHen es Perl 5, ¿puedes agregar un enlace? No pude ejecutar mi código allí de manera adecuada.
— Veitcel
¡Feliz de ver a un nuevo golfista de Perl! Agregué el enlace TIO a su respuesta y mejoré el formato.
— Dada
2

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.

— Luke Sawczak
fuente
1
Bienvenido a PPCG! Buena primera presentación! Sin embargo, cumpliendo con los estándares de E / S de nuestro sitio, su envío debe ser una función de una cadena o tomar entrada; no puede asumir que la entrada está en una variable. ¡Esperamos que disfrute su estancia! :)
— HyperNeutrino
Gracias; editó una función en, pero también guardó 5 bytes en el cuerpo: D
— Luke Sawczak
1
@LukeSawczak ahorra una tonelada de bytes cambiando a un espacio para la sangría, y tal vez agregue un ¡Pruébelo en línea! enlace si quieres
— Stephen
1
Puede eliminar el espacio después return.
— CalculatorFeline
@LukeSawczak ¿cómo es esto? tio.run/…
— Stephen
2

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.
— Charlie
fuente
2

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.

— Charlie
fuente
1
Dije en otra respuesta, pero en caso de que lo olvide, ingrese como una matriz de python con un elemento
— solo ASCII el
Solo necesito la entrada para tener una nueva línea final.
— Neil
2

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!

— dormir
fuente
En lugar de una constante PREG_OFFSET_CAPTURE, puede usar el valor 256, $argnes una variable más corta en cuanto readline()a una entrada y creo ctype_uppery uso, lcfirsty ucfirstahorrará muchos bytes con un bucle y uso de $$iy operador ternario
— Jörg Hülsermann
2

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
— Kevin Cruijssen
fuente
1
Tome una en char[]lugar de una cadena para esta, ¡ahorrará muchos bytes!
— Olivier Grégoire
Por otro lado, también respondí con otro algoritmo. Y aquí, tomo los argumentos opuestos: in = String, out = char[]:-)
— Olivier Grégoire
2

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)))
— Renzo
fuente
2

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.

— Olivier Grégoire
fuente
@ceilingcat que no funciona: Hi! Test!debería convertirse Hi!tEst!, pero con su solución se convierte Hi!Test.
— Olivier Grégoire
2

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

Casos de prueba

— Tostadas de ingeniero
fuente
2

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!

— Alex
fuente
Puede guardar un par de bytes utilizando n.gsub(/./){}en lugar de n.size.times{};n: n.gsub(/./){(?A..?Z)===a[i]?$&.upcase: $&}.
— Jordania
2

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) :)
— jmatix
fuente
1
Bienvenido a PPCG! :)
— Stephen
Debe agregar una -nbandera para que su respuesta sea válida. Algunas cosas de golf: s/ //ges suficiente (no es necesario \s), y/a-z/A-Z/es lo mismo que tr[a-z][A-Z], puedes usar -pflag para no necesitar el último print, no necesitas el paréntesis lc$&.
— Dada
1

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))))
— Chas Brown
fuente
1

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!

— V. Courtois
fuente
1

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}
— callejero
fuente
1

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!

— A. Pooja
fuente
1

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!

— Dada
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.