String case

String case
You are encouraged to solve this task according to the task description, using any language you may know.

Take the string "alphaBETA", and demonstrate how to convert it to UPPER-CASE and lower-case.

4D

$string:="alphaBETA"
$uppercase:=Uppercase($string)
$lowercase:=Lowercase($string) 

ActionScript

var string:String = 'alphaBETA';
var upper:String = string.toUpperCase();
var lower:String = string.toLowerCase();

Ada

<ada> with Ada.Characters.Handling; use Ada.Characters.Handling;

with Ada.Text_Io; use Ada.Text_Io;

procedure Upper_Case_String is
   S : String := "alphaBETA";
begin
   Put_Line(To_Upper(S));
   Put_Line(To_Lower(S));
end Upper_Case_String;</ada>

ALGOL 68

# Demonstrate toupper and tolower for standard ALGOL 68 
strings.  This does not work for multibyte character sets. #

PROC to upper = ( CHAR c )CHAR:
(
  IF ABS "a" <= ABS c & ABS c <= ABS "z" THEN
     REPR ( ABS c - ABS "a" + ABS "A" )
  ELSE
     c
  FI
);

PROC to lower = ( CHAR c )CHAR:
(
  IF ABS "A" <= ABS c & ABS c <= ABS "Z" THEN
     REPR ( ABS c - ABS "A" + ABS "a" )
  ELSE
     c
  FI
);

# upper-cases s in place #
PROC str to upper = (REF STRING s)VOID :
(
    FOR i FROM LWB s TO UPB s DO
        s[i] := toupper(s[i])
    OD
);

# lower-cases s in place #
PROC str to lower = (REF STRING s)VOID :
(
    FOR i FROM LWB s TO UPB s DO
        s[i] := tolower(s[i])
    OD
);

main: (
    STRING t := "alphaBETA";
    str to upper(t);
    printf(($"uppercase: "gl$, t));
    str to lower(t);
    printf(($"lowercase: "gl$, t))
)

APL

Works with: APL2

      a←'abcdefghijklmnopqrstuvwxyz'
      A←'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
      
      X←'alphaBETA'
      
      (a,⎕AV)[(A,⎕AV)⍳'alphaBETA']
alphabeta
      (A,⎕AV)[(a,⎕AV)⍳'alphaBETA']
ALPHABETA

BASIC

Works with: QuickBasic version 4.5

s$ = "alphaBETA"
PRINT UCASE$(s$)
PRINT LCASE$(s$)

C

Works with: gcc version 3.4.4 (cygming special, gdc 0.12, using dmd 0.125)

Library: libc

<c> // Demonstrate toupper and tolower for // standard C strings. // This does not work for multibyte character sets.

1. include <ctype.h>
2. include <stdio.h>

//upper-cases s in place void str_toupper(char *s) {

   while(*s)
   {
       *s=toupper(*s);
       s++;
   }

}

//lower-cases s in place void str_tolower(char *s) {

   while(*s)
   {
       *s=tolower(*s);
       s++;
   }

}

int main(int argc, char *argv[]) {

   char t[255]="alphaBETA";
   str_toupper(t);
   printf("uppercase: %s\n", t);
   str_tolower(t);
   printf("lowercase: %s\n", t);
   return 0;

} </c>

C++

Works with: g++ version 3.4.4 (cygming special)

Library: STL

This method does the transform in-place. Alternate methods might return a new copy or use a stream manipulator.

<cpp>

1. include <algorithm>

/// \brief in-place convert string to upper case /// \return ref to transformed string void str_toupper(std::string &str) {

 std::transform(str.begin(), 
                str.end(), 
                str.begin(),
                (int(*)(int)) std::toupper);

}

/// \brief in-place convert string to lower case /// \return ref to transformed string void str_tolower(std::string &str) {

 std::transform(str.begin(), 
                str.end(), 
                str.begin(),
                (int(*)(int)) std::tolower);

} </cpp>

Here is sample usage code:

<cpp>

1. include <iostream>

using namespace std; int main() {

 string foo("_upperCas3Me!!");
 str_toupper(foo);
 cout << foo << endl;
 str_tolower(foo);
 cout << foo << endl;
 return 0;

} </cpp>

C#

string array = "alphaBETA";
System.Console.WriteLine(array.ToUpper());
System.Console.WriteLine(array.ToLower());

