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

package
{
    public class Str
    {
        public static function main():void
        {
            var s:String = "hello";
            trace(s + " literal");
            var s2:String = s + " literal";
            trace(s2);
        }
    }
}

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;

Sample output:

Hello literal
Hello literal

AppleScript

try
    set endMsg to "world!"
    set totMsg to "Hello, " & endMsg
    display dialog totMsg
end try

AutoHotkey

s := "hello"
Msgbox, %s%
s1 := s . "  literal" ;the . is optional
Msgbox, %s1%

AWK

The AWK concatenation operator is nothing.

BEGIN {
   s = "hello"
   print s " literal"
   s1 = s " literal"
   print s1
}

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

STRING s := "hello";
print ((s + " literal", new line));
STRING s1 := s + " literal";
print ((s1, new line))

Output:

hello literal
hello literal

BASIC

Works with: QuickBasic version 4.5

Works with: Liberty BASIC

s$ = "hello"
PRINT s$;" literal" 'or s$ + " literal"
s2$ = s$ + " literal"
PRINT s2$

Output:

hello literal
hello literal

BBC BASIC

      stringvar1$ = "Hello,"
      stringvar2$ = stringvar1$ + " world!"
      PRINT "Variable 1 is """ stringvar1$ """"
      PRINT "Variable 2 is """ stringvar2$ """"

Output:

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

ZX Spectrum Basic

10 LET s$="Hello"
20 LET s$=s$+" World!"
30 PRINT s$

Batch File

set string=Hello
echo %string% World
set string2=%string% World

Bracmat

"Hello ":?var1 
& "World":?var2 
& str$(!var1 !var2):?var12 
& put$("var1=" !var1 ", var2=" !var2 ", var12=" !var12 "\n")

Output

var1= Hello  , var2= World , var12= Hello World

Burlesque

 
blsq ) "Hello, ""world!"?+
"Hello, world!"
 

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);
}

C++

#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;
}

Output:

hello literal
hello literal

C#

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);
    }
}

Clojure

(def a-str "abcd")
(println (str a-str "efgh"))
 
(def a-new-str (str a-str "efgh"))
(println a-new-str)

Common Lisp

(let ((s "hello"))
    (format t "~a there!~%" s)
    (let* ((s2 " there!")
           (s (concatenate 'string s s2)))
        (format t "~a~%" s)))

(defparameter *s* "hello")
(print (concatenate 'string *s* " literal"))
(defparameter *s1* (concatenate 'string *s* " literal"))
(print *s1*)

D

import std.stdio;
 
void main() {
    string s = "hello";
    writeln(s ~ " world");
    auto s2 = s ~ " world";
    writeln(s2);
}

Delphi

program Concat;
 
{$APPTYPE CONSOLE}
 
var
  s1, s2: string;
begin
  s1 := 'Hello';
  s2 := s1 + ' literal';
  WriteLn(s1);
  WriteLn(s2);
end.

DWScript

var s1 := 'Hello';
var s2 := s1 + ' World';
 
PrintLn(s1);
PrintLn(s2);

Dylan.NET

 
//to be compiled using dylan.NET v. 11.3.1.3 or later.
#refstdasm mscorlib.dll
 
import System
 
assembly concatex exe
ver 1.3.0.0
 
class public auto ansi Module1
 
   method public static void main()
        var s as string = "hello"
        Console::Write(s)
        Console::WriteLine(" literal")
        var s2 as string = s + " literal"
        Console::WriteLine(s2)
  end method
 
end class
 

Erlang

 
S = "hello",
S1 = S ++ " literal",
io:format ("~s literal~n",[S]),
io:format ("~s~n",[S1])
 

Sample output:

hello literal
hello literal

Euphoria

sequence s, s1
s = "hello"
puts(1, s & " literal")
puts(1,'\n')
s1 = s & " literal"
print (1, s1))
puts(1,'\n')

Output:

hello literal
hello literal

Factor

"wake up" [ " sheeple" append print ] [ ", you sheep" append ] bi print

Fantom

Illustrating in fansh:

 
fansh> a := "abc"
abc
fansh> b := a + "def"
abcdef
fansh> a
abc
fansh> b
abcdef
 

Forth

Works with: GNU Forth

s" hello" pad place
pad count type
s"  there!" pad +place    \ +place is called "append" on some Forths
pad count type

Fortran

program StringConcatenation
 
integer, parameter          :: maxstringlength = 64
character (maxstringlength) :: s1, s = "hello"
 
print *,s // " literal"
s1 = trim(s) // " literal"
print *,s1
 
end program

Gambas

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

 
DIM bestclub AS String
DIM myconcat AS String
bestclub = "Liverpool"
myconcat = bestclub & " Football Club"
 

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

Output:

hello
hello literal
hello literal

Golfscript

"Greetings ":s;
s"Earthlings"+puts
s"Earthlings"+:s1;
s1 puts

Groovy

def s = "Greetings "
println s + "Earthlings"
 
def s1 = s + "Earthlings"
println s1

Output:

Greetings Earthlings
Greetings Earthlings

Haskell

import System.IO
s = "hello"
s1 = s ++ " literal"
main = do putStrLn (s ++ " literal")
          putStrLn s1

HicEst

CHARACTER s = "hello", sl*100
 
WRITE() s // " literal"
sl = s // " literal"
WRITE() sl

Icon and Unicon

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

IDL

 
s1='Hello'
print, s1 + ' literal'
s2=s1 + ' literal'
print, s2
 

J

   s1 =. 'Some '
   ]s1, 'text '
Some text 
   ]s2 =. s1 , 'more text!'
Some more text!

For more info see:

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

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

Java

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);
   }
}

Output:

hello literal
hello literal

JavaScript

var s = "hello"
print(s + " there!")

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.

Lang5

: concat  2 compress "" join ;
'hello " literal" concat

Liberty BASIC

See BASIC

Lisaac

Section Header
 
+ name := STRING_CONCATENATION;
 
Section Public
 
- main <- (
  + sc : STRING_CONSTANT;
  + sv : STRING;
 
  sc := "Hello";
  (sc + " literal").println;
 
  sv := sc + " literal";
  sv.println;
 
);

Logo

make "s "hello
print word :s "| there!|

lua

 
a = "hello "
print(a .. "world")
c = a .. "world"
print(c)

Mathematica

str= "Hello ";
str<>"Literal"

MATLAB

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

Maxima

s: "the quick brown fox";
t: "jumps over the lazy dog";
sconcat(s, " ", t);
/* "the quick brown fox jumps over the lazy dog" */

Mercury

 
:- module string_concat.
:- interface.
 
:- import_module io.
:- pred main(io::di, io::uo) is det.
 
:- implementation.
:- import_module string.
 
main(!IO) :-
    S = "hello",
    S1 = S ++ " world",
    io.write_string(S, !IO), io.nl(!IO),
    io.write_string(S1, !IO), io.nl(!IO).
 

MUMPS

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

Output:

CACHE>D STRCAT^ROSETTA
 
STRING
STRING LITERAL

M4

M4 has macros rather than variables, but a macro expanded can work like a variable.

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

MAXScript

s = "hello"
print (s + " literal")
s1 = s + " literal"
print s1

Metafont

string a, b;
a := "String";
message a & " literal";
b := a & " literal";
message b;

Modula-3

Strings in Modula-3 are called TEXTs. Concatenation can use &, just like Ada.

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.

Modula-3 also provides modules for dealing with TEXTs, such as Text.

string1 := Text.Concat(string, " literal.\n");

Nemerle

Can be done with Concat() method or + operator:

using System;
using System.Console;
using Nemerle.Utility.NString; // contains method Concat()
 
module Stringcat
{
    Main() : void
    {
        def text1 = "This string has";
        def cat1  = Concat( " ", [text, "been concatenated"]);
        def cat2  = text1 + " also been concatenated";
        Write($"$cat1\n$cat2\n");
    }
}

NetRexx

/* NetRexx */
 
options replace format comments java crossref savelog symbols
 
s1 = 'any text value'
s2 = 'another string literal'
s3 = s1    s2 -- concatenate variables with blank space (note that only one blank space is added)
s4 = s1 || s2 -- concatenate variables with abuttal (here, no blank spaces are added)
s5 = s1    'another string literal' -- concatenate a variable and a literal with blank space
s6 = s1'another string literal'     -- concatenate a variable and a literal using abuttal
s7 = s1 || 'another string literal' -- ditto
 
say 's1:' s1 -- concatenation with blank space is employed here too
say 's2:' s2
say 's3:' s3
say 's4:' s4
say 's5:' s5
say 's6:' s6
say 's7:' s7
 

Output

s1: any text value
s2: another string literal
s3: any text value another string literal
s4: any text valueanother string literal
s5: any text value another string literal
s6: any text valueanother string literal
s7: any text valueanother string literal

Nimrod

Strings can be concatenated with &.

var str, str1 = "String"
echo(str & " literal.")
str1 = str1 & " literal."
echo(str1)

Objeck

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

Objective-C

#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;
}

OCaml

let s = "hello"
let s1 = s ^ " literal"
let () =
  print_endline (s ^ " literal");
  (* or Printf.printf "%s literal\n" s; *)
  print_endline s1

Openscad

a="straw";
b="berry";
c=str(a,b);    /* Concatenate a and b */
echo (c);

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

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

PARI/GP

s = "Hello ";
s = Str(s, "world");
\\ Alternately, this could have been:
\\ s = concat(s, "world");
print(s);

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.

Perl

my $s = 'hello';
print $s . ' literal', "\n";
my $s1 = $s . ' literal';
print $s1, "\n";

An example of destructive concatenation:

$s .= ' literal';
print $s, "\n";

Perl 6

Works with: Rakudo version #22 "Thousand Oaks"

my $s = 'hello';
say $s ~ ' literal';
my $s1 = $s ~ ' literal';
say $s1;

An example of mutating concatenation:

$s ~= ' literal';
say $s;

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

PL/I

 
declare (s, t) character (30) varying;
 
s = 'hello from me';
display (s || ' to you.' );
t = s || ' to you all';
display (t);
 

PowerShell

$s = "Hello"
Write-Host $s World.
 
# alternative, using variable expansion in strings
Write-Host "$s World."
 
$s2 = $s + " World."
Write-Host $s2

PHP

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

PicoLisp

(let Str1 "First text"
   (prinl Str1 " literal")
   (let Str2 (pack Str1 " literal")
      (prinl Str2) ) )

PureBasic

If OpenConsole()
 
  s$ = "hello"
  PrintN( s$ + " literal")
  s2$ = s$ + " literal"
  PrintN(s2$)
 
  Print(#CRLF$ + #CRLF$ + "Press ENTER to exit")
  Input()
  CloseConsole()
EndIf

Python

s1 = "hello"
print s1 + " world"
 
s2 = s1 + " world"
print s2

Output:

hello world
hello world

When concatenating many strings, it is more efficient to use the join method of a string object, which takes a list of strings to be joined. The string on which join is called is used as a separator.

s1 = "hello"
print ", ".join([s1, "world", "mom"])
 
s2 = ", ".join([s1, "world", "mom"])
print s2

Output:

hello, world
hello, world

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"

Racket

#lang racket
(define hello "hello")
(displayln hello)
 
(define world (string-append hello " " "world" "!"))
(displayln world)
 
;outputs:
;  hello
;  hello world!

Raven

# Cat strings
"First string and " "second string" cat print
 
# Join
[ "First string" "second string" "third string" ] " and " join print
 
# print
[ "First string" "second string" "third string" ] each print
 
# Formatted print
"\n" "Third string" "Second string" "First string" "%s %s %s %s" print
 
# Heredoc
" - NOT!!" as $x
"This is the only way to do it%($x)s" print
 

First string and second string
First string and second string and third string
First stringsecond stringthird string
First string Second string Third string 

This is the only way to do it - NOT!!

REBOL

s: "hello"
print s1: rejoin [s " literal"]
print s1

REXX

s = "hello"
say s "literal" 
t = s "literal"    /* Whitespace between the two strings causes a space in the output */
say t
 
                        /* The above method works without spaces too */
genus="straw"
say genus"berry"        /* This outputs strawberry */
say genus || "berry"    /* Concatenation using a doublepipe does not cause spaces */

Retro

with strings'
"hello" "literal" append puts

Ruby

s = "hello"
puts s + " literal"
s1 = s + " literal"
puts s1
s1 << " another" # append to s1

SAS

data _null_;
   a="Hello,";
   b="World!";
   c=a !! " " !! b;
   put c;
run;

Sather

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

Scala

 
val s = "hello"
val s2 = s + " world"
println(s2)
 

Scheme

(define s "hello")
(display (string-append s " literal"))
(newline)
(define s1 (string-append s " literal"))
(display s1)
(newline)

Seed7

$ include "seed7_05.s7i";
 
const proc: main is func
  local
    var string: s is "hello";
    var string: s2 is "";
  begin
    writeln(s <& " world");
    s2 := s & " world";
    writeln(s2);
  end func;

Output:

hello world
hello world

Slate

define: #s -> 'hello'.
inform: s ; ' literal'.
define: #s1 -> (s ; ' literal').
inform: s1.

Smalltalk

|s s1| s := 'hello'.
(s,' literal') printNl.
s1 := s,' literal'.
s1 printNl.

SNOBOL4

	greet1 = "Hello, "
	output = greet1
	greet2 = greet1 "World!"
	output = greet2
end

Standard ML

val s = "hello"
val s1 = s ^ " literal\n"
val () =
  print (s ^ " literal\n");
  print s1

Tcl

set s hello
puts "$s there!"
append s " there!"
puts $s

You can also just group the strings to concatenate together at the point where they are used, using Tcl's built-in syntactic concatenation:

set s "Hello "
set t "World"
set u "!"
puts $s$t$u  ;# There is nothing special here about using puts; just an example

TI-89 BASIC

"aard" → sv
Disp sv & "vark"
sv & "wolf" → sv2

TorqueScript

%string = "Hello";
echo(%string);
%other = " world!";
echo(%other);
echo(%string @ %other);

TUSCRIPT

 
$$ MODE TUSCRIPT
s = "Hello "
print s, "literal"
 
s1 = CONCAT (s,"literal")
print s1
 

Output:

Hello literal
Hello literal 

UNIX Shell

Works with: Bourne Shell

Works with: bash

s="hello"
echo "$s literal"
s1="$s literal"    # This method only works with a space between the strings
echo $s1
 
# To concatenate without the space we need squiggly brackets:
genus='straw'
fruit=${genus}berry  # This outputs the word strawberry
echo $fruit
 
 

UnixPipes

echo "hello" 
 | xargs -n1 -i echo {} literal

Visual Basic .NET

Platform: .NET

Works with: Visual Basic .NET version 9.0+

s = "Hello"
Console.WriteLine(s & " literal")
s1 = s + " literal"
Console.WriteLine(s1)

XPL0

func Concat(S1, S2, S3);        \Concatenate strings: S3:= S1 + S2
char S1, S2, S3;
int  C, I, J;
[I:= 0;
repeat  C:= S1(I);
        S3(I):= C & $7F;        \remove MSb terminator from first string
        I:= I+1;
until   C >= $80;
J:= 0;
repeat  C:= S2(J);
        S3(I+J):= C;
        J:= J+1;
until   C >= $80;
return S3;
];
 
code Text=12;
char A, B, C(80);
[A:= "Hello";
 B:= " World!";
Concat(A, B, C);
Text(0, C);
]

Yorick

var1 = "Hello";
var2 = var1 + ", world!";
write, var1;
write, var2;