Substring/Top and tail: Difference between revisions

 

* String with first character removed

* String with both the first and last characters removed

 

 

=={{header|Ada}}==

 

 

procedure Remove_Characters is

Put_Line("Without_Last: """ & S(S'First .. S'Last-1) & """");

Put_Line("Without_Both: """ & S(S'First+1 .. S'Last-1) & """");

 

Output:

Without_Last: "upraiser"

Without_Both: "praiser"</pre>

 

=={{header|ALGOL 68}}==

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny].}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of '''format'''[ted] ''transput''.}}

 

STRING str="upraisers";

str[LWB str+2:UPB str-1], # remove 2 before and one after #

str[LWB str+2:UPB str-2] # remove both the first and last 2 characters #

Output:

<pre>

raise

</pre>

 

=={{header|AutoHotkey}}==

MsgBox % SubStr(MyString, 2)

MsgBox % SubStr(MyString, 1, StrLen(MyString)-1)

=={{header|AWK}}==

mystring="knights"

print substr(mystring,2) # remove the first letter

print substr(mystring,1,length(mystring)-1) # remove the last character

print substr(mystring,2,length(mystring)-2) # remove both the first and last character

 

=={{header|Bracmat}}==

Bracmat uses UTF-8 internally. The function <code>utf</code> fails if its argument isn't a valid UTF-8 multibyte string, but in two slightly different ways: an indefinite and a definite way. If the argument does not have the required number of bytes but otherwise seems to be ok, Bracmat's backtacking mechanism lenghtens the argument and then calls <code>utf</code> again. This is repeated until utf either succeeds or definitely fails. The code is far from efficient.

 

@( Δημοτική

: (%?a&utf$!a) ?"String with first character removed"

$ ( "String with both the first and last characters removed:"

!"String with both the first and last characters removed"

 

String with first character removed: ημοτική

String with last character removed: Δημοτικ

 

If the string is known to consist of 8-byte characters, we can use a simpler method. Essential are the <code>%</code> and <code>@</code> prefixes. The <code>%</code> prefix matches 1 or more elements (bytes, in the case of string pattern matching), while <code>@</code> matches 0 or 1 elements. In combination these prefixes match 1 and only 1 byte.

 

@("8-bit string":%@ ?"String with first character removed")

& @("8-bit string":?"String with last character removed" @)

$ ( "String with both the first and last characters removed:"

!"String with both the first and last characters removed"

 

String with first character removed: -bit string

String with last character removed: 8-bit strin

 

=={{header|C}}==

#include <stdlib.h>

#include <stdio.h>

 

return 0;

 

Result:

 

ANSI C provides little functionality for text manipulation outside of string.h. While a number of libraries for this purpose have been written, this example uses only ANSI C.

 

=={{header|C sharp}}==

using System;

 

}

}

 

Result:

tes

es</pre>

 

=={{header|D}}==

 

void main() {

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

 

Readln;

 

=={{header|Euphoria}}==

return s[2..$]

end function

end function

 

 

=={{header|Forth}}==

In Forth, strings typically take up two cells on the stack, diagrammed ( c-addr u ), with C-ADDR the address of the string and U its length. Dropping leading and trailing characters then involves simple mathematical operations on the address or length, without mutating or copying the string.

 

s" Hello" ;

 

hello 1- type \ => hell

 

 

This works for ASCII, and a slight variation (2 instead of 1 per character) will suffice for BIG5, GB2312, and like, but Unicode-general code can use +X/STRING and X\STRING- from Forth-200x's XCHAR wordset.

 

=={{header|Go}}==

Go strings are byte arrays that can hold whatever you want them to hold. Common contents are ASCII and UTF-8. You use different techniques depending on how you are interpreting the string. The utf8 package functions shown here allows efficient extraction of first and last runes without decoding the entire string.

 

import (

fmt.Println("Last rune removed: ", u[:len(u)-sizeLast])

fmt.Println("First and last removed:", u[sizeFirst:len(u)-sizeLast])

Output:

<pre>

First and last removed: ημοτικ

</pre>

 

=={{header|GW-BASIC}}==

20 PRINT MID$(A$,2)

30 PRINT LEFT$(B$,LEN(B$)-1)

 

=={{header|Haskell}}==

-- short for the particular operation.

 

main = do

let s = "Some string."

 

=={{header|Icon}} and {{header|Unicon}}==

The task is accomplished by sub-stringing.

write(s := "knight"," --> ", s[2:0]) # drop 1st char

write(s := "sock"," --> ", s[1:-1]) # drop last

write(s := "brooms"," --> ", s[2:-1]) # drop both

 

It could also be accomplished (less clearly) by assigning into the string as below. Very awkward for both front and back.

 

=={{header|J}}==

 

'''Example use:'''<br>

night

}: 'socks' NB. drop last item

sock

}: }. 'brooms' NB. drop first and last items

 

=={{header|Java}}==

 

public static void main( String[] args ){

System.out.println( "knight".substring( 1 ) );

// then do this using a regular expressions

}

 

Results:

room</pre>

 

 

alert("socks".slice(0, -1)); // strip last character

 

=={{header|Liberty BASIC}}==

Print Mid$(string$, 2)

Print Left$(string$, (Len(string$) - 1))

 

=={{header|Locomotive Basic}}==

 

20 PRINT MID$(a$,2)

30 PRINT LEFT$(b$,LEN(b$)-1)

 

=={{header|Lua}}==

 

print (string.sub("knights",1,-2)) -- remove the last character

 

 

=={{header|Nemerle}}==

using System.Console;

 

WriteLine($"$str -> $beg -> $end -> $both");

}

 

=={{header|Objeck}}==

bundle Default {

class TopTail {

}

}

 

=={{header|OCaml}}==

 

if str = "" then "" else

String.sub str 1 ((String.length str) - 1)

print_endline (strip_last_char "socks");

print_endline (strip_both_chars "brooms");

 

=={{header|PARI/GP}}==

dl(s)=concat(vecextract(Vec(s),1<<(#s-1)-1));

 

=={{header|Pascal}}==

 

=={{header|Perl}}==

 

print substr("socks", 0, -1), "\n"; # strip last character

 

In perl, we can also remove the last character from a string variable with the chop function:

 

$bits = chop($string); # The last letter is returned by the chop function

print $bits; # h

 

 

 

 

 

=={{header|PHP}}==

 

echo substr("knight", 1), "\n"; // strip first character

echo substr("socks", 0, -1), "\n"; // strip last character

echo substr("brooms", 1, -1), "\n"; // strip both first and last characters

 

=={{header|PicoLisp}}==

-> "night"

 

 

: (pack (cddr (rot (chop "brooms")))) # Remove first and last characters

 

=={{header|PL/I}}==

declare s character (100) varying;

s = 'now is the time to come to the aid of the party';

put skip list ('One character from each end removed=' ||

substr(s, 2, length(s)-2) );

OUTPUT:

<pre>

Last character removed=now is the time to come to the aid of the part

One character from each end removed=ow is the time to come to the aid of the part

</pre>

 

Works with SWI-Prolog.

 

 

remove_last(L, LR) :-

Output :

<pre> ?- remove_first_last_chars.

true.

</pre>

=={{header|PureBasic}}==

PrintN(Right("knight", Len("knight") - 1)) ;strip the first letter

PrintN(Left("socks", Len("socks")- 1)) ;strip the last letter

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

CloseConsole()

Sample output:

<pre>night

=={{header|Python}}==

 

print "socks"[:-1] # strip last character

 

=={{header|Ruby}}==

 

puts "socks"[0..-2] # strip last character

puts "socks".chop # alternate way to strip last character

 

=={{header|Scala}}==

 

=={{header|Seed7}}==

 

const proc: main is func

writeln("Without last: " <& stri[.. pred(length(stri))]);

writeln("Without both: " <& stri[2 .. pred(length(stri))]);

 

Output:

Without both: praiser

</pre>

 

=={{header|SNOBOL4}}==

"socks" rtab(1) . output ;* strip last character

 

=={{header|Tcl}}==

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

str="upraisers"

PRINT str2

PRINT str3

Output:

<pre>

upraiser

</pre>

 

=={{header|Vala}}==

// declare test string

string s = "Hello, world!";

// remove first and last letters

string s_first_last = s[1:s.length - 1];

 

=={{header|ZX Spectrum Basic}}==

 

20 PRINT FN l$("socks"): REM strip the last letter

30 PRINT FN b$("brooms"): REM strip both the first and last letter

9000 DEF FN f$(a$)=a$(2 TO LEN(a$))

9010 DEF FN l$(a$)=a$(1 TO LEN(a$)-(1 AND (LEN(a$)>=1)))

 

{{omit from|Openscad}}