your shift key is broken. wheNever you type two lines, the cApitaL
LetteRs in them get swappeD. you must write a program to fiX THIS!

Descripción

La entrada es de dos cadenas s1y tiene la s2misma longitud. Cada uno contendrá solo ASCII imprimible y tendrá al menos un carácter de longitud. Puede ingresarlos como dos cadenas, una matriz de dos cadenas o una sola cadena con s1ys2 separada por una pestaña o una nueva línea.

El resultado es el siguiente:

• Para cada personaje cen s1:

  • Si el carácter no es una letra, déjela sin cambios.

  • De lo contrario, si ces una carta:

    • Encuentra el carácter coincidente (el que está en el mismo índice) en s2.

      • Si es una letra mayúscula, la salida se ccapitaliza.

      • Si es una letra minúscula, salida cen minúscula.

      • De lo contrario, salida csin cambios.

• Luego haga lo mismo, excepto con s1y s2cambiado.

Esencialmente, todas las letras en las s1que el carácter coincidente s2es mayúscula, y todas las letras s1con una letra minúscula en el mismo índice s2deben ser minúsculas (y viceversa).

Casos de prueba

Entrada:

ABCDEfghijKlMnOpqrstuvwxyz
aaaaaaaaaaaaaaaa----------

Salida:

abcdefghijklmnopqrstuvwxyz
AAAAAaaaaaAaAaAa----------

Entrada:

PRogrammiNG puzZLes & CODe golf
SdlkhkfaladlKsdlalksdg7ldklDgsl

Salida:

Programming Puzzles & Code Golf
SDlkhkfalADlksdLAlksdg7LDkldgsl

Entrada:

AAAbbb111
Cc2Dd3Ee4

Salida:

AaABbb111
CC2dd3Ee4

Pyth, 19 18 bytes

LCmrW&@dG@drG1d2Cb

Esto define una función y que acepta y devuelve una lista de cadenas.

Verifique todos los casos de prueba a la vez en Pyth Compiler / Executor .

Gracias a @Jakube por jugar golf en 1 byte.

Cómo funciona

                   " (implicit) Initialize G to 'abcdefghijklmnopqrstuvwxyz'.

L                  " Define y(b):
                Cb "   Zip to turn the two strings into an array of char pairs.
  m                "   Map (implicit variable d):
      @dG          "     Intersect d with G.
         @drG1     "     Intersect d with G.upper().
    W&             "     If both are non-empty:
   r          d2   "       Apply swapcase() to d.
 C                 "   Zip to turn the character pairs back into two strings.

CJam, 25 bytes

{z{_el_eu&\__:^32&f^?}%z}

Esta es una función anónima que muestra una serie de cadenas de la pila y deja una a cambio.

En los navegadores compatibles, puede verificar todos los casos de prueba a la vez en el intérprete de CJam .

Casos de prueba

Código

qN/2/                     e# Read input and split into arrays of two strings.

{z{_el_eu&\__:^32&f^?}%z}

%                         e# Map the block over all string arrays.
:+N*                      e# Separate the strings by linefeeds.

Entrada

ABCDEfghijKlMnOpqrstuvwxyz
aaaaaaaaaaaaaaaa----------
PRogrammiNG puzZLes & CODe golf
SdlkhkfaladlKsdlalksdg7ldklDgsl
AAAbbb111
Cc2Dd3Ee4

Salida

abcdefghijklmnopqrstuvwxyz
AAAAAaaaaaAaAaAa----------
Programming Puzzles & Code Golf
SDlkhkfalADlksdLAlksdg7LDkldgsl
AaABbb111
CC2dd3Ee4

Cómo funciona

z                       e# Zip to transform the array of strings into an array
                        e# of character pairs.
 {                  }%  e# For each character pair:
  _el                   e#   Push a copy and convert to lowercase.
     _eu                e#   Push a copy and convert to uppercase.
        &               e#   Intersect. The result will be an empty string if
                        e#   and only if both characters are letters.
         \              e#   Swap the character pair on top of the stack.
          __            e#   Push two copies.
            :^          e#   XOR both characters.
              32&       e#   Logical AND with 32. This pushes 32 for letters of
                        e#   different cases and 0 for letters of the same case.
                 f^     e#   XOR each character with the result.
                   ?    e#   Select the original copy for non-empty intersection
                        e#   and the modified one otherwise.
                      z e# Zip to turn the characters pairs back into two strings.

C, 126 bytes

Este es mi primer intento en un código de golf, nunca. Avísame si hice algo mal.

Estoy usando operaciones bit a bit para realizar el cambio

Golfizado:

