Dadas dos cadenas de letras, transfiera el patrón de mayúsculas de cada cadena a la otra. Pocos bytes ganan.

Input:   CodeGolf xxPPCGxx  
Output:  coDEGOlf XxppCgxx

• Ambas cadenas serán de igual longitud y no vacías, con solo letras a..zy A..Z.
• Puede generar las dos cadenas resultantes en cualquier orden en relación con las entradas.
• Puede representar un par de cadenas como una cadena con un separador de un solo carácter sin letras para entrada y / o salida.
• Puede representar una cadena como una lista de caracteres o cadenas de un carácter, pero no como una secuencia de valores de puntos de código a menos que se trate simplemente de cadenas en su idioma.
• Su entrada y salida pueden representar cadenas de manera diferente.

Casos de prueba:

CodeGolf xxPPCGxx -> coDEGOlf XxppCgxx
lower UPPER -> LOWER upper
MiXeD lower -> mixed LoWeR
A A -> A A
ABcd EfGh -> AbCd EFgh

Java (JDK 10) , 66 bytes

a->b->{for(int i=a.length,t;i-->0;b[i]^=t)a[i]^=t=(a[i]^b[i])&32;}

Pruébalo en línea!

Explicaciones

a->b->{                           // Curried lambda
 for(int i=a.length,t;i-->0;      //  Descending loop on i,
                                  //  Declare t
     b[i]^=t                      //   Apply the case difference to b[i]
   )
  a[i]^=t=(a[i]^b[i])&32;         //   Assign the case difference of the two letters to t, and apply it to a[i].
}

C (gcc) , 86 58 55 53 bytes

• Ahorró veintiocho bytes gracias a Cows quack .
• Guardado tres bytes.
• Ahorró dos bytes gracias a Olivier Grégoire .

c(a,s,e)char*a,*s;{for(;*s++^=e=(*s^*a)&32;)*a++^=e;}

Pruébalo en línea!

Jalea , 9 bytes

O&32^/^OỌ

Pruébalo en línea!

Cómo funciona

O&32^/^OỌ  Main link. Argument: [s, t] (pair of strings)

O          Ordinal; replace each character with its code point.
 &32       Perform bitwise AND with 32, yielding 32 for lowercase letters, 0 for
           uppercase ones.
    ^/     Reduce by XOR, yielding 32 for letter pairs with different 
           capitalizations, 0 for letter pair with matching capitalizations.
      ^O   XOR the result with each of the code points.
        Ọ  Unordinal; replace each code point with its character.

APL (Dyalog Classic) , 13 12 bytes

⊖⊖819⌶¨⍨∊∘⎕a

Pruébalo en línea!

entrada y salida es una matriz de caracteres 2 × N

⎕a es el alfabeto en mayúscula 'ABC...Z'

∊∘⎕a devuelve una matriz booleana que indica qué letras en la entrada son mayúsculas

819⌶ convierte su argumento derecho a mayúsculas o minúsculas dependiendo de su argumento booleano a la izquierda ("819" es leetspeak para "BIG")

819⌶¨⍨hace eso para cada carácter ( ¨), intercambiando (⍨ ) los argumentos

⊖significa revertir verticalmente; uno ⊖actúa como argumento izquierdo 819⌶y el otro es la acción final

Pyth , 10 bytes

rVV_mmrIk1

Pruébalo aquí!

Explicación y trucos Pyth limpios utilizados

• rVV_mmrIk1- Programa completo. La entrada se toma de STDIN como una lista de dos cadenas, y la salida se escribe en STDOUT como una lista de dos listas de caracteres.

• mm - Para cada personaje en cada una de las cadenas:

  • Ik - Compruebe si es invariante en ...
  • r...1- ... Convertir a mayúsculas. Rendimientos True para caracteres en mayúscula y False para caracteres en minúscula.

• _ - Invierte esa lista.

• VV - Y doble vectorice la siguiente función sobre las dos listas:

  • r- Convertir a mayúsculas si el valor es True(aka 1), de lo contrario, convertir a minúsculas.

Esta presentación abusa del hecho de que r0y r1son las funciones en minúsculas y mayúsculas en Pyth, y usamos valores de verdad (los valores obtenidos al verificar si cada carácter es mayúscula, invertido) dando lugar Truea mayúsculas y Falseminúsculas. El hecho de que los booleanos son subclases de enteros en Python es muy útil para el enfoque que está utilizando esta respuesta. Los enfoques de Porting Dennis y Jonathan's Jelly resultaron en más de 18 bytes, por lo que estoy bastante contento con los trucos específicos de Pyth utilizados aquí.

MATL , 11 bytes

