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!

Descrição

A entrada é de duas strings s1e tem o s2mesmo comprimento. Cada um deles conterá apenas ASCII imprimível e terá pelo menos um caractere. Você pode inseri-las como duas strings, uma matriz de duas strings ou uma única string com s1e s2separadas por uma guia ou nova linha.

A saída é a seguinte:

• Para cada caractere cem s1:

  • Se o caractere não for uma letra, produza-o inalterado.

  • Caso contrário, se chouver uma letra:

    • Encontre o caractere correspondente (aquele no mesmo índice) em s2.

      • Se for uma letra maiúscula, a saída será ccapitalizada.

      • Se for uma letra minúscula, imprima cem minúscula.

      • Caso contrário, a saída cnão será alterada.

• Em seguida, faça a mesma coisa, exceto com s1e s2alternado.

Essencialmente, todas as letras nas s1quais o caractere correspondente s2é maiúsculo devem ser colocadas em maiúsculas e todas as letras s1com uma letra minúscula no mesmo índice em s2devem se tornar minúsculas (e vice-versa).

Casos de teste

Entrada:

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

Saída:

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

Entrada:

PRogrammiNG puzZLes & CODe golf
SdlkhkfaladlKsdlalksdg7ldklDgsl

Saída:

Programming Puzzles & Code Golf
SDlkhkfalADlksdLAlksdg7LDkldgsl

Entrada:

AAAbbb111
Cc2Dd3Ee4

Saída:

AaABbb111
CC2dd3Ee4

Pitão, 19 18 bytes

LCmrW&@dG@drG1d2Cb

Isso define uma função y que aceita e retorna uma lista de strings.

Verifique todos os casos de teste de uma vez no Pyth Compiler / Executor .

Graças a @Jakube por jogar fora um byte.

Como 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}

Essa é uma função anônima que exibe uma matriz de seqüências de caracteres da pilha e deixa uma em troca.

Nos navegadores suportados, você pode verificar todos os casos de teste ao mesmo tempo no interpretador CJam .

Casos de teste

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

Saída

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

Como 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

Esta é a minha primeira tentativa de um código de golfe, sempre. Deixe-me saber se fiz algo errado.

Estou usando operações bit a bit para executar a alternância

Golfe:

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

Ungolfed:

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: substituído && por *

SQL (PostGreSQL), 427 bytes

Apesar do tamanho enorme, isso acabou sendo um pouco menor do que eu esperava. Eu não tinha certeza de que seria capaz de fazê-lo para ser honesto. Eu suspeito que ainda há muito a ser feito :)

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

Formatado e 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

Execução de teste

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

Isso cria uma função que aceita duas strings e retorna uma tupla de strings. Nada de inteligente está acontecendo aqui; simplesmente definimos uma função interna que implementa diretamente o algoritmo na especificação e a chamamos duas vezes.

