#!/usr/local/bin/perl
#
use strict;
use warnings;

print
   map { s{0{2,}}{0}; $_ }
   <DATA>;

__END__
215000007801
300000324002
890000457651
210004563401
201045139158
[download]

and the output is

21507801
30324002
890457651
2104563401
201045139158
[download]

I hope this is of use.

Cheers,

JohnGG

Update: Looks like I've misunderstood. If you say the first zero should not be touched, why does 890000457651 become 89457651 and not 890457651? Perhaps you could clarify what you require.

print
   map { s{0{2,}}{0}; $_ }
   <DATA>;
[download]

I know this is completely OT and that in this particular case it wouldn't make a difference, but we recommend all the time against slurping files in all at once unless really needed, so please do not spread the word against this recommendation:

s/0{2,}/0/, print while <DATA>;
[download]

is not terribly more verbose. (I also changed the curlies as delimiters in the s operator because in this case they seemed confusing to me.)

we recommend all the time against slurping files in all at once unless really needed

Do we? How strange. Why?

Seems to me that slurping is a perfectly valid technique in the right circumstances, for instance, parsing command output or working with small to middling data sets. People have even gone to the trouble of writing modules to support the idiom.

In this case it would appear that ultibuzz has a data set of 5000000 numbers so slurping, as it turns out, would definitely not be appropriate.

Cheers,

JohnGG

1. Always keep the first two numbers intact
2. If any zeros start at position 3, remove them all.
3. If you didn't do that, then if two or more zeros start after position 3, truncate them to a single 0
4. If you didn't do either of the first two techniques, then remove a single 0 starting at position 3 or later entirely.

#!/usr/bin/perl

use strict;
use warnings;
use Test::More;

my %output_for
    = ( '215000007801' => '21507801',
        '300000324002' => '30324002',
        '890000457651' => '89457651',
        '210004563401' => '214563401',
        '201045139158' => '20145139158', );

plan tests => scalar keys %output_for;

while ( my ($input, $correct_output) = each %output_for ) {
    my $orig_input = $input;
    $input = &compress_numstring( $input );
    is( $input, $correct_output, "Solved '$orig_input'" );
}

sub compress_numstring {
  my $starting_num = shift;
  return $starting_num
   unless(defined $starting_num && $starting_num =~ /^(\d{2})(\d+)/);
  my( $keep, $modify ) = ($1,$2);
  ( $modify =~ s/^0+// ) ||
  ( $modify =~ s/0{2,}/0/ ) ||
  ( $modify =~ s/(?<!0)0([1-9]|$)/$1/ );
  return $keep . $modify;
}
[download]

(for the regex fanboys:


sub compress_numstring {
  substr($_[0], 2) =~ s/(^0+|(0)0+|(?<!0)0([1-9]|$))/$2$3/;
  return $_[0];
}
[download]


does the same thing as the other function, but with more job security)
Unfortunately, 'use warnings' will complain.

my $keep = substr( $_, 0, 2 );
$_ = substr( $_, 2, length($_) );
s/0+/0;
$_ = $keep . $_;
[download]

For the benefit of other monks who might be trying their hand at this:

use Test::More;

my %output_for
    = ( '215000007801' => '21507801',
        '300000324002' => '30324002',
        '890000457651' => '89457651',
        '210004563401' => '214563401',
        '201045139158' => '20145139158', );

plan tests => scalar keys %output_for;

sub solution {
    # (this doesn't work)
    $_[0] =~ s{ \A ([^0]+ 0) ([^0]*) 0+ ([^0]+0) }{$1$2$3}x
#        ||
#    $_[0] =~ s{ \A ([^0]+) 0+ ([^0]) }{$1$2}x;
}

while ( my ($input, $correct_output) = each %output_for ) {
    my $orig_input = $input;
    solution( $input );
    is( $input, $correct_output, "Solved '$orig_input'" );
}
[download]

Because it's not Thursday after dark. If it were, the 0 would have been replaced with a jack and he'd be on the way to a royal fizzbin. Unless he got a kronk, but that'd just be bad luck.

I think the problem is that he doesn't understand his own spec well enough to either write the regex nor to explain it to us. It's probably time for the OP to sit down, go back to square one, and enumerate just what it is that's trying to be accomplished.

Cheers
Chris

sure
we get 12 digit numbers from another firm these numbers can vary from 4 -12 digits and are fileld up with 0
the problem is we get an letter how they fill up the numbers but they miss several possibilitys so i get the problem here decoding this 12 digit numbers to remove the right 0 and not 0 that are part of the digit.

the explanation was 2 sentencis wich dosnt really help for anything ^^
and we are not in the position to force a change in their process then we woud get these numbers in paper form so we need to do workarounds to get the right numbers, or atleast not many failurs :D

kd ultibuzz

I feel the need to ask, might it be easier to convert your numbers to the other firm's numbers? Or maybe not try to convert anyone's numbers, but use both yours and theirs and match them up using a database or something? Maybe if I understood how and why they seem to add 0 in very odd places, it would be easier to figure out how to deal with this. I'm not a regex person, so this is my stab at this:
Read more... (3 kB)
I'm sure there is a serious performance hit for not using a regex.

sorry for the bad explanation, i try to explain it better
the following regex will produce this

s/(?<=\d{2})0*(?<=\d{4})0+//

output
215000007801 -> 2157801
300000324002 -> 30324002
890000457651 -> 89457651
210004563401 -> 214563401
201045139158 -> 201045139158
[download]

these 2 outputs are wrong
201045139158 -> 201045139158
215000007801 -> 2157801
shoud be
215000007801 -> 21507801
201045139158 -> 20145139158

now i try to explain the rule better,counting starts at 0
the 0 , 1 digits shoud be untouched
if the 2 digit is a 0 and the next digit is a 0 remove all 0 untill first non 0
if the 2 digit a 0 and the next is a non 0 remove the 0
if the 3 digit is a 0 and follows by a 0 then remove all 0 except the 0 at 3 digit
if the 3 digit is a 0 and the next digit is a non 0 remove only the 0
if the 4 digit is a 0 remove it and all following 0 untill non 0

i hope that makes it a bit clearer, i know its kinda confusing

kd ultibuzz

i will test the help u all already given tomorrow at office,thx alot

Hi, You need an anchor '^' to make sure the matchings start from the beginning of your strings..and your requirements might be written into two patterns which would be much easier to understand(the order of two s/// expressions matters)..

#!/usr/bin/perl
use warnings;
use strict;

while(<DATA>) {
    s/^(\d\d[1-9])0(?=[1-9])/$1/;
    s/^(\d\d(?:[1-9]0)?)0+/$1/;

    print;
}

__DATA__
215000007801
300000324002
890000457651
210004563401
201045139158

Regards,
Xicheng

your right 2 patterns look easyer,

i am testing atm 5 million numbers and afterwards they will check with the system, then i know if all fit are some fail.

same testing atm for the regex fanboy pattern ;)

thx alot for the quick and very good help
kd ultibuzz




UPDATE:there is a problem with numbers like

215100069395
215100069395
215100153821
they shoud change into
215169395
215169395
2151153821

but they remained unchanged

UPDATE 2:i have it running with an if loop, if digit 2 or 3 is 0 use new pattern else my old one ^^
this isn't nice at all and i don't like it ;)