kG91<P32*-c

Pruébalo en línea!O verificar todos los casos de prueba .

Explicación

k      % Implicit input: 2-row char matrix. Convert to lower-case
G      % Push input again 
91<    % Less than 91?, element-wise. Gives 1 for upper-case
P      % Flip vertically
32*    % Multiply by 32, element-wise
-      % Subtract, element-wise
c      % Convert to char. Implicit display

Haskell , 78 bytes

import Data.Char
c x|isUpper x=toUpper|1<2=toLower
(!)=zipWith c
x#y=(y!x,x!y)

Pruébalo en línea!

J , 36 31 27 bytes

-9 bytes gracias a FrownyFrog!

(XOR"$32*[:~:/97>])&.(3&u:)

Pruébalo en línea!

La solución anterior fue:

J , 36 31 bytes

-5 bytes gracias a FrownyFrog!

|:@(XOR 32*0~:/@|:97>])&.(3&u:)

Pruébalo en línea!

Cómo funciona:

                          (3&u:)  converts the strings to code points
   (                    )&.       then do the following and convert back to chars
                    97>]          check if they are uppercase letters 
             0~:/@|:              transpose and check if the two values are different
          32*                     multiply by 32 (32 if different, 0 otherwise)
      XOR                         xor the code point values with 32 or 0
 |:@                              and transpose

R , 118 94 75 72 bytes

m=sapply(scan(,""),utf8ToInt);w=m>96;apply(m-32*(w-w[,2:1]),2,intToUtf8)

Pruébalo en línea!

Debe haber una forma mucho más golfista. -43 bytes gracias a Giuseppe que me señaló la solución MATL de Luis Mendo. El enlace TIO contiene una solución de función para el mismo recuento de bytes.

m=sapply(a<-scan(,""),utf8ToInt)    # Turns input into a matrix of bytecode (2 columns)
w=m>96                              # Predicate : which chars are lower?
apply(m-32*(w-w[,2:1]),2,intToUtf8) # -32*w turns the string to UPPER
                                    # +32*w[,2:1] swaps capitalization
                                    # intToUtf8 turns bytecode to strings

Bonificación: ¡La salida es un vector con nombre cuyos nombres son las cadenas de entrada originales!

Código de máquina x86-64, 14 bytes

Se puede llamar desde C (convención de llamadas SysV x86-64) con este prototipo:

void casexchg(char *rdi, char *rsi);  // modify both strings in place

Una versión de longitud explícita con longitud rcxes del mismo tamaño. void casexchg(char *rdi, char *rsi, int dummy, size_t len);

Utiliza el mismo algoritmo de intercambio de bits que las respuestas de C y Java: si ambas letras son el mismo caso, ninguna necesita cambiar. Si son el caso opuesto, ambos deben cambiar.

Use XOR para diferenciar el bit de mayúsculas y minúsculas de las dos cadenas. mask = (a XOR b) AND 0x20es 0 para igual o 0x20 para diferente. a ^= mask; b ^= maskcaseflip ambas letras si fueran mayúsculas y minúsculas. (Debido a que los códigos de letras ASCII para superior e inferior difieren solo en el bit 5).

Listado NASM (desde nasm -felf64 -l/dev/stdout). Use cut -b 26- <casexchg.lst >casexchg.lstpara volver a convertir esto en algo que pueda armar.

   addr    machine
 6         code          global casexchg
 7         bytes         casexchg:
 8                       .loop:
 9 00000000 AC               lodsb                ; al=[rsi] ; rsi++
10 00000001 3207             xor   al, [rdi]
11 00000003 2420             and   al, 0x20       ; 0 if their cases were the same: no flipping needed
12                       
13 00000005 3007             xor   [rdi], al      ; caseflip both iff their cases were opposite
14 00000007 3046FF           xor   [rsi-1], al
15                       
16 0000000A AE               scasb                ; cmp al,[rdi] / inc rdi
17                           ; AL=0 or 0x20.
18                           ; At the terminating 0 in both strings, AL will be 0 so JNE will fall through.
19                           ; 0x20 is ASCII space, which isn't allowed, so AL=0x20 won't cause early exit
20 0000000B 75F3             jne  .loop
21                       ;    loop  .loop            ; caller passes explict length in RCX
22                       
23 0000000D C3               ret

  size = 0xe bytes = 14
24 0000000E 0E           db $ - casexchg_bitdiff

La loopinstrucción lenta también es de 2 bytes, igual que un corto jcc. scasbsigue siendo la mejor manera de aumentar rdicon una instrucción de un byte. Supongo que podríamos xor al, [rdi]/ stosb. Sería del mismo tamaño pero probablemente más rápido para elloop caso (la memoria src + store es más barata que la memoria dst + reload). ¡Y todavía establecería ZF apropiadamente para el caso de longitud implícita!

