Duplicar y cambiar la caja

34

El objetivo es, después de haber tomado una cadena como entrada, duplicar cada letra latina y "alternar" su mayúscula (es decir, mayúsculas se convierte en minúsculas y viceversa).

Ejemplo de entradas y salidas:

Input      Output
bad        bBaAdD
Nice       NniIcCeE
T e S t    Tt eE Ss tT
s E t      sS Ee tT
1!1!1st!   1!1!1sStT!
n00b       nN00bB     
(e.g.)     (eE.gG.)
H3l|@!     Hh3lL|@!

La entrada consta de símbolos ASCII imprimibles.

No debe duplicar letras no latinas, números, caracteres especiales.

code-golf string nicael
fuente
17
Este es un desafío muy agradable, simple pero no trivial.
Mego

Respuestas:

10

Jalea, 5 bytes

żŒsQ€

Pruébalo en línea!

Cómo funciona

żŒsQ€  Main link. Argument: s (string)

 Œs    Yield s with swapped case.
ż      Zip s with the result.
   Q€  Unique each; deduplicate each pair of characters.
Dennis
fuente
17

Python, 56 54 bytes

lambda s:''.join(c+c.swapcase()*c.isalpha()for c in s)

Pruébalo en Ideone .

Dennis
fuente
Dang! Me jugó por 4 bytes ...
R. Kap
¿Cómo mantiene esto los caracteres que no son letras? Creo que aparecerían como cadenas vacías.
atlasólogo
@atlasologist Como puede ver en Ideone, no lo hacen. *tiene mayor precedencia que +, por lo que solo afecta ca mayúsculas y minúsculas.
Dennis
Ohh, está bien, no lo pensé así. Agradable.
atlasólogo
16

JavaScript ES6, 70 68 66 64 bytes

Ahorró 2 bytes gracias a @Kevin Lau - no Kenny

Guardado 2 bytes gracias a @ Cᴏɴᴏʀ O'Bʀɪᴇɴ

s=>s.replace(/[A-Z]/gi,l=>l+l[`to${l<"a"?"Low":"Upp"}erCase`]())

Explicación

Esto utiliza un realmente hacky:

l[`to${l<"a"?"Low":"Upp"}erCase`]()

que sin golf es:

l[`to${
   l < "a" ?
   "Low" : 
   "Upp"
}erCase`]()

