String concatenation

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

Basic Data Operation
This is a basic data operation. It represents a fundamental action on a basic data type.

You may see other such operations in the Basic Data Operations category, or:

Integer Operations
Arithmetic | Comparison

Boolean Operations
Bitwise | Logical

String Operations
Concatenation | Interpolation | Comparison | Matching

Memory Operations
Pointers & references | Addresses

Create a string variable equal to any text value. Create another string variable whose value is the original variable concatenated with another string literal.

To illustrate the operation, show the content of the variables.

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

AutoHotkey

<lang AutoHotkey>s := "hello" Msgbox, %s% s1 := s . " literal" ;the . is optional Msgbox, %s1%</lang>

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

Works with: ALGOL 68 version Revision 1 - no extensions to language used

Works with: ALGOL 68G version Any - tested with release 1.18.0-9h.tiny

Works with: ELLA ALGOL 68 version Any (with appropriate job cards) - tested with release 1.8-8d

<lang algol68>STRING s := "hello"; print ((s + " literal", new line)); STRING s1 := s + " literal"; print ((s1, new line))</lang> Output:

hello literal
hello literal

BASIC

Works with: QuickBasic version 4.5

Works with: Liberty BASIC

<lang qbasic>s$ = "hello" print s$;" literal" 'or s$ + " literal" s2$ = s$ + " literal" print s2$</lang> Output:

hello literal
hello literal

BBC BASIC

