Duplicate & switch case

Question

The goal is, having taken a string as input, duplicate each latin letter and "toggle" its case (i.e. uppercase becomes lowercase and vice-versa).

Example inputs & outputs:

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

The input consists of printable ASCII symbols.

You shouldn't duplicate non-latin letters, numbers, special chars.

Answer 1

Jelly, 5 bytes

żŒsQ€

Try it online!

How it works

żŒ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.

Answer 2

Python, 56 54 bytes

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

Test it on Ideone.

Answer 3

JavaScript ES6, 70 68 66 64 bytes

Saved 2 bytes thanks to @Kevin Lau - not Kenny

Saved 2 bytes thanks to @Cᴏɴᴏʀ O'Bʀɪᴇɴ

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

Explanation

This uses a really hacky:

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

which ungolfed is:

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

Basically l < "a" checks if the code point of the letter is less then the code point of a (therefore being an uppercase letter). If it is it'll do to + Low + erCase which becomed l['toLowerCase']() and makes the character lowercase. ` quotes allow string formatting so essentially you can think of:

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

as: "to" + (l<"a" ? "Low" : "Upp") + "erCase" which generates the function to call (make the string upper or lower case). We put this in square brackets [ ... ] which lets us access a property given its name as a string. This returns the appropriate function and then we just call it.

Answer 4

Ruby, 37 33 (30 + -p flag) bytes

swapcase to the rescue! Sort of. -4 bytes from @Lynn.

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

Answer 5

C, 63 60 bytes

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

Uses the fact that 'a' XOR 32 == 'A', etc.

Three bytes saved thanks to FryAmTheEggman.

Answer 6

CJam, 11 bytes

l_el_eu.+.|

Test it here.

Explanation

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

Answer 7

Pyth, 7 bytes

sm{+dr2

Test suite.

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

Answer 8

Python 3.5, 60 56 bytes:

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

A full program. Will try to golf more.

Try It Online! (Ideone)

Answer 9

Haskell, 73 bytes

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

Answer 10

Cheddar, 118 104 bytes

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

First real Cheddar answer!!! This is a lot less climactic than I thought it would be... ;_;

Works with release 1.0.0-beta.9, non-competing.

---

As you can tell I didn't design cheddar to be 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...");

---

Update: 7/14/16 I've finished ternaries making this come down to 84 bytes

Cheddar, 84 bytes

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

works as of version v1.0.0-beta.14

Answer 11

Retina, 28 27 21 bytes

Those are tabs, not spaces.

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

Try it online

Thanks for the suggestions everyone.

Answer 12

C, 87 80

Pass a string as input to f() and the output is written to STDOUT. The string is not modified.

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

Answer 13

sed, 30 bytes

29 bytes code + 1 byte parameter -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'

Answer 14

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

With the -p flag, run

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

Takes advantage of the fact that swapcase! will return nil on anything but an ASCII letter, which translates to an empty string when returned out of the gsub block. @Jordan saved a byte by capturing the previous character in a look-behind.

Answer 15

J, 31 29 bytes

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

Explanation

[:;]<@~."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

Answer 16

Haskell, 121, 101, 85, 82

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

Answer 17

Perl, 36 bytes (35 + -n flag)

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

(-p tag needed)

(-2 bytes thanks to @Dom Hasting)

Short explanation:
ord returns the numeric value of a char. ord(any lower case) >= 97, and ord(any upper case) <= 90).

Run with :

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

Answer 18

R, 191 187 168 156 98 99 bytes

99 bytes due to improvements fro Giuseppe and MickyT.

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

Answer 19

Stax, 7 6 bytes

Thanks to @recursive for a byte saved!

┤§ÆP♦■

Run and debug it at staxlang.xyz! (link is to unpacked version)

Unpacked (7 bytes):

c:~\{um

Explanation:

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.

Answer 20

05AB1E, 7 bytes

Code:

vyyš«Ù?

Explanation:

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

Uses the CP-1252 encoding. Try it online!

Answer 21

Pyke, 8 6 bytes

FDl4+}

Try it here!

Answer 22

V, 21 bytes

Try it online!

Too many bytes...

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

Answer 23

Actually, 8 bytes

`;Öo╔`MΣ

Try it online!

Explanation:

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

Answer 24

MATL, 11 9 bytes

tYov"@uv!

Try it Online

Explanation

        % 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

Answer 25

Perl, 28 22 21 bytes (20 + -p flag)

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

Answer 26

T-SQL, 244

The byte total includes a one-byte string. Replace the example input string "Q" with the string you want to try.

DECLARE @I VARCHAR(MAX)='Q',@O VARCHAR(MAX)='',@ CHAR #:SELECT @=LEFT(@I,1),@O+=@+CASE WHEN @ LIKE'[A-Za-z]'COLLATE Thai_BIN THEN CASE WHEN ASCII(@)/13IN(5,6)THEN LOWER(@)ELSE UPPER(@)END ELSE''END,@I=STUFF(@I,1,1,'')IF LEN(@I)>0GOTO # PRINT @O

