#include <string> // string
#include <iostream>  // cin, cout
#include <cstdlib> //  malloc
 
using namespace std;
 
int palindrome(const char* W)
{
  char *jj;
  const char *i, *j;
  for(i=W  ; *i  ;i++) ;  // compute len=(i-W)
  if (!(j=jj=(char *)calloc(sizeof(char),(i-W)+1)))
    {
      perror("calloc");
      exit(-1);
    }
  for(  ; i > W  ;i--,jj++) *jj=*(i-1); // reverse copy 
  for(   ; *i && (*i == *j);i++,j++ ); //compare
  return !*i ; //  true if end reached.
}
 
int main(int argc, char **args)
{
  string phrase;
  for (; getline(cin,phrase); )
    cout << palindrome(phrase.c_str()) << endl;
  return 0;
}

1234
0
1111
1
1221
1
12344321
1
2
1
331133
1
33113
0
    (intro, palabra vacía, que es palindromo)
1

#include <string> // string
#include <iostream>  // cin, cout
#include <cstdlib> //  malloc
 
#include <cctype> // isspace
#define sp(c) isspace((c)) // shortcut    
 
using namespace std;
 
int palindrome(const char* W)
{
  const char *i, *j;
  char *jj; 
 
  for(i=W  ; *i  ;i++) ; 
  if (!(j=jj=(char *)calloc(sizeof(char),(i-W)+1))) // len=(i-W)
    {
      perror("calloc");
      exit(-1);
    }
  for(  ; i > W  ;i--,jj++) *jj=*(i-1); // reverse copy 
  const char *b; // key!
  for ( ; *i && (sp(*i)||sp(*j) || (*i==*j)); i+=(*i==*j)||sp(*i), j+=(*b==*j)||sp(*j)) b=i;
  return !*i ; //  true if end reached.
}
 
 
int main(int argc, char **args)
{
  string phrase;
  for (; getline(cin,phrase); )
    cout << palindrome(phrase.c_str()) << endl;
  return 0;
}

dabale arroz a la zorra el              abad
1
dabale arroz a la zorra el abad
1
dabale arroz al zorro el  abad
0
               (30 espacios en blanco e intro)
1

• con python no haria falta la variable "b" porque puede simular la asignacion simultanea.
• se puede prescindir una de las variables, "j" o "jj" (la que quede debe se (char *)), a cambio de un bucle similar al primero para rescatar de nuevo la longitud de la cadena, antes de el último for de comparación 

...
#include<conio.h>
#define getchr  _getchr
 
using namespace std;
 
