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!

La description

L'entrée est de deux chaînes s1et s2de longueur égale. Ils contiendront chacun uniquement des caractères ASCII imprimables et compteront au moins un caractère. Vous pouvez les saisir sous la forme de deux chaînes, d'un tableau de deux chaînes ou d'une seule chaîne avec s1et s2séparées par un onglet ou une nouvelle ligne.

La sortie est la suivante:

• Pour chaque personnage cdans s1:

  • Si le caractère n'est pas une lettre, sortez-le inchangé.

  • Sinon, si cc'est une lettre:

    • Recherchez le caractère correspondant (celui du même index) dans s2.

      • S'il s'agit d'une lettre majuscule, la sortie est en cmajuscule.

      • S'il s'agit d'une lettre minuscule, sortez cen minuscule.

      • Sinon, sortie cinchangée.

• Faites ensuite la même chose, sauf avec s1et s2commuté.

Essentiellement, toutes les lettres dans s1lesquelles le caractère correspondant en s2majuscule doit être en majuscule et toutes les lettres s1avec une lettre minuscule au même index dans s2doivent devenir minuscules (et vice versa).

Cas de test

Contribution:

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

Sortie:

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

Contribution:

PRogrammiNG puzZLes & CODe golf
SdlkhkfaladlKsdlalksdg7ldklDgsl

Sortie:

Programming Puzzles & Code Golf
SDlkhkfalADlksdLAlksdg7LDkldgsl

Contribution:

AAAbbb111
Cc2Dd3Ee4

Sortie:

AaABbb111
CC2dd3Ee4

Pyth, 19 18 octets

LCmrW&@dG@drG1d2Cb

Ceci définit une fonction y qui accepte et retourne une liste de chaînes.

Vérifiez tous les cas de test à la fois dans le compilateur / exécuteur Pyth .

Merci à @Jakube d'avoir joué au golf sur 1 octet.

Comment ça marche

                   " (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 octets

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

Il s'agit d'une fonction anonyme qui extrait un tableau de chaînes de la pile et en laisse une en retour.

Dans les navigateurs pris en charge, vous pouvez vérifier tous les cas de test à la fois dans l' interpréteur CJam .

Cas de test

Code

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.

Contribution

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

Sortie

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

Comment ça marche

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 octets

C'est ma première tentative de golf de code, jamais. Faites-moi savoir si j'ai fait quelque chose de mal.

J'utilise des opérations au niveau du bit pour effectuer la commutation

Golfé:

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

Non 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

modifier: && remplacé par *

SQL (PostGreSQL), 427 octets

Malgré sa taille énorme, cela a fini par être un peu plus petit que ce à quoi je m'attendais. Je n'étais pas sûr que j'allais pouvoir le faire pour être honnête. Je soupçonne qu'il y a encore beaucoup à faire :)

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

Formaté et commenté

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

Essai

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 octets

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

Cela crée une fonction qui accepte deux chaînes et renvoie un tuple de chaînes. Rien de particulièrement intelligent ne se passe ici; nous définissons simplement une fonction interne qui implémente directement l'algorithme dans la spécification et l'appelons deux fois.

Non 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 octets

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()et toLowerCase()prend beaucoup d'octets mais String.fromCharCode()est encore plus long

Mathematica, 173 169 155 155 octets

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]&

