Пример #1
0
char *left_rotate_string(char *pStr, unsigned int n)
{
	if(pStr == NULL) return NULL;

	int len = strlen(pStr);
	if(len > 0 || n == 0 || n >= len)
	{
		char *pFirstStart = pStr;
		char *pFirstEnd = pStr + n - 1;
		char *pSecondStart = pStr + n;
		char *pSecondEnd = pStr + len - 1;

		reverse_string(pFirstStart, pFirstEnd);
		reverse_string(pSecondStart, pSecondEnd);
		reverse_string(pFirstStart, pSecondEnd);
	}

	return pStr;
}
Пример #2
0
int
main()
{
    char str[1024] = "";
    printf("STRING : ");
    scanf("%s", str);

    reverse_string(str);
    return 0;
}
main()
{
	char* source_string = "kayak";
	char reverseString[40];
	
	printf("The length of %s is %d\n", source_string, string_length(source_string));
	
	reverse_string(source_string, reverseString);
	
	is_palindrome(source_string, reverseString);
}
Пример #4
0
int main( void ) {
	char s[100];

	printf( "Enter string:\n" );
	fgets( s, 100, stdin );

	reverse_string(s);

	printf("%s\n", s );

	return 0;
}
Пример #5
0
int main (int argc, char const *argv[])
{
	char str[] = "This is the string to reverse";
	int n = strlen(str);
	printf("Original string: %s\n", str);
	reverse_string(str, n);
	printf("Reversed string: %s\n", str);
	
	char str2[] = "first";
	n = strlen(str2);
	printf("Original string: %s\n", str2);
	reverse_string(str2, n);
	printf("Reversed string: %s\n", str2);
	
	char str3[] = "second";
	n = strlen(str3);
	printf("Original string: %s\n", str3);
	reverse_string(str3, n);
	printf("Reversed string: %s\n", str3);
	return 0;
}
Пример #6
0
int isPalindrome(int n){
  char str[10];
  char rev[10];
  sprintf(str, "%d", n);
  strcpy(rev, str);
  reverse_string(rev);
  if(strcmp(str,rev) == 0){
    return 1;
  } else {
    return 0;
  }
}
Пример #7
0
int
main()
{
  int *num1;
  int *num2;
  char str1[] = "";
  char str2[] = "foo bar";

  num1 = malloc(sizeof(int));
  num2 = malloc(sizeof(int));

  assert(num1);
  assert(num2);

  *num1 = 1;
  *num2 = 2;

  printf("Before swap:\n");
  printf("============\n");
  printf("*num1: %d\n", *num1);
  printf("*num2: %d\n", *num2);
  printf("str1: %s\n", str1);
  printf("str2: %s\n", str2);

  // Swap two integers
  swap_int(num1, num2);
  
  // Reverse string
  reverse_string(str1);
  reverse_string(str2);

  printf("\nAfter swap:\n");
  printf("============\n");
  printf("*num1: %d\n", *num1);
  printf("*num2: %d\n", *num2);
  printf("str1: %s\n", str1);
  printf("str2: %s\n", str2);

  return 0;
}
Пример #8
0
common::Menu menu()
{
	common::Menu menu("Arrays and Strings");
	menu.add("uc", "All unique chars", [] {
		// Print headline
		std::cout << common::underline("All unique chars") << std::endl;
		std::cout << "Check whether every character of the string occurs only "
			"once." << std::endl << std::endl;
		// Read input, run algorithm and print result
		std::string string = common::read_string("String:");
		bool result = all_unique_chars(string);
		std::cout << "Result: " << (result ? "true" : "false") << std::endl;
		common::pause();
	});
	menu.add("uci", "All unique chars (in place)", [] {
		// Print headline
		std::cout << common::underline("All unique chars (in place)") <<
			std::endl;
		std::cout << "Check whether every character of the string occurs only "
			"once without using an additional data structure." << std::endl <<
			std::endl;
		// Read input, run algorithm and print result
		std::string string = common::read_string("String:");
		bool result = all_unique_chars(string);
		std::cout << "Result: " << (result ? "true" : "false") << std::endl;
		common::pause();
	});
	menu.add("rv", "Reverse string", [] {
		// Print headline
		std::cout << common::underline("Reverse string") << std::endl;
		std::cout << "Reverse the order of characters in a C style string." <<
			std::endl << std::endl;
		// Read input, run algorithm and print result
		std::string string = common::read_string("String:");
		reverse_string(string);
		std::cout << "Result: " << string << std::endl;
		common::pause();
	});
	menu.add("rd", "Remove duplicate characters", [] {
		// Print headline
		std::cout << common::underline("Remove duplicate characters") <<
			std::endl;
		std::cout << "Remove duplicate characters that follow each other." <<
			std::endl << std::endl;
		// Read input, run algorithm and print result
		std::string string = common::read_string("String:");
		remove_duplicate_chars(string);
		std::cout << "Result: " << string << std::endl;
		common::pause();
	});
	return menu;
}
Пример #9
0
/**
    我们首先对 X 和Y 两段分别进行翻转操作,这样就能得到XTYT。
    接着再对XTYT 进行翻转操作,得到(XTYT)T=(YT)T(XT)T=YX
*/
void left_handed_rc1(char *s, int n){
    char *first_start=s, *first_end=s, *second_start, *second_end=s;
    int len=0;

    if(n==0 || s==NULL)
        return;

    while(*second_end!='\0'){
        len++;
        second_end++;
    }

    if(n>=len)
        n=n%len;

    first_end=first_start+n;
    second_start=first_end;

    reverse_string(first_start, first_end);
    reverse_string(second_start, second_end);
    reverse_string(first_start, second_end);
}
Пример #10
0
int main( int main,char** argc ) {
	
	char input[] = "soumyamandi" ;
	//char input[] = "a" ;

	printf("input is : %s\n",input ) ;

	reverse_string( input ) ;
	printf("reverse input is : %s\n", input ) ;


	return 0 ;
}
Пример #11
0
/*
 * Question 4: CHALLENGE (Tech Interview Question)
 * 
 * Write a function reverse_words that takes a string and reverses the order 
 * of the words in the string. You can assume all letters are lowercase or 
 * digits, there are no punctuation marks, and all words are separated by a 
 * space.
 *
 * Examples:
 *     "be sure to drink your ovaltine" -> "ovaltine your drink to sure be"
 *     "o hai world" -> "world hai o"
 */
