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!

Описание

Вход две строки, s1и s2, равны по длине. Каждый из них будет содержать только печатный ASCII и иметь длину не менее одного символа. Вы можете ввести их как две строки, массив из двух строк, или одну строку с s1и s2разделены либо вкладки или символ новой строки.

Вывод следующий:

• Для каждого персонажа cв s1:

  • Если символ не буква, выведите его без изменений.

  • В противном случае, если cэто письмо:

    • Найдите соответствующий символ (тот же индекс) в s2.

      • Если это заглавная буква, то вывод cзаглавными.

      • Если это строчная буква, выведите cстрочную.

      • В противном случае вывод cбез изменений.

• Затем сделайте то же самое, за исключением s1и s2переключился.

По сути, все буквы, s1для которых совпадающий символ в s2является заглавной, должны быть заглавными, а все буквы s1с строчной буквой в том же индексе s2должны быть строчными (и наоборот).

Контрольные примеры

Входные данные:

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

Выход:

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

Входные данные:

PRogrammiNG puzZLes & CODe golf
SdlkhkfaladlKsdlalksdg7ldklDgsl

Выход:

Programming Puzzles & Code Golf
SDlkhkfalADlksdLAlksdg7LDkldgsl

Входные данные:

AAAbbb111
Cc2Dd3Ee4

Выход:

AaABbb111
CC2dd3Ee4

Pyth, 19 18 байт

LCmrW&@dG@drG1d2Cb

Это определяет функцию y, которая принимает и возвращает список строк.

Проверьте все тестовые случаи одновременно в Pyth Compiler / Executor .

Спасибо @Jakube за отыгрывание 1 байта.

Как это работает

                   " (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 байтов

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

Это анонимная функция, которая извлекает массив строк из стека и оставляет одну взамен.

В поддерживаемых браузерах вы можете проверить все тестовые случаи одновременно в интерпретаторе CJam .

Контрольные примеры

Код

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.

вход

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

Выход

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

Как это работает

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 байтов

Это моя первая попытка в коде гольф, когда-либо. Дайте мне знать, если я сделал что-то не так.

Я использую побитовые операции для переключения

Golfed:

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

изменить: заменить && на *

SQL (PostGreSQL), 427 байт

Несмотря на его огромный размер, он оказался немного меньше, чем я ожидал. Я не был уверен, что смогу сделать это, если честно. Я подозреваю, что многое еще можно сделать :)

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

Отформатировано и прокомментировано

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

Тестовый забег

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

Юлия, 140 байт

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

Это создает функцию, которая принимает две строки и возвращает кортеж строк. Ничего особенно умного здесь не происходит; мы просто определяем внутреннюю функцию, которая непосредственно реализует алгоритм в спецификации, и вызываем ее дважды.

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 байт

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()и toLowerCase()занимают много байтов, но String.fromCharCode()еще дольше

Mathematica, 173 169 155 байтов

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