Básicamente l < "a"verifica si el punto de código de la letra es menor que el punto de código de a(por lo tanto, es una letra mayúscula). Si es así, hará lo to + Low + erCaseque se convirtió l['toLowerCase']()y hará que el carácter sea minúscula. `las comillas permiten el formateo de cadenas, así que esencialmente puedes pensar en:

`to${l < "a" ?"Low" : "Upp"}erCase`

como: "to" + (l<"a" ? "Low" : "Upp") + "erCase"que genera la función para llamar (hacer que la cadena sea mayúscula o minúscula). Ponemos esto entre corchetes [ ... ]que nos permite acceder a una propiedad dada su nombre como una cadena. Esto devuelve la función apropiada y luego simplemente la llamamos.

Downgoat
fuente
3
/[A-Z]/gies una expresión regular más corta: 3
Value Ink
@ KevinLau-notKenny oh buena captura, gracias!
Downgoat
1
to${l<"a"?"Lower":"Upper"}Caseato${l<"a"?"Low":"Upp"}erCase
Conor O'Brien
@ CᴏɴᴏʀO'Bʀɪᴇɴ oh bien, gracias!
Downgoat
44
l[`to${l<"a"?"Low":"Upp"}erCase`]()Creo que tenemos una nueva definición del mal.
gcampbell
10

Ruby, 37 33 (30 + -pbandera) bytes

swapcase¡al rescate! Más o menos. -4 bytes de @Lynn.

gsub(/[a-z]/i){$&+$&.swapcase}
Tinta de valor
fuente
gsub(/[a-z]/i){$&+$&.swapcase}más la pbandera es de 31 bytes.
Lynn
1
@Lynn Creo que el consenso era la diferencia de edición necesaria del script predeterminado, por lo que el pindicador (space)-ptambién es de 3 bytes.
Value Ink el
8

C, 63 60 bytes

f(char*s){for(;*s;s++)isalpha(putchar(*s))&&putchar(32^*s);}

Utiliza el hecho de que 'a' XOR 32 == 'A', etc.

Tres bytes guardados gracias a FryAmTheEggman.

Lynn
fuente
puede mover el s++en el último putchar( &&putchar(32^*s++)) para guardar un byte
Giacomo Garabello
Creo que se puede sustituir &&con *, ¿verdad?
aloisdg dice Reinstate Monica
1
Estoy bastante seguro de que ambos no funcionan, si pienso en cómo &&funciona el comportamiento de cortocircuito.
Lynn
f(char*s){isalpha(putchar(*s))&&putchar(32^*s);*s&&f(1+s);}recursivo?
l4m2
1
f(char*s){*s&&f(1+s,isalpha(putchar(*s))&&putchar(32^*s));}recursivo?
l4m2
6

CJam, 11 bytes

l_el_eu.+.|

Pruébalo aquí.

Explicación

l      e# Read input.
_el    e# Duplicate, convert to lower case.
_eu    e# Duplicate, convert to upper case.
.+     e# Concatenate the two characters in matching positions from those two
       e# strings. E.g. "ab!" "AB!" would give ["aA" "bB" "!!"].
       e# For each character from the original string and the corresponding 
.|     e# string from this list, take the set union (which eliminates duplicates
       e# and keeps the order the values appear in from left to right, so that
       e# the original case of each letter comes first).
Martin Ender
fuente
5

Pyth , 7 bytes

sm{+dr2

Banco de pruebas .

sm{+dr2    input: Q
sm{+dr2dQ  implicit arguments

        Q  input
 m         for each character as d:
     r2d       swapcase
   +d          prepend d
  {            deduplicate
s          join as string
Monja permeable
fuente
Jaja, eso es realmente rápido: D
nicael
5

Haskell, 73 bytes

l=['a'..'z']
u=['A'..]
(>>= \c->c:maybe""pure(lookup c$zip l u++zip u l))
Lynn
fuente
5

Cheddar , 118104 bytes

(s)->s.chars.map((i)->{if String.letters has i.lower{if i<"a"{i+i.lower}else{i+i.upper}}else{i}}).join()

Primera respuesta real de Cheddar !!! Esto es mucho menos climático de lo que pensé que sería ...; _;

Funciona con la versión 1.0.0-beta.9 , no competitiva.

Como se puede ver, no diseñé el cheddar para ser golf: /

Sin golf:

(str) -> str.chars.map(
    (i) -> {
        if String.letters has i {
            if i < "a" { // Check char code, meaning it's upper case if true
                i+i.lower
            }
            else {
                i+i.upper
            }
        } else {
            i
        }
    }
).join()

Uso:

var doThing = <code here>;
doThing("input...");

Actualización: 14/07/16 He terminado ternaries haciendo que esto se reduzca a 84 bytes

Cheddar, 84 bytes

(s)->s.chars.map((i)->String.letters has i.lower?i<"a"?i+i.lower:i+i.upper:i).join()

funciona a partir de la versión v1.0.0-beta.14

Downgoat
fuente
44
¡Hurra! ¡Hemos estado esperando este momento por mucho tiempo!
DJMcMayhem
Con uno o dos cambios de nombre de método, también es válido Sidef
cat
@cat o_o la similitud es inquietante
Downgoat
Bueno, ambos están influenciados por Perl, Perl 6, Ruby, Python, etc., así que no es tan sorprendente: P
cat
1
@cat oh no no no no no, el queso cheddar no fue influenciado por python
Downgoat
4

Retina, 28 27 21 bytes

Esas son pestañas, no espacios.

.
$&  $&
T`lL    p`Ll_`  .

