DEV Community

Daily Challenge #1 - String Peeler

dev.to staff on June 28, 2019

Hey, everyone. We've decided to host a daily challenge series. We'll have a variety of challenges, ranging in difficulty and complexity. If you cho...

Read full post

Displaying a subset of the total comments. Please sign in to view all comments on this post.

Alvaro Montoro • Jun 28 '19 • Edited

CSS

Just add the class removeFirstAndLastLetter to a tag, and see the first and last letter "removed" from the text 😋

.removeFirstAndLastLetter {
  background: #fff;
  font-family: monospace;
  white-space: nowrap;
  position: relative;
  display: inline-block;
}

.removeFirstAndLastLetter::before,
.removeFirstAndLastLetter::after {
  content: "\00a0";
  background: #fff;
  top: 0;
  display: block;
  position: absolute;
  height: 100%;
  width: auto;
}

.removeFirstAndLastLetter::after {
  right: 0;
}

And as an extra, it can be stylized and animated, so you can see the letters fade out:

Ben Halpern • Jun 29 '19

Ha! This one is great.

Alvaro Montoro • Jun 29 '19

Thanks :)

Ryland G • Jun 28 '19 • Edited

JavaScript

(someString) => someString.length > 2 ? someString.slice(1, -1) : undefined;

Python

someString[1:-1] if len(someString) > 2 else None

C++

someString.size() > 2 ? someString.substr(1, someString.size() - 1) : null;

int trimString(char someString[])
{
  if (strlen(someString) > 2) {
    char *copy = malloc((strlen(someString) - 2) * sizeof(char));
    memmove (copy, someString + 1, strlen(someString) - 2);
    printf("%s", copy);
    free(copy);
    return 0;
  }
  return 1;
}

Rafael Acioly • Jun 29 '19

Let people do something 😂

Jerome De Leon • Mar 30 '20

HAHAHA damn. Let me finish my code LOL.

Clay Murray • Jun 29 '19 • Edited

Let's just go wild

(someString) => {
   switch(someString.length){
   case 0:
   case 1:
   case 2:
       return null;
   default:
       const arr = someString.split("")
       arr.pop();
       arr.reverse();
       arr.pop();
       arr.reverse();
       return arr.join("")
   }
}

Why not?

Ibrahim Abdullahi Aliyu • Apr 15 '20

This is indeed wild

Alvaro Montoro • Jun 28 '19 • Edited

In JavaScript it could be 24 bytes:

f=s=>s.slice(1,-1)||null

Andrew Brown 🇨🇦 • Jun 29 '19 • Edited

I am surprised no one wrote test code. Sometimes in interviews with challenge this simple and you have access to run ruby they are expecting to see test code. Check out my ruby test code tutorials buds.

I notice lots of people are raising an error instead of ignoring or returning null so they have failed the challenge's instructions.

require "test/unit"

# remove the first and last letter of a string
# if there is less than 2 characters return zero.
def quartered value
  raise ArgumentError, 'Argument is not a string' unless value.is_a? String
  return value unless value.size > 2
  value[0] = ''
  value.chop
end


class QaurteredTest < Test::Unit::TestCase
  def test_quartered
    assert_equal 'orl', quartered('world'), "quartered('world') should return a string called 'orl'"
  end

  def test_quartered_ignore
    assert_equal 'hi', quartered('hi'), "quartered('hi') should return 'hi'"
  end

  def test_quartered_invalid
    assert_raise_message('Argument is not a string', "quartered(2) should raise exception") do
      quartered(2)
    end
  end
end

Ben Halpern • Jun 28 '19 • Edited

Ruby


def remove_first_and_last(string)
  raise "Invalid" if string.size < 3
  string[1..string.size-2]
end

MetaDave 🇪🇺 • Aug 7 '19

I think you can get away with string[1..-2] there, Ben.

Ceban Dumitru • Jun 30 '19 • Edited

BASH