Это функция, принимающая массив из двух строк, например, {"Foo","bAR"}и выводящая массив из двух строк. Un-пространственно-сжать его, перезапись схему , f@xкак f[x]там , где она появляется, расширяя обозначения сокращений ( f=0>1он же False, t=!fиначе True, c=Charactersи u=ToUpperCaseQ), и снимите замены UpperCaseQ [#] с #==u@#(этот символ равен ее версии в верхнем регистре), это:

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

Интерфейс: трейлинг &делает это функцией. Его аргумент вставляется как "#" в обоих случаях /@ #. Например, f=0>1; ... & [{"AAAbbb111", "Cc2Dd3Ee4"}]производит вывод {AaABbb111,CC2dd3Ee4}.

Обработка: Сказано в обычном снаружи в порядке:

• Выводом MapThread[...]является список из двух списков символов. StringJoin применяется к каждому из этих двух списков символов, чтобы сформировать список из двух строк, выводимых.
• MapThread[#[#2]&, ... , 2]действует на массив из двух списков элементов размером 2 на n. Первый список представляет собой массив функций 2 на n. Второй список представляет собой массив символов 2 на n Characters /@ #, списки символов в двух входных строках. Работает на глубине 2, т. Е. Над функциями и отдельными персонажами.
• Reverse[...] меняет местами два подсписка функций, так что MapThread будет применять функции второй строки к первой строке и наоборот.
• { ... } & является анонимной функцией, которая применяется к каждой из двух входных строк.
• {LetterQ[#], UpperCaseQ[#]} & /@ Characters[#]разбивает строку на список символов, а затем заменяет каждый символ двумя списками элементов. В этих двух списках элементов первый элемент - это Trueесли символ является буквой, а в Falseпротивном случае аналогичным образом второй элемент указывает, является ли символ заглавным. UpperCaseQ[]не может вернуть истину, если не получил письмо.
• /. {{False, _} -> (# &), {True, True} -> ToUpperCase, {True, False} -> ToLowerCase}заменяет эти два списка элементов функциями. (Расширение сокращений tи fпроисходит до того , как совпадающая попытку.) Если список из двух элементов имеют в Falseкачестве своего первого элемента, он заменяется функцией (# &), функция идентификации. (Скобки необходимы, в противном случае стрелка связывается более тесно, чем амперсанд.) В противном случае список из двух элементов начинается с того True, что символ представляет собой букву, и мы выводим функции ToUpperCaseи ToLowerCaseсоответствуют их регистру. (Проверять это последнее Falseне нужно, на самом деле {_,_}->ToLowerCaseсработало бы, отлавливая все, что еще не было заменено, но это было бы не короче и не мрачнее.)

Единственная проблема заключалась в том, чтобы найти краткий способ объединить двумерный массив функций в массив аргументов.

Изменить: Благодаря @Martin Büttner для ловли «полезно» вырезать / вставить LineBreak обратных косых черт, то 1>0и 1<0аббревиатуры, а также для указания посчитать длину в байтах не символы (независимо от тех , которые :-))

Edit2: Кроме того, спасибо @Martin Büttner за то, что он указал на то, что загрязнение глобального пространства имен является приемлемым гольфом, напомнив мне об одном приложении функции символа и предложив заменить две заглавные функции на одну аббревиатуру и использовать одну для эмуляции другой (сохранение четыре символа). (Я думаю, что он делал это раньше. :-))

Python 3, 131 байт

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)

Функция возвращает строки в кортеже

Эрланг, 157 байт

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

Упакует две строки (фактически, списки) в список с двумя символами-кортежами и отображает каждый символ в соответствующий регистр, используя понимание списка.

Python 2, 101 байт

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

Анонимная функция, которая принимает две строки и возвращает выходные строки в списке. Я пометил это как Python 2, потому что Python 3 не позволяет I,I[::-1]сидеть одному в конце, как это.

Python, 126 байт

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

Функция fвозвращает строки в кортеже

C 181 байт

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

Были проблемы с укорочением имен стандартных библиотек (# определение их занимает 11 символов). Использует основную рекурсию и глобальные переменные x и y в качестве аргументов.

main (<non-zero>, argv) = вызвать main (0, {argv [1], argv [2]}), затем вывести новую строку, затем вызвать main (0, {argv [2], argv [1]})

main (0, {x, y}) = если x является концом строки, возвращает 0, иначе выведите правильный регистр первого символа x и вызовите main (0, {x + 1, y + 1}).

Запустите с двумя строками в качестве аргументов.

C - 164 153 байта - 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

Будет ли обновление, если я могу получить wc -c. Работает очень хорошо на самом деле

F #, 211 символов

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

могло быть лучше ...

Матлаб, 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

Пример:

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

C 164 байта

В значительной степени реализует алгоритм, как описано в задаче. Принимает 2 строки в качестве входных параметров.

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

Руби, 102

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

Принимает оригинальные строки, пары букв в массивах. Если они ниже / cap или cap / ниже, то поменяйте местами на обоих. Затем перенесите массивы обратно в наш упорядоченный массив.

Это требует запятой новой строки при вводе.

Perl 5.10+, 101 99 байт

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

96 байтов + 3 байта для флагов командной строки p00. Принимает одну строку с разделителями новой строки в качестве входных данных:

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

Или вы можете ввести ввод на STDIN:

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

Сломано:

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
'

Первая попытка в скале, 138 символов

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 - это функция, которая принимает две входные строки и выполняет работу с локальной функцией, используемой два раза, для изменения регистра строк.

Тот же код, с отступом и просто более читаемыми именами:

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
} 

Желе , 13 байт

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

Монадическая ссылка, принимающая и возвращающая списки из двух «строк» ​​(списки символов в желе).

Попробуйте онлайн!

Python 2 , 97 байт

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

Попробуйте онлайн!

Tcl , 194 байта

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}

Попробуйте онлайн!

Haskell , 109 91 байт

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

Спасибо @Laikoni за 16 байтов!

Попробуйте онлайн!