String concatenation
You are encouraged to solve this task according to the task description, using any language you may know.
Set a string variable equal to any text value. Print it to the console concatenated with a string literal. Create a new string variable whose value is the other variable concatenated with a string literal. Print this new variable.
ActionScript
<lang actionscript> package {
public class Str
{
public static function main():void
{
var s:String = "hello";
trace(s + " literal");
var s2:String = s + " literal";
trace(s2);
}
}
} </lang>
Ada
<lang ada> with Ada.Text_IO; use Ada.Text_IO;
procedure String_Concatenation is
S : String := "Hello";
begin
Put_Line (S & " literal");
declare
S1 : String := S & " literal";
begin
Put_Line (S1);
end;
end String_Concatenation; </lang> Sample output:
Hello literal Hello literal
AWK
The AWK concatenation operator is just a space. <lang awk>BEGIN {
s = "hello" print s " literal" s1 = s " literal" print s1
}</lang>
ALGOL 68
STRING s := "hello"; print ((s + " literal", new line)); STRING s1 := s + " literal"; print ((s1, new line))
Output:
hello literal hello literal
BASIC
<lang qbasic>s$ = "hello" print s$;" literal" 'or s$ + " literal" s2$ = s$ + " literal" print s2$</lang> Output:
hello literal hello literal
C
<lang c>#include <stdio.h>
- include <stdlib.h>
- include <string.h>
char *sconcat(const char *s1, const char *s2) {
char *s0 = malloc(strlen(s1)+strlen(s2)+1); strcpy(s0, s1); strcat(s0, s2); return s0;
}
int main() {
const char *s = "hello";
char *s2;
printf("%s literal\n", s);
/* or */
printf("%s%s\n", s, " literal");
s2 = sconcat(s, " literal");
puts(s2);
free(s2);
}</lang>
C++
<lang cpp>#include <string>
- include <iostream>
int main() {
std::string s = "hello"; std::cout << s << " literal" << std::endl; std::string s2 = s + " literal"; std::cout << s2 << std::endl; return 0;
}</lang> Output:
hello literal hello literal
C#
<lang csharp>using System;
class Program {
static void Main(string[] args) {
string s = "hello";
Console.WriteLine(s + " literal");
string s2 = s + " literal";
Console.WriteLine(s2);
}
}</lang>
D
<lang d>string s = "hello"; writefln(s ~ " world"); auto s2 = s ~ " world"; writefln(s2); </lang>
E
<lang e> def a := "rose" println(a + "bud") def b := a + "tte" println(b) </lang>
Forth
<lang forth>s" hello" pad place pad count type s" there!" pad +place \ +place is called "append" on some Forths pad count type</lang>
Fortran
<lang fortran>program StringConcatenation
integer, parameter :: maxstringlength = 64 character (*), parameter :: s = "hello" character (maxstringlength) :: s1
print *,s // " literal" s1 = s // " literal" print *,s1
end program</lang>
Groovy
<lang groovy>def s = "Greetings " println s + "Earthlings"
def s1 = s + "Earthlings" println s1</lang>
Output:
Greetings Earthlings Greetings Earthlings
Haskell
<lang haskell>import System.IO s = "hello" s1 = s ++ " literal" main = do putStrLn (s ++ " literal")
putStrLn s1</lang>
Java
<lang java5>public class Str{
public static void main(String[] args){
String s = "hello";
System.out.println(s + " literal");
String s2 = s + " literal";
System.out.println(s2);
}
}</lang> Output:
hello literal hello literal
JavaScript
<lang javascript>var s = "hello" print(s + " there!") </lang>
Logo
make "s "hello print word :s "| there!|
Objective-C
<lang objc>#import <Foundation/Foundation.h>
int main() {
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
NSString *s = @"hello";
printf("%s%s\n", [s UTF8String], " literal");
NSString *s2 = [s stringByAppendingString:@" literal"];
// or, NSString *s2 = [NSString stringWithFormat:@"%@%@", s, @" literal"];
puts([s2 UTF8String]);
/* or */
NSMutableString *s3 = [NSMutableString stringWithString: s];
[s3 appendString: @" literal"];
puts([s3 UTF8String]);
[pool release];
return 0;
}</lang>
M4
M4 has macros rather than variables, but a macro expanded can work like a variable. <lang m4>define(`concat',`$1$2')dnl define(`A',`any text value')dnl concat(`A',` concatenated with string literal') define(`B',`concat(`A',` and string literal')')dnl B</lang>
MAXScript
s = "hello" print (s + " literal") s1 = s + " literal" print s1
Metafont
<lang metafont>string a, b; a := "String"; message a & " literal"; b := a & " literal"; message b;</lang>
Modula-3
Strings in Modula-3 are called TEXTs. Concatenation can use &, just like Ada.
<lang modula3>MODULE Concat EXPORTS Main;
IMPORT IO;
VAR string: TEXT := "String";
string1: TEXT;
BEGIN
IO.Put(string & " literal.\n"); string1 := string & " literal.\n"; IO.Put(string1);
END Concat.</lang>
Modula-3 also provides modules for dealing with TEXTs, such as Text.
<lang modula3>string1 := Text.Concat(string, " literal.\n");</lang>
OCaml
<lang ocaml>let s = "hello" let s1 = s ^ " literal" let () =
print_endline (s ^ " literal"); (* or Printf.printf "%s literal\n" s; *) print_endline s1</lang>
Pascal
<lang pascal>Program StringConcat;
Var
s, s1 : String;
Begin
s := 'hello';
writeln(s + ' literal');
s1 := concat(s, ' literal');
{ s1 := s + ' literal'; works too, with FreePascal }
writeln(s1);
End.</lang>
Perl
<lang perl>#! /usr/bin/perl my $s = "hello"; print $s . " literal" . "\n"; my $s1 = $s . " literal"; print $s1 . "\n";</lang>
PHP
<lang php><?php $s = "hello"; echo $s . " literal" . "\n"; $s1 = $s . " literal"; echo $s1 . "\n"; ?></lang>
Python
<lang python>s = "hello" print s + " literal" s1 = s + " literal" print s1</lang>
Ruby
<lang ruby>s = "hello" puts s + " literal" s1 = s + " literal" puts s1</lang>
Scheme
<lang scheme>(define s "hello") (display (string-append s " literal")) (newline) (define s1 (string-append s " literal")) (display s1) (newline)</lang>
Smalltalk
|s s1| s := 'hello'. (s,' literal') printNl. s1 := s,' literal'. s1 printNl.
Standard ML
<lang sml>val s = "hello" val s1 = s ^ " literal\n" val () =
print (s ^ " literal\n"); print s1</lang>
Tcl
<lang tcl>set s hello puts "$s there!" append s " there!" puts $s</lang> You can also just group the strings to concatenate together at the point where they are used, using Tcl's built-in syntactic concatenation: <lang tcl>set s "Hello " set t "World" set u "!" puts $s$t$u ;# There is nothing special here about using puts; just an example</lang>
UNIX Shell
s="hello" echo "$s literal" s1="$s literal" echo $s1
UnixPipes
echo "hello"
| xargs -n1 -i echo {} literal