Remove lowercase letter if it is followed by an uppercase letter

Question

The goal is to get from string $a="NewYork" new string without lowercase that stands before uppercase.

In this example, we should get output "NeYork"

I tried to do this through positions of small and big letters in ASCII table, but it doesn't work. I'm not sure is it possible to to do this in similar way, through positions in ASCII table.

function delete_char($a)
{
 global $b;
    $a = 'NewYork';
   
    for($i =0; $i<strlen($a); $i++)
    {
         if( ord($a[$i])< ord($a[$i+1])){//this solves only part of a problem 
           chop($a,'$a[$i]');
         }
         else{
            $b.=$a[$i];
         }
    }
    return $b;
}

Answer 1

This is something a regular expression handles with ease

<?php

$a ="NewYorkNewYork";
$reg="/[a-z]([A-Z])/";
echo preg_replace($reg, "$1", $a); // NeYorNeYork

The regular expression searches for a lower case letter followed by an upper case letter, and captures the upper case one. preg_replace() then replace that combination with just the captured letter ($1).

See https://3v4l.org/o43bO

Answer 2

You don't need to capture the uppercase letter and use a backreference in the replacement string.

More simply, match the lowercase letter then use a lookahead for an uppercase letter -- this way you only replace the lowercase character with an empty string. (Demo)

echo preg_replace('~[a-z](?=[A-Z])~', '', 'NewYork');
// NeYork

---

As for a review of your code, there are multiple issues.

• global $b doesn't make sense to me. You need the variable to be instantiated as an empty string within the scope of the custom function only. It more simply should be $b = '';.

• The variable and function naming is unhelpful. A function's name should specifically describe the function's action. A variable should intuitively describe the data that it contains. Generally speaking, don't sacrifice clarity for brevity.

• As a matter of best practice, you should not repeatedly call a function when you know that the value has not changed. Calling strlen() on each iteration of the loop is not beneficial. Declare $length = strlen($input) and use $length over and over.

• $a[$i+1] is going to generate an undefined offset warning on the last iteration of the loop because there cannot possibly be a character at that offset when you already know the length of the string has been fully processed. In other words, the last character of a string will have an offset of "length - 1". There is more than one way to address this, but I'll use the null coalescing operator to set a fallback character that will not qualify the previous letter for removal.

• Most importantly, you cannot just check that the current ord value is less than the next ord value. See here that lowercase letters have an ordinal range of 97 through 122 and uppercase letters have an ordinal range of 65 through 90. You will need to check that both letters meet the qualifying criteria for the current letter to be included in the result string.

Rewrite: (Demo)

function removeLowerCharBeforeUpperChar(string $input): string
{
    $output = '';
    $length = strlen($input);
    for ($offset = 0; $offset < $length; ++$offset) {
        $currentOrd = ord($input[$offset]);
        $nextOrd = ord($input[$offset + 1] ?? '_');

        if ($currentOrd < 97
            || $currentOrd > 122
            || $nextOrd < 65
            || $nextOrd > 90
        ){
            $output .= $input[$offset];
        }
    }
    return $output;
}

echo removeLowerCharBeforeUpperChar('MickMacKusa');
// MicMaKusa

Or with ctype_ functions: (Demo)

function removeLowerCharBeforeUpperChar(string $input): string
{
    $output = '';
    $length = strlen($input);
    for ($offset = 0; $offset < $length; ++$offset) {
        $nextLetter = $input[$offset + 1] ?? '';
        if (ctype_lower($input[$offset]) && ctype_upper($nextLetter)) {
            $output .= $nextLetter; // omit current letter, save next
            ++$offset; // double iterate
        } else {
            $output .= $input[$offset]; // save current letter
        }
    }
    return $output;
}

To clarify, I would not use the above custom function in a professional script and both snippets are not built to process strings containing multibyte characters.

Answer 3

Simply, I create new variable $s used for store new string to be returned and a make loop iterate over $a string, I used ctype_upper to check if next character not uppercase append it to $s. at the end i return $s concatenate with last char of string.

function delete_char(string $a): string
{
  if(!strlen($a))
  {
     return '';
  }

  $s='';
  for($i = 0; $i < strlen($a)-1; $i++)
  {
      if(!ctype_upper($a[$i+1])){
        $s.=$a[$i];
      }
  }
  return $s.$a[-1];
}
echo delete_char("NewYork");//NeYork

Answer 4

Something like this maybe?

<?php
    $word = 'NewYork';
    preg_match('/.[A-Z].*/', $word, $match);
    if($match){
        $rlen = strlen($match[0]); //length from character before capital letter
        $start = strlen($word)-$rlen; //first lower case before the capital
        $edited_word = substr_replace($word, '', $start, 1); //removes character
        echo $edited_word; //prints NeYork
    }
?>