Ungolfed:

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()e toLowerCase()ocupa muitos bytes, mas String.fromCharCode()é ainda mais longo

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 é uma função que pega uma matriz de duas strings, por exemplo, {"Foo","bAR"}e gera uma matriz de duas strings. Un-espacialmente comprimindo-la, reescrevendo o esquema f@xcomo f[x]onde quer que apareça, ampliando as abreviaturas Notation ( f=0>1aka False, t=!faka True, c=Characterse u=ToUpperCaseQ), e un-substituindo UpperCaseQ [#] com #==u@#(este personagem é igual a sua versão uppercased), é:

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

Interface: o trailing &torna isso uma função. Seu argumento é inserido como o "#" nas duas instâncias de /@ #. Por exemplo, f=0>1; ... & [{"AAAbbb111", "Cc2Dd3Ee4"}]produz a saída {AaABbb111,CC2dd3Ee4}.

Processamento: Contado normalmente fora em ordem:

• A saída de MapThread[...]é uma lista de duas listas de caracteres. StringJoin é aplicado a cada uma dessas duas listas de caracteres para produzir uma lista de duas seqüências, a saída.
• MapThread[#[#2]&, ... , 2]atua em uma matriz de duas listas de elementos 2 por n. A primeira lista é uma matriz de 2 por n de funções. A segunda lista é uma matriz de caracteres 2 por n Characters /@ #, as listas de caracteres nas duas seqüências de entrada. Funciona na profundidade 2, ou seja, nas funções e nos caracteres individuais.
• Reverse[...] troca as duas sublistas de funções para que o MapThread aplique as funções da segunda sequência à primeira e vice-versa.
• { ... } & é uma função anônima aplicada a cada uma das duas seqüências de entrada.
• {LetterQ[#], UpperCaseQ[#]} & /@ Characters[#]divide uma string em uma lista de caracteres e substitui cada caractere por duas listas de elementos. Nessas duas listas de elementos, o primeiro elemento é Truese o caractere é uma letra e False, do mesmo modo, o segundo elemento indica se o caractere está em maiúsculas. UpperCaseQ[]não pode retornar verdadeiro se não receber uma carta.
• /. {{False, _} -> (# &), {True, True} -> ToUpperCase, {True, False} -> ToLowerCase}substitui essas duas listas de elementos por funções. (A expansão das abreviações te focorre antes da tentativa de correspondência.) Se uma lista de dois elementos tiver Falsecomo primeiro elemento, ela será substituída pela função (# &), a função de identidade. (Os parênteses são necessários, caso contrário, a seta se liga mais firmemente que o e comercial.) Caso contrário, a lista de dois elementos começa com True, o caractere era uma letra e produzimos as funções ToUpperCasee ToLowerCasecorrespondentes ao seu caso. (A verificação deste último Falseé desnecessária, de fato {_,_}->ToLowerCasefuncionaria, capturando qualquer coisa que ainda não tivesse sido substituída, mas isso não seria mais curto e mais obscuro.)

O único desafio foi descobrir uma maneira sucinta de compactar uma matriz bidimensional de funções em uma matriz de argumentos.

Edit: Obrigado a @Martin Büttner por capturar barras invertidas de corte / colar "úteis", as 1>0e 1<0abreviações, e também pela orientação para contar o comprimento em bytes, não em caracteres (sejam eles :-))

Edit2: Mais agradecimentos a @Martin Büttner por apontar que poluir o espaço para nome global é um golfe aceitável, lembrando-me de um aplicativo de função de caractere e sugerindo substituir as duas funções em maiúsculas por uma abreviação de um e usar o outro para emular o outro (salvar quatro caracteres). (Eu acho que ele já fez isso 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)

A função retorna seqüências de caracteres em uma 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).

Fecha as duas seqüências de caracteres (na verdade, listas) em uma lista de tuplas de dois caracteres e mapeia cada caractere para o caso apropriado usando uma compreensão de 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]]

Uma função anônima que pega duas cadeias e retorna as cadeias de saída em uma lista. Eu marquei isso como Python 2 porque o Python 3 não permite I,I[::-1]ficar sozinho no final assim.

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

A função fretorna seqüências de caracteres em uma 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);}

Ocorreu um problema ao encurtar os nomes das bibliotecas padrão de uma maneira interessante (# defini-los exige 11 caracteres de sobrecarga). Usa recursão principal e variáveis ​​globais x e y como argumentos.

main (<zero-zero>, argv) = chama main (0, {argv [1], argv [2]}), depois imprime uma nova linha e depois chama main (0, {argv [2], argv [1]})

main (0, {x, y}) = se x é o final de string, retorne 0, caso contrário, imprima o caso correto do primeiro caractere de xe chame main (0, {x + 1, y + 1}).

Execute com as duas cadeias como argumentos.

C - 164 153 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

Será atualizado se eu conseguir baixar o wc -c. Funciona muito bem, na verdade

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

poderia ser melhor ...

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;

Ungolfed:

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

Exemplo:

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

C, 164 bytes

Praticamente implementando o algoritmo, conforme descrito no problema. Toma 2 strings 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]);}

Ungolfed:

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*''

Pega as seqüências originais, emparelha as letras em matrizes. Se eles são inferiores / máximo ou máximo / inferior, troque em ambos. Em seguida, transponha as matrizes de volta para nossa matriz ordenada.

Isso requer uma nova linha à direita na 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 os sinalizadores da linha de comando p00. Usa uma única string delimitada por nova linha como entrada:

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

Ou você pode inserir a entrada em STDIN:

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

Quebrado:

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
'

Primeira tentativa em 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 é uma função que pega as duas cadeias de entrada e executa o trabalho, com uma função local, usada duas vezes, para alterar o caso das cadeias.

O mesmo código, com recuo e apenas alguns nomes mais legíveis:

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
} 

Gelatina , 13 bytes

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

Um link monádico que aceita e retorna listas de duas "strings" (listas de caracteres no Jelly).

Experimente online!

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

Experimente online!

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}

Experimente online!

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]

Obrigado a @Laikoni por 16 bytes!

Experimente online!