if [[ ${#1} > 2 ]]; then
    echo "${1:1:$(($#1-2))}";
else echo "not validated";
fi

orenovadia • Sep 18 '19 • Edited

I was surprised to find that -1 to work as well:

V=abcde
echo "${V:1:-1}"

Exequiel Beker • Jun 29 '19

I tried to not use any str function.

char* trimFirstAndLastLetters(char* str)
{
    int index = 1;

    if(str[0] == '\0' || str[1] == '\0') {
        return NULL;
    }

    while(*(str + index) != '\0') {
        *(str + (index - 1)) = *(str + index);
        index++;
    }

    /* Remove last one */
    *(str + (index - 2)) = '\0';
    return str;
}

Corey Alexander • Jun 28 '19 • Edited

Rust

fn remove_first_and_last(string: &str) -> &str {
    remove_first_and_last_n_chars(&string, 1)
}

fn remove_first_and_last_n_chars(string: &str, chars_to_remove: usize) -> &str {
    if string.len() <= (2 * chars_to_remove) {
        panic!("Input string too short")
    }
    let start = chars_to_remove;
    let end = string.len() - 1 - chars_to_remove;

    &string[start..end]
} 

fn main() {
    println!("Ans: {}", remove_first_and_last("Hello, world!"));
    println!("Ans: {}", remove_first_and_last_n_chars("Hello, world!", 2));
    println!("Ans: {}", remove_first_and_last_n_chars("aa", 1));
    println!("Ans: {}", remove_first_and_last_n_chars("aa", 2));
}

View it in the Rust Playground here: play.rust-lang.org/?version=stable...

Andreas Jakof • Sep 24 '19

in C# as Extension-Method

public static string Peel(this string toPeel)
{
    int residual = toPeel.Length -2;
    if (residual < 1) return null;

    return toPeel.SubString(1,residual); //skip the first and take all but the last char
}

Martin Himmel • Jun 28 '19

PHP

function remove_string_ends($str) {
    if (strlen($str) <= 2) {
        return null;
    }
    return substr($str, 1, -1);
}

Claudio Scatoli • Jun 28 '19 • Edited

I like that substr trick with the -1, didn't think of that!

How about this one liner?

<?php

function trimThis(string $str)
{
    return (mb_strlen($str) <= 2) ? null : substr($str,1,-1);
}

Use mb_string to support multibyte chars, such as Chinese

Also typehinted the argument, you never know...

This one is even shorter, possible only if the arg is typehinted tho

<?php
function trimThis(string $str) {
    return substr($str,1,-1) ?: null;
}

When the string is shorter than 2, substr returns false;
when the length is 2, substr returns "".

In both cases it's false, the the return is null.

Edit: many typos, I'm on mobile :/

Corey Alexander • Jun 28 '19 • Edited

Ruby

Basic

def remove_first_and_last(some_string)
  raise 'Not long enough' unless some_string.length > 2

  some_string[1..-2]
end

Extra

def remove_first_and_last_n_characters(some_string, chars_to_remove: 1)
  raise 'Not long enough' unless some_string.length > (chars_to_remove * 2)

  start_index = chars_to_remove
  end_index = -1 - chars_to_remove
  some_string[start_index..end_index]
end

Kasper Meyer • Jul 7 '19 • Edited

Ruby solution

require "minitest/autorun"

class WordTrimmer
  def initialize word
    @word = word
  end

  def trim
    @word.length <= 2 ? @word : @word[1..-2]
  end
end

class WordTrimmerTest < MiniTest::Test
  def test_removing_first_and_last_letter
    assert_equal "aspe", WordTrimmer.new("kasper").trim
  end

  def test_ignoring_two_letter_word
    assert_equal "hi", WordTrimmer.new("hi").trim
  end

  def test_ignoring_one_letter_word
    assert_equal "I", WordTrimmer.new("I").trim
  end
end

Rafi • Sep 18 '19 • Edited

solution in SQL (postgres)

\set str 'hello world'

select (
     case
       when (select length(:'str') > 2) 
        then (select substr(:'str', 2, length(:'str') - 2) ) 
else 'invalid string' end );

Michael Lang • Aug 9 '19

Ruby Language Version

With specs

def trim value
  value.to_s[1...-1]
end

require "spec"

describe "#trim" do
  it { expect(trim "Foo Bar").to eq "oo Ba"}
  it { expect(trim "Foo").to eq "o"}
  it { expect(trim "Fo").to eq ""}
  it { expect(trim "F").to eq ""}
  it { expect(trim nil).to be_nil}
  it { expect(trim 777).to eq "7"}
end

output

>> rspec debook_ends.rb
......

Finished in 0.00696 seconds (files took 0.15187 seconds to load)
6 examples, 0 failures

Tom Ekander • Jun 28 '19

ReasonML

let strip = text =>
  String.(
    length(text) > 2
      ? switch (sub(text, 1, length(text) - 2)) {
        | s => Some(s)
        | exception _ => None
        }
      : None
  );

strip("hello"); // Some("ell")
strip("ab"); // None
strip(""); // None

jmc • Jun 30 '19

Clojure:

(defn trim [s]
  (apply str (drop-last (rest s))))

Vladislav Guleaev • Jun 28 '19 • Edited

function removeChar(str){
 return str.substr(1, str.length - 2)
};

Praneet Nadkar • Jul 16 '19 • Edited

In C#, I would use in built string function Trim()
In my opinion we don't need Substring() here.
Just call :

readedInput.Trim(readedInput[0], readedInput[readedInput.Length - 1])

With 2 length validation:

var trimmed = readedInput.Length > 2 ? readedInput.Trim(readedInput[0], readedInput[readedInput.Length - 1]) : "Invalid" ;

Andreas Jakof • Sep 24 '19

But what if the input would be "aaajldflbbb"?

When using Trim(char[]), all appearances of the characters given to the method at the beginning and at the end, will be removed, leaving "jldfl".

Removes all leading and trailing occurrences of a set of characters specified in an array from the current String object.

Werner Echezuría • Jun 28 '19

Rust

fn trim_string(string: &str) -> &str {
    if string.len() <= 2 {
        panic!("Input string too short");
    }
    &string[1..string.len() - 1]
}

Vinicius Cavagnolli • Jun 28 '19

VB5 / VB6

Function Challenge1(input As String) As String
    If len(input) <= 2 Then
        Challenge1 = Nothing
    Else
        Challenge1 = Mid$(input, 2, len(input) - 2) 
    End If
End Function

Visual Basic .NET

Function Challenge1(input as String)
    Return If(input.Length > 2, Mid(input, 2, len(input) - 2), Nothing)
End Function

string Challenge1(string input) => input.Length > 2 ? input.Substring(1, input.Length - 2) : null;

C# using LINQ (because yes)

string Challenge1(string input) => input.Length > 2 ? string.Concat(input.Skip(1).Take(input.Length - 2)) : null;

Rodrigo Sene • Jul 8 '19

JAVA

public class Solution {

    public static String getStringCore(String input){
        if(input.length() > 2){
            return input.substring(1, input.length() -1);
        }
        return "invalid input";
    }

    public static void main(String[] arg){
        System.out.println(Solution.getStringCore("let's do it agin"));
    }
}

Robin Victorino • Jul 9 '19 • Edited

Hi!

A bit late to the party, but here's a Groovy one:

String peel(String toPeel) {
    if(!(toPeel?.length() > 2)) {
        throw new Exception('Can\'t peel a string shorter than 3 characters')
    }
    return toPeel[1..-2]
}

flamangoes • Jul 26 '19

My approach in groovy...

Not sure if "ignore <2 chars" means "don't consider" or "ignore the trimming"

Don't consider =>

String peel(String toPeel) {
    toPeel[1..-2]
}

Ignore =>

String peel(String toPeel) {
    toPeel?.length() >2 ? toPeel[1..-2] : toPeel
}

I don't like returning null.

Josh • Aug 2 '19 • Edited

Trivial in Ruby:

def double_chop(string)
  return string if string.length <= 2
  string[1..-2]
end

double_chop("hello world") # => "ello worl"
double_chop("book")        # => "oo"
double_chop("OOP")         # => "O"
double_chop("hi")          # => "hi"

Shannon Crabill • Aug 2 '19

I liked today's challenge so I'm going back to do past ones

def string_peeler(string)
  if string.length > 2
    string.delete(string[0]).delete(string[-1])
  end
end

Returns

string_peeler("hi") => nil 
string_peeler("killer") => "ille" 
string_peeler("BOB") => "O"

Devendra Dhanal • Aug 12 '19

const stringTrimmer = input => input.length <=2 ? null : input.substring(1, input.length - 1)



console.log(stringTrimmer("Lorem Ipsum")) // orem Ipsu
console.log(stringTrimmer("John Doe")) // ohn Do
console.log(stringTrimmer("Fox jumps over")) // ox jumps ove
console.log(stringTrimmer("Lorem")) // ore
console.log(stringTrimmer("Lo")) // null

Jarod Smith • Aug 16 '19


// "enterprise" solution
function peelString(str = '')
{
  //validate
  if(typeof(str) != 'string')
    throw new Error(`${str}, ${typeof(str)} is not a string`);
  if(str.length <= 2)
    throw new Error(`${str} does not have atleast 3 letters`);

  // process
  return str.substring(1,str.length-1);
}

My "enterprise" solution

Ilyes Chouia • Aug 23 '19 • Edited

PHP:


function removeFirstAndLastLetter($text){
    return substr($text, 1, -1);
}
echo removeFirstAndLastLetter("Oh no, I lost two letters");

// Outputs : h no, I lost two letter

Ganesh Prasad • Aug 24 '19


const test = require ('./tester');

const f = str => str.length > 2 ? str.slice(1, -1) : null;
test (f, [
    {
        in: ['Dev'],
        out: 'e',
    },
    {
        in: ['GP'],
        out: null,
    },
    {
        in: ['hello'],
        out: 'ell'
    }
]);

[PASSED]  Case #1: e
[PASSED]  Case #2: null
[PASSED]  Case #3: ell

Iago Angelim Costa Cavalcante • Sep 11 '19

Elixir

def remove_primeiro_ultimo_caracteres(string, caracter_removido \\ 1) do
    unless String.length(string) > (caracter_removido * 2) do
      raise 'Tamanho da string é menor que 2'
    end

    inicio = caracter_removido
    fim = -1 - caracter_removido
    String.slice(string, inicio..fim)
  end

Peter • Sep 24 '19

Solution in Go:

package main

import (
    "fmt"
)

func main() {
    p, err := peel("hello")
    if err != nil {
        panic(err)
    }
    fmt.Println(p)
}

func peel(s string) (string, error) {
    if len(s) < 3 {
        return "", fmt.Errorf("Input string too short")
    }
    return s[1 : len(s)-1], nil
}

Running example in Go Playground

Michael Baas • Oct 10 '19

APL (using Dyalog APL)

as a direct function:

      peeler←{1↓¯1↓⍵}

Testing it

      peeler 'Works'
ork

Try it online!

kesprit • Oct 14 '19

Swift

func removeFirstAndLastLetter(value: String) -> String? {
    guard value.count > 3 else { return nil }
    var result = value.dropFirst()
    result.popLast()
    return String(result)
}

David Wickes • Oct 28 '19

Factor

USING: kernel math sequences ;
IN: dev.to-daily-challenge

: not-first-and-last ( str -- str ) dup length 2 >  [ rest but-last ] [ ] if ;

and some tests

USING: tools.test dev.to-daily-challenge ;
IN: dev.to-daily-challenge.tests

{ "ell" } [ "hello" not-first-and-last ] unit-test
{ "e" } [ "hel" not-first-and-last ] unit-test
{ "ha" } [ "ha" not-first-and-last ] unit-test
{ "" } [ "" not-first-and-last ] unit-test

Bruce Axtens • Oct 31 '19

I've only just stumbled over the Daily Challenge. Oh well, here's my C# Linq solution (different from the other one) and returns an empty string if length <= 2.

public static string StringPeeler(string str) => string.Join("", from ch in str.ToCharArray(1, str.Length - 2) select ch);

Adan ϟ • Nov 9 '19

I'll start doing this challenges in Dart :D

import 'dart:io';

main() {
  stdout.writeln('Phrase?');
  String phrase = stdin.readLineSync();
  phrase.length > 2 ? print(phrase.substring(1, phrase.length - 1)) : print('Invalid Phrase');
}

Anil Kumar Khandei • Nov 13 '19

I am so many months late in the game so starting with the first one.

 public static string StringPeeler(string InputStr)
        {
            if (InputStr.Length <= 2)
            {
                return "invalid";
            }
            else
            {
                return InputStr.Substring(1, InputStr.Length - 2);
            }
        }

And also unit tested the same:

 [TestMethod]
        public void StringPeeler_InvalidTest()
        {
           var result= DEVToChallenges.StringPeeler("a");

            Assert.IsTrue(result == "invalid");
        }
        [TestMethod]
        public void StringPeeler_InvalidTestTwo()
        {
            var result = DEVToChallenges.StringPeeler("an");

            Assert.IsTrue(result == "invalid");
        }

        [TestMethod]
        public void StringPeeler_InvalidTestThree()
        {
            var result = DEVToChallenges.StringPeeler("ant");

            Assert.IsFalse(result == "invalid");
        }

        [TestMethod]
        public void StringPeeler_ValidTestOne()
        {
            var result = DEVToChallenges.StringPeeler("cobol");

            Assert.IsTrue(result == "obo");
        }

Tallie • Nov 22 '19

My solution using Python and list comprehension :)

def stringPeeler(string_to_peel):
    if len(string_to_peel) > 2:
        return "".join([x for i, x in enumerate(list(string_to_peel)) if (len(string_to_peel) - 1) > i > 0])
    else:
        return None

Peter Bunting • Nov 23 '19

In F#. Not the most straightforward way to solve this, but I wanted to use the language Array splicing.

let stringToByteArray (s:string)= System.Text.Encoding.ASCII.GetBytes s
let byteArraySplice x y (b: byte[]) = b.[x..y]
let byteArrayToString (b: byte[]) = System.Text.Encoding.ASCII.GetString b

let stringPeeler s = 
    s
    |> stringToByteArray
    |> byteArraySplice 1 (s.Length - 2)
    |> byteArrayToString

printfn "%s" <| stringPeeler "abcdefgh"
printfn "%s" <| stringPeeler "ab"
printfn "%s" <| stringPeeler "a"

Peter Bunting • Nov 23 '19

And it turns out that you don't even need to explicitly convert it to an array. F# will let you do splicing on a string. So a much better solution is:

let stringPeeler (s: string) = s.[1..(s.Length - 2)]

Vivek • Dec 24 '19

Swift - 5

var str = "Hello, playground"
func stringPeeler(input: String) -> String? {
    if (input.count <= 2) {
        return nil;
    }

    return String(input.dropLast().dropFirst())
}

print(stringPeeler(input: str)!)

David Figueroa • Jan 8 '20

Powershell

function Remove-FirstAndLastCharacter {
    param(
        [parameter(Mandatory,ValueFromPipelineByName)]
        [string]$Input
    )
    if ($Input.length -ge 3)
    { 
        return $Input.SubString(1,$Input.Length - 2)
    }
}

Kyle Jones • Jan 26 '20

In Python:

def peel_string(text):
    if len(text) > 2:
        return text[1:(len(text) - 1)]
    return None

print(peel_string("Testing"))
print(peel_string("Hi"))
print(peel_string(""))

Jesse Doka • Apr 1 '20 • Edited

Python

def string_peeler(string):
    stringarr = []
    newstring = ''

    for x in string:
        stringarr.append(x)

    del(stringarr[0])
    del(stringarr[-1])

    for em in stringarr:
        newstring += em
    print(newstring)

string_peeler('Missing two letters')

Aaron Stroud • May 19 '20

I see a lot of solutions removing characters without checking to see if they're "letters." Here's my JavaScript solution.

// Remove the first and last _letters_ in a string
function removeFirstLastLetters(str) {
  if (str.length < 3) {
    return null;
  }
  else {
    const regex = /[a-zA-Z]/;

    let firstCharIndex = str.search(regex);

    if (firstCharIndex === -1 ) {
      return null;
    }

    else {
      let lastCharIndex = str.length - str.split("").reverse().join("").search(regex);

      return str.slice(0, firstCharIndex) + str.slice(firstCharIndex + 1, lastCharIndex - 1) + str.slice(lastCharIndex, str.length);
    }
  }
}

George Offley • Sep 14 '20 • Edited

Off the top of the head in Python 🐍🐍🐍🐍

def strip_first_last(string):
     if len(string) > 2:
          return string[1:-1]
     else:
          return None

print(strip_first_last("Hello World"))

Jen Chan • Dec 1 '19 • Edited

Handwrote my answer to practice:

const firstLast = (str) => {
const letters = [...str];

if (letters.length <=2){
return null;
}

let trimmed = letters.shift().pop();
return trimmed.join('');
}
Now to see if it works...

khaloscar • Aug 22 '23 • Edited

Im new to rust, and tried to get in some detailed error-handling.
Also added the functionality to not peel text that is too long as it does not make sense to me rn.
Maybe it would be better to take an String instead of &str as an argument, but idk.

fn peel_string(input: &str) -> Result<&str, Box<dyn Error>> {
    let output = match input.len() {
        3..=16 => Ok(&input[1..input.len() - 1]),
        len if len > 16 => Err("Input too long, should be 3-16 chars".into()),
        len if len == 0 =>Err("No input, should be 3-16 chars".into()),
        _ => Err("Input too short, should be 3-16 chars".into()),
    };

    output
}

karthick rajan • Sep 27 '19 • Edited

Purescript

flremove val =
let
value = toCharArray val
value1 = Array.length value
in
if (length val > 2)
then do
show $ fromCharArray $ Array.slice 1 (value1 -1) value
else ""

main = render =<< withConsole do
log $ flremove "string"

Geofrey Aduda • Nov 7 '19 • Edited

java function using string builder

public String removefirstWordLastWord(String mystring )
{
///Delete last and first character

StringBuilder chr=new StringBuilder(mystring);
String strresult="";
if (mystring.length()>=2)
{
chr.deleteCharAt(0);
chr.deleteCharAt(chr.length()-1);
strresult=chr.toString();
}else{
strresult=("Invalid String");
}
}

margo1993 • Nov 7 '19

Yesterday I started to discover golang, so i try do make these daily challenges in go.

My simple go solution

func RemoveFirstAndLastCharacterInWord(word string) (string, error) {
    wordLen := len(word)
    if wordLen < 3 {
        return "", errors.New("String: word is too short")
    }
    return word[1 : wordLen-1], nil
}

official_dulin • Sep 8 '20

Go:

package kata

func RemoveChar(word string) string {
  return word[1:len(word)-1]
}

Caleb Rudder • Jul 22 '19 • Edited

C++ that takes user input

string prompt = "Enter a string: ";
string userInput;

cout << prompt << endl;
getline(cin,userInput);

if (userInput.length() > 2) {

    userInput = userInput.substr(1, (userInput.length() - 2));

}

cout << userInput;

Rafael Acioly • Jun 29 '19

func strip(content string) (string, error){
    if len(content) <= 2 {
        return "", error.New("invalid length")
    }

    return content[1:len(content)-1], nil
}

sachindra@work • Oct 1 '19

function stringPeeler(str) {
return str.length > 2 ? str.substr(1, str.length-2) : 'Invalid String'
}

K.V.Harish • Oct 3 '19

My solution in js


const stringPeeler = (str) => str.length > 2 ? str.substr(1, str.length - 2) : `Invalid input to stringPeeler function ${str}`;

Harshal Raverkar • Oct 12 '19

if (str.Length <= 2) return; var t = str.Substring(1, str.Length - 2); Console.Write(t);

Jeffrey Hill • Dec 21 '22

const str => str.length > 2 ? str.slice(1, -1) : undefined;

Ronak Jethwa • May 20 '20

function remove_ends(str) {
    return str.length <= 2 ? null : str.substr(1,str.length-2);
}
remove_ends("string");

Ronak Jethwa • Jun 8 '20

return str.length > 2 ? str.slice(1,str.length-1) : str;

David Leger • Jun 12 '20

const peelString = (s: string): string => {
  return s.length > 2 ? s.slice(1, -1) : null;
}

peter279k • Jun 16 '20

Here is my simple solution :).

function removeChar(str){
 //You got this!
  return str.substr(1, str.length-2);
};

Michael Treanor • Nov 21 '19

Python:

code:

import sys
print("\n".join([arg[1:-1] for arg in sys.argv[1:] if len(arg) > 2]))

example:

# example

❯ ./first_and_last.py this is a bad example
hi
a
xampl

Dimitri Lahaye • Jul 8 '20

Here in JS

function remove(str) {
  if (str.length >= 3) {
    return str.slice(1, -1);
  }
}

cloudyhug • Aug 30 '19

Haskell

removeFirstAndLast :: String -> String
removeFirstAndLast s
  | length s <= 2 = s
  | otherwise     = init $ tail s

Long Nguyen • Mar 3 '20

Javascript

function removeFirstAndLast(txt) {
  if (typeof txt != "string" || !txt || txt.length < 2) {
    return null;
  }
  return txt.slice(1, txt.length - 1);
}

Rafi • Aug 24 '19

Rust

fn main() {
  let input = "Hello, world!";
  let output = &input[1..(input.len() - 1)];
  println!("{}", output);
}

spyrosko • Mar 18 '20 • Edited

function word(str) {

   let i = str.slice(1, -1);

   if (i) {
      return i;
   } else {
      return 'null';
   }
}

pochirajuAnirudh • Aug 24 '19

Python 3

def remove_first_and_last_characters(input_string):
    if len(input_string) < 3 or type(input_string) != str:
        return "invalid"
    return input_string[1:-1]

Maynard Cabalitan • Aug 30 '19 • Edited

Ruby

def trimmer(str)
  str.length  > 2  ? str[1..-2] : 'invalid'
end

class String
  def trimmer
    self.length > 2 ? self[1..-2] : 'invalid'
  end
end

Craig McIlwrath • Aug 19 '19

Haskell:

removeFirstAndLast :: [a] -> Maybe [a]
removeFirstAndLast xs 
  | length xs < 3 = Nothing 
  | otherwise = Just $ init $ tail xs

As a bonus, it works on any type of list

Jordon Replogle • Jun 28 '19

Perl?

$testing = "Happy coding!";
print &peeler($testing) . "\n";

sub peeler {
    my $str = shift;
    if(length($str) > 2) {
        return substr($str, 1, -1);
    }
}

E. Choroba • Jul 3 '19

Or maybe just

sub peeler { shift =~ s/^.|.$//gr }

Vicente G. Reyes • Jun 28 '19 • Edited

Python

def remove(yo):
    if yo <= 2:
        print("Not enough characters in string")
    else:
    return yo[1:-1]

Mohit Mahajan • Jul 13 '20

I am new to the coding world so my code may not be that much efficient, but i am happy with the fact that i wrote it.

import sys
def trim_characters(input_string):
return_string=""
#print(return_string)
if (len(input_string))>2:
for i in range(0, len(input_string)):
if i!=0 and i!=len(input_string)-1:
return_string=return_string + input_string[i]
print("Output string : "+ return_string)
else:
print("Minnimum 3 characters are allowed")
trim_characters(sys.argv[1])

Cent • Jan 4 '20

Codepen


const stringPeeler = text => {
  return text.length < 3 ? null : text.substr(1, text.length-2);
}

Ben Lovy • Jul 9 '19

I'm late to the party, catching up one by one!

Haskell:

trimAtBothEnds :: String -> Maybe String
trimAtBothEnds s = if ((length s) <= 2) then Nothing else Just (init.tail $ s)