Pruébalo en línea! con un _start que lo llama en argv [1], argv [2] y usa sys_write en el resultado

k , 14 bytes

{`c$l+|x-l:_x}

Pruébalo en línea! Entrada / salida es una lista de dos cadenas.

Python 3 , 83 bytes

lambda a,b:(g(a,b),g(b,a))
g=lambda*a:[chr(ord(x)&95|(y>'Z')<<5)for x,y in zip(*a)]

Pruébalo en línea!

-3 bytes gracias a Mr. Xcoder
-3 bytes gracias a Chas Brown

Haskell , 78 bytes

c!d=([c..'z']++[';'..])!!sum[32|(c>'Z')/=(d>'Z')]
(#)=zipWith(!)
s%t=(s#t,t#s)

Pruébalo en línea!

QBasic, 133 bytes

INPUT a$,b$
FOR i=1TO LEN(a$)
c=ASC(MID$(a$,i,1))
d=ASC(MID$(b$,i,1))
s=32AND(c XOR d)
?CHR$(c XOR s);
r$=r$+CHR$(d XOR s)
NEXT
?
?r$

Toma las dos cadenas separadas por comas y genera los resultados separados por nueva línea. Utiliza el algoritmo de violín de la respuesta de Dennis's Jelly . Aparte de eso, el truco principal del golf aquí es que la primera cadena de resultados se imprime directamente, un carácter a la vez, que es un poco más corto que guardar ambas cadenas de resultados en variables e imprimirlas fuera del bucle.

JavaScript, 77 74 73 bytes

W=>W.map((w,x)=>w.map((c,i)=>W[+!x][i][`to${c>{}?'Low':'Upp'}erCase`]()))

f=
W=>W.map((w,x)=>w.map((c,i)=>W[+!x][i][`to${c>{}?'Low':'Upp'}erCase`]()))

console.log(
    f([[...'CodeGolf'],[...'xxPPCGxx']])
)

Toma una matriz de matrices de caracteres, emite una matriz de matrices de caracteres.

_{-1 byte ( @Arnauld ): c>'Z'→c>{}}

Retina , 75 bytes

^
¶
+`¶(([A-Z])|(.))(.*)¶(([A-Z])|(.))
$#6*$u$1$#7*$l$1¶$4$#2*$u$5$#3*$l$5¶

Pruébalo en línea! Explicación: las nuevas líneas se utilizan como marcadores para determinar la cantidad de cadena que se ha procesado. La expresión regular intenta hacer coincidir las letras mayúsculas o en su defecto cualquier carácter. Si una letra mayúscula coincide, entonces el otro carácter está en mayúscula; de lo contrario, está en minúscula y viceversa, mientras que las líneas nuevas avanzan al siguiente carácter.

Python 3 , 76 75 bytes

lambda a,b:''.join(chr(ord(x)&95|ord(y)&32)for x,y in zip(a+' '+b,b+'a'+a))

Pruébalo en línea!

Emite el resultado como una cadena con un separador de un solo carácter.

Gracias a Jonathon Allan por 1 byte.

Ensamblaje (nasm, x64, Linux) , 25 bytes (fuente de 123 bytes)

Bytes hexadecimales:

0x88, 0xE6, 0x30, 0xC6, 0x80, 0xE6, 0x20, 0x88
0xF2, 0x66, 0x31, 0xD0, 0x88, 0x26, 0xAA, 0xAC
0x8A, 0x26, 0x8A, 0x07, 0x08, 0xE4, 0x75, 0xE8, 0xC3

El punto de entrada de la función está en a, con las cadenas pasadas en el uso RDIy RSI.

b:MOV DH,AH
XOR DH,AL
AND DH,32
MOV DL,DH
XOR AX,DX
MOV [RSI],AH
STOSB
LODSB
a:MOV AH,[RSI]
MOV AL,[RDI]
OR AH,AH
JNZ b
RET

Pruébalo en línea!

Jalea , 13 bytes

=Œu=/ị"Ɱż"Œs$

Pruébalo en línea!

También 13: =ŒuṚ×32ạŒlO$Ọ(o =ŒuṚæ«5ạŒlO$Ọ)

Carbón , 17 bytes

Ｅθ⭆ι⎇№α§§θ¬κμ↥λ↧λ

Pruébalo en línea! El enlace es a la versión detallada del código. Toma la entrada como una matriz de dos cadenas. Explicación:

 θ                  Input array
Ｅ                   Map over strings
   ι                Current string
  ⭆                 Map over characters
         θ          Input array
           κ        Outer loop index
          ¬         Logical Not
        §           Index into array
            μ       Inner loop index
       §            Index into array
      α             Uppercase characters
     №              Count number of matches
              λ λ   Current character
             ↥      Uppercase
               ↧    Lowercase
    ⎇               Ternary
                    Implicitly print

F #, 120 bytes

Tío.

open System
let g=Seq.fold2(fun a x y->a+string(x|>if y>'Z'then Char.ToLower else Char.ToUpper))""
let b f s=g f s,g s f

Pruébalo en línea!

La función gtoma las dos cadenas como parámetros. Seq.fold2aplica una función con un acumulador ( a) a cada elemento ( xy y) en las cadenas. Inicialmente aes una cadena vacía, y le agrega el carácter convertido en cada iteración.

bEs la función principal. Primero se convierte fcon respecto a s, y luego se convierte scon respecto a f. Luego devuelve una tupla con ambos valores.

Prólogo (SWI) , 121 bytes

[H|T]-[I|U]-[J|V]-[K|W]:-((H>96,I>96;H<92,I<92),J=H,K=I;H>96,J is H-32,K is I+32;J is H+32,K is I-32),T-U-V-W.
_-_-[]-[].

Pruébalo en línea!

Ruby , 74 69 bytes

->a,b{a.zip(b).map{|x|x.one?{|y|y>?_}?x.map(&:swapcase):x}.transpose}

Pruébalo en línea!

La entrada y la salida son matrices de caracteres, por lo que el pie de página realiza transformaciones de cadenas.

Todavía no estoy seguro de si este es un buen enfoque del problema, pero este desafío definitivamente parece un buen escenario de uso para el swapcasemétodo.

PHP 4.1.2 , 40 bytes

Reemplace el par de comillas con el byte A0 (en ISO-8859-1 o Windows-1252, esto es NBSP) para obtener el recuento de bytes que se muestra, luego ejecute desde un navegador web (o desde la línea de comando), proporcionando las cadenas como los argumentos de cadena de consulta (o variables de entorno) ay b.

<?=$a^$c=($a^$b)&str_pad("",2e5),_,$b^$c;

En esta versión de PHP, register_globals está activado de forma predeterminada, por lo que las cadenas se asignarán automáticamente a las variables $ay $b. Aumente el valor 2e5(200000) si es necesario.

PHP 7.1+, 58 bytes

Ejecutar en la línea de comando, usando php -r 'code here' string1 string2 :

[,$a,$b]=$argv;echo("$b $a"^$a.=" $b")&str_pad("",3e5)^$a;

El valor 3e5 (300000) se elige para exceder (MAX_ARG_STRLEN * 2 + 1) en la mayoría de los sistemas Linux (específicamente, x86 y otras arquitecturas para las cuales PAGE_SIZE es 4096, y MAX_ARG_STRLEN es 131072), para evitar problemas con cualquier posible cadena de entrada. Aumentar si es necesario.

Pruébalo en línea!

Stax , 10 bytes

▌Ö↑o╓→ì]yç