<lang bbcbasic> stringvar1$ = "Hello,"

     stringvar2$ = stringvar1$ + " world!"
     PRINT "Variable 1 is """ stringvar1$ """"
     PRINT "Variable 2 is """ stringvar2$ """"</lang>

Output:

Variable 1 is "Hello,"
Variable 2 is "Hello, world!"

ZX Spectrum Basic

<lang basic}10 LET s$="Hello" 20 LET s$=s$+" World!" 30 PRINT s$</lang>

Batch File

<lang dos>set string=Hello echo %string% World set string2=%string% World</lang>

C

<lang c>#include <stdio.h>

1. include <stdlib.h>
2. include <string.h>

char *sconcat(const char *s1, const char *s2) {

 char *s0 = (char *)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>

1. 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) {
       var s = "hello";
       Console.Write(s);
       Console.WriteLine(" literal");
       var s2 = s + " literal";
       Console.WriteLine(s2);
   }

}</lang>

Clojure

<lang lisp>(def a-str "abcd") (println (str a-str "efgh"))

(def a-new-str (str a-str "efgh")) (println a-new-str)</lang>

Common Lisp

<lang lisp>(let ((s "hello"))

   (format t "~a there!~%" s)
   (let* ((s2 " there!")
          (s (concatenate 'string s s2)))
       (format t "~a~%" s)))</lang>

<lang lisp>(defparameter *s* "hello") (print (concatenate 'string *s* " literal")) (defparameter *s1* (concatenate 'string *s* " literal")) (print *s1*)</lang>

D

<lang d>import std.stdio;

void main() {

   string s = "hello";
   writeln(s ~ " world");
   auto s2 = s ~ " world";
   writeln(s2);

}</lang>

Delphi

<lang delphi>program Concat;

{$APPTYPE CONSOLE}

var

 s1, s2: string;

begin

 s1 := 'Hello';
 s2 := s1 + ' literal';
 WriteLn(s1);
 WriteLn(s2);

end.</lang>

Dylan.NET

<lang Dylan.NET> //include mscorlib.dll in the same directory as this program //to be ccompiled usiing the under development dylan.NET

1. refasm mscorlib.dll

import System

assembly concatex exe ver 1.1.0.0

class public auto ansi Module1

  method public static void main()
     var s1 as string = "concat"
     var s2 as string = "enation"
     Console::Write(s1)
     Console::WriteLine(s2)
     var s3 as string = String::Concat(s1,s2)
     Console::WriteLine(s3)
 end method

end class </lang>

Output is: concatenation
concatenation

Erlang

<lang Erlang> S = "hello", S1 = S ++ " literal", io:format ("~s literal~n",[S]), io:format ("~s~n",[S1]) </lang> Sample output:

hello literal
hello literal

Euphoria

<lang Euphoria>sequence s, s1 s = "hello" puts(1, s & " literal") puts(1,'\n') s1 = s & " literal" print (1, s1)) puts(1,'\n')</lang>

Output:

hello literal
hello literal

Factor

<lang factor>"wake up" [ " sheeple" append print ] [ ", you sheep" append ] bi print</lang>

Fantom

Illustrating in fansh: <lang fantom> fansh> a := "abc" abc fansh> b := a + "def" abcdef fansh> a abc fansh> b abcdef </lang>

Forth

Works with: GNU 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>

Gambas

In gambas, the ampersand symbol is used as a concatenation operator:

<lang gambas> DIM bestclub AS String DIM myconcat AS String bestclub = "Liverpool" myconcat = bestclub & " Football Club" </lang>

Go

<lang go>package main

import "fmt"

func main() {

   // text assigned to a string variable
   s := "hello"

   // output string variable
   fmt.Println(s)

   // this output requested by original task descrption, although
   // not really required by current wording of task description.
   fmt.Println(s + " literal")

   // concatenate variable and literal, assign result to another string variable
   s2 := s + " literal"

   // output second string variable
   fmt.Println(s2)

}</lang> Output:

hello
hello literal
hello literal

Golfscript

<lang golfscript>"Greetings ":s; s"Earthlings"+puts s"Earthlings"+:s1; s1 puts</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>

HicEst

<lang HicEst>CHARACTER s = "hello", sl*100

WRITE() s // " literal" sl = s // " literal" WRITE() sl</lang>

Icon and Unicon

<lang Icon>procedure main() s1 := "hello" write(s2 := s1 || " there.") # capture the reuslt for write(s2) # ... the 2nd write end</lang>

IDL

<lang idl> s1='Hello' print, s1 + ' literal' s2=s1 + ' literal' print, s2 </lang>

J

<lang J> s1 =. 'Some '

  ]s1, 'text '

Some text

  ]s2 =. s1 , 'more text!'

Some more text!</lang> For more info see:

http://www.jsoftware.com/help/dictionary/d320.htm on ,

http://www.jsoftware.com/help/dictionary/d500.htm on ]

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>

LabVIEW

The two input on the left are String Controls, the output on the right is a String Indicator. All of them can be placed on the Front Panel. the Concatenate Strings function can be placed on the Block Diagram. You can switch between the Front Panel and the Block Diagram by pressing Ctrl+E.

Liberty BASIC

See BASIC

Lisaac

<lang Lisaac>Section Header

+ name := STRING_CONCATENATION;

Section Public

- main <- (

 + sc : STRING_CONSTANT;
 + sv : STRING;

 sc := "Hello";
 (sc + " literal").println;

 sv := sc + " literal";
 sv.println;

);</lang>

Logo

<lang logo>make "s "hello print word :s "| there!|</lang>

lua

<lang lua> a = "hello " print(a .. "world") c = a .. "world" print(c)</lang>

MATLAB

<lang MATLAB>>> string1 = '1 Fish'

string1 =

1 Fish

>> string2 = [string1 ', 2 Fish, Red Fish, Blue Fish']

string2 =

1 Fish, 2 Fish, Red Fish, Blue Fish</lang>

MUMPS

<lang MUMPS> STRCAT

SET S="STRING"
WRITE !,S
SET T=S_" LITERAL"
WRITE !,T
QUIT

</lang>

Output:

CACHE>D STRCAT^ROSETTA
 
STRING
STRING LITERAL

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

<lang maxscript>s = "hello" print (s + " literal") s1 = s + " literal" print s1</lang>

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>

Nimrod

Strings can be concatenated with &. <lang nimrod>var str, str1 = "String" echo(str & " literal.") str1 = str1 & " literal." echo(str1)</lang>

Objeck

<lang objeck> bundle Default {

 class Repeat {
   function : Main(args : String[]) ~ Nil {
     s := "hello";
     s->PrintLine();
     " literal"->PrintLine();
     s->Append(" literal");
     s->PrintLine();
   }
 }

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

Oz

Strings are lists and are concatenated with the "Append" function. However, often "virtual strings" are used instead. "Virtual string are designed as a convenient way to combine strings, byte strings, atoms, integers and floats to compound strings without explicit concatenation and conversion".

<lang oz>declare S = "hello" {System.showInfo S#" literal"} %% virtual strings are constructed with "#" S1 = {Append S " literal"} {System.showInfo S1} </lang>

PARI/GP

<lang>s = "Hello "; s = Str(s, "world"); \\ Alternately, this could have been: \\ s = concat(s, "world"); print(s);</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>my $s = 'hello'; print $s . ' literal', "\n"; my $s1 = $s . ' literal'; print $s1, "\n";</lang>

An example of destructive concatenation:

<lang perl>$s .= ' literal'; print $s, "\n";</lang>

Perl 6

Works with: Rakudo version #22 "Thousand Oaks"

<lang perl6>my $s = 'hello'; say $s ~ ' literal'; my $s1 = $s ~ ' literal'; say $s1;</lang>

An example of mutating concatenation:

<lang perl6>$s ~= ' literal'; say $s;</lang>

Note also that most concatenation in Perl is done implicitly via interpolation.

PL/I

<lang PL/I> declare (s, t) character (20) varying;

s = 'hello from me'; display (s || ' to you.' ); t = s; display (t || ' to you all.' ); </lang>

PowerShell

<lang powershell>$s = "Hello" Write-Host $s World.

1. alternative, using variable expansion in strings

Write-Host "$s World."

$s2 = $s + " World." Write-Host $s2</lang>

PHP

<lang php><?php $s = "hello"; echo $s . " literal" . "\n"; $s1 = $s . " literal"; echo $s1 . "\n"; ?></lang>

PicoLisp

<lang PicoLisp>(let Str1 "First text"

  (prinl Str1 " literal")
  (let Str2 (pack Str1 " literal")
     (prinl Str2) ) )</lang>

PureBasic

<lang PureBasic>If OpenConsole()

 s$ = "hello"
 PrintN( s$ + " literal")
 s2$ = s$ + " literal"
 PrintN(s2$)

 Print(#CRLF$ + #CRLF$ + "Press ENTER to exit")
 Input()
 CloseConsole()

EndIf</lang>

Python

<lang python>import std.stdio;

void main() {

   string s = "hello";
   writeln(s ~ " world");
   auto s2 = s ~ " world";
   writeln(s2);

}</lang>

R

<lang R>hello <- "hello" paste(hello, "literal") # "hello literal" hl <- paste(hello, "literal") #saves concatenates string to a new variable paste("no", "spaces", "between", "words", sep="") # "nospacesbetweenwords"</lang>

REBOL

<lang REBOL>s: "hello" print s1: rejoin [s " literal"] print s1</lang>

REXX

<lang rexx> s = "hello" say s "literal" t = s "literal" say t

/* The above method works without spaces too */ genus="straw" say genus"berry" /* This outputs strawberry */

</lang>

Retro

<lang Retro>with strings' "hello" "literal" append puts</lang>

Ruby

<lang ruby>s = "hello" puts s + " literal" s1 = s + " literal" puts s1 s1 << " another" # append to s1</lang>

Sather

<lang sather>class MAIN is

 main is
   s ::= "hello";
   #OUT + s + " literal\n";
   s2 ::= s + " literal";
   #OUT + s2 + "\n";
 end;

end;</lang>

Scheme

<lang scheme>(define s "hello") (display (string-append s " literal")) (newline) (define s1 (string-append s " literal")) (display s1) (newline)</lang>

Slate

<lang slate>define: #s -> 'hello'. inform: s ; ' literal'. define: #s1 -> (s ; ' literal'). inform: s1.</lang>

Smalltalk

<lang smalltalk>|s s1| s := 'hello'. (s,' literal') printNl. s1 := s,' literal'. s1 printNl.</lang>

SNOBOL4

<lang snobol> greet1 = "Hello, " output = greet1 greet2 = greet1 "World!" output = greet2 end</lang>

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>

TI-89 BASIC

<lang ti89b>"aard" → sv Disp sv & "vark" sv & "wolf" → sv2</lang>

TUSCRIPT

<lang tuscript> $$ MODE TUSCRIPT s = "Hello " print s, "literal"

s1 = CONCAT (s,"literal") print s1 </lang> Output:

Hello literal
Hello literal 

UNIX Shell

Works with: Bourne Shell

Works with: bash

<lang sh>s="hello" echo "$s literal" s1="$s literal" # This method only works with a space between the strings echo $s1

1. To concatenate without the space we need squiggly brackets:

genus='straw' fruit=${genus}berry # This outputs the word strawberry echo $fruit

</lang>

UnixPipes

<lang bash>echo "hello"

| xargs -n1 -i echo {} literal</lang>

Visual Basic .NET

Platform: .NET

Works with: Visual Basic .NET version 9.0+

<lang vbnet>s = "Hello" Console.WriteLine(s & " literal") s1 = s + " literal" Console.WriteLine(s1)</lang>

Yorick

<lang yorick>var1 = "Hello"; var2 = var1 + ", world!"; write, var1; write, var2;</lang>