String prepend: Difference between revisions
(→{{header|Forth}}: Add Fortran.) |
m (added whitespace before the TOC (table of contents), added a ;Task: (bold) header, added other whitespace to the task's preamble.) |
||
Line 1: | Line 1: | ||
{{task|Basic language learning}} |
{{task|Basic language learning}} |
||
{{basic data operation}} |
|||
[[Category:String manipulation]] [[Category: String manipulation]] [[Category:Simple]] |
|||
[[Category:String manipulation]] |
|||
[[Category: String manipulation]] |
|||
[[Category:Simple]] |
|||
{{omit from|bc|No string operations in bc}} |
{{omit from|bc|No string operations in bc}} |
||
{{omit from|dc|No string operations in dc}} |
{{omit from|dc|No string operations in dc}} |
||
;Task: |
|||
Create a string variable equal to any text value. |
Create a string variable equal to any text value. |
||
Prepend the string variable with another string literal. |
Prepend the string variable with another string literal. |
||
If your language supports any idiomatic ways to do this without referring to the variable twice in one expression, include such solutions. |
If your language supports any idiomatic ways to do this without referring to the variable twice in one expression, include such solutions. |
||
To illustrate the operation, show the content of the variable. |
To illustrate the operation, show the content of the variable. |
||
<br><br> |
|||
=={{header|Ada}}== |
=={{header|Ada}}== |
Revision as of 17:22, 7 July 2016
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
- Task
Create a string variable equal to any text value.
Prepend the string variable with another string literal.
If your language supports any idiomatic ways to do this without referring to the variable twice in one expression, include such solutions.
To illustrate the operation, show the content of the variable.
Ada
In Ada, a variable of type String cannot change its length. So the variable S which we will change, need to be of the type Unbounded_String. Thus the need for conversions from String literal to Unbounded_String for initialization, and from Unbounded_String to String for printing.
<lang Ada>with Ada.Text_IO; with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
procedure Prepend_String is
S: Unbounded_String := To_Unbounded_String("World!");
begin
S := "Hello " & S;-- this is the operation to prepend "Hello " to S. Ada.Text_IO.Put_Line(To_String(S));
end Prepend_String;</lang>
- Output:
Hello World!
ALGOL 68
File: String_prepend.a68<lang algol68>#!/usr/bin/a68g --script #
- -*- coding: utf-8 -*- #
STRING str := "12345678"; "0" +=: str; print(str)</lang>
- Output:
012345678
AutoHotkey
<lang autohotkey>s := "foo" s := s "bar" Msgbox % s</lang>
- Output:
foobar
AWK
<lang AWK>
- syntax: GAWK -f STRING_PREPEND.AWK
BEGIN {
s = "bar" s = "foo" s print(s) exit(0)
} </lang>
- Output:
foobar
BASIC
<lang BBC BASIC>S$ = " World!" S$ = "Hello" + S$ PRINT S$ </lang>
- Output:
Hello World!
Applesoft BASIC
BBC BASIC
Bracmat
<lang bracmat> World!:?string & str$("Hello " !string):?string & out$!string</lang>
Hello World!
C
<lang c>#include<stdio.h>
- include<string.h>
- include<stdlib.h>
int main() {
char str[100]="my String"; char *cstr="Changed "; char *dup; sprintf(str,"%s%s",cstr,(dup=strdup(str))); free(dup); printf("%s\n",str); return 0;
}</lang>
- Output:
Changed my String
C++
<lang cpp>include <vector>
- include <algorithm>
- include <string>
- include <iostream>
int main( ) {
std::vector<std::string> myStrings { "prepended to" , "my string" } ; std::string prepended = std::accumulate( myStrings.begin( ) ,
myStrings.end( ) , std::string( "" ) , []( std::string a , std::string b ) { return a + b ; } ) ;
std::cout << prepended << std::endl ; return 0 ;
}</lang>
- Output:
prepended tomy string
C#
<lang csharp>using System;
namespace PrependString {
class Program { static void Main(string[] args) { string str = "World"; str = "Hello " + str; Console.WriteLine(str); Console.ReadKey(); } }
}</lang>
Hello World
Clojure
<lang clojure>(def s (ref "World")) (dosync (alter s #(str "Hello " %)))
user=> @s "Hello World"</lang>
COBOL
<lang COBOL> identification division.
program-id. prepend. data division. working-storage section. 1 str pic x(30) value "World!". 1 binary. 2 len pic 9(4) value 0. 2 scratch pic 9(4) value 0. procedure division. begin. perform rev-sub-str move function reverse ("Hello ") to str (len + 1:) perform rev-sub-str display str stop run .
rev-sub-str. move 0 to len scratch inspect function reverse (str) tallying scratch for leading spaces len for characters after space move function reverse (str (1:len)) to str . end program prepend.</lang>
Hello World!
<lang cobol> >>SOURCE FREE PROGRAM-ID. prepend.
DATA DIVISION. WORKING-STORAGE SECTION. 01 str PIC X(30) VALUE "world!".
PROCEDURE DIVISION.
MOVE FUNCTION CONCATENATE("Hello, ", str) TO str DISPLAY str .
END PROGRAM prepend.</lang>
Common Lisp
A macro is necessary in order to prepend a string in-place: <lang lisp>(defmacro prependf (s &rest strs)
"Prepend the given string variable with additional strings. The string variable is modified in-place." `(setf ,s (concatenate 'string ,@strs ,s)))
(defvar *str* "foo") (prependf *str* "bar") (format T "~a~%" *str*)</lang>
- Output:
barfoo
D
<lang d>import std.stdio;
void main() {
string s = "world!"; s = "Hello " ~ s; writeln(s);
}</lang>
- Output:
Hello world!
Déjà Vu
<lang dejavu>local :s "world!" set :s concat( "Hello " s) !print s</lang>
- Output:
Hello world!
EchoLisp
<lang scheme> define-syntax-rule
(set!-string-prepend a before) (set! a (string-append before a))) → #syntax:set!-string-prepend
(define name "Presley")
→ name
(set!-string-prepend name "Elvis ") name
→ "Elvis Presley"
</lang>
Elena
<lang elena>#import system.
- symbol program =
[
#var s := "World". s := "Hello " + s. console writeLine:s. // Alternative way #var s2 := String new:"World". s2 insert:"Hello " &at:0. console writeLine:s2.
].</lang>
Elixir
<lang Elixir> str1 = "World!" str = "Hello, " <> str1 </lang>
- Output:
"Hello, World!"
Emacs Lisp
version 1
<lang Emacs Lisp> (defun glue (str1 str2)
(concat str1 str2) )
</lang>
version 2
<lang Emacs Lisp> (defun glue (str1 str2)
(format "%s%s" str1 str2) )
</lang> Eval: <lang Emacs Lisp> (setq str "World!") (setq str (glue "Hello, " str) ) (insert str) </lang> Output:
Hello, World!
Erlang
- Output:
1> S = "world". "world" 2> "Hello " ++ S. "Hello world"
ERRE
<lang ERRE> ...... S$=" World!" S$="Hello"+S$ PRINT(S$) ...... </lang>
- Output:
Hello World!
F#
<lang fsharp>let mutable s = "world!" s <- "Hello, " + s printfn "%s" s</lang>
Factor
<lang factor> "world" "Hello " prepend </lang>
Forth
Forth has no string prepend word, but adding it is not difficult. This demonstration starts from the low level operations that Forth gives us and quickly builds a simple set of "WORDS" (sub-routines) that let us move strings from address to address. Strings are just an address on the data stack so we can reference them as many times as we need to. Our prepend word makes use of the Return stack as a temporary storage for the address of the string we want to prepend. Standard Forth also provides a named general purpose buffer called PAD, so we make use of that too. With this PREPEND becomes part of the language.
<lang>\ the following functions are commonly native to a Forth system. Shown for completeness
- C+! ( n addr -- ) dup c@ rot + swap c! ; \ primitive: increment a byte at addr by n
- +PLACE ( addr1 length addr2 -- ) \ Append addr1 length to addr2
2dup 2>r count + swap move 2r> c+! ;
- PLACE ( addr1 len addr2 -- ) \ addr1 and length, placed at addr2 as counted string
2dup 2>r 1+ swap move 2r> c! ;
\ Example begins here
- PREPEND ( addr len addr2 -- addr2)
>R \ push addr2 to return stack PAD PLACE \ place the 1st string in PAD R@ count PAD +PLACE \ append PAD with addr2 string PAD count R@ PLACE \ move the whole thing back into addr2 R> ; \ leave a copy of addr2 on the data stack
- writeln ( addr -- ) cr count type ; \ syntax sugar for testing</lang>
Test our language extensions interactively at the console
256 buffer: string1 ok s" needs no introduction!" string1 place ok string1 writeln needs no introduction! ok s" This string " string1 prepend writeln This string needs no introduction! ok
Fortran
Early Fortran had almost no ability to manipulate text except via overwriting text literals in a FORMAT statement used in a READ, that would then appear when the same FORMAT statement was used in a WRITE. With Fortran IV came the ability to use arrays of integers and the A1 format code in READ and WRITE statements for them. With sixteen-bit integers, one might use A2 and so forth, but the numerical values of the integers would not be convenient especially if the sign bit was involved. This would be even more difficult with floating-point variables. Still, the desire for good headings and annotations and flexible layout flogged one onwards. With F77 came the CHARACTER type... <lang Fortran> CHARACTER*66 TEXT
TEXT = "World!" TEXT = "Hello "//TEXT WRITE (6,*) TEXT END </lang>
This means that variable TEXT has space for 66 characters, addressed as TEXT(first:last) starting with one. There is no associated string length facility, so the first assignment places the six characters of the supplied literal, followed by spaces all the way to the end of TEXT. Alternatively, TEXT(1:6) = "World!"
would place only six characters, leaving the rest of TEXT to hold whatever it may. This would probably be unsuitable for the next statement, which prepends "Hello " to the content of TEXT (including positions past six) and assigns the result to TEXT, overwriting its previous content - with the aid of a temporary working area. Only characters up to the capacity of the recipient will be transferred from the expression's result, and if the result is shorter than the capacity of the recipient, trailing spaces will be added. All of this is extra effort! And when TEXT is written out, all 66 characters will be sent forth. It is useful to have a function that locates the last non-blank character!
With F90, and standardised in F2003, came extensions that enable a variable to be "cut-to-fit" on each usage. The first assignment would discard any storage associated with TEXT and re-assign space matching the size of the expression's result, so TEXT would have six characters. In the next statement, the expression would be evaluated and produce twelve characters (six from "Hello ", and the six of the current size of TEXT), then the current storage for text would be discarded and TEXT re-allocated to be of size twelve. At some cost in overhead.
Go
<lang go>s := "world!" s = "Hello, " + s</lang>
Haskell
<lang haskell> Prelude> let f = (++" World!") Prelude> f "Hello" </lang>
- Output:
"Hello world!"
Icon and Unicon
<lang unicon>s := "world!" s := "Hello, " || s</lang>
J
<lang j> s=: 'value'
s
value
s=: 'new ',s s
new value</lang>
Java
<lang java>public class Prepend {
public static void main(String[] args) { String s = "world!"; System.out.println("Hello " + s); }
}</lang>
- Output:
Hello world!
JavaScript
<lang javascript>// No built-in prepend var s=", World" s = "Hello" + s print(s);</lang>
jq
<lang jq>"world!" as $s | "Hello " + $s</lang>
Julia
<lang julia>s = "world!" s = "Hello " * s</lang>
Lasso
<lang Lasso>local(x = ', World!')
- x->merge(1,'Hello')
- x // Hello, World!</lang>
LFE
Using the concatenation operator:
<lang lisp> > (set s "world") "world" > (++ "hello " s) "hello world" </lang>
Using the concatenation function:
<lang lisp> > (set s "world") "world" > (string:concat "hello " s) "hello world" </lang>
LiveCode
The idiomatic way is to use "before"<lang LiveCode>put "world" into x put "hello" before x put x // hello world</lang>
Lua
By concatenation:
<lang lua> s = "12345678" s = "0" .. s print(s)</lang>
By string formatting:
<lang lua> s = "12345678" s = string.format("%s%s", "0", s) print(s)</lang>
By list joining:
<lang lua> s = "12345678" s = table.concat({"0", s}) print(s)</lang>
- Output:
of each solution
012345678
Mathematica
<lang Mathematica>a = "any text value"; a = "another string literal" <> a (* using concatenation (no built-in prepend) *)</lang>
- Output:
"another string literalany text value"
Mercury
<lang mercury>:- module string_prepend.
- - interface.
- - import_module io.
- - pred main(io::di, io::uo) is det.
- - implementation.
- - import_module string.
main(!IO) :-
S = "World!\n", io.write_string("Hello " ++ S, !IO).</lang>
- Output:
Hello World!
NetRexx
<lang NetRexx>s_ = 'world!' s_ = 'Hello, 's_ say s_</lang>
- Output:
Hello, world!
NewLISP
<lang NewLISP>(setq str "bar") (push "foo" str) (println str)</lang>
Nim
<lang nim>var str = "12345678" str = "0" & str echo str</lang>
Oforth
<lang Oforth>" World" "Hello" swap + println</lang>
- Output:
Hello World
PARI/GP
Not supported in GP. <lang parigp>s = "world!"; s = Str("Hello, ", s)</lang>
- Output:
%1 = "Hello, world!"
Pascal
<lang Pascal>program StringPrepend; {$mode objfpc}{$H+}
uses
{$IFDEF UNIX}{$IFDEF UseCThreads} cthreads, {$ENDIF}{$ENDIF} Classes { you can add units after this };
var
s: String = ' World !';
begin
s := 'Hello' + s; WriteLn(S); ReadLn;
end.</lang>
- Output:
Hello World !
Perl
<lang perl>my $str = 'bar'; substr $str, 0, 0, 'Foo'; print $str;</lang>
- Output:
Foobar
Perl 6
<lang perl6># explicit concatentation $_ = 'byte'; $_ = 'kilo' ~ $_; .say;
- interpolation as concatenation
$_ = 'buck'; $_ = "mega$_"; .say;
- lvalue substr
$_ = 'bit'; substr-rw($_,0,0) = 'nano'; .say;
- regex substitution
$_ = 'fortnight'; s[^] = 'micro'; .say;
- reversed append assignment
$_ = 'cooper'; $_ [R~]= 'mini'; .say;</lang>
- Output:
kilobyte megabuck nanobit microfortnight minicooper
PicoLisp
<lang picolisp>(setq Str1 "12345678!") (setq Str1 (pack "0" Str1)) (println Str1)</lang>
- Output:
"012345678!"
PL/I
<lang PL/I> Pre_Cat: procedure options (main); /* 2 November 2013 */
declare s character (100) varying; s = ' bowl'; s = 'dust' || s; put (s);
end Pre_Cat; </lang>
dust bowl
PowerShell
<lang PowerShell> $str = "World!" $str = "Hello, " + $str $str </lang>
Hello, World!
Prolog
In its admirable wisdom, Prolog is generally unfriendly to state mutations and destructive assignment. However, it is also very flexible. Using the traditional representation of strings as lists of character codes, and the non-logical predicate `setarg/3`, we can destructively set the head and tail of the list to achieve a mutation of the variable holding the string. I define an operator for the purpose:
<lang prolog>
- - op(200, xfx, user:(=+)).
%% +Prepend =+ +Chars % % Will destructively update Chars % So that Chars = Prepend prefixed to Chars. % eazar001 in ##prolog helped refine this approach.
[X|Xs] =+ Chars :-
append(Xs, Chars, Rest), nb_setarg(2, Chars, Rest), nb_setarg(1, Chars, X).
</lang>
Example of this abomination in action:
<lang prolog> ?- Str = `World!`, `Hello, ` =+ Str. Str = "Hello, World!".</lang>
Note: I can't imagine when I would want to do this in Prolog.
PureBasic
<lang purebasic>S$ = " World!" S$ = "Hello" + S$ If OpenConsole()
PrintN(S$)
Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input() CloseConsole()
EndIf</lang>
- Output:
Hello World!
Python
File: string_prepend.py
<lang python>#!/usr/bin/env python
- -*- coding: utf-8 -*-
s = "12345678" s = "0" + s # by concatenation print(s)</lang>
- Output:
012345678
Racket
<lang racket>;there is no built-in way to set! prepend in racket (define str "foo") (set! str (string-append "bar " str)) (displayln str)
- but you can create a quick macro to solve that problem
(define-syntax-rule (set-prepend! str value)
(set! str (string-append value str)))
(define macrostr " bar") (set-prepend! macrostr "foo") (displayln macrostr) </lang>
- Output:
bar foo foo bar
REXX
<lang rexx>zz= 'llo world!' /*─────────────── using literal abuttal.────────────*/ zz= 'he'zz /*This won't work if the variable name is X or B */ say zz
gg = "llo world!" /*─────────────── using literal concatenation.──────*/
gg = 'he' || gg
say gg
aString= 'llo world!' /*─────────────── using variable concatenation.─────*/
bString= "he"
aString= bString || aString
say aString</lang>
output
hello world! hello world! hello world!
Ring
<lang ring> aString = "World!" bString = "Hello, " + aString see bString + nl </lang>
Ruby
There is a method for prepending a string, aptly named "prepend". <lang ruby>str = "llo world" str.prepend("He") p str #=> "Hello world"</lang>
Scala
Evaluation in Scala worksheet <lang scala> val s = "World" // Immutables are recommended //> s : String = World
val f2 = () => ", " //Function assigned to variable //> f2 : () => String = <function0> val s1 = "Hello" + f2() + s //> s1 : String = Hello, World println(s1); //> Hello, World</lang>
Seed7
<lang seed7>$ include "seed7_05.s7i";
const proc: main is func
local var string: s is "world!"; begin s := "Hello " & s; writeln(s); end func;</lang>
- Output:
Hello world!
Sidef
<lang ruby>var str = 'llo!'; str.sub!(/^/, 'He'); say str;</lang>
or <lang ruby>var str = 'llo!'; str.prepend!('He'); say str;</lang>
- Output:
Hello!
SNOBOL4
<lang SNOBOL4> s = ', World!'
OUTPUT = s = 'Hello' s
END</lang>
- Output:
Hello, World!
Swift
<lang Swift>var str = ", World" str = "Hello \(str)" println(str)</lang>
- Output:
Hello, World!
Tcl
Concatenation is a fundamental feature of Tcl's basic language syntax. <lang tcl>set s "llo world" set s "he$s" puts $s</lang>
- Output:
hello world
Ursa
<lang ursa>decl string s
- set s to "world"
set s "world"
- prepend "hello "
set s (+ "hello " s)
- outputs "hello world"
out s endl console</lang>
VBA
<lang VB>Function StringPrepend() Dim s As String s = "bar" s = "foo" & s Debug.Print s End Function</lang>
VBScript
<lang vb>s = "bar" s = "foo" & s WScript.Echo s</lang>
- Output:
foobar
Wart
<lang python>s <- "12345678" s <- ("0" + s)</lang>
zkl
<lang zkl>s:="bar"; s="foo"+s; s.println(); s:=Data(0,0,"bar").insert(0,"foo").text; s.println();</lang>
- Output:
foobar foobar
- Programming Tasks
- Basic language learning
- Basic Data Operations
- String manipulation
- Simple
- Bc/Omit
- Dc/Omit
- Ada
- ALGOL 68
- AutoHotkey
- AWK
- BASIC
- Applesoft BASIC
- BBC BASIC
- Bracmat
- C
- C++
- C sharp
- Clojure
- COBOL
- Common Lisp
- D
- Déjà Vu
- EchoLisp
- Elena
- Elixir
- Emacs Lisp
- Erlang
- ERRE
- F Sharp
- Factor
- Forth
- Fortran
- Go
- Haskell
- Icon
- Unicon
- J
- Java
- JavaScript
- Jq
- Julia
- Lasso
- LFE
- LiveCode
- Lua
- Mathematica
- Mercury
- NetRexx
- NewLISP
- Nim
- Oforth
- PARI/GP
- Pascal
- Perl
- Perl 6
- PicoLisp
- PL/I
- PowerShell
- Prolog
- PureBasic
- Python
- Racket
- REXX
- Ring
- Ruby
- Scala
- Seed7
- Sidef
- SNOBOL4
- Swift
- Tcl
- Ursa
- VBA
- VBScript
- Wart
- Zkl