This script works in SQL Server 2008 R2, although you can try it in SQL Server 2016 here. This SQL works by iterating through the characters in the input string @I, checking each character using a short-named collation and ASCII codes. When one character is processed, the result is added to the output string @O and removed from @I.

Answer 27

Japt v2.0a0, 8 bytes

r\lÈ+c^H

Try it

---

Explanation

r            :Replace
 \l          :Regex /[a-z]/gi
   È         :Pass each match X through a function
    +        :  Append
    c        :  The charcode of X
     ^       :  Bitwise XORed
       H     :  With 32

Answer 28

str, 6 bytes

d#S:#q

Try it online!

Explanation

d#S:#q
          over each character:
d         duplicate
 #S       swapcase
   :      concatenate
    #q    uniq-ify string

Answer 29

Python, 59 bytes

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

Edited to fix repeating non-alphabetic characters

Answer 30

Julia, 40 bytes

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

Try it online!

Answer 31

C#, 82 71 bytes

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

C# lambda where the input and the output are string. Try it online.

11 bytes thanks to @Lynn trick.

Answer 32

PHP 4.1, 57 bytes

This code assumes access through a web server (Apache, for example), using the default configuration.

You can pass the string by sending the key S by any means (POST, GET, COOKIE, SESSION...).

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

Answer 33

Common Lisp (Lispworks), 262 bytes

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

Answer 34

Java 8, 105 104 80 bytes

a->{for(char c:a)System.out.print(c+(c>64&c<91|c>96&c<123?(char)(c^32)+"":""));}

Explanation:

Try it here.

a->{                          // Method with character-array parameter and no return-type
  for(char c:a)               //  For each character in the input:
    System.out.print(c        //   Print the current character
     +(c>64&c<91|c>96&c<123?  //   And if it's a letter:
       (char)(c^32)+""        //    Print the letter again with reversed case
      :                       //   Else:
       ""));}                 //    Print nothing more

Answer 35

Rust, 250 bytes

fn main(){let(mut i,mut o)=(String::new(),String::new());std::io::stdin().read_line(&mut i);let b:&[u8]=i.trim().as_bytes();for x in b{o.push(*x as char);if*x>64&&*x<91{o.push((x+32)as char)}else if*x>96&&*x<123{o.push((x-32)as char)}}print!("{}",o)}

Ungolfed

fn main() {
    let (mut input_string, mut output_string) = (String::new(), String::new());
    std::io::stdin().read_line(&mut input_string);
    let bytes: &[u8] = input_string.trim().as_bytes();

    for x in bytes {
        output_string.push(*x as char);
        if *x > 64 && *x < 91 {
            //is_uppercase
            output_string.push((x + 32) as char);
        } else if *x > 96 && *x < 123 {
            //is_lowercase
            output_string.push((x - 32) as char);
        }
    }
    print!("{}", output_string);
}

This answer assumes the input only consists of ASCII characters. It uses comparisons and addition/subtraction instead of library functions as it is shorter.

Answer 36

Add++, 100 bytes

D,g,@,O91 65r$e
D,l,@,O123 97r$eBn
D,w,@~,S
D,f,@~,€gB]VAbU€lB]GBcB+32€*B]VAbU€OB]GBcB+€CJABc€wB@B+J

Try it online!

This is annoyingly long. Let's compare this answer to the current shortest, Dennis' Jelly answer:

żŒsQ€

Here, I've split it into three parts: ż, Œs and Q€, highlighted to show the corresponding parts in the Add++ code, as so:

D,g,@,O91 65r$e
D,l,@,O123 97r$eBn
D,w,@~,S
D,f,@~,€gB]VAbU€lB]GBcB+32€*B]VAbU€OB]GBcB+€CJABc€wB@B+J

How it works

		; A note on functions:
		; Each function returns the value on the top of the stack
		; A function has 'flags' that change its behaviour:
		;
		;	@	-	Specifies an argument to be taken
		;	~	-	Splats the arguments to the stack

D,u,@,		; Declare a monadic function 'u'
		; Example argument:	['I']
	O	; Ordinal;	STACK = [73]
	91 65r	; [65 ... 90];	STACK = [73 [65 66 ... 89 90]]
	$e	; Contains?	STACK = [1]

D,l,@,		; Declare a monadic function 'l'
		; Example argument:	['i']
	O	; Ordinal;	STACK = [105]
	123 97r	; [97 ... 122];	STACK = [105 [97 98 ... 121 122]]
	$e	; Contains?	STACK = [1]
	Bn	; Negate;	STACK = [-1]

D,w,@~,		; Declare a monadic function 'w'
		; Example argument:	[['N' 'n']]
	S	; Deduplicate;	STACK = [['N' 'n']]