int main(){
....
 

• No uses ni "_getchr()", ni system("PAUSE"). Esta última, aunque te funcione, lo que hace es abrir todo un proceso costoso que NADA tiene que ver con tu algoritmo.... Tendría sentido en programación Batch* de windows.
  Ejecuta el programa desde una consola abierta expresamente para eso, no lanzándolos desde el IDE... busca dónde se guarda el ".exe" y des la consola lo ejecutas. Así todos los símbolos se quedan para que los puedas ver
• Si aún quieres lanzarlos desde el IDE, (Visual C++, Dev-Cpp....) prueba a poner un sencillo "cin >> ch" , con "ch" de tipo "char"... que espera latente a leer un caracter (más el enter). As'i al menos, lo podran ejecutar otras plataformas no windows. Pero ojo, estas marcando un "protocolo"  de entrada totalmente inútil... Mejor ejecuta desde consola!
  

c=(N%3==0)*N

#include <stdio.h>
#include <assert.h>
 
 
/*
  P : M >= 3
  Q : c = sum i : 3 <= i <= M and (i%3==0) : i
     
  I : Q[M/n] and 3 <= n <= M
  B : n > 3 
     
  Quota (n) = n - 3 >= 0 
  Step : n = n - 1
  Restore : c = c + (n-1)*\chi((n-1)%3==0)
      
*/
 
#define DEBUG
 
unsigned int mult3(const unsigned int N)
{
  assert(N>=3);
  unsigned int n,c;
  for(n=N,c=(N%3==0)*N;n>3;n--)
    {
#ifdef DEBUG
      if (n%3==0) printf("%d ",n);
#endif
      if (((n-1)%3==0)) c+=(n-1);
    }
#ifdef DEBUG
      printf("%d ",3);
#endif
  return c;
}
 
 
 
int main()
{
  unsigned int M;
  int e;
  for ( ; (e=scanf("%u",&M))==1;)
    printf(" --> %u\n",mult3(M));
  if (e!=EOF)
    {
      printf("Not a integer");
      return -1;
    }
  return 0;
}

3
3  --> 3
4
3  --> 3
5
3  --> 3
6
6 3  --> 9
7
6 3  --> 9
8
6 3  --> 9
9
9 6 3  --> 18
10
9 6 3  --> 18

for (init; B ; step) body

• init : donde se dan valores a las variables al principio
• B : guarda que determina cuándo termina su ejecución. (Después del init y del step en segundas vueltas)
• step : incremento de variable, para que el bucle progrese hacia su terminación (después del body)
• body: aproxima el cómputo parcial a la solución definitivadespues de evaluar la guarda y antes de step

#include <stdio.h>
#include <assert.h>
 
 
/*
  P : M >= 3
  Q : c = sum i : 3 <= i <= M and (i%3==0) : i
 
  I : Q[M/n] and 3 <= n <= M
  B : n < M
 
  Quota (n) = M - n >= 0 
  Step : n = n + 1
  Restore : c = c + (n+1)*\chi((n+1)%3==0)
  
*/
 
#define DEBUG
 
unsigned int mult3(const unsigned int N)
{
  assert(N>=3);
  unsigned int n,c;
#ifdef DEBUG
      printf("%d ",3);
#endif
  for(n=c=3;n<N;n++)
    {
      if (((n+1)%3==0)) c+=(n+1);
#ifdef DEBUG
      if ((n+1)%3==0) printf("%d ",n+1);
#endif
    }
  return c;
}
 
 
 
int main()
{
  unsigned int M;
  int e;
  for ( ; (e=scanf("%u",&M))==1;)
    printf(" --> %u\n",mult3(M));
  if (e!=EOF)
    {
      printf("Not a integer");
      return -1;
    }
  return 0;
}
 
 
 

3
3  --> 3
4
3  --> 3
5
3  --> 3
6
3 6  --> 9
7
3 6  --> 9
8
3 6  --> 9
9
3 6 9  --> 18
10
3 6 9  --> 18

Mis preguntas son:
¿Por qué el carácter '\n' no lo imprime cuando lo lee?
El número 20 se lo salta al terminar de leer la primera línea, ¿Por qué?
fscanf lee '\n' ?  '\n' es un char, cierto?

Espero sus respuestas

long ftell(FILE *stream)

pos=lseek(fd,0,SEEK_CUR)

#include <stdlib.h> // exit()...
#include <assert.h> // assert
#include <unistd.h> // open,read,close (Low-level IO), 
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h> // open,O_RDONLY...
#include <stdio.h> //p printf
 
 
#include <ctype.h> // isprint
 
int main()
{
  char c;
  int n;
  int fd;
  const char *pattern="%d\t%c\t%d\n";
  char row[80];
  if (!(fd=open("texto.txt",O_RDONLY)))
    {
      perror("open");
      exit(EXIT_FAILURE);
    }
  printf("ASCII\tPrint\tPos\n");
  while((n=read(fd,&c,sizeof(char)))> 0)
    {
      assert(isascii(c));
      if ((n=sprintf(row,pattern,c,isprint(c)?c:' ',lseek(fd,0,SEEK_CUR)))<0)
	{
	  perror("sprintf");
	  exit(EXIT_FAILURE);
	}
      printf(row);
    }
  if (n==-1)
    {
      perror("read");
      exit(EXIT_FAILURE);
    }
  close(fd);
  exit(EXIT_SUCCESS);
}
 

supholasadkjholasad
adholadsa

 
ASCII	Print	Pos
115	s	1
117	u	2
112	p	3
104	h	4
111	o	5
108	l	6
97	a	7
115	s	8
97	a	9
100	d	10
107	k	11
106	j	12
104	h	13
111	o	14
108	l	15
97	a	16
115	s	17
97	a	18
100	d	19
10	 	20
97	a	21
100	d	22
104	h	23
111	o	24
108	l	25
97	a	26
100	d	27
115	s	28
97	a	29
10	 	30

  fun A(in int n) dev int
  {
     case n==0 : dev 1
     case n> 0 : dev 2*A(n-1) + 3
  }

#include <stdio.h>
 
unsigned int A(const unsigned int n)
{
  if (n==0) return 1;
  if (n>0) return (2*A(n-1) + 3);
}
 
#define MAXIMUM 20
 
int main(int argc, char *args[])
{
  unsigned int n;
  for( n=0; n<MAXIMUM ; n++)
    printf("A\(%2u\) : %8u\n",n,A(n));
}

A( 0) :        1
A( 1) :        5
A( 2) :       13
A( 3) :       29
A( 4) :       61
A( 5) :      125
A( 6) :      253
A( 7) :      509
A( 8) :     1021
A( 9) :     2045
A(10) :     4093
A(11) :     8189
A(12) :    16381
A(13) :    32765
A(14) :    65533
A(15) :   131069
A(16) :   262141
A(17) :   524285
A(18) :  1048573
A(19) :  2097149

unsigned int A(const unsigned int n)
{
  return n?(2*A(n-1)+3):1 ;
}

 sets
 int
 operations
 + : (int, int) -> int
 constants
 0 : int
 axioms
 a + b = b + a  [comm]
 (a + b) + c = a + (b + c)  [assoc]
 a + 0 = a  [e.neutro]
 ....

 sets
 stack, int, bool
 constants
 empty : stack
 operations
 push : (stack,int) -> stack
 pop  : stack - -> stack
 head : stack - -> int
 isempty : stack -> bool
 var 
 i : int
 p : stack
 axioms
 pop(push(p,i))=p
 head(push(p,i))=i
 isempty(empty)=true
 ...

#ifndef _STACK_TOY_
#define _STACK_TOY_
#define MAXIMUM 200
 
#include <assert.h>
 
typedef struct
{
  // I : 0 <= many <= MAXIMUM
  unsigned int many;
  unsigned int M[MAXIMUM];
} STACK, *PSTACK;
 
void empty( PSTACK pstack)
{
  pstack->many = 0 ;
}
 
void push(PSTACK pstack, const int i)
{
  assert((pstack->many)<MAXIMUM);
  pstack->M[pstack->many++]=i;
  return;
}
 
void pop(PSTACK pstack)
{
  assert((pstack->many)>0);
  pstack->many--;
  return;
}
 
 
int head(const PSTACK pstack)
{
  assert((pstack->many)>0);
  return pstack->M[pstack->many -1];
}
 
int isempty(const PSTACK pstack)
{
  return  (pstack->many == 0 );
}
 
 
#endif

buleano = funcion Espalindromo(array bytes B() )
    entero j,k, n

    j= b.length -1 // tamaño del array
    Hacer mientras (k<j)
        hacer mientras b(k) sea espacio   // buscar siguiente 'carácter válido'
            k +=1
        repetir
     
        hacer mientras b(j) sea espacio   // buscar anterior 'carácter válido'
            j -=1
        repetir

        Si b(k) es distinto de b(j) devolver false
 
        k +=1
        j -=1
    repetir

    devolver true
fin funcion

• la primera, importante, de corrección,. supongamos la entrada de una frase de 420 espacios ... Entonces el primer bucle anidado progresa indefinidamente más allá de los límites permitidos...Lo que invalida el cómputo
• La segunda, no tan importante, de complejidad temporal (en constante). Supongamos una frase de 420 caracteres, el primero y el ultimo distintos de espacio e iguales entre si, y el resto, entre medias espacios. Por ejemplo A....418 espacios...A.  Entonces, el algoritmo recorre cada casilla es recorrida 2 veces (420), cuando se puede hacer en una vez.  Repito, es una diferencia de constante, O(2n), vs O(n) en el caso peor. No es tan grave.
  

  Pseudocode:
  -----------

 P:
  n,m=0,N
  while (n<m) and V[n]==' ')
    n=n+1
  while (n<m) and V[m-1]==' ')
    m = m - 1
 I:
  while (m -n > 1 ) and (V[n]==V[m-1] )
     n=n+1
     while (n<m) and V[n]==' ')
       n=n+1
     m = m - 1
     while (n<m) and V[m-1]==' ')
       m = m - 1
  done
  Q:
  return (m-n)<=1

 init,
 while b do 
   restore
   step
 done

