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

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

Це моя перша спроба кодового гольфу, коли-небудь. Дайте мені знати, чи зробив я щось не так.

Я використовую побітові операції для виконання комутації

Гольф:

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

Безголівки:

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

Це створює функцію, яка приймає два рядки і повертає кордону рядків. Нічого особливо розумного тут не відбувається; ми просто визначаємо внутрішню функцію, яка безпосередньо реалізує алгоритм у специфікації, і викликаємо його двічі.

Безголівки:

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()навіть довше

Математика, 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 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 за те, що ви знайшли "корисні" відрізки / вставки рядкових рядків, абревіатури 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]сидіти на самоті в кінці так.

Пітон, 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);}

Виникла проблема зі скороченням стандартних імен бібліотеки гідним способом ((# define'ing їх займає 11 символів накладних витрат). В якості аргументів використовується основна рекурсія та глобальні змінні x та y.

main (<non-zero>, argv) = call main (0, {argv [1], argv [2]}), потім надрукувати новий рядок, а потім виклик main (0, {argv [2], argv [1]})

main (0, {x, y}) = якщо x закінчується повернення рядка 0, інакше надрукуйте правильний регістр першого символу x та call 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;

Безголівки:

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

Безголівки:

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

Бере оригінальні рядки, з’єднує букви з масивів. Якщо вони або нижчі / ковпак, або кришка / нижня, то замініть на обох. Потім перемістіть масиви назад в наш упорядкований масив.

Для цього потрібен новий рядок у введенні.

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$

Монадічна Посилання, що приймає та повертає списки з двох "рядків" (списки символів в Jelly).

Спробуйте в Інтернеті!

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

Спробуйте в Інтернеті!