Pruébalo en línea

Gracias a todos por las sugerencias.

mbomb007
fuente
Los espacios son comidos por SE.
Conor O'Brien
[A-Za-z]->i`[A-Z]
Downgoat
Martin y yo estábamos hablando en el chat, y se nos ocurrió: retina.tryitonline.net/…
FryAmTheEggman
@FryAmTheEggman Ah, me olvidé _. Sin embargo, voy a usar pestañas para poder probar todos los casos de prueba a la vez.
mbomb007
1
Pero el conjunto de pruebas no tiene que jugar golf: P Solo dejar una nota que dice "la primera línea hace que se ejecute por separado en cada línea" suele ser lo suficientemente bueno. Aquí, te ahorraría la locura de los caracteres de tabulación.
FryAmTheEggman
4

C, 87 80

Pase una cadena como entrada f()y la salida se escribe en STDOUT. La cadena no se modifica.

f(char*v){for(;*v;++v)putchar(*v),isalpha(*v)?putchar(*v-32+64*!islower(*v)):0;}
owacoder
fuente
¿Puedes proporcionar una forma de probarlo en línea?
aloisdg dice Reinstate Monica
@aloisdg Pruebe ideone.com
gato
4

sed, 30 bytes

Código de 29 bytes + parámetro de 1 byte -r

s/([a-z])|([A-Z])/&\u\1\l\2/g

Uso:

echo -e 'bad\nNice\nT e S t\ns E t\n1!1!1st!\nn00b\n(e.g.)\nH3l|@!' |\
sed -r 's/([a-z])|([A-Z])/&\u\1\l\2/g'
Marco
fuente
4

J, 31 29 bytes

[:;]<@~."1@,.tolower,.toupper

Explicación

[:;]<@~."1@,.tolower,.toupper  Input: s
                      toupper  Convert s to all uppercase
             tolower           Convert s to all lowercase
                    ,.         Join them as columns in a 2d array
   ]                           Identity function, get s
           ,.                  Prepend s as a column to the 2d array
      ~."1@                    Take the unique chars on each row
    <@                         Box them
[:;                            Unbox the list of boxes and join their contents and return
millas
fuente
4

Haskell, 121, 101, 85, 82

import Data.Char
g n|isLower n=toUpper n|1<2=toLower n
(>>= \x->x:[g x|isAlpha x])
Zylviij
fuente
3
Al reemplazar el if-then-else por guardias, puede guardar 15 bytes más o menos. Y isLoweres más corto que la construcción con elem, por 5 bytes más.
arjanen
1
>>=es concatMap(o concat.map) con argumentos volteadas: f n = n >>= (\x->if isAlpha x then[x,r x]else[x]). Puede ir sin puntos y omitir el nombre de la función y reemplazar la definición de fcon (>>= \x->if isAlpha x then[x,r x]else[x]).
nimi
1
En lugar de otherwiseque puede utilizar cualquier expresión que se evalúa True, por ejemplo 1<2. Puede reemplazar el if .. then .. elsecon una lista por comprensión: \x->[x]++[g x|isAlpha x]. Ah, y hay un error: el segundo toUpperen gdebe ser una toLower.
nimi
1
Oh, uno más: [x]++es x:.
nimi
4

Perl, 36 bytes (35 + -nbandera)

s/[a-z]/$&.(ord$&<97?lc$&:uc$&)/ige

( -petiqueta necesaria)

(-2 bytes gracias a @Dom Hasting)

Breve explicación:
orddevuelve el valor numérico de un carácter. ord(any lower case) >= 97y ord(any upper case) <= 90).

Corre con : 

perl -pe 's/[a-z]/$&.(ord$&<97?lc$&:uc$&)/ige'
Dada
fuente
Aún necesita usar /io su expresión regular coincidirá con varios puntos de código entre letras.
Oleg V. Volkov
@ OlegV.Volkov oh cierto, gracias, respuesta editada.
Dada
Lo bajó un byte más, utilizando su método: ¡ Pruébelo en línea!
Xcali
4

Ruby, 31 + 1 = 32 30 + 1 = 31 bytes

Con la -pbandera, corre

gsub(/(?<=(.))/){$1.swapcase!}

Aprovecha el hecho de que swapcase!devolverá nilcualquier cosa que no sea una letra ASCII, que se traduce en una cadena vacía cuando se devuelve fuera del gsubbloque. @Jordan guardó un byte al capturar al personaje anterior en una retrospectiva.

histocrat
fuente
Emparejar //y luego usar $`[-1]es inteligente.
Jordania
1
Me las arreglé para cortar seis bytes de búsqueda hacia atrás con: gsub(/(?<=(.))/){$1.swapcase!}. Sin embargo, el mismo concepto básico, así que siéntase libre de usarlo.
Jordania
¡Guay! Eso me parece un byte más corto.
histocrat
Er, sí, un byte. Creo que tenía un código extra allí para probar que accidentalmente conté.
Jordania
No hay necesidad de usar la versión auto modificable de .swapcase!. (Quiero decir, eliminar el !.)
manatwork
4