#include <cstring> // strlen
#include <string>
#include <iostream>
 
using namespace std;
 
int palindrome(const char* W)
{
  int i,j;
  for(i=0,j=strlen(W); (i<j) && (W[i]==' ');i++);
  for( ; (i<j) && (W[j-1]==' ');j--);
  for( ; (j - i) > 1 && (W[i]==W[j-1]); )
    {
      for(i++; (i<j) && (W[i]==' ');i++);
      for(j--; (i< j) && (W[j-1]==' ');j--);
    }
  return ((j-i) <= 1 );
}
 
 
 
int main(int argc, char **args)
{
  string phrase;
  for (; getline(cin,phrase); )
    cout << palindrome(phrase.c_str()) << endl;
  return 0;
}

dabale arroz a la zorra el              abad
1
dabale arroz a                   la zorra el abad
1
dabale arroz al zorro el abad
0
                                                                                    
1

  Palindrome on a given phrase, length(N) >= 0

  As a problem decission, we model it as an optimization problem

  P : W[N], N>= 0
  Q : 1 >= max i,j : 0 <=i <=j <= N and
                 (j>i) ->
                 ( V[i]!=' ' and V[j-1]!=' ' and
                   #k:0<=k<=i:V[k]!=' ' == #k:j<=k<=N:V[k-1]!=' ' and
                   V[i]!=V[j-1] )  
                   : j-i

