Le but est, après avoir pris une chaîne comme entrée, de dupliquer chaque lettre latine et de "basculer" sa casse (c.-à-d. Que les majuscules deviennent des minuscules et vice-versa).

Exemple d'entrées et de sorties:

Input      Output
bad        bBaAdD
Nice       NniIcCeE
T e S t    Tt eE Ss tT
s E t      sS Ee tT
1!1!1st!   1!1!1sStT!
n00b       nN00bB     
(e.g.)     (eE.gG.)
H3l|@!     Hh3lL|@!

L'entrée consiste en symboles ASCII imprimables.

Vous ne devez pas dupliquer les lettres non latines, les chiffres, les caractères spéciaux.

Gelée, 5 octets

żŒsQ€

Essayez-le en ligne!

Comment ça marche

żŒsQ€  Main link. Argument: s (string)

 Œs    Yield s with swapped case.
ż      Zip s with the result.
   Q€  Unique each; deduplicate each pair of characters.

Python, 56 à 54 octets

lambda s:''.join(c+c.swapcase()*c.isalpha()for c in s)

Testez-le sur Ideone .

JavaScript ES6, 70 68 66 64 octets

2 octets sauvés grâce à @ Kevin Lau - pas Kenny

2 octets sauvés grâce à @ Cᴏɴᴏʀ O'Bʀɪᴇɴ

s=>s.replace(/[A-Z]/gi,l=>l+l[`to${l<"a"?"Low":"Upp"}erCase`]())

Explication

Cela utilise vraiment un hacky:

l[`to${l<"a"?"Low":"Upp"}erCase`]()

quel non-golf est:

l[`to${
   l < "a" ?
   "Low" : 
   "Upp"
}erCase`]()

l < "a"Vérifie fondamentalement si le point de code de la lettre est inférieur au point de code dea (donc en majuscule). Si c'est le cas, il fera ce to + Low + erCasequi est devenu l['toLowerCase']()et rendra le caractère minuscule. `les guillemets permettent le formatage de chaîne, donc vous pouvez essentiellement penser à

`to${l < "a" ?"Low" : "Upp"}erCase`

comme: "to" + (l<"a" ? "Low" : "Upp") + "erCase" qui génère la fonction à appeler (place la chaîne en majuscule ou en minuscule). Nous mettons cela entre crochets, [ ... ]ce qui nous permet d'accéder à une propriété étant donné son nom sous forme de chaîne. Cela retourne la fonction appropriée et ensuite nous l'appelons simplement.

Rubis, 37 33 (30 + -pdrapeau) octets

swapcaseà la rescousse! Sorte de. -4 octets de @Lynn.

gsub(/[a-z]/i){$&+$&.swapcase}

C, 63 60 octets

f(char*s){for(;*s;s++)isalpha(putchar(*s))&&putchar(32^*s);}

Utilise le fait que 'a' XOR 32 == 'A', etc.

Trois octets sauvés grâce à FryAmTheEggman.

CJam, 11 octets

l_el_eu.+.|

Testez-le ici.

Explication

l      e# Read input.
_el    e# Duplicate, convert to lower case.
_eu    e# Duplicate, convert to upper case.
.+     e# Concatenate the two characters in matching positions from those two
       e# strings. E.g. "ab!" "AB!" would give ["aA" "bB" "!!"].
       e# For each character from the original string and the corresponding 
.|     e# string from this list, take the set union (which eliminates duplicates
       e# and keeps the order the values appear in from left to right, so that
       e# the original case of each letter comes first).

Pyth , 7 octets