D,f,@~,		; Declare a monadic function 'f'
		; Example argument:		['N' 'i' 'c' 'e' '!']
	€u	; Map 'u' over €ach;	STACK = [1 0 0 0 0]
	B]	; Wrap the stack;	STACK = [[1 0 0 0 0]]
	V	; Save;			STACK = []
	AbU	; Push argument;	STACK = ['N' 'i' 'c' 'e' '!']
	€l	; Map 'l' over €ach;	STACK = [0 -1 -1 -1 0]
	B]	; Wrap;			STACK = [[0 -1 -1 -1 0]]
	G	; Retrieve;		STACK = [[0 -1 -1 -1 0] [1 0 0 0 0]]
	BcB+	; Column sums;		STACK = [1 -1 -1 -1 0]
	32€*	; Multiply €ach by 32;	STACK = [32 -32 -32 -32 0]
	B]	; Wrap;			STACK = [[32 -32 -32 -32 0]]
	V	; Save;			STACK = []
	AbU€OB]	; Codepoints of input;	STACK = [[78 105 99 101 33]]
	G	; Retrieve;		STACK = [[78 105 99 101 33] [32 -32 -32 -32 0]]
	BcB+	; Column sums;		STACK = [110 73 67 69 33]
	€C	; Convert to chars;	STACK = ['n' 'I' 'C' 'E' '!']
	JABc	; Zip with argument;	STACK = [['n' 'N'] ['I' 'i'] ['C' 'c'] ['E' 'e'] ['!' '!']]
	€w	; Map 'w' over €ach;	STACK = [['n' 'N'] ['I' 'i'] ['C' 'c'] ['E' 'e'] ['!']]
	B@	; Reverse each;		STACK = [['N' 'n'] ['i' 'I'] ['c' 'C'] ['e' 'E'] ['!']]
	B+	; Sum each;		STACK = ['Nn' 'iI' 'cC' 'eE' '!']
	J	; Join;			STACK = ['NniIcCeE!']

Answer 37

Kotlin, 87 86 bytes

x->x.map{c->if(c.isLetter())"$c${(c.toInt()xor 32).toChar()}" else c}.joinToString("")

Try it online!

I wish Kotlin had a ternary operator, but it doesn't so I'm stuck with the more verbose if/else.

I feel like I can get this shorter if I can find a way to consolidate map{} and joinToString() in one call.

Answer 38

SNOBOL4 (CSNOBOL4), 139 bytes

	U =&UCASE
	L =&LCASE
	I =INPUT
S	I LEN(1) . X REM . I	:F(O)
	X ANY(L U)	:S(D)F(A)
D	X =X REPLACE(X,L U,U L)
A	O =O X	:(S)
O	OUTPUT =O
END	

Try it online!

The line X ANY(L U) :S(D)F(A) checks if any of X are Upper or Lowercase, going to D if so or to A if not. Then D duplicates and swaps case, and A concatenates the results together, finally outputting once I has no characters.

Answer 39

C, 62 bytes

Function that reads from stdin and writes to stdout:

f(c){while(c=getchar())printf(isalpha(c)?"%c%c":"%c",c,c^32);}

Answer 40

Erlang, 106 bytes

f(S)->G=string,lists:flatten([case G:to_upper(C)==G:to_lower(C)of true->C;false->[C,C bxor 32]end||C<-S]).

Uses Lynn's XOR trick to toggle the case.

Answer 41

Gema, 37 characters

<J>=$1@upcase{$1}
<K>=$1@downcase{$1}

Sample run:

bash-4.3$ gema '<J>=$1@upcase{$1};<K>=$1@downcase{$1}' <<< 'H3l|@!'
Hh3lL|@!

Answer 42

PowerShell, 102 Bytes

-join([char[]]$args[0]|%{$_;if($_-cmatch'[A-Z]'){"$_".ToLower()}if($_-cmatch'[a-z]'){"$_".ToUpper()}})

Run the script with an argument like so:

PS C:\PretendDirectory> .\DupeCase.ps1 "Hello World ?!!1"
HheElLlLoO WwoOrRlLdD ?!!1

Ungolfed:

-join([char[]]$args[0] | % {
    $_
    if($_-cmatch'[A-Z]'){
        "$_".ToLower()
    }
    if($_-cmatch'[a-z]'){
        "$_".ToUpper()
    }
})

Explanation:

This script splits the argument from a string into a character array, and loops through the array. It returns a given character then, if it's an upper case letter between A and Z returns a lowercase version using the built in function, does the same for lowercase letters. To wrap up it joins the array into a single string.

Answer 43

Yabasic, 133 bytes

A yabasic answer that takes input as a raw string and outputs to the STDOUT.

Line Input""S$
For i=1To Len(S$)
c$=Mid$(S$,i,1)
u$=Upper$(c$)
?c$;
If"@"<u$And u$<"["Then
If c$=u$Then?Lower$(c$);Else?u$;Fi
Fi
Next

Try it online!

Answer 44

Java, 259 bytes

for (i=0;i<in.length();i++)
{
if(Character.isLowerCase(in.charAt(i))){
o=o+in.charAt(i)+Character.toUpperCase(in.charAt(i));}
else if(Character.isUpperCase(in.charAt(i))){o=o+in.charAt(i)+Character.toLowerCase(in.charAt(i));}
else {o=o+in.charAt(i);}}