void reverse_words(string s) {
  int string_length = string_len(s);

  /* reverse the whole string */
  reverse_string(s, 0, string_length - 1);

  /* we call reverse_string on every word, separated by spaces */
  int word_length = 0;
  for (int i = 0; s[i]; i++) {
    if (s[i] == ' ') {
      /* case in which string begins with space */
      if (i != 0)
	reverse_string(s, i - word_length, i - 1);
      word_length = 0;
    } else {
      word_length++;
    }
  }

  /* case in which our string does not end with a space */
  if (word_length != 0)
    reverse_string(s, string_length - word_length, string_length - 1);
}
Пример #12
0
static void
dump_hexadecimal(int fd, unsigned long value, int width)
{
    int len;
    char buffer[sizeof(unsigned long) * 2 + 1];
    len = 0;
    do {
        buffer[len] = Py_hexdigits[value & 15];
        value >>= 4;
        len++;
    } while (len < width || value);
    reverse_string(buffer, len);
    write(fd, buffer, len);
}
Пример #13
0
int
main()
{
  char *s1 = "hello, world!";
  char s2[] = "foo bar";
  char *s3, *s4;
  char s5[] = "hello, world!";
  char s6[] = "";

  s3 = malloc(strlen(s1) * sizeof(char) + 1);
  s4 = malloc(strlen(s2) * sizeof(char) + 1);

  assert(s3);
  assert(s4);

  printf("Before reversing:\n");
  printf("=================\n");
  printf("s1: %s\n", s1);
  printf("s2: %s\n", s2);
  printf("s5: %s\n", s5);
  printf("s6: %s\n", s6);

  reverse_string(s3, s1);
  reverse_string(s4, s2);

  reverse_char_array(s5);
  reverse_char_array(s6);

  printf("\nAfter reversing:\n");
  printf("=================\n");
  printf("s3: %s\n", s3);
  printf("s4: %s\n", s4);
  printf("s5: %s\n", s5);
  printf("s6: %s\n", s6);

  return 0;
}
Пример #14
0
void far control_window()
{
int i;

	make_win(45,15,64,19);
	clear_win(REVERSE_VIDEO);
	draw_box();

	
	for(i = 0 ; i < 3 ; i++)
		reverse_string(controls[i],win_y_low + 1 + i,win_x_low + 2);


	make_win(10,3,60,17);
}
Пример #15
0
char * reverse_word (const char *str)
{
  int from, to;
  int length = strlen (str);
  
  char *buffer = (char*) calloc (length + 1, sizeof (char));
  strcpy (buffer, str);
  
  // Reverse entire the string
  reverse_string (buffer, 0, length - 1);
  
  // Then, reverse again for each words
  for (from = 0, to = 0; to <= length; to++)
  {
    if (buffer[to] == ' ' || buffer[to] == '\0')
    {
      // Don't reverse if word has only one-character
      if (from != to - 1) reverse_string (buffer, from, to - 1);
      from = to + 1;
    }
  }
  
  return buffer;
}
Пример #16
0
bool strcmp_reverse(char *str1, char* str2){
  

  if(strlen(str1) != strlen(str2)){
    return false;
  }
  char *new = reverse_string(str2);
  int val = strcmp(str1,new);
  free(new);
  if(val == 0){
    return true;
  } else{
    return false;
  }
}
Пример #17
0
static void
dump_decimal(int fd, int value)
{
    char buffer[7];
    int len;
    if (value < 0 || 999999 < value)
        return;
    len = 0;
    do {
        buffer[len] = '0' + (value % 10);
        value /= 10;
        len++;
    } while (value);
    reverse_string(buffer, len);
    write(fd, buffer, len);
}
int main(int argc, char* argv[])
{
  char *p;

  reverse_string(argv[1], strlen(argv[1]));

  printf("\nThe reverse string is:\n");

  for(p = argv[1]; *p != '\0'; p++)
  {
    printf("%c", *p);
  }
  printf("\n");

  return 0;
}
Пример #19
0
/*
 * Question 0:
 *
 * Write a program where the function main prints out all the command line 
 * arguments in order, one per line.
 */