sm{+dr2

Suite de test .

sm{+dr2    input: Q
sm{+dr2dQ  implicit arguments

        Q  input
 m         for each character as d:
     r2d       swapcase
   +d          prepend d
  {            deduplicate
s          join as string

Python 3.5, 60 56 octets:

for i in input():print(end=i+i.swapcase()[:i.isalpha()])

Un programme complet. Je vais essayer de jouer plus au golf.

Essayez-le en ligne! (Idéone)

Haskell, 73 octets

l=['a'..'z']
u=['A'..]
(>>= \c->c:maybe""pure(lookup c$zip l u++zip u l))

Cheddar , 118 à 104 octets

(s)->s.chars.map((i)->{if String.letters has i.lower{if i<"a"{i+i.lower}else{i+i.upper}}else{i}}).join()

Première vraie réponse au cheddar !!! C’est beaucoup moins décisif que je ne le pensais…;

Fonctionne avec la version 1.0.0-beta.9 , non concurrente.

Comme vous pouvez le constater, je n’ai pas conçu le cheddar pour devenir golfy: /

Ungolfed:

(str) -> str.chars.map(
    (i) -> {
        if String.letters has i {
            if i < "a" { // Check char code, meaning it's upper case if true
                i+i.lower
            }
            else {
                i+i.upper
            }
        } else {
            i
        }
    }
).join()

Usage:

var doThing = <code here>;
doThing("input...");

Mise à jour: 14/07/16 J'ai terminé les ternaires, ce qui en fait un octet de 84 octets.

Cheddar, 84 octets

(s)->s.chars.map((i)->String.letters has i.lower?i<"a"?i+i.lower:i+i.upper:i).join()

fonctionne à partir de la version v1.0.0-beta.14

Retina, 28 27 21 octets

Ce sont des onglets, pas des espaces.

.
$&  $&
T`lL    p`Ll_`  .

Essayez-le en ligne

Merci à tous pour les suggestions.

C, 87 80

Passez une chaîne en entrée f()et la sortie est écrite dans STDOUT. La chaîne n'est pas modifiée.

f(char*v){for(;*v;++v)putchar(*v),isalpha(*v)?putchar(*v-32+64*!islower(*v)):0;}

sed, 30 octets

29 octets code + 1 octet paramètre -r

s/([a-z])|([A-Z])/&\u\1\l\2/g

Usage:

echo -e 'bad\nNice\nT e S t\ns E t\n1!1!1st!\nn00b\n(e.g.)\nH3l|@!' |\
sed -r 's/([a-z])|([A-Z])/&\u\1\l\2/g'

J, 31 29 octets

[:;]<@~."1@,.tolower,.toupper

Explication

[:;]<@~."1@,.tolower,.toupper  Input: s
                      toupper  Convert s to all uppercase
             tolower           Convert s to all lowercase
                    ,.         Join them as columns in a 2d array
   ]                           Identity function, get s
           ,.                  Prepend s as a column to the 2d array
      ~."1@                    Take the unique chars on each row
    <@                         Box them
[:;                            Unbox the list of boxes and join their contents and return

Haskell, 121, 101, 85, 82

import Data.Char
g n|isLower n=toUpper n|1<2=toLower n
(>>= \x->x:[g x|isAlpha x])

Perl, 36 octets ( -ndrapeau 35 + )

s/[a-z]/$&.(ord$&<97?lc$&:uc$&)/ige

( -ptag nécessaire)

(-2 octets grâce à @Dom Hasting)

Explication courte:
ordrenvoie la valeur numérique d'un caractère. ord(any lower case) >= 97, Et ord(any upper case) <= 90).

Courir avec :

perl -pe 's/[a-z]/$&.(ord$&<97?lc$&:uc$&)/ige'

Ruby, 31 + 1 = 32 30 + 1 = 31 octets

Avec le -pdrapeau, courir

gsub(/(?<=(.))/){$1.swapcase!}

Profite du fait que swapcase!renverra niln'importe quoi sauf une lettre ASCII, ce qui se traduira par une chaîne vide lorsqu'il sera renvoyé en dehors du gsubbloc. @ Jordan a sauvegardé un octet en capturant le caractère précédent dans un regard.

R, 191 187 168 156 98 99 octets

99 octets dus à des améliorations de Giuseppe et MickyT .

paste0(x<-unlist(strsplit(readline(),"")),gsub("[^A-Za-z]","",chartr("a-zA-Z","A-Za-z",x)),collapse="")

05AB1E , 7 octets

Code:

vyyš«Ù?

Explication:

v       # For each in input.
 yyš    # Push y and y swapcased.
    «Ù  # Concatentate and uniquify.
      ? # Print without a newline.

Utilise le codage CP-1252 . Essayez-le en ligne!

Pyke, 8 à 6 octets

FDl4+}

Essayez-le ici!

V , 21 octets

Essayez-le en ligne!

Trop d'octets ...

Ó./°ò
Íá/°°
Îlg~lÎHògJ

En fait, 8 octets

`;Öo╔`MΣ

Essayez-le en ligne!

Explication:

`;Öo╔`MΣ
`;Öo╔`M   for each character in input:
 ;          duplicate the character
  Ö         swap case
   o        append to original character
    ╔       remove duplicated characters
       Σ  concatenate

MATL, 11 à 9 octets

tYov"@uv!

Essayez-le en ligne

Explication

        % Implicitly grab input as string
t       % Duplicate the input
Yo      % Swap case of all characters
v       % Vertically concatenate the original and swap-cased versions
"       % For each column (letter in the original)
  @u    % Compute the unique values (without sorting)
  v!    % Vertically concatenate with the existing output and transpose
        % Implicit end of for loop and implicit display

Perl, 28 22 21 octets (20 + -pdrapeau)

s/[a-z]/$&.$&^$"/ige

Stax , 7 à 6 octets

Merci à @recursive pour un octet enregistré!

┤§ÆP♦■

Exécutez-le et corrigez-le sur staxlang.xyz! (lien est à la version décompressée)

Décompressé (7 octets):

c:~\{um

Explication:

c:~\{um
c          Copy the top element of the stack (the input, in this case).
 :~        Switch case of each letter in the copy.
   \       Zip. This produces an array of two-character strings.
    { m    Map a block over this array of two-character strings.
     u       Get all unique elements.
           Implicit concatenate and print.

Python, 59 octets

lambda s:''.join((x,x+x.swapcase())[x.isalpha()]for x in s)

Édité pour corriger les caractères répétés non alphabétiques

Julia, 40 octets

!s=[print(c,isalpha(c)?c$' ':"")for c=s]

Essayez-le en ligne!

PHP 4.1, 57 octets

Ce code suppose l'accès via un serveur Web (Apache, par exemple), en utilisant la configuration par défaut.

Vous pouvez passer la chaîne en envoyant la clé Spar tout moyen ( POST, GET, COOKIE, SESSION...).

<?for($i=0;$c=$S[$i++];)echo$c,ctype_alpha($c)?$c^' ':'';

C #, 82 71 octets

s=>string.Concat(s.Select(c=>c+(char.IsLetter(c)?(char)(c^32)+"":"")));

C # lambda où se trouvent l’entrée et la sortie string. Essayez-le en ligne .

11 octets grâce au truc @Lynn.

Common Lisp (Lispworks), 262 octets

(defun f(s)(let((b""))(dotimes(i(length s))(if(lower-case-p(elt s i))(progn #1=(setf b(concatenate 'string b(string #2=(elt s i))))(setf b(concatenate 'string b(string(char-upcase #2#)))))(progn #1#(setf b(concatenate 'string b(string(char-downcase #2#)))))))b))

ungolfed:

(defun f (s)
  (let ((b ""))
    (dotimes (i (length s))
      (if (lower-case-p (elt s i))
          (progn
           #1=(setf b (concatenate 'string b (string #2=(elt s i))))
           (setf b (concatenate 'string b (string (char-upcase #2#)))))
        (progn
          #1#
          (setf b (concatenate 'string b (string (char-downcase #2#)))))))
    b))

Usage:

CL-USER 1 > (f "abc")
"aAbBcC"

CL-USER 2 > (f "bad")
"bBaAdD"