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!

Descrizione

L'input è di due stringhe s1e s2, uguale in lunghezza. Ciascuno conterrà solo ASCII stampabile e avrà una lunghezza di almeno un carattere. Puoi inserirli come due stringhe, un array di due stringhe o una singola stringa con s1e s2separati da una scheda o da una nuova riga.

L'output è il seguente:

• Per ogni personaggio cin s1:

  • Se il personaggio non è una lettera, l'output è invariato.

  • Altrimenti, se cè una lettera:

    • Trova il carattere corrispondente (quello con lo stesso indice) in s2.

      • Se è una lettera maiuscola, l'output è in cmaiuscolo.

      • Se è una lettera minuscola, l'output è cin minuscolo.

      • Altrimenti, output cinvariato.

• Quindi fai la stessa cosa, tranne con s1e s2cambiato.

In sostanza, tutte le lettere s1per le quali il carattere corrispondente s2è maiuscolo devono essere maiuscole e tutte le lettere s1con una lettera minuscola nello stesso indice s2dovrebbero diventare minuscole (e viceversa).

Casi test

Ingresso:

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

Produzione:

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

Ingresso:

PRogrammiNG puzZLes & CODe golf
SdlkhkfaladlKsdlalksdg7ldklDgsl

Produzione:

Programming Puzzles & Code Golf
SDlkhkfalADlksdLAlksdg7LDkldgsl

Ingresso:

AAAbbb111
Cc2Dd3Ee4

Produzione:

AaABbb111
CC2dd3Ee4

Pyth, 19 18 byte

LCmrW&@dG@drG1d2Cb

Questo definisce una funzione y che accetta e restituisce un elenco di stringhe.

Verifica tutti i casi di test contemporaneamente nel compilatore / esecutore Pyth .

Grazie a @Jakube per giocare a golf a 1 byte.

Come funziona

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

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

Questa è una funzione anonima che estrae una matrice di stringhe dallo stack e ne lascia una in cambio.

Nei browser supportati, è possibile verificare tutti i casi di test contemporaneamente nell'interprete CJam .

Casi test

Codice

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.

Ingresso

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

Produzione

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

Come funziona

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 byte

Questo è il mio primo tentativo di giocare a golf a codice, mai. Fammi sapere se ho fatto qualcosa di sbagliato.

Sto usando le operazioni bit a bit per eseguire la commutazione

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

modifica: sostituito && con *

SQL (PostGreSQL), 427 byte

Nonostante le sue enormi dimensioni, alla fine è stato un po 'più piccolo di quanto mi aspettassi. Non ero abbastanza sicuro che sarei stato in grado di farlo per essere onesto. Ho il sospetto che ci sia ancora molto da fare :)

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

Formattato e commentato

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

Prova

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 byte

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

Questo crea una funzione che accetta due stringhe e restituisce una tupla di stringhe. Non sta succedendo nulla di particolarmente intelligente; definiamo semplicemente una funzione interna che implementa direttamente l'algoritmo nella specifica e la chiamiamo due volte.

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 byte

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()occupa molti byte ma String.fromCharCode()è anche più lungo

Mathematica, 173 169 155 byte

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