int main(int argc, string argv[]) {
  for (int i = 0; i < argc; i++) {
    printf("arg[%d]: %s\n", i, argv[i]); 
    printf("length: %d\n", string_len(argv[i]));
    printf("num occurrences of %c: %d\n", 'e', num_occur(argv[i],'e'));
    reverse_string(argv[i],0,4);
    printf("reverse, start = %d, end = %d: %s", 0, 4, argv[i]);
    printf("\n");
  }
  
  char s[] = "be sure to drink your ovaltine";
  printf("%s\n", s);
  reverse_words(s);
  printf("%s\n", s);
  return 0;
}
Пример #20
0
void Menu::executeSTRREV() {
	string tempStr;

	cout << "\t문자열 뒤집기 함수를 선택하셨습니다. 문자열을 입력해주세요.\n ▶  ";

	cin.ignore(1, '\n');
	getline(cin, tempStr);

	char* temp = new char[tempStr.length() + 1];
	strcpy(temp, tempStr.c_str());

	reverse_string(temp);
	cout << "◆ 뒤집혀진 문자열 확인 : " << temp << endl;

	delete[] temp;
}
Пример #21
0
int main(int argc, char * argv[])
{
	if (argc > 1)
	{
		int count;
		printf("There are %d valid arguments\n", argc - 1 );
	
		for(count=1;count<argc;count++)
		{
			printf("%d: %s\n", count, argv[count]);
			printf("This argument reversed is: ");
			reverse_string(argv[count]);
		}
	
		return 0;
	}
}
Пример #22
0
// Algorithm: Modular Power: x^e(MOD n).
long int ModPower(long int x, long int e, long int n)
{// To calculate y:=x^e(MOD n).
//long y;
   long int y;
   long int t;
   int i;
   int BitLength_e;
   char b[STACK_SIZE];
   //printf("e(decimal) = %ld\n",e);
   decimal_to_binary(e,b);
   if(print_flag)
      printf("b = %s\n", b);
   BitLength_e = strlen(b);
   y = x;
   reverse_string(b);
   for(i = BitLength_e - 2; i >= 0 ; i--)
   {
      if(print_flag)
         printf("\nb[%d]=%c", i, b[i]);
      if(b[i] == '0')
         t = 1;
      else t = x;
         y = (y * y) MOD n;
      if ( y < 0 ) 
      {
         y = -y;
         y = (y - 1) * (y MOD n) MOD n;
         printf("y is negative\n");
      }
      y = (y*t) MOD n;
      if ( y < 0 ) 
      {
         y = -y;
         y = (y - 1) * (y MOD n) MOD n;
         printf("y is negative\n");
      }
   }
   if ( y < 0 ) 
   {
      y = -y;
      y = (y - 1) * (y MOD n) MOD n;
      printf("y is negative\n");
   }
   return y;
} // end of ModPower().
Пример #23
0
int main(void)
{
    // variables //
    char *string, *cleanedString, *hexString, *reverseString, c;
    int count = 0;
    
    
    // call read function to get input string //
    string = read_string();
    
    // print out string //
    printf("\nInput string is %s", string);
    
    // call clean function to clean string //
    cleanedString = clean_string(string);
    
    // print out cleaned string //
    printf("\n\nCleaned string is %s", cleanedString);
    
    // call create string to single out hex values //
    hexString = create_string(string);
    
    // pring out hex string //
    printf("\n\nHex string is %s", hexString);
    
    // call reverse function to reverse string //
    reverseString = reverse_string(string);
    
    // print out reversed string //
    printf("\n\nReversed string is %s", reverseString);
    
    // get count of replaced characters //
    printf("\n\nEnter a character to replace: ");
    scanf("%c", &c);
    count = replace_character(string, c);
    printf("\nThere is %d occurence(s) of character %c in the string.", count, c);
    
    
    
    
    
    
}
Пример #24
0
int main(void)
{
	// test reverse_string()

	char string[LIMIT];

	printf("Enter a string to reverse: ");
	get(string, LIMIT);
	while (string[0] != '\0')
	{
		reverse_string(string);
		printf("Your string reversed: %s\n", string);

		printf("Enter a string to reverse (empty line to quit): ");
		get(string, LIMIT);
	}

	puts("Bye");
	return 0;
}
Пример #25
0
main()
{
    char string[100];
    printf("Enter a string\n");
    gets(string);
    int length=string_length(string);
    if(length<=0)
        {
        printf("Not enough characters\n");
        }
    else
    if(length>100)
        {   
        printf("Too many characters\n");
        }
    else
        {
        reverse_string(string, length);
        printf("Reverse of entered string is %s \n", string);
        return 0;
        }
    }
