Confirming existence of lapindromes
Firstly, there's no reason for us to dump all of this in main.

The logic for determining whether or not a string is a lapindrome can (and should) simply exist in a function that takes a string and returns a bool.

bool isLapindrome(const char *string);


This function has the single responsibility of determining whether or not the input string is a Lapindrome, and it returns a true/false indicating as much.




 if(len%2 !=0)
    {
        for(i=0;i&lt;len/2;i++)
        {
            for(j=(len/2)+1;j&lt;len;j++)
            {
                if(s[i] == s[j])
                {
                    if(b[i] &amp;&amp; b[j] )
                    {
                        b[i]=0;
                        b[j]=0;
                        count+=1;
                    }
                }
            }
        }
    }
     else if(len%2 ==0)
    {
        for(i=0;i&lt;len/2;i++)
        {
            for(j=(len/2);j&lt;len;j++)
            {
                if(s[i] == s[j])
                {
                    if(b[i] &amp;&amp; b[j] )
                    {
                        b[i]=0;
                        b[j]=0;
                        count+=1;
                    }
                }
            }
        }
    }



Correct me if I'm wrong, but by my eyes, the parts inside each half of these if and else are identical except the starting position of the inner loop.

That looks to be the case, so why don't we refactor, starting from the inside and working out.

Rather than nested if statements, we can simply have a single conditional.

if (s[i] == s[j] &amp;&amp; b[i] &amp;&amp; b[j]) {
    b[i] = 0;
    b[j] = 0;
    ++count;
}


And rather than effectively copy &amp; pasting our loop, we can instead calculate our starting position of the inner loop more effectively:

for (i = 0; i &lt; len/2; ++i) {
    for (j = (len/2 + len%2); j &lt; len; ++j) {


Notice how this produces the same result?  Your version of the code is effectively...

if (someCalculation == 1) {
    // ...
        for (j = len/2 + 1; // ...
} else if (someCalculation == 0) {
    // ...
        for (j = len/2 + 0; // ...


(Anything % 2 can only be 1 or 0.)

So we've already eliminated two levels of nesting without even moving anything out to its own function.

for (i = 0; i &lt; len/2; ++i) {
    for (j = (len/2 + len%2); j &lt; len; ++j) {
        if (s[i] == s[j] &amp;&amp; b[i] &amp;&amp; b[j]) {
            b[i] = 0;
            b[j] = 0;
            ++count;
        }
    }
}




Some other comments regarding readability...

All of your variable names are unreadably and meaninglessly short.  


What is s?  
What is b?
What is i?
What is j?
What is z?
I assume len is length.  Why not just use length?


We also have this mess of variable declarations:


int len,b[strlen(s)],z;
int i,j,count =0;
len=strlen(s);



I'm not familiar enough with C to know how expensive strlen is, and while I'm sure it's not horrendous, I also can't imagine it's a completely free call.  And when it does make sense to avoid duplicating function calls, we definitely should.

So for starters:

int length = strlen(inputString);


Next, I'd use any one of the options in this Stack Overflow answer to get yourself a bool type for what b is supposed to be.

bool characterChecked[length];


And then, while it is generally okay to use 1-letter variables for loop iterators, I think we should make it more clear what's going on.  If you're writing C99 code, you can just declare them straight in the loop:

for(int i = 0; // ...


And this would be ideal, especially when we consider that this limits the variables scope to only within the loop.  A variable's scope should be as limited as possible.  A variable's scope should be no larger than necessary.

But if you're on C89, this isn't an option.  As such, we should declare our variables closer to where the for loop actually exists and potentially even leave a comment.

int i;
for(i = 0; //...


Single letter variable names aren't very self-documenting.  (Loop iterators do have some special historical treatment however.  But for your other single-letter variables, we definitely need better.)