Substring/Top and tail: Difference between revisions
Add Ecstasy example
Thundergnat (talk | contribs) (Rename Perl 6 -> Raku, alphabetize, minor clean-up) |
(Add Ecstasy example) |
||
| (43 intermediate revisions by 28 users not shown) | |||
Line 1:
{{task}}
[[Category:String manipulation]]
The task is to demonstrate how to remove the first and last characters from a string.
Line 14 ⟶ 15:
Programs for other encodings (such as 8-bit ASCII, or EUC-JP) are not required to handle all Unicode characters.
{{Template:Strings}}
<br><br>
=={{header|11l}}==
{{trans|Python}}
<syntaxhighlight lang="11l">print(‘knight’[1..])
print(‘socks’[0 .< (len)-1])
print(‘brooms’[1 .< (len)-1])</syntaxhighlight>
{{out}}
<pre>
night
sock
room
</pre>
=={{header|360 Assembly}}==
<
SUBSTRTT CSECT
USING SUBSTRTT,R13 base register
Line 43 ⟶ 61:
S6 DS CL6
YREGS
END SUBSTRTT</
{{out}}
<pre>
Line 53 ⟶ 71:
=={{header|ACL2}}==
<
(coerce (rest (coerce str 'list)) 'string))
Line 67 ⟶ 85:
(str-rdc "string")
(str-rest "string")
(str-rest (str-rdc "string"))</
=={{header|Action!}}==
<syntaxhighlight lang="action!">PROC Main()
CHAR ARRAY text="qwertyuiop"
CHAR ARRAY res(20)
BYTE n,m
PrintF("Original string:%E ""%S""%E%E",text)
SCopyS(res,text,2,text(0))
PrintF("String without the top:%E ""%S""%E%E",res)
SCopyS(res,text,1,text(0)-1)
PrintF("String without the tail:%E ""%S""%E%E",res)
SCopyS(res,text,2,text(0)-1)
PrintF("String without the top and the tail:%E ""%S""%E%E",res)
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Top_and_tail.png Screenshot from Atari 8-bit computer]
<pre>
Original string:
"qwertyuiop"
String without the top:
"wertyuiop"
String without the tail:
"qwertyuio"
String without the top and the tail:
"wertyuio"
</pre>
=={{header|Ada}}==
<
procedure Remove_Characters is
Line 81 ⟶ 132:
Put_Line("Without_Last: """ & S(S'First .. S'Last-1) & """");
Put_Line("Without_Both: """ & S(S'First+1 .. S'Last-1) & """");
end Remove_Characters;</
Output:
Line 92 ⟶ 143:
With UTF8 support in Ada 2012 (Wide_Character of literals is automatic):
<
with Ada.Strings.UTF_Encoding.Wide_Strings;
Line 124 ⟶ 175:
("Without_Both: """ & U (U'First + 1 .. U'Last - 1) & """"));
end Remove_Characters;</
Output:
Line 134 ⟶ 185:
=={{header|Aime}}==
<
o_newline();
o_text(delete("knights", -1));
o_newline();
o_text(delete(delete("knights", 0), -1));
o_newline();</
{{out}}
<pre>nights
Line 150 ⟶ 201:
{{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";
Line 163 ⟶ 214:
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>
Line 175 ⟶ 226:
raiser
raise
</pre>
=={{header|Amazing Hopper}}==
<syntaxhighlight lang="amazing hopper">
#include <hopper.h>
#proto showmessage(_X_)
main:
s="message", t=s
++s, _show message(s)
s=t
--s, _show message(s)
++s, _show message(s)
{0}return
.locals
showmessage(_S_)
{_S_,"\n"}print
back
</syntaxhighlight>
{{out}}
<pre>
essage
messag
essag
</pre>
=={{header|Apex}}==
<
String strOrig = 'brooms';
String str1 = strOrig.substring(1, strOrig.length());
Line 195 ⟶ 270:
String str3 = strOrig.replaceAll( '^.|.$', '' );
system.debug(str3);
</syntaxhighlight>
{{out}}
Line 208 ⟶ 283:
=={{header|AppleScript}}==
<
set stringLength to (count aString) -- The number of characters in the text.
Line 236 ⟶ 311:
end if
return substring1 & linefeed & substring2 & linefeed & substring3</
{{output}}
Line 242 ⟶ 317:
This is some tex
his is some tex"</pre>
=={{header|Arturo}}==
<syntaxhighlight lang="rebol">knight: "knight"
socks: "socks"
brooms: "brooms"
print drop knight. ; strip first character
print slice knight 1 (size knight)-1 ; alternate way to strip first character
print chop socks ; strip last character
print take socks (size socks)-1 ; alternate way to strip last character
print slice socks 0 (size socks)-2 ; yet another way to strip last character
print chop drop brooms ; strip both first and last characters
print slice brooms 1 (size brooms)-2 ; alternate way to strip both first and last characters</syntaxhighlight>
{{out}}
<pre>night
night
sock
sock
sock
room
room</pre>
=={{header|AutoHotkey}}==
<
MsgBox % SubStr(MyString, 2)
MsgBox % SubStr(MyString, 1, StrLen(MyString)-1)
MsgBox % SubStr(MyString, 2, StrLen(MyString)-2)</
=={{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|BASIC}}==
<
20 PRINT FN L$("SOCKS"): REM STRIP THE LAST LETTER
30 PRINT FN B$("BROOMS"): REM STRIP BOTH THE FIRST AND LAST LETTER
Line 265 ⟶ 366:
9000 DEF FN F$(A$)=RIGHT$(A$,LEN(A$)-1)
9010 DEF FN L$(A$)=LEFT$(A$,LEN(A$)-1)
9020 DEF FN B$(A$)=FN L$(FN F$(A$))</
==={{header|Applesoft BASIC}}===
<syntaxhighlight lang="qbasic">10 s$ = "Rosetta Code"
20 PRINT s$
30 PRINT MID$(s$,2)
40 PRINT LEFT$(s$,LEN(s$)-1)
50 PRINT MID$(s$,2,LEN(s$)-2) </syntaxhighlight>
==={{header|Chipmunk Basic}}===
{{works with|Chipmunk Basic|3.6.4}}
<syntaxhighlight lang="qbasic">10 s$ = "Rosetta Code"
20 print s$
30 print mid$(s$,2)'strip first
40 print left$(s$,len(s$)-1)'strip last
50 print mid$(s$,2,len(s$)-2)'strip first and last</syntaxhighlight>
==={{header|MSX Basic}}===
{{works with|GW-BASIC}}
<syntaxhighlight lang="qbasic">10 S$ = "Rosetta Code"
20 PRINT S$
30 PRINT MID$(S$, 2) 'strip first
40 PRINT LEFT$(S$, LEN(S$) - 1) 'strip last
50 PRINT MID$(S$, 2, LEN(S$) - 2) 'strip first and last</syntaxhighlight>
==={{header|QBasic}}===
{{works with|QBasic|1.1}}
{{works with|QuickBasic|4.5}}
<syntaxhighlight lang="qbasic">s$ = "Rosetta Code"
PRINT s$
PRINT MID$(s$, 2) 'strip first
PRINT LEFT$(s$, LEN(s$) - 1) 'strip last
PRINT MID$(s$, 2, LEN(s$) - 2) 'strip first and last</syntaxhighlight>
==={{header|BASIC256}}===
<syntaxhighlight lang="freebasic">s$ = "Rosetta Code"
print s$
PRINT MID$(s$, 2) 'strip first
PRINT LEFT$(s$, LEN(s$) - 1) 'strip last
PRINT MID$(s$, 2, LEN(s$) - 2) 'strip first and last</syntaxhighlight>
==={{header|True BASIC}}===
<syntaxhighlight lang="qbasic">LET s$ = "Rosetta Code"
PRINT s$
PRINT (s$)[2:maxnum] !strip first
PRINT (s$)[1:len(s$)-1] !strip last
PRINT (s$)[2:2+len(s$)-2-1] !strip first and last
END</syntaxhighlight>
==={{header|XBasic}}===
{{works with|Windows XBasic}}
<syntaxhighlight lang="xbasic">PROGRAM "Substring"
VERSION "0.0000"
DECLARE FUNCTION Entry ()
FUNCTION Entry ()
s$ = "Rosetta Code"
PRINT s$
PRINT MID$(s$, 2) 'strip first
PRINT LEFT$(s$, LEN(s$) - 1) 'strip last
PRINT MID$(s$, 2, LEN(s$) - 2) 'strip first and last
END FUNCTION
END PROGRAM</syntaxhighlight>
==={{header|Yabasic}}===
<syntaxhighlight lang="freebasic">s$ = "Rosetta Code"
print s$
PRINT MID$(s$, 2) 'strip first
PRINT LEFT$(s$, LEN(s$) - 1) 'strip last
PRINT MID$(s$, 2, LEN(s$) - 2) 'strip first and last</syntaxhighlight>
==={{header|IS-BASIC}}===
<
110 PRINT S$(2:)
120 PRINT S$(:LEN(S$)-1)
130 PRINT S$(2:LEN(S$)-1)</
==={{header|Sinclair ZX81 BASIC}}===
Note that strings are indexed from 1.
<
20 LET S$="KNIGHTS"
30 REM WITH FIRST CHARACTER REMOVED:
Line 282 ⟶ 458:
60 PRINT S$( TO LEN S$-1)
70 REM WITH BOTH REMOVED:
80 PRINT S$(2 TO LEN S$-1)</
{{out}}
<pre>NIGHTS
KNIGHT
NIGHT</pre>
==={{header|Microsoft Small Basic}}===
When I tried using Unicode characters, it printed question marks, though ASCII works fine.
<syntaxhighlight lang="vbnet">
string = "Small Basic"
TextWindow.WriteLine(Text.GetSubTextToEnd(string, 2)) 'Without the first character
TextWindow.WriteLine(Text.GetSubText(string, 1, Text.GetLength(string) - 1)) 'Without the last character
TextWindow.WriteLine(Text.GetSubText(string, 2, Text.GetLength(string) - 2)) 'Without the first and last characters
</syntaxhighlight>
{{out}}
<pre>
mall Basic
Small Basi
mall Basi
</pre>
=={{header|BQN}}==
Drop(<code>↓</code>) is the main function used here.
<syntaxhighlight lang="bqn"> str ← "substring"
"substring"
1↓str
"ubstring"
¯1↓str
"substrin"
1↓¯1↓str
"ubstrin"</syntaxhighlight>
=={{header|BBC BASIC}}==
<
PRINT MID$(s$, 2)
PRINT LEFT$(s$)
PRINT LEFT$(MID$(s$, 2))</
=={{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"
Line 316 ⟶ 519:
$ ( "String with both the first and last characters removed:"
!"String with both the first and last characters removed"
));</
<pre>!substringUTF-8
Line 325 ⟶ 528:
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" @)
Line 338 ⟶ 541:
$ ( "String with both the first and last characters removed:"
!"String with both the first and last characters removed"
));</
<pre>!substring-8-bit
Line 346 ⟶ 549:
=={{header|Burlesque}}==
<
blsq ) "RosettaCode"[-
"osettaCode"
Line 357 ⟶ 560:
blsq ) "RosettaCode"~-
"osettaCod"
</syntaxhighlight>
=={{header|C}}==
<
#include <stdlib.h>
#include <stdio.h>
Line 384 ⟶ 587:
return 0;
}</
Result:
Line 394 ⟶ 597:
=={{header|C sharp}}==
<
using System;
Line 407 ⟶ 610:
}
}
</syntaxhighlight>
Result:
Line 415 ⟶ 618:
=={{header|C++}}==
<
#include <iostream>
Line 424 ⟶ 627:
std::cout << "Without first and last letter: " << word.substr( 1 , word.length( ) - 2 ) << " !\n" ;
return 0 ;
}</
Output:
<PRE>Without first letter: remier League !
Line 432 ⟶ 635:
=={{header|Clojure}}==
<
user=> (subs "knight" 1)
"night"
Line 446 ⟶ 649:
"sock"
user=> (apply str (rest (drop-last "brooms")))
"room"</
=={{header|COBOL}}==
<
program-id. toptail.
Line 465 ⟶ 668:
display data-field(2:length of data-field - 2)
goback.
end program toptail.</
{{out}}
Line 476 ⟶ 679:
=={{header|Common Lisp}}==
<code>subseq</code> will signal an error if you provide invalid start or end values.
<
*STR*
> (subseq *str* 1) ; remove first character
Line 483 ⟶ 686:
"∀Ꮺ✤Л"
> (subseq *str* 1 (1- (length *str*))) ; remove first and last character
"Ꮺ✤Л"</
=={{header|D}}==
Version for ASCII strings or Unicode dstrings:
<
void main() {
Line 498 ⟶ 701:
// strip both first and last characters
writeln("brooms"[1 .. $ - 1]);
}</
{{out}}
<pre>night
sock
room</pre>
=={{header|Dart}}==
<syntaxhighlight lang="dart">void main() {
String word = "Premier League";
print("Without first letter: ${word.substring(1)} !");
print("Without last letter: ${word.substring(0, word.length - 1)} !");
print("Without first and last letter: ${word.substring(1, word.length - 1)} !");
}</syntaxhighlight>
{{out}}
<pre>Same as C++ entry.</pre>
=={{header|Delphi}}==
<
{$APPTYPE CONSOLE}
Line 518 ⟶ 731:
Readln;
end.</
=={{header|EasyLang}}==
<syntaxhighlight>
s$ = "Easylang"
print substr s$ 1 (len s$ - 1)
print substr s$ 2 (len s$ - 1)
print substr s$ 2 (len s$ - 2)
</syntaxhighlight>
{{out}}
<pre>
Easylan
asylang
asylan
</pre>
=={{header|Ecstasy}}==
Generally, extracting substrings in Ecstasy is most easily performed using the slice operator, but there is also a <code>substring()</code> method:
<syntaxhighlight lang="ecstasy">
module Substrings {
void run(String[] args = []) {
String s = args.size > 0 ? args[0] : "hello";
@Inject Console console;
console.print(
$|Original : { s .quoted()=}
|Remove first: { s.substring(1) .quoted()=}
|Remove first: {(s.size < 1 ? "" : s[1..<s.size ]).quoted()=}
|Remove last : {(s.size < 1 ? "" : s[0..<s.size-1]).quoted()=}
|Remove both : {(s.size < 2 ? "" : s[1..<s.size-1]).quoted()=}
);
}
}
</syntaxhighlight>
{{out}}
<pre>
x$ xec Substrings
Original : s .quoted()="hello"
Remove first: s.substring(1) .quoted()="ello"
Remove first: (s.size < 1 ? "" : s[1..<s.size ]).quoted()="ello"
Remove last : (s.size < 1 ? "" : s[0..<s.size-1]).quoted()="hell"
Remove both : (s.size < 2 ? "" : s[1..<s.size-1]).quoted()="ell"
x$ xec Substrings a
Original : s .quoted()="a"
Remove first: s.substring(1) .quoted()=""
Remove first: (s.size < 1 ? "" : s[1..<s.size ]).quoted()=""
Remove last : (s.size < 1 ? "" : s[0..<s.size-1]).quoted()=""
Remove both : (s.size < 2 ? "" : s[1..<s.size-1]).quoted()=""
x$ xec Substrings ab
Original : s .quoted()="ab"
Remove first: s.substring(1) .quoted()="b"
Remove first: (s.size < 1 ? "" : s[1..<s.size ]).quoted()="b"
Remove last : (s.size < 1 ? "" : s[0..<s.size-1]).quoted()="a"
Remove both : (s.size < 2 ? "" : s[1..<s.size-1]).quoted()=""
x$ xec Substrings abc
Original : s .quoted()="abc"
Remove first: s.substring(1) .quoted()="bc"
Remove first: (s.size < 1 ? "" : s[1..<s.size ]).quoted()="bc"
Remove last : (s.size < 1 ? "" : s[0..<s.size-1]).quoted()="ab"
Remove both : (s.size < 2 ? "" : s[1..<s.size-1]).quoted()="b"
</pre>
=={{header|Eero}}==
<
int main()
Line 538 ⟶ 812:
Log( '%@', s[1 .. s.length-2] ) // strip both first and last characters
return 0</
Output:<pre>
Line 548 ⟶ 822:
=={{header|Elena}}==
ELENA 4.x :
<
public program()
Line 557 ⟶ 831:
console.printLine(testString.Substring(0, testString.Length - 1));
console.printLine(testString.Substring(1, testString.Length - 2))
}</
{{out}}
<pre>
Line 566 ⟶ 840:
=={{header|Elixir}}==
<
"abcdefg"
iex(2)> String.slice(str, 1..-1)
Line 573 ⟶ 847:
"abcdef"
iex(4)> String.slice(str, 1..-2)
"bcdef"</
=={{header|Emacs Lisp}}==
<syntaxhighlight lang="lisp">(let ((string "top and tail"))
(substring string 1) ;=> "op and tail"
(
(substring string 1 (1- (length string)))) ;=> "op and tai"</syntaxhighlight>
=={{header|Erlang}}==
<
"Hello"
2> string:sub_string(Str, 2). % To strip the string from the right by 1
Line 601 ⟶ 863:
"Hell"
4> string:sub_string(Str, 2, length(Str)-1). % To strip the string from both sides by 1
"ell"</
=={{header|Euphoria}}==
<
return s[2..$]
end function
Line 616 ⟶ 878:
end function
puts(1, strip_first("knight"))
puts(1, strip_last("write"))
puts(1, strip_both("brooms"))
=={{header|F_Sharp|F#}}==
<
let main args =
let s = "一二三四五六七八九十"
Line 627 ⟶ 889:
printfn "%A" (s.Substring(0, s.Length - 1))
printfn "%A" (s.Substring(1, s.Length - 2))
0</
Output
<pre>"二三四五六七八九十"
Line 634 ⟶ 896:
=={{header|Factor}}==
<
"Rosetta code" [ rest ] [ but-last ] [ rest but-last ] tri
[ print ] tri@</
{{out}}
<pre>
Line 647 ⟶ 909:
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" ;
Line 654 ⟶ 916:
hello 1- type \ => hell
hello 1 /string 1- type \ => ell</
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|Fortran}}==
<
character(len=5) :: string
Line 669 ⟶ 931:
write (*,*) string(2:len(string)-1)
end program substring</
=={{header|FreeBASIC}}==
<
Dim s As String = "panda"
Line 682 ⟶ 944:
Print s2
Print s3
Sleep</
{{out}}
Line 691 ⟶ 953:
and
</pre>
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
void local fn DoIt
CFStringRef s = @"knights"
print s
CFStringRef s1 = mid(s, 1, len(s) - 1)
print s1
CFStringRef s2 = left(s, len(s) - 1)
print s2
CFStringRef s3 = mid(s, 1, len(s) - 2)
print s3
end fn
fn DoIt
HandleEvents
</syntaxhighlight>
{{output}}
<pre>
knights
nighs
knight
night
</pre>
=={{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 (
Line 716 ⟶ 1,006:
fmt.Println("Last rune removed: ", u[:len(u)-sizeLast])
fmt.Println("First and last removed:", u[sizeFirst:len(u)-sizeLast])
}</
Output:
<pre>
Line 727 ⟶ 1,017:
Last rune removed: Δημοτικ
First and last removed: ημοτικ
</pre>
=={{header|Golfscript}}==
When I tried using Unicode characters, the interpreter generated a mess, though ASCII works fine.
<syntaxhighlight lang="golfscript">
"Golfscript"(;n
"Golfscript");n
"Golfscript"(;);
</syntaxhighlight>
{{out}}
<pre>
olfscript
Golfscrip
olfscrip
</pre>
=={{header|Groovy}}==
Solution:
<
def tail = { it.size() > 1 ? it[1..-1] : '' }</
Test:
<
println """
original: ${testVal}
Line 741 ⟶ 1,045:
tail: ${tail(testVal)}
top&tail: ${tail(top(testVal))}
"""</
Output:
Line 750 ⟶ 1,054:
=={{header|GW-BASIC}}==
<
20 PRINT MID$(A$,2)
30 PRINT LEFT$(B$,LEN(B$)-1)
40 PRINT MID$(C$,2,LEN(C$)-2)</
=={{header|Haskell}}==
<
-- short for the particular operation.
Line 773 ⟶ 1,077:
main = do
let s = "Some string."
mapM_ (\f -> putStrLn . f $ s) [remFirst, remLast, remBoth]</
Alternative solution with builtin functions:
<
main = do
Line 793 ⟶ 1,097:
-- You can combine functions using `.`,
-- which is pronounced "compose" or "of"
middle = init . tail</
In short:
<
main = mapM_ print $ [tail, init, init . tail] <*> ["knights"]</
{{Out}}
<pre>"nights"
Line 805 ⟶ 1,109:
=={{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
end</
It could also be accomplished (less clearly) by assigning into the string as below. Very awkward for both front and back.
<
=={{header|J}}==
Line 818 ⟶ 1,122:
'''Example use:'''<br>
<
night
}: 'socks' NB. drop last item
sock
}: }. 'brooms' NB. drop first and last items
room</
=={{header|Java}}==
I solve this problem two ways. First I use substring which is relatively fast for small strings, since it simply grabs the characters within a set of given bounds. The second uses regular expressions, which have a higher overhead for such short strings, but work correctly with all Unicode code points, not just those in the Basic Multilingual Plane.
<
public static void main( String[] args ){
System.out.println( "knight".substring( 1 ) );
Line 841 ⟶ 1,145:
// then do this using a regular expressions
}
}</
Results:
Line 851 ⟶ 1,155:
room</pre>
Nearly all current solutions for this task fail to work correctly: the task says "The program must reference logical characters (code points), not 8-bit code units for UTF-8 or 16-bit code units for UTF-16." The code below works correctly with all Unicode characters, without using regular expressions as the above program does.
<syntaxhighlight lang="java">public class SubstringTopAndTail {
public static void main( String[] args ){
var s = "\uD83D\uDC0Eabc\uD83D\uDC0E"; // Horse emoji, a, b, c, horse emoji: "🐎abc🐎"
var sizeOfFirstChar = Character.isSurrogate(s.charAt(0)) ? 2 : 1;
var sizeOfLastChar = Character.isSurrogate(s.charAt(s.length() - 1)) ? 2 : 1;
var removeFirst = s.substring(sizeOfFirstChar);
var removeLast = s.substring(0, s.length() - sizeOfLastChar);
var removeBoth = s.substring(sizeOfFirstChar, s.length() - sizeOfLastChar);
System.out.println(removeFirst);
System.out.println(removeLast);
System.out.println(removeBoth);
}
}</syntaxhighlight>
Results:
<pre>abc🐎
🐎abc
abc</pre>
=={{header|JavaScript}}==
<syntaxhighlight lang="javascript">alert("knight".slice(1)); // strip first character
alert("socks".slice(0, -1)); // strip last character
alert("brooms".slice(1, -1)); // strip both first and last characters</
=={{header|Joy}}==
<syntaxhighlight lang="joy">DEFINE
dropfirst == 1 drop;
droplast == dup size pred take.
"abcd" dropfirst.
"abcd" droplast.
"abcd" dropfirst droplast.</syntaxhighlight>
If a string is known to be non-empty, the <code>rest</code> operator could be used instead of <code>dropfirst</code>.
{{out}}
<pre>"bcd"
"abc"
"bc"</pre>
=={{header|jq}}==
jq uses 0-based indexing, so [1:] yields all but the first character, it being understood that data strings in jq are JSON strings. [0:-1], which can be abbreviated to [:-1], yields all but the last character, and so on. Here are some examples:<
"一二三四五六七八九十"[:-1]' => "一二三四五六七八九"
Line 865 ⟶ 1,206:
"a"[1:-1] # => ""
</syntaxhighlight>
Recent versions of jq also have regular expression support, with named captures. This leads to many other possibilities, e.g.<
=={{header|Julia}}==
<
"y String"
Line 876 ⟶ 1,217:
julia> "My String"[2:end-1] # without first and last characters
"y Strin"</
=={{header|K}}==
K provides the system function <code>_di</code> to delete an element at
a specified index. The following code is implemented using this feature.
<syntaxhighlight lang="k">
s: "1234567890"
"1234567890"
Line 890 ⟶ 1,231:
(s _di -1+#s) _di 0 /String with both 1st and last character removed
"23456789"
</syntaxhighlight>
Another way to implement without using the above system function:
<syntaxhighlight lang="k">
s: "1234567890"
"1234567890"
Line 901 ⟶ 1,242:
1 - -1 _ s /Delete 1st and last character
"23456789"
</syntaxhighlight>
=={{header|Kotlin}}==
<
fun main(args: Array<String>) {
val s = "Rosetta"
Line 910 ⟶ 1,251:
println(s.dropLast(1))
println(s.drop(1).dropLast(1))
}</
{{out}}
Line 918 ⟶ 1,259:
osett
</pre>
=={{header|Lambdatalk}}==
<syntaxhighlight lang="lisp">
{def R rosetta} -> rosetta
{W.rest {R}} -> osetta
{W.reverse {W.rest {W.reverse {R}}}} -> rosett
{W.rest {W.reverse {W.rest {W.reverse {R}}}}} -> osett
or
{W.slice 1 {W.length {R}} {R}} -> osetta
{W.slice 0 {- {W.length {R}} 1} {R}} -> rosett
{W.slice 1 {- {W.length {R}} 1} {R}} -> osett
{def J ストリング} -> ストリング
{W.rest {J}} -> トリング
{W.reverse {W.rest {W.reverse {J}}}} -> ストリン
{W.rest {W.reverse {W.rest {W.reverse {J}}}}} -> トリン
</syntaxhighlight>
=={{header|Lasso}}==
<
// String with first character removed
Line 930 ⟶ 1,293:
// String with both the first and last characters removed
string_remove(string_remove(#str,-startposition=#str->size,-endposition=#str->size),-startposition=1,-endposition=1)</
{{out}}
<pre>he quick grey rhino jumped over the lazy green fox.
Line 936 ⟶ 1,299:
he quick grey rhino jumped over the lazy green fox</pre>
<
#mystring -> remove(1,1)
Line 945 ⟶ 1,308:
'<br />'
#mystring -> remove(1,1)& -> remove(#mystring -> size,1)
#mystring</
-> ÜÄÖカ
Line 951 ⟶ 1,314:
Ä =={{header|Lasso}}==
<
// String with first character removed
Line 963 ⟶ 1,326:
// String with both the first and last characters removed
string_remove(string_remove(#str,-startposition=#str->size,-endposition=#str->size),-startposition=1,-endposition=1)
// > he quick grey rhino jumped over the lazy green fox</
=={{header|Liberty BASIC}}==
<
Print Mid$(string$, 2)
Print Left$(string$, (Len(string$) - 1))
Print Mid$(string$, 2, (Len(string$) - 2))</
=={{header|LiveCode}}==
<
answer char 2 to len(x) of x // pple
answer char 1 to -2 of x // ppl
answer char 2 to -2 of x // ppl</
=={{header|Locomotive Basic}}==
<
20 PRINT MID$(a$,2)
30 PRINT LEFT$(b$,LEN(b$)-1)
40 PRINT MID$(c$,2,LEN(c$)-2)</
=={{header|Logo}}==
<
print butfirst :s
print butlast :s
print butfirst butlast :s</
=={{header|Logtalk}}==
Using atoms for representing strings:
<
:- object(top_and_tail).
Line 1,005 ⟶ 1,368:
:- end_object.
</syntaxhighlight>
Sample output:
<
| ?- top_and_tail::test('Rosetta').
String with first character cut: osetta
Line 1,013 ⟶ 1,376:
String with first and last characters cut: osett
yes
</syntaxhighlight>
=={{header|Lua}}==
<
print (string.sub("knights",1,-2)) -- remove the last character
print (string.sub("knights",2,-2)) -- remove the first and last characters</
=={{header|Maple}}==
There are several ways to do this. The first is, I think, the simplest.
<
> s[2..-1];
"ome string"
Line 1,031 ⟶ 1,394:
> s[2..-2];
"ome strin"</
The same functionality exists in the form of a procedure:
<
"ome string"
Line 1,040 ⟶ 1,403:
> substring( s, 2 .. -2 );
"ome strin"</
Furthermore, there is a slightly different version in the "StringTools" package:
<
> SubString( s, 2 .. -1 );
> SubString( s, 1 .. -1 );
Line 1,051 ⟶ 1,414:
"some string"
"ome strin"</
(The difference between "substring" and "StringTools:-SubString" lies in how each treats a name as input; the former returns a name, while the latter returns a string.)
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">StringDrop["input string",1]
StringDrop["input string",-1]
StringTake["input string",{2,-2}]
</syntaxhighlight>
=={{header|MATLAB}} / {{header|Octave}}==
The following case will not handle UTF-8. However, Matlab supports conversion of utf-8 to utf-16 using native2unicode().
<syntaxhighlight lang="matlab">
% String with first character removed
% String with last character removed
% String with both the first and last characters removed
</syntaxhighlight>
=={{header|MiniScript}}==
<
print test[1:]
print test[:-1]
print test[1:-1]
</syntaxhighlight>
{{out}}
<pre>
Line 1,085 ⟶ 1,447:
his thin
</pre>
=={{header|MIPS Assembly}}==
Thanks to [https://www.chibialiens.com/mips/ Chibialiens] for the header/footer, font, and print routines.
<syntaxhighlight lang="mips">.include "\SrcAll\Header.asm"
.include "\SrcAll\BasicMacros.asm"
.include "\SrcALL\AdvancedMacros.asm"
.include "\SrcALL\MemoryMap.asm"
; .definelabel UserRam,0xA0010000 (this is defined in the header)
CursorX equ 0x100 ;offset from label UserRam
CursorY equ 0x101 ;offset from label UserRam
main:
jal Cls
nop
la a0,MyString
la a1,UserRam+0x1000
push a0
push a1
jal strcpy
addiu a0,1 ;branch delay slot - increment base address prior to branching
pop a0 ;deliberately pop in the "wrong order"
pop a1 ;because printString uses $a0
jal PrintString
nop
jal NewLine
nop
la a0,MyString
la a1,UserRam+0x1000
push a0
push a1
jal strcpy
nop ;branch delay slot
;after a strcpy, a0/a1 both point to the null terminator
subiu a1,1
move t0,zero
sb t0,(a1)
.ifdef buildPSX
nop ;load delay slot
.endif
pop a0
pop a1
jal PrintString
nop
jal NewLine
nop
la a0,MyString
la a1,UserRam+0x1000
push a0
push a1
jal strcpy
addiu a0,1 ;branch delay slot
;after a strcpy, a0/a1 both point to the null terminator
subiu a1,1
move t0,zero
sb t0,(a1)
.ifdef buildPSX
nop ;load delay slot
.endif
pop a0
pop a1
jal PrintString
nop
jal NewLine
nop
halt:
nop
j halt
nop
MyString:
.ascii "Hello World"
.byte 0
.align 4
MyFont:
.ifdef buildn64
.incbin "\ResN64\ChibiAkumas.fnt"
.endif
.ifdef buildPSX
.incbin "\ResPSX\ChibiAkumas.fnt"
.endif
.include "\SrcALL\graphics.asm"
.include "\SrcAll\monitor.asm"
.include "\SrcALL\Multiplatform_Math_Integer.asm"
.include "\SrcALL\BasicFunctions_v2.asm"
.include "\SrcN64\Footer.asm"</syntaxhighlight>
{{out}}
<pre>ello World
Hello Worl
ello Worl</pre>
[https://ibb.co/CHwTrMb Screenshot of PlayStation 1 Emulator]
=={{header|Neko}}==
Line 1,090 ⟶ 1,560:
'''$ssub''' ''sub-string'' takes string, position (zero-relative), length arguments.
<syntaxhighlight lang="actionscript">/**
Subtring/Top-Tail in Neko
*/
Line 1,100 ⟶ 1,570:
$print($ssub(data, 1, len - 1), "\n")
$print($ssub(data, 0, len - 1), "\n")
$print($ssub(data, 1, len - 2), "\n")</
{{out}}
Line 1,111 ⟶ 1,581:
=={{header|Nemerle}}==
<
using System.Console;
Line 1,125 ⟶ 1,595:
WriteLine($"$str -> $beg -> $end -> $both");
}
}</
=={{header|NetRexx}}==
<
* 02.08.2013 Walter Pachl translated from REXX
**********************************************************************/
Line 1,139 ⟶ 1,609:
End
If l>=2 Then
Say 'string first & last character removed =' z.substr(2,l-2)</
=={{header|NewLISP}}==
<
;; strip first char
(println (1 str))
Line 1,148 ⟶ 1,618:
(println (0 -1 str))
;; strip both first and last characters
(println (1 -1 str)))</
=={{header|Nim}}==
<
let s = "Hänsel ««: 10,00€"
echo "Original: ", s
echo
echo
echo "With first and last characters removed: ", s.runeSubStr(1, s.runeLen - 2)
# Using the runes type and slices
let r = s.toRunes
echo "With first and last characters removed (other way): ", r[1 .. ^2]</syntaxhighlight>
{{out}}
<pre>
With first and last characters removed: änsel ««: 10,00
With first and last characters removed (other way): änsel ««: 10,00</pre>
=={{header|Objeck}}==
<
bundle Default {
class TopTail {
Line 1,178 ⟶ 1,650:
}
}
</syntaxhighlight>
=={{header|OCaml}}==
<
if str = "" then "" else
String.sub str 1 ((String.length str) - 1)
Line 1,199 ⟶ 1,671:
print_endline (strip_last_char "socks");
print_endline (strip_both_chars "brooms");
;;</
=={{header|Oforth}}==
<
s right(s size 1-) println
s left(s size 1-) println
s extract(2, s size 1- ) println ;</
{{out}}
Line 1,217 ⟶ 1,689:
=={{header|PARI/GP}}==
<
dl(s)=concat(vecextract(Vec(s),1<<(#s-1)-1));
db(s)=concat(vecextract(Vec(s),1<<(#s-1)-2));</
=={{header|Pascal}}==
''See also [[
{{works with|Extended Pascal}}
<syntaxhighlight lang="pascal">program topAndTail(output);
var
line: string(20);
begin
line := 'ABCDEF';
if length(line) > 1 then
begin
{ string with first character removed }
writeLn(subStr(line, 2));
{ index range expression: only possible for strings }
{ _not_ designated `bindable` [e.g. `bindable string(20)`] }
writeLn(line[2..length(line)]);
{ string with last character removed }
writeLn(subStr(line, 1, length(line) - 1));
{ only legal with non-bindable strings: }
writeLn(line[1..length(line)-1])
end;
{ string with both the first and last characters removed }
if length(line) > 2 then
begin
writeLn(subStr(line, 2, length(line) - 2));
{ only for non-bindable strings: }
writeLn(line[2..length(line)-1])
end
end.</syntaxhighlight>It is imperative that <tt>firstCharacterIndex + substringLength</tt> specified to <tt>subStr(source, firstCharacterIndex, substringLength)</tt> must be valid index in <tt>source</tt>. Therefore you need to perform checks beforehand.
=={{header|Perl}}==
<
print substr("socks", 0, -1), "\n"; # strip last character
print substr("brooms", 1, -1), "\n"; # strip both first and last characters</
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
print $string; # ouc # See we really did chop the last letter off</
=={{header|Phix}}==
{{libheader|Phix/basics}}
<!--<syntaxhighlight lang="phix">-->
<span style="color: #008080;">constant</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"(test)"</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">2</span><span style="color: #0000FF;">..-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">..-</span><span style="color: #000000;">2</span><span style="color: #0000FF;">]</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">2</span><span style="color: #0000FF;">..-</span><span style="color: #000000;">2</span><span style="color: #0000FF;">]</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
Line 1,248 ⟶ 1,753:
"test"
</pre>
=={{header|Phixmonti}}==
<syntaxhighlight lang="phixmonti">include ..\Utilitys.pmt
"(test)"
dup 1 del ?
dup -1 del ?
dup 1 del -1 del ?</syntaxhighlight>
Or...
<syntaxhighlight lang="phixmonti">include ..\Utilitys.pmt
"(test)"
len 1 - 2 swap slice ?
len 1 - 1 swap slice ?
len 2 - 2 swap slice ?</syntaxhighlight>
=={{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|Picat}}==
===Functions===
<syntaxhighlight lang="picat">go =>
test("upraisers"),
test("Δημοτική"),
nl.
test(S) =>
println(s=S),
println(butfirst=S.slice(2)),
println(butfirst=S.tail),
println(butfirst=S[2..S.len]),
println(butlast=S.but_last()),
println(butfirst_butlast=S.tail.but_last),
println(butfirst_butlast=slice(S,2,S.length-1)),
println(butfirst_butlast=[S[I] : I in 2..S.length-1]),
println(butfirst_butlast=S[2..S.length-1]),
nl.
but_last(S) = S.slice(1,S.length-1).</syntaxhighlight>
{{out}}
<pre>s = upraisers
butfirst = praisers
butfirst = praisers
butfirst = praisers
butlast = upraiser
butfirst_butlast = praiser
butfirst_butlast = praiser
butfirst_butlast = praiser
butfirst_butlast = praiser
s = Δημοτική
butfirst = ημοτική
butfirst = ημοτική
butfirst = ημοτική
butlast = Δημοτικ
butfirst_butlast = ημοτικ
butfirst_butlast = ημοτικ
butfirst_butlast = ημοτικ
butfirst_butlast = ημοτικ</pre>
===Using append/3===
{{trans|Prolog}}
<syntaxhighlight lang="picat">go2 =>
test2("upraisers"),
nl,
test2("Δημοτική"),
nl.
test2(L) :-
L = [_|L1],
remove_last(L, L2),
remove_last(L1, L3),
writef("Original string : %s\n", L),
writef("Without first char : %s\n", L1),
writef("Without last char : %s\n", L2),
writef("Without first/last chars : %s\n", L3).
remove_last(L, LR) :-
append(LR, [_], L).</syntaxhighlight>
{{out}}
<pre>Original string : upraisers
Without first char : praisers
Without last char : upraiser
Without first/last chars : praiser
Original string : Δημοτική
Without first char : ημοτική
Without last char : Δημοτικ
Without first/last chars : ημοτικ</pre>
=={{header|PicoLisp}}==
<
-> "night"
Line 1,265 ⟶ 1,860:
: (pack (cddr (rot (chop "brooms")))) # Remove first and last characters
-> "room"</
=={{header|PL/I}}==
<syntaxhighlight lang="pl/i">
declare s character (100) varying;
s = 'now is the time to come to the aid of the party';
Line 1,276 ⟶ 1,871:
put skip list ('One character from each end removed=' ||
substr(s, 2, length(s)-2) );
</syntaxhighlight>
OUTPUT:
<pre>
Line 1,282 ⟶ 1,877:
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>
=={{header|Plain English}}==
<syntaxhighlight lang="plainenglish">To run:
Start up.
Demonstrate removing the first and last characters from "Rosetta Code".
Wait for the escape key.
Shut down.
To demonstrate removing the first and last characters from a string:
Slap a substring on the string.
Add 1 to the substring's first.
Write the substring on the console.
Subtract 1 from the substring's first.
Subtract 1 from the substring's last.
Write the substring on the console.
Add 1 to the substring's first.
Write the substring on the console.</syntaxhighlight>
{{out}}
<pre>
osetta Code
Rosetta Cod
osetta Cod
</pre>
Line 1,287 ⟶ 1,905:
{{works with|PowerShell|4.0}}
===First method===
<syntaxhighlight lang="powershell">
$string = "top and tail"
$string
Line 1,293 ⟶ 1,911:
$string.Substring(0, $string.Length - 1)
$string.Substring(1, $string.Length - 2)
</syntaxhighlight>
===Second method===
<syntaxhighlight lang="powershell">
$string = "top and tail"
$string
Line 1,301 ⟶ 1,919:
$string[0..($string.Length - 2)] -join ""
$string[1..($string.Length - 2)] -join ""
</syntaxhighlight>
<b>Output:</b>
<pre>
Line 1,313 ⟶ 1,931:
Works with SWI-Prolog.
<
remove_last(L, LR) :-
Output :
<pre> ?- remove_first_last_chars.
Line 1,335 ⟶ 1,953:
=={{header|PureBasic}}==
<
PrintN(Right("knight", Len("knight") - 1)) ;strip the first letter
PrintN(Left("socks", Len("socks")- 1)) ;strip the last letter
Line 1,342 ⟶ 1,960:
Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()
CloseConsole()
EndIf</
Sample output:
<pre>night
Line 1,350 ⟶ 1,968:
=={{header|Python}}==
<
print "socks"[:-1] # strip last character
print "brooms"[1:-1] # strip both first and last characters</
Or, composing atomic functional expressions for these slices:
<
Line 1,410 ⟶ 2,028:
if __name__ == '__main__':
main()</
{{Out}}
<pre>['nights', 'knight', 'night']
['ocks', 'sock', 'ock']
['rooms', 'broom', 'room']</pre>
=={{header|Quackery}}==
As a dialogue in the Quackery shell.
<pre>/O> $ "callipygian"
... say "original string: "
... dup echo$ cr
... say "without head: "
... dup behead drop echo$ cr
... say "without tail: "
... -1 split drop dup echo$ cr
... say "topped and tailed: "
... behead drop echo$ cr
...
original string: callipygian
without head: allipygian
without tail: callipygia
topped and tailed: allipygia
</pre>
=={{header|Racket}}==
<
#lang racket
Line 1,426 ⟶ 2,064:
(substring str 0 (sub1 (string-length str)))
(substring str 1 (sub1 (string-length str)))
</syntaxhighlight>
Output:
Line 1,439 ⟶ 2,077:
(formerly Perl 6)
We use musical sharps and flats to illustrate that
<syntaxhighlight lang="raku"
print qq:to/END/;
Line 1,461 ⟶ 2,099:
{ substr($s, 1, *-1) }
{ $s.substr(1, *-1) }
END</
{{out}}
<pre>Original:
Line 1,480 ⟶ 2,118:
=={{header|Raven}}==
<
$s print "\n" print
Line 1,494 ⟶ 2,132:
$str offTheTop println
$str offTheTail println
$str offTheTop offTheTail println</
{{out}}
<pre>123456789
Line 1,503 ⟶ 2,141:
===error prone===
This REXX version is error prone in that if the string is less than two characters, then the '''left''' and/or '''substr''' BIFs will fail (because of an invalid length specified).
<
@ = 'abcdefghijk'
say ' the original string =' @
Line 1,513 ⟶ 2,151:
║ However, the original string may be null or exactly one byte in length which ║
║ will cause the BIFs to fail because of either zero or a negative length. ║
╚═══════════════════════════════════════════════════════════════════════════════╝ */</
'''output'''
<pre>
Line 1,524 ⟶ 2,162:
===robust version===
This REXX version correctly handles a string of zero (null) or one byte.
<
@ = 'abcdefghijk'
say ' the original string =' @
Line 1,538 ⟶ 2,176:
say 'string first character removed =' substr(@, 2)
say 'string last character removed =' left(@, max(0, L-1) )
say 'string first & last character removed =' substr(@, 2, max(0, L-2) )</
'''output''' is the same as the 1<sup>st</sup> REXX version.
===faster version===
This REXX version is faster (uses '''parse''' instead of multiple BIFs).
<
@ = 'abcdefghijk'
say ' the original string =' @
Line 1,557 ⟶ 2,195:
parse var @ 2 z +(n)
if n==0 then z= /*handle special case of a length of 2.*/
say 'string first & last character removed =' z /*stick a fork in it, we're all done. */</
'''output''' is the same as the 1<sup>st</sup> REXX version. <br><br>
=={{header|Ring}}==
<
aString = "1Welcome to the Ring Programming Language2"
see substr(aString,2,len(aString)-1) + nl +
substr(aString,1,len(aString)-1) + nl +
substr(aString,2,len(aString)-2) + nl
</syntaxhighlight>
=={{header|RPL}}==
Basic RPL:
"Knight" 2 OVER SIZE SUB
"Socks" 1 OVER SIZE 1 - SUB
"Brooms" 2 OVER SIZE 1 - SUB
From HP-48 versions, one can also do this way:
"Knight" TAIL
"Socks" REVLIST TAIL REVLIST
"Brooms" TAIL REVLIST TAIL REVLIST
{{out}}
<pre>
3: night
2: Sock
1: room
</pre>
=={{header|Ruby}}==
<
puts "socks"[0..-2] # strip last character
puts "socks".chop # alternate way to strip last character
puts "brooms"[1..-2] # strip both first and last characters
puts "与今令"[1..-2] # => 今</
=={{header|Run BASIC}}==
<
print mid$(s$,2) 'strip first
print left$(s$,len(s$) -1) 'strip last
print mid$(s$,2,len(s$) -2) 'strip first and last</
=={{header|Rust}}==
One possibility is to modify the owned string representation:
<syntaxhighlight lang="rust">fn main() {
let s = String::from("žluťoučký kůň");
let mut modified = s.clone();
modified.remove(0);
println!("{}", modified);
let mut modified = s.clone();
modified.pop();
println!("{}", modified);
let mut modified = s;
modified.remove(0);
modified.pop();
println!("{}", modified);
}</syntaxhighlight>
Another possibility is to cut a string slice (moreover, this version assumes
nothing about the string length):
<syntaxhighlight lang="rust">fn main() {
let s = "žluťoučký kůň";
println!(
"{}",
s.char_indices()
.nth(1)
.map(|(i, _)| &s[i..])
.unwrap_or_default()
);
println!(
"{}",
s.char_indices()
.nth_back(0)
.map(|(i, _)| &s[..i])
.unwrap_or_default()
);
println!(
"{}",
s.char_indices()
.nth(1)
.and_then(|(i, _)| s.char_indices().nth_back(0).map(|(j, _)| i..j))
.map(|range| &s[range])
.unwrap_or_default()
);
}</syntaxhighlight>
=={{header|Scala}}==
{{libheader|Scala}}
<
println("socks".init) // strip last character
println("brooms".tail.init) // strip both first and last characters</
=={{header|Scheme}}==
<syntaxhighlight lang="scheme">(define (string-top s)
(if (string=? s "") s (substring s 0 (- (string-length s) 1))))
(define (string-tail s)
(if (string=? s "") s (substring s 1 (string-length s))))
(define (string-top-tail s)
(string-tail (string-top s)))</syntaxhighlight>
=={{header|sed}}==
Remove the first character:
<syntaxhighlight lang="sed">s/.//</syntaxhighlight>
Remove the last character:
<syntaxhighlight lang="sed">s/.$//</syntaxhighlight>
Remove the first and the last character in one step (a bit more complex, to correctly handle single-character strings):
<syntaxhighlight lang="sed">s/.\(\(.*\).\)\{0,1\}/\2/</syntaxhighlight>
=={{header|Seed7}}==
<
const proc: main is func
Line 1,599 ⟶ 2,321:
writeln("Without last: " <& stri[.. pred(length(stri))]);
writeln("Without both: " <& stri[2 .. pred(length(stri))]);
end func;</
Output:
Line 1,610 ⟶ 2,332:
=={{header|SenseTalk}}==
<
set message to peaceSymbol & "Peace!"
put message
Line 1,616 ⟶ 2,338:
put characters 1 to -2 of message
put the second to penultimate characters of message
</syntaxhighlight>
Output:
<
☮Peace!
Peace!
☮Peace
Peace
</syntaxhighlight>
=={{header|Sidef}}==
Strip any characters:
<
say "socks".substr(0, -1); # strip last character
say "brooms".substr(1, -1); # strip both first and last characters
say "与今令".substr(1, -1); # => 今</
{{out}}
<pre>
Line 1,640 ⟶ 2,362:
Strip graphemes:
<
say gstr-/^\X/; # strip first grapheme
say gstr-/\X\z/; # strip last grapheme
say gstr.sub(/^\X/).sub(/\X\z/); # strip both first and last graphemes</
{{out}}
<pre>
Line 1,654 ⟶ 2,376:
{{works with|GNU Smalltalk}}
These all use built-in collection methods that will work with any kind of ordered collection, not just Strings. There is no error checking. They will fail if the string is not at least two characters long.
<
s := 'upraisers'.
Transcript show: 'Top: ', s allButLast; nl.
Transcript show: 'Tail: ', s allButFirst; nl.
Transcript show: 'Without both: ', s allButFirst allButLast; nl.
Transcript show: 'Without both using substring method: ', (s copyFrom: 2 to: s size - 1); nl.
</syntaxhighlight>
{{out}}
<pre>
Line 1,669 ⟶ 2,391:
=={{header|SNOBOL4}}==
<
"socks" rtab(1) . output ;* strip last character
"brooms" len(1) rtab(1) . output ;* strip both first and last characters</
=={{header|Standard ML}}==
<
val str = "abcde" : string
- String.substring(str, 1, String.size str - 1);
Line 1,681 ⟶ 2,403:
val it = "abcd" : string
- String.substring(str, 1, String.size str - 2);
val it = "bcd" : string</
=={{header|Swift}}==
Swift strings are native Unicode strings and do not index through the code points. Swift's <code>String.Index</code> refers to true Unicode characters (Unicode grapheme clusters). Swift standard library has generic functionality that not only works with strings, but also with any type that conforms to relevant protocols. The first method presented here uses generic functions from Swift standard library:
<
println(dropFirst(txt))
println(dropLast(txt))
println(dropFirst(dropLast(txt)))</
{{out}}
<pre>123456789
Line 1,695 ⟶ 2,417:
12345678</pre>
The other method is slicing by range subscripting:
<
println(txt[txt.startIndex.successor() ..< txt.endIndex])
println(txt[txt.startIndex ..< txt.endIndex.predecessor()])
println(txt[txt.startIndex.successor() ..< txt.endIndex.predecessor()])</
{{out}}
<pre>123456789
Line 1,704 ⟶ 2,426:
12345678</pre>
Another way is mutating the string:
<
txt.removeAtIndex(txt.startIndex)
txt.removeAtIndex(txt.endIndex.predecessor())</
The above functions return what they remove.
You can also extend String type and define BASIC-style functions:
<
/// Ensure positive indexes
Line 1,763 ⟶ 2,485:
txt.right(1) // Right part without first character
txt.left(-1) // Left part without last character
txt.mid(1,-1) // Middle part without first and last character</
=={{header|Tcl}}==
<
puts [string range "write" 0 end-1];
puts [string range "brooms" 1 end-1];
=={{header|TorqueScript}}==
Line 1,791 ⟶ 2,513:
=={{header|TUSCRIPT}}==
<
$$ MODE TUSCRIPT
str="upraisers"
Line 1,801 ⟶ 2,523:
PRINT str2
PRINT str3
</syntaxhighlight>
Output:
<pre>
Line 1,814 ⟶ 2,536:
First ''or'' last character:
<
echo "${str#?}" # Remove first char
echo "${str%?}" # Remove last char</
First ''and'' last character:
: Only zsh supports nested string manipulation.
: <
: bash and ksh, use substring expansion, from character index 1 for length of (string length) minus 2
: <
: POSIX shells like dash, need a temp variable
: <
=={{header|Vala}}==
<
// declare test string
string s = "Hello, world!";
Line 1,837 ⟶ 2,559:
// remove first and last letters
string s_first_last = s[1:s.length - 1];
</syntaxhighlight>
=={{header|VBScript}}==
<
End Function
WScript.Echo "Top: UPRAISERS = " & TopNTail("UPRAISERS","top")
WScript.Echo "Tail: UPRAISERS = " & TopNTail("UPRAISERS","tail")
WScript.Echo "Both: UPRAISERS = " & TopNTail("UPRAISERS","both")</
{{out}}
Line 1,859 ⟶ 2,581:
Tail: UPRAISERS = UPRAISER
Both: UPRAISERS = PRAISER</pre>
=={{header|Wren}}==
{{libheader|Wren-str}}
As Wren's string slicing and other built-in methods generally work at the byte level, we use the above module for this task which works at the code-point level.
<syntaxhighlight lang="wren">import "./str" for Str
var a = "Beyoncé"
var b = Str.delete(a, 0)
var len = a.codePoints.count
var c = Str.delete(a, len-1)
var d = Str.delete(c, 0)
for (e in [a, b, c, d]) System.print(e)</syntaxhighlight>
{{out}}
<pre>
Beyoncé
eyoncé
Beyonc
eyonc
</pre>
=={{header|XPL0}}==
<
char S, P;
[S:= "Smiles";
Line 1,872 ⟶ 2,614:
Text(0, S+1); \first and last characters removed
CrLf(0);
]</
Output:
Line 1,882 ⟶ 2,624:
=={{header|zkl}}==
<
"Smiles"[0,-1] //-->Smile
"Smiles"[1,-1] //-->mile</
[] format is [offset (zero based), length]. * means "to the end", a
negative number means from the end.
Line 1,890 ⟶ 2,632:
=={{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
Line 1,897 ⟶ 2,639:
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)))
9020 DEF FN b$(a$)=FN l$(FN f$(a$)) </
{{omit from|GUISS}}
| |||