Пример #26
0
static void	reverse_string(char *str)
{
	char	c;
	char	*p;
	char	*q;

	p = str;
	if (!p)
		return ;
	q = p + 1;
	if (*q == '\0')
		return ;
	c = *p;
	reverse_string(q);
	while (*q != '\0')
	{
		*p = *q;
		p++;
		q++;
	}
	*p = c;
}
static void string_reverse_implementation(sqlite3_context* ctx, int argc, sqlite3_value** argv) {
    const unsigned char* input = 0;
    int input_type;
    sqlite_uint64 input_length;
    char* result;
    int* decoded;

    if (argc < 1) {
        sqlite3_result_error(ctx, "not enough parameters", -1);
        return;
    }

    if (argc > 1) {
        sqlite3_result_error(ctx, "too many parameters", -1);
        return;
    }

    input_type = sqlite3_value_type(argv[0]);

    if (input_type != SQLITE_NULL) {
        input = sqlite3_value_text(argv[0]);
    }

    if (input == 0) {
        sqlite3_result_null(ctx);
        return;
    }

    input_length = strlen_utf8(input);
    result = sqlite3_malloc(4 * input_length + 1);
    decoded = sqlite3_malloc(sizeof(int) * input_length);

    decode_utf8(input, decoded);
    reverse_string(decoded, result, input_length);

    sqlite3_free(decoded);

    sqlite3_result_text(ctx, result, -1, result_string_destructor);
}
Пример #28
0
/* Algorithm: Modular Power: x^e(mod n) using 
   the repeated square-and-multiply algorithm */
long int ModPower(long int x, long int e, long int n)
{
	// To calculate y:=x^e(mod n).
        //long y;
        long int y;
	long int t;
        int i;
	int BitLength_e;
	char b[STACK_SIZE];

        //printf("e(decimal) = %ld\n",e);
	decimal_to_binary(e,b);
	if(print_flag)
	 printf("b = %s\n", b);
	BitLength_e = strlen(b);
        
	y = x;

	reverse_string(b);

	for(i = BitLength_e - 2; i >= 0 ; i--)
	{
		if(print_flag)
		 printf("\nb[%d]=%c", i, b[i]);
		if(b[i] == '0')
			t = 1;
		else t = x;
                y = y * y;
                y = modulo (y, n);

		y = y*t;
                y = modulo (y, n);
	}

        
	return y;
        
} 
Пример #29
0
static char *
common_suffix (char **argv, int argc)
{
  char **my_argv, *res;
  int i, my_argc;

  my_argv = (char **) malloc (sizeof (char *) * argc);

  for (i = 1, my_argc = 1; i < argc; i++)
    {
      if (!skip_arg (argv, &i))
	my_argv[my_argc++] = reverse_string (argv[i]);
    }

  res = common_string (my_argv, my_argc, '.');

  for (i = 1; i < my_argc; i++)
    free (my_argv[i]);

  free (my_argv);

  return res;
}
Пример #30
0
int main(void)
{
    const unsigned int SIZE = 128;
    char str[SIZE];
    char ch;

    do
    {
        puts("Input a string:");
        __fpurge(stdin);
        fgets(str, SIZE, stdin);
        str[strlen(str) - 1] = '\0';

        puts("After Reverse:");
        reverse_string(str);
        puts(str);
        
        puts("Enter any key except q to go on.");
        __fpurge(stdin);
        ch = getchar();
    } while (ch != 'q');

    return 0;
}