main(u,a,s,t)char**a,*s,*t;{for(s=a[1],t=a[2];*t;s++,t++)isalpha(*s)*isalpha(*t)?u=(*t^*s)&32,*t^=u,*s^=u:0;*s=10;puts(a[1]);}

Sin golf:

main(u,a,s,t) char**a,*s,*t; {       // K&R style arguments
    for(s=a[1],t=a[2];*t;s++,t++)    // initialize loop.
        isalpha(*s) * isalpha(*t) ? // ensure both characters are letters (if)
            u = (*t^*s) & 0x20,      // check if characters have swapped case
            *t^=u,                   // if so, xor the bit which represents case
            *s^=u                    // for both characters in the string.
        :0;                          // end ternary statement (endif)
    *s=10;                           // replace null terminator in first string 
    puts(a[1]);                      // with newline. This allows both output to 
}                                    // be printed out all at once

editar: reemplazado && con *

SQL (PostGreSQL), 427 bytes

A pesar de su gran tamaño, esto terminó siendo un poco más pequeño de lo que esperaba. No estaba muy seguro de poder hacerlo honestamente. Sospecho que todavía hay mucho por hacer :)

CREATE FUNCTION F(TEXT,TEXT)RETURNS TABLE(S TEXT) AS'SELECT unnest(array[string_agg(CASE WHEN T~''[A-Z]''THEN upper(S)WHEN T~''[a-z]''THEN lower(S)ELSE S END,''''),string_agg(CASE WHEN S~''[A-Z]''THEN upper(T)WHEN S~''[a-z]''THEN lower(T)ELSE T END,'''')])FROM(SELECT ROW_NUMBER()OVER()N,S FROM regexp_split_to_table($1,'''')X(S))A JOIN(SELECT ROW_NUMBER()OVER()M,T FROM regexp_split_to_table($2,'''')Y(T))B ON N=M'LANGUAGE SQL

Formateado y comentado

-- Declare the function spec
CREATE FUNCTION F(TEXT,TEXT)RETURNS TABLE(S TEXT) AS  
'SELECT unnest(   -- turns array into a table
    array[        -- build array of the column results
    string_agg( -- Aggregate the result into a string
        CASE 
        WHEN T~''[A-Z]''THEN upper(S) -- uppercase it if corresponding char is uppercase
        WHEN T~''[a-z]''THEN lower(S) -- lowercase it if corresponding char is lowercase
        ELSE S END
        ,''''),
    string_agg( -- Same as the previous but swap strings
        CASE 
        WHEN S~''[A-Z]''THEN upper(T)
        WHEN S~''[a-z]''THEN lower(T)
        ELSE T END
        ,'''')
    ])