Il s'agit d'une fonction prenant un tableau de deux chaînes, par exemple {"Foo","bAR"}et produisant un tableau de deux chaînes. En le compressant spatialement, en réécrivant le schéma f@xcomme f[x]partout où il apparaît, en développant les abréviations de notation ( f=0>1aka False, t=!faka Trueet c=Characters, u=ToUpperCaseQ) et en ne remplaçant pas UpperCaseQ [#] par #==u@#(ce caractère équivaut à sa version majuscule), c'est:

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

Interfaçage: la fin en &fait une fonction. Son argument est inséré comme le "#" dans les deux instances de /@ #. Par exemple, f=0>1; ... & [{"AAAbbb111", "Cc2Dd3Ee4"}]produit la sortie {AaABbb111,CC2dd3Ee4}.

Traitement: Raconté à l'extérieur habituel dans l'ordre:

• La sortie du MapThread[...]est une liste de deux listes de caractères. StringJoin est appliqué à chacune de ces deux listes de caractères pour produire une liste de deux chaînes, la sortie.
• MapThread[#[#2]&, ... , 2]agit sur un tableau de deux listes d'éléments 2 par n. La première liste est un tableau de fonctions 2 par n. La deuxième liste est un tableau de caractères 2 par n Characters /@ #, les listes de caractères dans les deux chaînes d'entrée. Il travaille en profondeur 2, c'est-à-dire sur les fonctions et les caractères individuels.
• Reverse[...] échange les deux sous-listes de fonctions afin que MapThread applique les fonctions de la deuxième chaîne à la première chaîne et vice versa.
• { ... } & est une fonction anonyme qui est appliquée à chacune des deux chaînes d'entrée.
• {LetterQ[#], UpperCaseQ[#]} & /@ Characters[#]divise une chaîne en une liste de caractères, puis remplace chaque caractère par deux listes d'éléments. Dans ces deux listes d'éléments, le premier élément est Truesi le caractère est une lettre et Falsesinon, de même, le deuxième élément indique si le caractère est en majuscule. UpperCaseQ[]ne peut pas retourner vrai s'il ne reçoit pas de lettre.
• /. {{False, _} -> (# &), {True, True} -> ToUpperCase, {True, False} -> ToLowerCase}remplace ces deux listes d'éléments par des fonctions. (L'expansion des abréviations tet fse produit avant toute tentative de correspondance.) Si une liste à deux éléments a Falsecomme premier élément, elle est remplacée par la fonction (# &), la fonction d'identité. (Les parenthèses sont nécessaires, sinon la flèche se lie plus étroitement que l'esperluette.) Sinon, la liste des deux éléments commence par True, le caractère était une lettre, et nous sortons les fonctions ToUpperCaseet ToLowerCasecorrespondant à sa casse. (Vérifier ce dernier Falsen'est pas nécessaire, en fait {_,_}->ToLowerCasecela fonctionnerait, attraper tout ce qui n'a pas encore été remplacé, mais ce ne serait pas plus court et plus obscur.)

Le seul défi consistait à trouver un moyen succinct de compresser un tableau bidimensionnel de fonctions en un tableau d'arguments.

Edit: Merci à Büttner pour attraper @ Martin couper / coller linebreak antislashs « utile », les 1>0et 1<0abréviations, et aussi pour la direction de compter la longueur en octets pas de caractères (quels qu'ils sont :-))

Edit2: Merci encore à @Martin Büttner pour avoir souligné que la pollution de l'espace de noms global est un golf acceptable, me rappelant une application de fonction de caractère et suggérant de remplacer les deux fonctions majuscules par une abréviation pour l'une et d'utiliser l'une pour émuler l'autre (sauvegarde quatre caractères). (Je pense qu'il l'a déjà fait. :-))

Python 3, 131 octets

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 fonction renvoie des chaînes dans un tuple

Erlang, 157 octets

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

Zippe les deux chaînes (en fait, les listes) dans une liste de tuple à deux caractères et mappe chaque caractère au cas approprié à l'aide d'une compréhension de liste.

Python 2, 101 octets

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

Une fonction anonyme qui prend deux chaînes et renvoie les chaînes de sortie dans une liste. J'ai marqué cela comme Python 2 parce que Python 3 ne permet pas I,I[::-1]de rester seul à la fin comme ça.

Python, 126 octets

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 fonction frenvoie des chaînes dans un tuple

C, 181 octets

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

Nous avons eu du mal à raccourcir les noms de bibliothèque standard de manière utile (# les définir prend 11 caractères de surcharge). Utilise la récurrence principale et les variables globales x et y comme arguments.

main (<non-zero>, argv) = appeler main (0, {argv [1], argv [2]}) puis imprimer la nouvelle ligne puis appeler main (0, {argv [2], argv [1]})

main (0, {x, y}) = si x est la fin de la chaîne, retournez 0, sinon imprimez la casse correcte du premier caractère de x et appelez main (0, {x + 1, y + 1}).

Exécutez avec les deux chaînes comme arguments.

C - 164153 octets - 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

Mettra à jour si je peux obtenir wc -c en panne. Fonctionne très bien en fait

F #, 211 caractères

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

cela pourrait être mieux ...

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;

Non 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

Exemple:

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

C, 164 octets

Implémenter à peu près l'algorithme comme décrit dans le problème. Prend 2 chaînes comme paramètres d'entrée.

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

Non 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 */
}

Rubis, 102

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

Prend les chaînes originales, associe les lettres dans les tableaux. S'ils sont inférieurs / capuchon ou capuchon / inférieur, échangez les deux. Transposez ensuite les tableaux dans notre tableau ordonné.

Cela nécessite une nouvelle ligne de fin en entrée.

Perl 5.10+, 101 99 octets

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

96 octets + 3 octets pour les drapeaux de ligne de commande p00. Prend une seule chaîne délimitée par des sauts de ligne en entrée:

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

Ou vous pouvez entrer une entrée sur STDIN:

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

En panne:

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
'

Première tentative à Scala, 138 caractères

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 est une fonction qui prend les deux chaînes d'entrée et fait le travail, avec une fonction locale, utilisée deux fois, pour changer la casse des chaînes.

Le même code, avec indentation et juste quelques noms plus lisibles:

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
} 

Gelée , 13 octets

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

Un lien monadique acceptant et renvoyant des listes de deux "chaînes" (listes de personnages dans Jelly).

Essayez-le en ligne!

Python 2 , 97 octets

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

Essayez-le en ligne!

Tcl , 194 octets

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}

Essayez-le en ligne!

Haskell , 109 91 octets

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

Merci à @Laikoni pour 16 octets!

Essayez-le en ligne!