Clojure

 (def string "alphaBETA)
 (println (. string toUpperCase))
 (println (. string toLowerCase))

ColdFusion

converting a string literal

<cfset upper = UCase("alphaBETA")>
<cfset lower = LCase("alphaBETA")>

converting the value of a variable

<cfset string = "alphaBETA">
<cfset upper = UCase(string)>
<cfset lower = LCase(string)>

Common Lisp

You can use the string-upcase function to perform upper casing:

CL-USER> (string-upcase "alphaBETA")
"ALPHABETA"

and you can do lower casing by using string-downcase:

CL-USER> (string-downcase "alphaBETA")
"alphabeta"

D

<d>import tango.text.Unicode : toUpper, toLower; import tango.io.Stdout;

void main() {

   auto str = "alphaBETA";
   Stdout(str.toUpper()).newline;
   Stdout(str.toLower()).newline;

}</d>

Delphi

 writeln(uppercase('alphaBETA'));
 writeln(lowercase('alphaBETA'));

E

["alphaBETA".toUpperCase(),
 "alphaBETA".toLowerCase()]

Factor

"alphaBETA" >lower
"alphaBETA" >upper

Forth

ANS Forth does not have words to convert case for either strings or characters. For known alpha-numeric ASCII characters, the following can be used:

: tolower ( C -- c ) 32 or ;
: toupper ( c -- C ) 32 invert and ;
: lower ( addr len -- ) over + swap  do i c@ tolower i c!  loop ;
: upper ( addr len -- ) over + swap  do i c@ toupper i c!  loop ;

If the character range is unknown, these definitions are better:

: tolower ( C -- c ) dup [char] A [char] Z 1+ within if 32 + then ;
: toupper ( c -- C ) dup [char] a [char] z 1+ within if 32 - then ;

Works with: Win32Forth version 4.2

create s ," alphaBETA"
s count type
s count 2dup upper type
s count 2dup lower type

Output:

alphaBETA
ALPHABETA
alphabeta

Haskell

import Data.Char

s = "alphaBETA"

lower = map toLower s
upper = map toUpper s

IDL

str = "alphaBETA"
print, str
print, strupcase(str) 
print, strlowcase(str)

J

upper=: (a.,~a.{~65+i.26) {~ (a.,~a.{~97+i.26) i. ]
lower=: (a.,~a.{~97+i.26) {~ (a.,~a.{~65+i.26) i. ]

For example:

   upper 'alphaBETA'
ALPHABETA
   lower 'alphaBETA'
alphabeta

Java

String str = "alphaBETA";
System.out.println(str.toUpperCase());
System.out.println(str.toLowerCase());

JavaScript

alert( "alphaBETA".toUpperCase() );
alert( "alphaBETA".toLowerCase() );

Output:

ALPHABETA
alphabeta

Works with: NJS version 0.2.5

var string = "alphaBETA";
var uppercase = string.toUpperCase();
var lowercase = string.toLowerCase();

Logo

print uppercase "alphaBETA  ; ALPHABETA
print lowercase "alphaBETA  ; alphabeta

Nial

toupper 'alphaBETA'
=ALPHABETA
tolower 'alphaBETA'
=alphabeta

OCaml

<ocaml>let _ =

 let str = "alphaBETA" in
 Printf.printf "%s\n" (String.uppercase str);
 Printf.printf "%s\n" (String.lowercase str);

</ocaml>

Oz

%% to compile : ozc -x <file>
functor
import Open Application
define
  Stdout = {New Open.file init(name:stdout)}

  proc{PrintLn Msg} {Stdout write(vs:Msg#'\n')} end

  fun{SwapCase Ch}
    if{Char.isUpper Ch} then {Char.toLower Ch}
    elseif {Char.isLower Ch} then {Char.toUpper Ch}
    else Ch end
  end

  fun{StrCase CharCaseFunc InStr}
      {Map InStr CharCaseFunc}
  end

  {PrintLn {StrCase Char.toUpper "alphaBETA"}}
  {PrintLn {StrCase Char.toLower "alphaBETA"}}
  {PrintLn {StrCase SwapCase "alphaBETA"}}
  
  {Application.exit 0}
end

OpenEdge/Progress

   caps("alphaBETA") 
   lc("alphaBETA")

Perl

Works with: Perl version 5.x

my $string = "alphaBETA";
print uc($string), "\n";
print lc($string), "\n";

Also works in Perl 4 if the my is removed.

Works with: Perl version 6

my $string = "alphaBETA";
say $string.uc
say $string.lc

Pop11

lvars str = 'alphaBETA';
lowertoupper(str) =>
uppertolower(str) =>

Python

s = "alphaBETA"
print s.upper()
print s.lower()

Raven

'alphaBETA' upper
'alhpaBETA' lower

Ruby

Works with: Ruby version 1.8

"alphaBETA".downcase # => "alphabeta"
"alphaBETA".upcase # => "ALPHABETA"
"alphaBETA".swapcase # => "ALPHAbeta"

Scheme

(define s "alphaBETA")
(list->string (map char-upcase (string->list s)))
(list->string (map char-downcase (string->list s)))

Seed7

writeln(upper("alphaBETA"));
writeln(lower("alphaBETA"));

Smalltalk

'ALPHAbeta' asUppercase.
'ALPHAbeta' asLowercase.

Standard ML

val strupr = String.map Char.toUpper;
val strlwr = String.map Char.toLower;

Test

- strupr "alphaBETA";
val it = "ALPHABETA" : string
- strlwr "alphaBETA";
val it = "alphabeta" : string

SQL

Works with: MS SQL version 2005

declare @s varchar(10)
set @s = 'alphaBETA'
print upper(@s)
print lower(@s)

Tcl

set string alphaBETA
string toupper $string
# ==> ALPHABETA
string tolower $string
#==>  alphabeta

Toka

 needs ctype
 
 [ i 1 - ] is i
 [ string.getLength 0 [ dup i + c@ toupper over i + c! ] countedLoop ] is string.toUpper
 [ string.getLength 0 [ dup i + c@ tolower over i + c! ] countedLoop ] is string.toLower
 
 " alphaBETA" string.toUpper type cr
 " alphaBETA" string.toLower type cr

Visual Basic .NET

Works with Visual Basic 2008.

' Define 's'
Dim s AS String = "alphaBETA"

' Change 's' to Upper Case.
s =  s.ToUpper()

' Change 's' to Lower Case.
s = s.ToLower()