FROM
    -- split the first string
   (SELECT ROW_NUMBER()OVER()N,S FROM regexp_split_to_table($1,'''')X(S))A
    JOIN
    -- split the second string
   (SELECT ROW_NUMBER()OVER()M,T FROM regexp_split_to_table($2,'''')Y(T))B 
   ON N=M
'
LANGUAGE SQL

Prueba de funcionamiento

SELECT F(A,B) AS Result
FROM (VALUES 
    ('AAAbbb111', 'Cc2Dd3Ee4'), 
    ('ABCDEfghijKlMnOpqrstuvwxyz', 'aaaaaaaaaaaaaaaa----------'), 
    ('PRogrammiNG puzZLes & CODe golf', 'SdlkhkfaladlKsdlalksdg7ldklDgsl')
    )A(A,B)

Result
-----------------------------
AaABbb111
CC2dd3Ee4
abcdefghijklmnopqrstuvwxyz
AAAAAaaaaaAaAaAa----------
Programming Puzzles & Code Golf
SDlkhkfalADlksdLAlksdg7LDkldgsl

Julia, 140 bytes

f(s,t)=(C(x,y)=(i=0;z="";for c=x i+=1;z*=string(isalpha(c)?isupper(y[i])?uppercase(c):islower(t[i])?lowercase(c):c:c)end;z);(C(s,t),C(t,s)))

Esto crea una función que acepta dos cadenas y devuelve una tupla de cadenas. Nada particularmente inteligente está sucediendo aquí; simplemente definimos una función interna que implementa directamente el algoritmo en la especificación y lo llamamos dos veces.

Sin golf:

function f(s, t)
    C(x, y) = begin
        i = 0
        z = ""
        for c in x
            i += 1
            if isalpha(c)
                if isupper(y[i])
                    z *= string(uppercase(c))
                elseif islower(y[i])
                    z *= string(lowercase(c))
                else
                    z *= string(c)
                end
            else
                z *= string(c)
            end
        end
        return z
    end

    return (C(s, t), C(t, s))
end

JavaScript ES6, 128 108 bytes

s=(a,b,t)=>[...a].map((l,i)=>/[^a-z]/.exec(b[i])?l.toUpperCase():l.toLowerCase()).join``+(t?'':`
`+s(b,a,1))

JavaScript toUpperCase()y toLowerCase()ocupa muchos bytes pero String.fromCharCode()es aún más largo

Mathematica, 173 169 155 bytes

f=0>1;t=!f;c=Characters;u=ToUpperCase;StringJoin/@MapThread[#@#2&,{Reverse[{LetterQ@#,#==(u@#)}&/@c@#/.{{f,_}->(#&),{t,t}->u,{t,f}->ToLowerCase}&/@#],c/@#},2]&

Esta es una función que toma una matriz de dos cadenas, por ejemplo, {"Foo","bAR"}y genera una matriz de dos cadenas. Sin comprimir espacialmente, reescribiendo el esquema f@xcomo f[x]donde aparezca, expandiendo las abreviaturas de notación ( f=0>1aka False, t=!faka True,c=Characters y u=ToUpperCaseQ), y poco reemplazando UpperCaseQ [#] con #==u@#(este personaje es igual a su versión uppercased), que es:

StringJoin /@ MapThread[#[#2] &, {
    Reverse[
        { LetterQ[#], UpperCaseQ[#] } & /@ Characters[#] /. 
        { {False, _} -> (# &), {True, True} -> ToUpperCase, 
          {True, False} -> ToLowerCase } & /@ #
    ],
    Characters /@ #
}, 2] &

Interfaz: el final & hace de esto una función. Su argumento se inserta como el "#" en ambas instancias de /@ #. Por ejemplo, f=0>1; ... & [{"AAAbbb111", "Cc2Dd3Ee4"}]produce la salida {AaABbb111,CC2dd3Ee4}.

Procesamiento: contado en el exterior habitual en orden:

• La salida de MapThread[...]es una lista de dos listas de caracteres. StringJoin se aplica a cada una de estas dos listas de caracteres para producir una lista de dos cadenas, la salida.
• MapThread[#[#2]&, ... , 2]actúa en una matriz de dos listas de elementos de 2 por n. La primera lista es una matriz de funciones de 2 por n. La segunda lista es una matriz de caracteres de 2 por n,Characters /@ # , las listas de caracteres en las dos cadenas de entrada. Funciona en profundidad 2, es decir, en las funciones y caracteres individuales.
• Reverse[...] intercambia las dos sublistas de funciones para que MapThread aplique las funciones de la segunda cadena a la primera cadena y viceversa.
• { ... } & es una función anónima que se aplica a cada una de las dos cadenas de entrada.
• {LetterQ[#], UpperCaseQ[#]} & /@ Characters[#]divide una cadena en una lista de caracteres, luego reemplaza cada carácter con dos listas de elementos. En estas listas de dos elementos, el primer elemento es Truesi el carácter es una letra y False, de lo contrario, el segundo elemento indica si el carácter es mayúscula. UpperCaseQ[]no puede devolver verdadero si no recibe una carta.
• /. {{False, _} -> (# &), {True, True} -> ToUpperCase, {True, False} -> ToLowerCase}reemplaza estas dos listas de elementos con funciones. (La expansión de las abreviaturas ty fse produce antes de intentar cualquier juego.) Si una lista de dos elementos tiene Falsecomo su primer elemento, es reemplazado con la función (# &), la función identidad. (Los paréntesis son necesarios, de lo contrario la flecha se une más estrechamente que el signo.) De lo contrario, los dos elementos de la lista comienza con Trueel personaje era una carta, y las funciones de salida ToUpperCasey ToLowerCasecorrespondiente a su caso. (Verificar esto último Falsees innecesario, de hecho {_,_}->ToLowerCasefuncionaría, atrapando cualquier cosa que aún no haya sido reemplazada, pero esto no sería más corto y más oscuro).

El único desafío fue encontrar una manera sucinta de comprimir una matriz de funciones bidimensional en una matriz de argumentos.

Editar: Gracias a @Martin Büttner por capturar barras diagonales de corte / pegado "útiles", abreviaturas 1>0y 1<0abreviaturas, y también por la guía para contar la longitud en bytes, no en caracteres (cualesquiera que sean :-))

Edit2: Además, gracias a @Martin Büttner por señalar que contaminar el espacio de nombres global es un juego de golf aceptable, recordándome la aplicación de una función de personaje y sugiriendo reemplazar las dos funciones en mayúscula por una abreviatura para una y usar la una para emular la otra (guardar cuatro caracteres) (Creo que ya ha hecho esto antes :-))

Python 3, 131 bytes

def j(s,g):p=lambda s,g:''.join(i.upper()if j.istitle()else i.lower()if j.islower()else i for i,j in zip(s,g));return p(s,g),p(g,s)

La función devuelve cadenas en una tupla

Erlang, 157 bytes

f(A,B)->S=string,G=fun(A,B)->[if Q>64andalso Q<91->S:to_upper(P);Q>96andalso Q<123->S:to_lower(P);true->P end||{P,Q}<-lists:zip(A,B)]end,G(A,B)++"\n"++G(B,A).

Comprime las dos cadenas (en realidad, las listas) en una lista de tuplas de dos caracteres y asigna cada carácter al caso apropiado utilizando una comprensión de la lista.

Python 2, 101 bytes

lambda*I:["".join([a.upper(),a.lower(),a][~-b.isalpha()or"Z"<b]for a,b in zip(*X))for X in I,I[::-1]]

Una función anónima que toma dos cadenas y devuelve las cadenas de salida en una lista. He marcado esto como Python 2 porque Python 3 no permite I,I[::-1]sentarse solo al final así.

Python, 126 bytes

t="".join;s="low","upp";y=lambda a,b:eval("a"+".%ser()"%s[b.isupper()]*b.isalpha());f=lambda a,b:(t(map(y,a,b)),t(map(y,b,a)))

La función fdevuelve cadenas en una tupla

C, 181 bytes

char*x,*y;main(int a,char**_){a?x=_[2],y=_[1],main(0,0),putchar(10),x=_[1],y=_[2],main(0,0):(*x?putchar(!isupper(*x)?!islower(*x)?*y:tolower(*y):toupper(*y)),x++,y++,main(0,0):0);}

Tuve problemas para acortar los nombres de las bibliotecas estándar de una manera que valió la pena (# definirlos requiere 11 caracteres de sobrecarga). Utiliza la recursividad principal y las variables globales x e y como argumentos.

main (<non-zero>, argv) = call main (0, {argv [1], argv [2]}) luego imprime nueva línea y luego llama a main (0, {argv [2], argv [1]})

main (0, {x, y}) = si x es el final de la cadena, devuelve 0, de lo contrario, imprime el caso correcto del primer carácter de x y llama a main (0, {x + 1, y + 1}).

Ejecutar con las dos cadenas como argumentos.

C - 164153 Bytes - GCC

#define r z[_][w]
main(_,z,w)char**z;{while(--_)for(w=0;r;r+=r<25?97:r<91&&r>64?z[!(_-1)+1][w]-=32,_-1?z[_-1][w]-=97:0,32:0,w++);puts(z[1]),puts(z[2]);}

gcc prog.c

./a.out AfdgF a2dfsd

Se actualizará si puedo obtener wc -c abajo. Funciona muy bien en realidad

F #, 211 caracteres

let n x y=List.fold2(fun a i j->a@match j with|c when c>='A'&&c<='Z'->[Char.ToUpper i]|c when c>='a'&&c<='z'->[Char.ToLower i]|_->[i])[](x|>Seq.toList)(y|>Seq.toList)|>String.Concat
let m a b =n a b+"\n"+n b a

podría ser mejor ...

Matlab, 140

function [s,t]=f(s,t)
c=s>96&s<123;C=s>64&s<91;d=t>96&t<123;D=t>64&t<91;s(c&D)=s(c&D)-32;s(C&d)=s(C&d)+32;t(d&C)=t(d&C)-32;t(D&c)=t(D&c)+32;

Sin golf:

function [s,t] = f(s,t)
c = s>96 & s<123;         % letters that are lowercase in 1st string
C = s>64 & s<91;          % letters that are uppercase in 1st string
d = t>96 & t<123;         % letters that are lowercase in 2nd string
D = t>64 & t<91;          % letters that are uppercase in 2nd string
s(c&D) = s(c&D) - 32;     % make uppercase in 1st string
s(C&d) = s(C&d) + 32;     % make lowercase in 1st string
t(d&C) = t(d&C) - 32;     % make uppercase in 2nd string
t(D&c) = t(D&c) + 32;     % make lowercase in 2nd string

Ejemplo:

>> [s,t]=f('PRogrammiNG puzZLes & CODe golf','SdlkhkfaladlKsdlalksdg7ldklDgsl')
s =
Programming Puzzles & Code Golf
t =
SDlkhkfalADlksdLAlksdg7LDkldgsl

C, 164 bytes

Prácticamente implementando el algoritmo como se describe en el problema. Toma 2 cadenas como parámetros de entrada.

char*a,*b;main(c,v)char**v;{for(a=v[1],b=v[2];*a&&*b;++a,++b)isupper(*a)&&islower(*b)?*a+=32,*b-=32:isupper(*b)&&islower(*a)?*b+=32,*a-=32:0;puts(v[1]);puts(v[2]);}

Sin golf:

char *a, *b; /* Helpers */

main(c, v)
char **v;
{
    /* While strings not terminated... */
    for (a = v[1], b = v[2]; *a && *b; ++a, ++b)
        isupper(*a) && islower(*b)
            ? *a += 32, *b -= 32 /* Make first string lowercase, second uppercase */
            : isupper(*b) && islower(*a)
                ? *b += 32, *a -= 32; /* Make second string lowercase, first uppercase */

    puts(v[1]); /* print out first string */
    puts(v[2]); /* print out second string */
}

Ruby, 102

$><<gets.chars.zip(gets.chars).map{|i|/[a-z][A-Z]|[A-Z][a-z]/=~i*''?(i.map &:swapcase):i}.transpose*''

Toma las cadenas originales, empareja las letras en matrices. Si son más bajos / cap o cap / más bajos, intercambie ambos. Luego transponga las matrices nuevamente a nuestra matriz ordenada.

Esto requiere una nueva línea final en la entrada.

Perl 5.10+, 101 99 bytes

perl -p00e '/\n/;s/([a-z])(?=.{$-[0]}([a-z]))/$x=($1^$2)&" ";$s{$-[2]}=$2^$x;$1^$x/egis;s|.|$s{$-[0]}//$&|eg'

96 bytes + 3 bytes para las banderas de línea de comando p00. Toma una sola cadena delimitada por nueva línea como entrada:

$ echo -e "AAAbbb111\nCc2Dd3Ee4" | perl -p00e '...'

O puede ingresar la entrada en STDIN:

$ perl -p00e '...'
AAAbbb111 <Enter>
Cc2Dd3Ee4 <Ctrl+D>

Desglosado:

perl -p00e'  # Slurp everything into $_, print $_ automatically at the end
    /\n/;    # Match first newline, setting $-[0] to length(s1)

    s/
        ([a-z])  # Match a single letter in s1
        (?=
            .{$-[0]}  # Match n chars where n is length(s1) (until corresponding char in s2)
            ([a-z])   # Corresponding letter in s2
        )
    /
        $x=($1^$2)&" ";   # Check whether bit 6 is the same for both chars.
                          # (Only difference between a lowercase and uppercase ASCII letter
                          # is bit 6; ASCII space is 100000 in binary)

        $s{$-[2]}=$2^$x;  # Swap case of corresponding char in s2 and store in %s,
                          # with position as the key

        $1^$x             # Swap case of current char
    /egis;

    s|.|$s{$-[0]}//$&|eg  # Do a second pass through $_. If there's a value stored in %s
                          # corresponding to this position, use it
'

Primer intento en scala, 138 caracteres

def f(s:String,t:String)={val g=(a:Char,o:Char)=>if(o.isUpper)a.toUpper else a.toLower;s.zip(t).map(c=>(g.tupled(c),g(c._2, c._1))).unzip}

f es una función que toma las dos cadenas de entrada y hace el trabajo, con una función local, utilizada dos veces, para cambiar el caso de las cadenas.

El mismo código, con sangría y solo un poco más de nombres legibles:

def f_ungolfed(first : String, second : String) = {
  val aux = (c1: Char, c2: Char) => if (c2.isUpper) c1.toUpper else c1.toLower
    first.zip(second).map(
         c => (aux.tupled(c), aux.tupled(c.swap))
    ).unzip
} 

Jalea , 13 bytes

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

Un enlace monádico que acepta y devuelve listas de dos "cadenas" (listas de caracteres en Jelly).

Pruébalo en línea!

Python 2 , 97 bytes

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

Pruébalo en línea!

Tcl , 194 bytes

proc C a\ b {proc L x\ y {expr [[set S string] is u $y]?"[$S tou $x]":"[$S is lo $y]"?"[$S tol $x]":"$x"}
lmap x [split $a ""] y [split $b ""] {append s [L $x $y]
append t [L $y $x]}
list $s $t}

Pruébalo en línea!

Haskell , 109 91 bytes

import Data.Char
(!)=zipWith f
f c|isUpper c=toUpper|isAlpha c=toLower|1<3=id
a#b=[b!a,a!b]

¡Gracias a @Laikoni por 16 bytes!

Pruébalo en línea!