i.e., the greatest segment not fullfilling palindrome conditions,
      1 or 0 if all of them fullfill.
      (see picture below)

                             (true)
                             15-16
                          ..........
              7----------------------------------24
          5----------------------------------------25
        4---------------------------------------------27
      3-------------------------------------------------28
    2-----------------------------------------------------29
  1---------------------------------------------------------30
0-------------------------------------------------------------31

0                                                               N=32
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|d|a|b|a|l|e| |a|r|r|o|z| |a| |l|a| |z|o|r|r|a| |e|l| |a|b|a|d| |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+


  (Long step strategy)

  B : (m-n) > 1 and V[n]==V[m-1]
  I :  0 <= n <= m <= N and
       (m-n> 1) -> (V[n]!=' ' and V[m-1]!=' ') and
       \forall i,j : 0 <= i < n and m<j<=N and
                     V[i]!=' ' and V[j-1]!=' ' and
		     #k:0<=k<=i:V[k]!=' ' == #k:j<=k<=N:V[k-1]!=' ' 
                   :
                   V[i]==V[j-1] )
  
  C(m,n) = m -n >= 0
  Step: (At least decreases on 2, since B: m-n > 1 )
      n, m = n + (a-n), m-(m-b)
      where
         a = max i : n < i < m and AllessBl(V,n+1,i):i
         b = min i : a <= i < m and AllessBl(V,i,m-1):i


      
  O(n), despite the nested loops

 Pseudocode
  -----------

 P:
  n,m=0,N
  while (n<m-1) and V[n]==' ')
    n=n+1
  while (n<m) and V[m-1]==' ')
    m = m - 1
 I:
  while (m -n > 1 ) and (V[n]==V[m-1] )
     n=n+1
     while (n<m-1) and V[n]==' ')
       n=n+1
     m = m - 1
     while (n<m) and V[m-1]==' ')
       m = m - 1
  done
  Q:
  return (m-n)<=1