R, 191 187 168 168 156 98 99 bytes

99 bytes debido a mejoras para Giuseppe y MickyT .

paste0(x<-unlist(strsplit(readline(),"")),gsub("[^A-Za-z]","",chartr("a-zA-Z","A-Za-z",x)),collapse="")
rturnbull
fuente
98 bytes , tal vez en algún momento del año que viene, podemos encontrar otro golf de este, jajaja.
Giuseppe
1
Odio ser portador de malas noticias, pero falla en casos de prueba con espacios. readline()puede usarse, pero costará un byte
MickyT
@MickyT gracias, arreglado ahora.
rturnbull
@MickyT scanfuncionará con la entrada dada entre comillas (como suele ser el caso de los argumentos de línea de comandos en otros idiomas)
Giuseppe
@Giuseppe Lo siento, no me di cuenta de eso. Solo pensé que se dividía automáticamente en espacios en blanco a menos que especifique un carácter que no sea un espacio en blanco. Lo siento rturnbull
MickyT
3

05AB1E , 7 bytes

Código:

vyyš«Ù?

Explicación:

v       # For each in input.
 yyš    # Push y and y swapcased.
    «Ù  # Concatentate and uniquify.
      ? # Print without a newline.

Utiliza la codificación CP-1252 . Pruébalo en línea!