Questa è una funzione che prende una matrice di due stringhe, ad es. {"Foo","bAR"}E produce una matrice di due stringhe. Un-spazialmente-comprimerlo, riscrivere lo schema f@xcome f[x]laddove appare, ampliando le abbreviazioni notazione ( f=0>1alias False, t=!falias True, c=Characterse u=ToUpperCaseQ), e non-sostituzione UpperCaseQ [#] con #==u@#(questo carattere è uguale sua versione maiuscolo), è:

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

Interfaccia: il finale lo &rende una funzione. Il suo argomento è inserito come "#" in entrambe le istanze di /@ #. Ad esempio f=0>1; ... & [{"AAAbbb111", "Cc2Dd3Ee4"}]produce l'output {AaABbb111,CC2dd3Ee4}.

Elaborazione: indicata normalmente all'esterno per:

• L'output di MapThread[...]è un elenco di due elenchi di caratteri. StringJoin viene applicato a ciascuna di queste due liste di caratteri per produrre un elenco di due stringhe, l'output.
• MapThread[#[#2]&, ... , 2]agisce su una matrice di due elenchi di elementi 2 per n. Il primo elenco è un array di funzioni 2 per n. Il secondo elenco è un array di caratteri 2 per n Characters /@ #, gli elenchi di caratteri nelle due stringhe di input. Funziona a profondità 2, cioè sulle funzioni e sui singoli caratteri.
• Reverse[...] scambia le due liste secondarie di funzioni in modo che MapThread applichi le funzioni della seconda stringa alla prima stringa e viceversa.
• { ... } & è una funzione anonima che viene applicata a ciascuna delle due stringhe di input.
• {LetterQ[#], UpperCaseQ[#]} & /@ Characters[#]divide una stringa in un elenco di caratteri, quindi sostituisce ogni carattere con due elenchi di elementi. In questi due elenchi di elementi, il primo elemento è Truese il carattere è una lettera e False, in caso contrario, il secondo elemento indica se il carattere è maiuscolo. UpperCaseQ[]non può restituire vero se non riceve una lettera.
• /. {{False, _} -> (# &), {True, True} -> ToUpperCase, {True, False} -> ToLowerCase}sostituisce questi due elenchi di elementi con funzioni. (L'espansione delle abbreviazioni te si fverifica prima che venga tentata qualsiasi corrispondenza.) Se un elenco di due elementi ha Falsecome primo elemento, viene sostituito con la funzione (# &), la funzione identità. (Le parentesi sono necessarie, altrimenti la freccia si lega più strettamente della e commerciale). Altrimenti l'elenco dei due elementi inizia con True, il carattere era una lettera e vengono emesse le funzioni ToUpperCasee ToLowerCasecorrispondenti al suo caso. (Il controllo di quest'ultimo Falsenon è necessario, infatti {_,_}->ToLowerCasefunzionerebbe, catturando tutto ciò che non è stato ancora sostituito, ma questo non sarebbe più breve e più oscuro.)

L'unica sfida era capire un modo sintetico per comprimere una serie di funzioni bidimensionali in una serie di argomenti.

Modifica: Grazie a @Martin Büttner per la cattura di "utili" barre rovesciate, le abbreviazioni 1>0e le interruzioni di riga 1<0, e anche per la guida a contare la lunghezza in byte e non i caratteri (qualunque siano :-))

Edit2: Ulteriore grazie a @Martin Büttner per aver sottolineato che inquinare lo spazio dei nomi globale è un golf accettabile, ricordandomi un'applicazione di una funzione di carattere e suggerendo di sostituire le due funzioni maiuscole con un'abbreviazione per uno e di utilizzare l'una per emulare l'altro (salvando quattro caratteri). (Penso che l'abbia già fatto. :-))

Python 3, 131 byte

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 funzione restituisce stringhe in una tupla

Erlang, 157 byte

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 le due stringhe (in realtà, gli elenchi) in un elenco di due tuple di caratteri e mappa ogni personaggio nel caso appropriato usando una comprensione dell'elenco.

Python 2, 101 byte

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 funzione anonima che accetta due stringhe e restituisce le stringhe di output in un elenco. L'ho contrassegnato come Python 2 perché Python 3 non consente I,I[::-1]di sedersi da solo alla fine in quel modo.

Python, 126 byte

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 funzione frestituisce stringhe in una tupla

C, 181 byte

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

Ho avuto problemi ad abbreviare i nomi delle librerie standard in modo utile, (# definirli richiede 11 caratteri di sovraccarico). Utilizza la ricorsione principale e le variabili globali x e y come argomenti.

main (<non-zero>, argv) = chiama main (0, {argv [1], argv [2]}) quindi stampa newline quindi chiama main (0, {argv [2], argv [1]})

main (0, {x, y}) = se x è la fine della stringa restituisce 0, altrimenti stampa il caso corretto del primo carattere di x e chiama main (0, {x + 1, y + 1}).

Esegui con le due stringhe come argomenti.

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

Si aggiorna se riesco a scaricare wc -c. Funziona davvero molto bene

F #, 211 caratteri

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

potrebbe essere migliore ...

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

Esempio:

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

C, 164 byte

Praticamente implementando l'algoritmo come descritto nel problema. Accetta 2 stringhe come parametri di input.

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

Prende le stringhe originali, abbina le lettere negli array. Se sono in basso / tappo o tappo / inferiore, quindi scambiare su entrambi. Quindi trasporre gli array nel nostro array ordinato.

Ciò richiede una nuova riga finale nell'input.

Perl 5.10+, 101 99 byte

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

96 byte + 3 byte per i flag della riga di comando p00. Accetta come input una singola stringa delimitata da newline:

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

Oppure puoi inserire input su STDIN:

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

Suddiviso:

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
'

Primo tentativo in scala, 138 caratteri

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 è una funzione che accetta le due stringhe di input e fa il lavoro, con una funzione locale, usata due volte, per cambiare il caso delle stringhe.

Lo stesso codice, con rientro e solo molti nomi più leggibili:

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 byte

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

Un collegamento monadico che accetta e restituisce elenchi di due "stringhe" (elenchi di personaggi in Jelly).

Provalo online!

Python 2 , 97 byte

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

Provalo online!

Tcl , 194 byte

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}

Provalo online!

Haskell , 109 91 byte

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

Grazie a @Laikoni per 16 byte!

Provalo online!