void str_reverse(char *str,int length,int pos){
if((length%2)!=0){//odd length
*(str+pos+((length-1)/2)) ^= *(str+((length-1)/2)-pos);//XOR swap
*(str+((length-1)/2)-pos) ^= *(str+pos+((length-1)/2));
*(str+pos+((length-1)/2)) ^= *(str+((length-1)/2)-pos);
if(pos==((length-1)/2))
return;
str_reverse(str,length,pos+1);
}else if(((length%2)==0)&&(pos==1)){
*(str+(length/2)) ^= *(str+(length/2)-pos);
*(str+(length/2)-pos) ^= *(str+(length/2));
*(str+(length/2)) ^= *(str+(length/2)-pos);
str_reverse(str,length,pos+1);
}else{
*(str+(length/2)-pos) ^= *(str+(length/2)+pos-1);
*(str+(length/2)+pos-1) ^= *(str+(length/2)-pos);
*(str+(length/2)-pos) ^= *(str+(length/2)+pos-1);
if(pos==(length/2))
return;
str_reverse(str,length,pos+1);
}
return;
}
int main() {
char* line = console_read_line(100, 1000);
str_reverse(line);
printf("%s\n", line);
free(line);
return 0;
}
char* get_encoding(symbol *h, int c){
/*
get_encoding() - given the root of a symbol table-tree and a character,
returns the encoding (i.e. the code) of that character as a char*
*/
char *buf;
buf = malloc(sizeof(char)*ENCODING_BUFFER_SIZE);
int bufctr=0;
symbol *s, *s_i;
s=seek_symbol(h,c);
if (!(s == NULL)){
s_i=s;
while(s_i->parent != NULL){
if (s_i->parent->left==s_i)
buf[bufctr++]='0';
else if (s_i->parent->right==s_i)
buf[bufctr++]='1';
else
fprintf(stderr,"ERROR: unexpected error, weirdly orphaned node detected");
s_i=s_i->parent;
}
}
buf[bufctr]='\0';
str_reverse(buf,bufctr);
return buf;
}
//개인키 복호화
void _tw2_get_decode_key (char* skey, char* out_key, char* out_key_time, int cnt, int flag)
{
char akey[ASIZE], *pkey;
register int i, j;
const int length = 60; //키길이
const int codec[] = { 0, 1, 0, 2, 5, 2, 0, 3, 3, 0, 7 }; //11개
int k, asize = sizeof(codec) / sizeof(codec[0]);
char *str[] = {"key ", "phone", "email", "time "};
while (cnt--) {
pkey = akey;
i = 0;
while (*skey != 19 && i++ < ASIZE-2) *pkey++ = *skey++;
*pkey = '\0';
//복호화
str_reverse (akey);
for (i=0; i < (int)str_len (akey); i++) {
k = i + asize;
akey[i] += (k * (codec[i%asize])) % 33;
akey[i] -= 20;
}
//akey[i] = '\0';
if (flag) printf ("%s: %s\n", str[cnt], akey);
if (cnt==0) str_copy (out_key, akey);
if (cnt==3) str_copy (out_key_time, akey);
//키길이(length)까지 채워진 랜덤문자
for (j = i; j < length; j++) *skey++;
}
}
//개인키 암호화
int _tw2_getchar_encode_key (char* msg, char* akey, int flag)
{
register int i=0, j;
const int length = 60; //키길이
const int codec[] = { 0, 1, 0, 2, 5, 2, 0, 3, 3, 0, 7 }; //11개
int c, k, asize = sizeof(codec) / sizeof(codec[0]);
if (flag) {
printf ("%s", msg);
while ((c = getchar()) != (int)'\n' && i < length-2)
akey[i++] = c;
akey[i] = '\0';
} else i = str_len (akey);
//암호화
for (j=0; j < i; j++) {
k = j + asize;
akey[j] -= (k * (codec[j%asize])) % 33;
akey[j] += 20;
}
str_reverse (akey);
akey[i] = 19; //키의 끝
//랜덤문자로 키길이(length)까지 채움
time_rand_seed_init ();
for (j = i+1; j < length; j++)
akey[j] = time_random_between (33, 126); //출력가능한 아스키문자
akey[j] = '\0';
return i; //입력받은 키의 길이
}
int main(int argc, const char *argv[])
{
char buf[1000];
scanf("%s", buf);
str_reverse(buf);
printf("%s", buf);
return 0;
}
int main()
{
int i,n;
scanf("%i", &n);
for (i=0; i<n; i++) {
setup();
scanf("%s%s", str_a, str_b);
str_reverse(str_a);
str_reverse(str_b);
sprintf(sum, "%i", atoi(str_a) + atoi(str_b));
str_reverse(sum);
printf("%i\n", atoi(sum));
teardown();
}
return 0;
}
int main(int argc, char* argv[]) {
if (1 == argc) {
printf("Please provide a string to reverse!\n");
return 1;
}
printf("Reversed: \"%s\"\n", str_reverse(argv[1]));
return 0;
}
int main()
{
char input[100];
printf("Enter some text\n");
scanf("%s", input);
printf("%s\n", str_reverse(input));
return 0;
}
int main(){
char st[5];
st[0]='h';
st[1]='e';
st[2]='l';
st[3]='l';
st[4]='o';
char *ptr;
ptr=st;
str_reverse(ptr,5,1);
int i;
for(i=0;i<5;i++)
printf("%c",*(ptr+i));
return 0;
}
//---------------------------------------------------------------------------
boolean safe_palindrome( const int dw_palindrome )
{
int max_bits;
bit_max( max_bits );
//two buffers
char forward_text[max_bits + 1];
char reverse_text[max_bits + 1];
//make into str representation
int_to_str( forward_text , dw_palindrome );
memcpy( (void*) reverse_text , forward_text , max_bits + 1 );
//reverse string
str_reverse( forward_text );
//compare
return compare_str( forward_text , reverse_text );
}
int main() {
//create tcp socket and establish a connection
TCPServerSocket tcpServerSocket;
int ret = tcpServerSocket.initialize();
ASSERT(ret == 0);
int serverUdpPort = tcpServerSocket.negotiate();
ASSERT(serverUdpPort > 1024);
tcpServerSocket.close();
//open a udp socket and listen for str
UDPSocket udpSocket;
ret = udpSocket.open(serverUdpPort);
ASSERT(ret == 0);
LOG("Server opened UDP Port %i\n", serverUdpPort);
char buf[1024];
unsigned long remoteIp;
int remotePort;
//read, reverse string and send it back to client
int readBytes = udpSocket.read(buf, 1024, remoteIp, remotePort);
buf[readBytes] = '\0';
ASSERT(readBytes > 0);
LOG("Server Received: %s\n", buf);
//Reverse the string and write to the buffer again
str_reverse(buf);
int writeBytes = udpSocket.write(remoteIp, remotePort, (const char *) buf, readBytes);
ASSERT(writeBytes > 0);
LOG("Server sent: %s\n", buf);
udpSocket.close();
return 0;
}
int main(int argc, char *argv[])
{
char s1[100];
char *s2;
int len;
printf("Input the string:\n");
gets(s1);
len = strlen(s1);
s2 = malloc(len + 1);
if (s2 == NULL) {
printf(" Malloc error\n");
return -1;
}
str_reverse(s1, s2);
printf("Length: %d\n", len);
printf("Words: %d\n", str_word_num(s1));
printf("Reverse: %s\n", s2);
return 0;
}
/* 数字转成字符串并直接输出到串口
* @n: 被转换的目标数字
* @base: 进制
* @is_signed: 是否是有符号的类型
* return: 转换成字符串后的字节数
*/
static size_t itoa(int n, size_t base, size_t is_signed)
{
size_t count = 0;
char *p = str;
int SIGNED_FLG = UNSIGNED;
//确定最终结果是否是负数
if ((base == 10) && (is_signed) && (n < 0)) {
SIGNED_FLG = SIGNED;
n *= -1;
}
//排除n == 0的情况，因为0会导致下面的for循环直接退出
if (!n) {
*p++ = '0';
count++;
}
for (; n; p++, n /= base, count++) {
*p = tab[n % base];
}
if (SIGNED_FLG == SIGNED) {
*p++ = '-';
count++;
}
*p = '\0';
str_reverse(str);
print_str(str);
return count;
}
int main() {
char str[50];
gets(str);
str_reverse(str, 0);
}
void str_reverse(char str[], int mark) {
if (str[mark] != '\0') {
str_reverse(str, mark+1);
printf("%c",str[mark]);
}
}
static int
parse_domain_list(FPST ** const domain_list_p,
FPST ** const domain_rev_list_p,
FPST ** const domain_substr_list_p,
const char * const file)
{
char buf[MAX_QNAME_LENGTH + 1U];
char *line;
FILE *fp;
char *ptr;
FPST *domain_list;
FPST *domain_list_tmp;
FPST *domain_rev_list;
FPST *domain_rev_list_tmp;
FPST *domain_substr_list;
FPST *domain_substr_list_tmp;
size_t line_len;
BlockType block_type = BLOCKTYPE_UNDEFINED;
int ret = -1;
assert(domain_list_p != NULL);
assert(domain_rev_list_p != NULL);
assert(domain_substr_list_p != NULL);
*domain_list_p = NULL;
*domain_rev_list_p = NULL;
*domain_substr_list_p = NULL;
domain_list = fpst_new();
domain_rev_list = fpst_new();
domain_substr_list = fpst_new();
if ((fp = fopen(file, "r")) == NULL) {
return -1;
}
while (fgets(buf, (int) sizeof buf, fp) != NULL) {
if ((line = trim_comments(untab(buf))) == NULL || *line == 0) {
continue;
}
line_len = strlen(line);
if (line[0] == '*' && line[line_len - 1] == '*') {
line[line_len - 1] = 0;
line++;
block_type = BLOCKTYPE_SUBSTRING;
} else if (line[line_len - 1] == '*') {
line[line_len - 1] = 0;
block_type = BLOCKTYPE_PREFIX;
} else {
if (line[0] == '*') {
line++;
}
if (line[0] == '.') {
line++;
}
str_reverse(line);
block_type = BLOCKTYPE_SUFFIX;
}
if (*line == 0) {
continue;
}
str_tolower(line);
if ((line = strdup(line)) == NULL) {
break;
}
if (block_type == BLOCKTYPE_SUFFIX) {
if ((domain_rev_list_tmp = fpst_insert_str(domain_rev_list, line,
(uint32_t) block_type)) == NULL) {
free(line);
break;
}
domain_rev_list = domain_rev_list_tmp;
} else if (block_type == BLOCKTYPE_PREFIX) {
if ((domain_list_tmp = fpst_insert_str(domain_list, line,
(uint32_t) block_type)) == NULL) {
free(line);
break;
}
domain_list = domain_list_tmp;
} else if (block_type == BLOCKTYPE_SUBSTRING) {
if ((domain_substr_list_tmp = fpst_insert_str(domain_substr_list, line,
(uint32_t) block_type)) == NULL) {
free(line);
break;
}
domain_substr_list = domain_substr_list_tmp;
} else {
free(line);
}
}
if (!feof(fp)) {
fpst_free(domain_list, free_list);
fpst_free(domain_rev_list, free_list);
fpst_free(domain_substr_list, free_list);
} else {
*domain_list_p = domain_list;
*domain_rev_list_p = domain_rev_list;
*domain_substr_list_p = domain_substr_list;
ret = 0;
}
fclose(fp);
return ret;
}
int main(int argc, char const *argv[]) {
/* str_new */
str_t string = str_new();
/* str_set */
str_set(string, " %d%d%d", 1, 2, 3);
/* str_append */
str_append(string, "appending end");
/* str_println */
str_println(string);
/* str_reverse */
str_reverse(string);
str_println(string);
/* str_length */
printf("size before trimming:\t%zu\n", str_length(string));
/* str_trim */
str_trim(string);
printf("size after trimming:\t%zu\n", str_length(string));
/* str_substr */
str_t substr = str_substr(string, 0, 3);
printf("substr before swap:\t");
str_println(substr);
printf("string before swap:\t");
str_println(string);
str_swap(substr, string);
printf("substr after swap:\t");
str_println(substr);
printf("string after swap:\t");
str_println(string);
printf("is string empty?\t%s\n",
str_isempty(string) ? "Yes" : "No");
printf("is substr equal to string?\t%s\n",
str_compare(substr, string) ? "No" : "Yes");
/* str_readFromFile */
str_readFromFile(string, "neostring.c");
printf("string size: %zu\t", str_length(string));
printf("string capacity: %zu\n", string->capacity);
str_set(string, "ok");
printf("Before trimToSize():\n");
printf("string size: %zu\t", str_length(string));
printf("string capacity: %zu\n", string->capacity);
/* str_trimToSize */
str_trimToSize(string);
printf("After trimToSize():\n");
printf("string size: %zu\t", str_length(string));
printf("string capacity: %zu\n", string->capacity);
str_set(string, "hello, world");
str_println(string);
printf("%zu\n", string->size);
printf("string has prefix ello?\t%s\n", str_hasPrefix(string, "ello") ? "Yes" : "No");
printf("%zu\n", string->size);
printf("string has suffix orld?\t%s\n", str_hasSuffix(string, "orld") ? "Yes" : "No");
/* str_clone */
str_t clone = str_clone(string);
/* str_toupper */
str_toupper(clone);
/* str_writeToFile */
str_writeToFile(clone, "./test.txt");
/* str_destroy */
str_destroy(string);
str_destroy(clone);
str_destroy(substr);
return 0;
}