Ejecutar y depurarlo

Aquí hay una representación no reflejada del mismo programa para mostrar cómo funciona.

        Example
        ["Ab", "cd"]                    
:)      [["Ab", "cd"], ["cd", "Ab"]]    Get all rotations of input
m       ["cd", "Ab"]                    For each, run the rest of program; print result
  M     ["cA", "db"]                    Transpose matrix
  {     "cA"                            Begin block for mapping to result
    B   "A" 99                          "Pop" first element from string array; leave the rest
    96> "A" 1                           Is the character code > 96?
    :c  "a"                             Set case of string; 0 -> upper,  1 -> lower
  m     "ab"                            Perform the map using the block

Ejecute este

Cristal , 108 bytes

def f(a,b)r=s=""
a.zip(b){|x,y|r+="`"<x<"{"?y.downcase: y.upcase
s+="`"<y<"{"?x.downcase: x.upcase}
{s,r}end

Pruébalo en línea!

¿Cómo funciona?

def f(a, b)                       # Strings as list of characters
r = s = ""                        # Strings buffers initialization
a.zip(b) do |x, y|                # Join two arrays to paired tuples and iterate
r+="`"<x<"{"?y.downcase: y.upcase # Check if character is downcase using triple
s+="`"<y<"{"?x.downcase: x.upcase # comparison and ascii table. Then apply it to
end                               # the other character using String methods
{s, r}                            # Return two new strings using a tuple
end                               # PS: Tuples are inmutable structures in Crystal