Найти все натуральные числа <= n, десятичная запись которых - строго упорядоченная последовательность

/////////////////////////////////////////////////////////////////////////////////////////
//Найти все натуральные числа, не превосходящие заданного числа N, десятичная запись которых 
//есть строго возрастающая или строго убывающая последовательность цифр.
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <iostream>
#include <string>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string     T_str;
/////////////////////////////////////////////////////////////////////////////////////////
void    print_increasing_and_decreasing_digits_sequences_for( int  n )
{
    bool    num_is_good     =   false;
 
    for( long long  i = 1; i <= n; ++i )
    {
        T_str   num_str     =   std::to_string(i);
 
        if  (
                num_str.size()  ==  1
            )
        {
            num_is_good     =   true;
        }
        else
        {
            int     diff    =   num_str[0]  -   num_str[1];
            num_is_good     =   diff    !=  0;
 
            if( num_is_good )
            {
                num_is_good     =       std::adjacent_find
                                            (
                                                num_str.begin   (),
                                                num_str.end     (),
 
                                                [=] (
                                                        char    L,
                                                        char    R
                                                    )
                                                {
                                                    return  ( L - R ) * diff    <=  0;
                                                }
                                            )
 
                                    ==  num_str.end();
            }//if
        }//else
 
        if( num_is_good )
        {
            std::cout   <<  i
                        <<  '\t';
        }//if
    }//for
}
/////////////////////////////////////////////////////////////////////////////////////////
int main()
{
    std::locale::global(std::locale(""));
    for(;;)
    {
        std::cout   <<  std::endl
                    <<  std::endl
                    <<  std::endl
                    <<  std::endl
                    <<  "n = ";
 
        int     n   =   0;
        std::cin    >>  n;
        print_increasing_and_decreasing_digits_sequences_for( n );
    };//for
}

int main(){
 
  unsigned n = 1000;
 
  for (unsigned start = 1; start < 10; ++start)
  {
    std::cout << start << " ";
 
    for (unsigned step = 1; step < 10 - start; ++step)
    {
      unsigned value_f = start;
      unsigned value_b = start;
 
      for (unsigned digit = start + step, mul = 10; digit < 10; digit += step, mul *= 10)
      {
        value_f = value_f * 10 + digit;
        if (value_f <= n)
          std::cout << value_f << " ";
 
        value_b = digit * mul + value_b;
        if (value_b <= n)
          std::cout << value_b << " ";
      }
    }
  }
                    
  std::cout << std::endl;
}

#include <iostream>
#include <algorithm>
#include <cmath>
 
unsigned next_pattern(unsigned pattern)
{
  unsigned int t = (pattern | (pattern - 1)) + 1;
  return t | ((((t & -t) / (pattern & -pattern)) >> 1) - 1);
}
 
const unsigned ASCENDING[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
const unsigned DESCENDING[] = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
 
void print_number(unsigned pattern, const unsigned table[], unsigned n)
{
  unsigned value = 0;
 
  for (unsigned i = 0; pattern != 0; pattern >>= 1, ++i)
    if ((pattern & 1) != 0)
    {
      value = value * 10 + table[i];
      if (value > n)
        break;
    }
 
  if (value <= n)
    std::cout << value << " ";
}
 
int main() 
{
  unsigned n = 1000;
 
  unsigned full_length = (unsigned) (std::log10(n) + .5) + 1;
 
  unsigned length = std::min(full_length, 9u);
  for (unsigned digits = 1; digits <= length; ++digits)
  {
    unsigned pattern = (1 << digits) - 1;
    do
      print_number(pattern, ASCENDING, n);
    while ((pattern = next_pattern(pattern)) <= 0x1FF);
  }
 
  length = std::min(full_length, 10u);
  for (unsigned digits = 1; digits <= length; ++digits)
  {
    unsigned pattern = (1 << digits) - 1;
    do
      print_number(pattern, DESCENDING, n);
    while ((pattern = next_pattern(pattern)) <= 0x3FF);
  }
 
  return 0;
}

unsigned int n;
int d;
 
void find(unsigned int k, unsigned int r)
{
    if (r<n) {if (r>9) cout << r << '\n';} else return;
    for (int i=k+d; d>0 ? i<=9 : i>=0; i+=d) find(i, r*10+i);
}
int _tmain(int argc, _TCHAR* argv[]) 
{
    cout << "Enter integer n, not so big :) :"; cin >> n;
    cout << "ascending: \n"; d = 1; find(0, 0);
    cout << "descending: \n"; d = -1; find(10, 0);
    system("pause");
    return 0;
}

#include <stdio.h>
 
using namespace std;
 
int isGood(int n)
{
    int p,c,f;
    if (n < 10) return 1;
    p=n%10;
    n=n/10;
    f=0;
    while (n)
    {
       c=n%10;
       if (c==p) return 0;
       if ((c>p) && (f==-1))  return 0;
       if (c>p) f=1;
       if ((c<p) && (f==1))  return 0;
       if (c<p) f=-1;
       p=c;
       n=n/10;
    }
    return 1;
}      
 
int main(int argc, char *argv[])
{
    int i,N;
    printf("N=");
    scanf("%d",&N);
    for (i=1; i<=N; i++)
      if (isGood(i)) printf("%d ",i);
    printf("\n");
    system("PAUSE");
    return EXIT_SUCCESS;
}