Adnan
fuente
¿Quizás podría proporcionar un enlace al intérprete?
nicael
2
@nicael ESTÁ vinculado ... Está justo allí en github.
mbomb007
Entonces, ¿no hay intérprete en línea? :(
nicael
@nicael Luego descárgalo y ejecútalo. No tiene que haber un intérprete en línea , solo un intérprete.
mbomb007
1
@nicael Sí, todavía no hay un intérprete en línea disponible :(. Sin embargo, la versión fuera de línea debería funcionar.
Adnan
3

En realidad, 8 bytes

`;Öo╔`MΣ

Pruébalo en línea!

Explicación:

`;Öo╔`MΣ
`;Öo╔`M   for each character in input:
 ;          duplicate the character
  Ö         swap case
   o        append to original character
    ╔       remove duplicated characters
       Σ  concatenate
Mego
fuente
3

MATL, 11 9 bytes

tYov"@uv!

Pruébalo en línea

Explicación

        % Implicitly grab input as string
t       % Duplicate the input
Yo      % Swap case of all characters
v       % Vertically concatenate the original and swap-cased versions
"       % For each column (letter in the original)
  @u    % Compute the unique values (without sorting)
  v!    % Vertically concatenate with the existing output and transpose
        % Implicit end of for loop and implicit display
Suever
fuente
3

Perl, 28 22 21 bytes (20 + -pbandera)

s/[a-z]/$&.$&^$"/ige
Oleg V. Volkov
fuente
Me imagino que puede guardar un byte usando en $"lugar de ' ', pero no lo he probado.
msh210
@ msh210, bien! ¿Cómo podría olvidar comprobar perlvar para las cadenas predeterminadas? ¡Gracias!
Oleg V. Volkov
3

Stax , 7 6 bytes

¡Gracias a @recursive por un byte guardado!

┤§ÆP♦■

¡Ejecútelo y depúrelo en staxlang.xyz! (el enlace es a la versión desempaquetada)

Desempaquetado (7 bytes):

c:~\{um

Explicación:

c:~\{um
c          Copy the top element of the stack (the input, in this case).
 :~        Switch case of each letter in the copy.
   \       Zip. This produces an array of two-character strings.
    { m    Map a block over this array of two-character strings.
     u       Get all unique elements.
           Implicit concatenate and print.
Khuldraeseth na'Barya
fuente
Gracias por probar Stax. Una mejora fácil que puede hacer es usar en ulugar de :g. Obtendrá todos los elementos únicos en una matriz, que es exactamente lo que desea en este caso. Aparte de eso, esto se ve muy bien.
recursivo
@recursive ¡Gracias! Olvidé eso: / Lo editaré pronto.
Khuldraeseth na'Barya
No funciona para 123. Es posible que deba cambiar el formato de todas las entradas (es decir, citarlas). El enlace también está roto. Necesitas reemplazar m=11con m=2. Hay un botón de generación de publicación PPCG en staxlang.xyz, por lo que es posible que desee usar ese.
Weijun Zhou
@WeijunZhou Gracias, arreglado!
Khuldraeseth na'Barya
2

Python, 59 bytes

lambda s:''.join((x,x+x.swapcase())[x.isalpha()]for x in s)

Editado para corregir caracteres no alfabéticos repetidos

atlasólogo
fuente
2

Julia, 40 bytes

!s=[print(c,isalpha(c)?c$' ':"")for c=s]

Pruébalo en línea!

Dennis
fuente
not s is (list comprehension)bien, Julia ...
gato
2

PHP 4.1, 57 bytes

Este código supone el acceso a través de un servidor web (Apache, por ejemplo), utilizando la configuración predeterminada.

Puede pasar la cadena mediante el envío de la clave Spor cualquier medio ( POST, GET, COOKIE, SESSION...).

<?for($i=0;$c=$S[$i++];)echo$c,ctype_alpha($c)?$c^' ':'';
Ismael Miguel
fuente
2

C #, 82 71 bytes

s=>string.Concat(s.Select(c=>c+(char.IsLetter(c)?(char)(c^32)+"":"")));

C # lambda donde están la entrada y la salida string. Pruébalo en línea .

11 bytes gracias al truco @Lynn.

aloisdg dice Reinstate Monica
fuente
2

Lisp común (Lispworks), 262 bytes

(defun f(s)(let((b""))(dotimes(i(length s))(if(lower-case-p(elt s i))(progn #1=(setf b(concatenate 'string b(string #2=(elt s i))))(setf b(concatenate 'string b(string(char-upcase #2#)))))(progn #1#(setf b(concatenate 'string b(string(char-downcase #2#)))))))b))

sin golf:

(defun f (s)
  (let ((b ""))
    (dotimes (i (length s))
      (if (lower-case-p (elt s i))
          (progn
           #1=(setf b (concatenate 'string b (string #2=(elt s i))))
           (setf b (concatenate 'string b (string (char-upcase #2#)))))
        (progn
          #1#
          (setf b (concatenate 'string b (string (char-downcase #2#)))))))
    b))

Uso:

CL-USER 1 > (f "abc")
"aAbBcC"

CL-USER 2 > (f "bad")
"bBaAdD"
sadfaf
fuente