char* header(int numero){ //Recibe numero de bytes, y lo devuelve en 4 bytes (Ej. recibe "2" y devuelve "0002")
char* asd=string_new();
char* num_char = string_itoa(numero);
num_char = string_reverse(num_char);
string_append(&asd,num_char);
free(num_char);
string_append(&asd,"0000");
char* longitud=string_substring(asd,0,4);
free(asd);
char* longitudPosta=string_reverse(longitud);
free(longitud);
return longitudPosta;
}
// convert 64 bit unique encoded hex to 10 hex digit 40 bit UID
// this is the same as em4x02 but with final output bits in a different order
BOOL unique_hex_to_hex(unsigned char *hex, unsigned char *unique)
{
BYTE tmp[64];
if(em4x02_hex_to_bin(tmp, unique))
{
string_reverse(tmp, 40);
binarraytohex(hex, tmp, 40);
string_byteswap(hex,10);
string_reverse(hex, 10);
return TRUE;
}
return FALSE;
}
/**
* Converts a given integer into a base 10 ASCII equivalent.
*
* @param n The number to convert.
* @param s Pointer to a buffer in which to store the resulting string.
* @return MICROBIT_OK, or MICROBIT_INVALID_PARAMETER.
*/
int itoa(int n, char *s)
{
int i = 0;
int positive = (n >= 0);
if (s == NULL)
return MICROBIT_INVALID_PARAMETER;
// Record the sign of the number,
// Ensure our working value is positive.
if (positive)
n = -n;
// Calculate each character, starting with the LSB.
do {
s[i++] = abs(n % 10) + '0';
} while (abs(n /= 10) > 0);
// Add a negative sign as needed
if (!positive)
s[i++] = '-';
// Terminate the string.
s[i] = '\0';
// Flip the order.
string_reverse(s);
return MICROBIT_OK;
}
void main() {
char fwd[] = "This is the forward string";
char* reversed;
printf("string: %s \n", fwd);
reversed = string_reverse(fwd);
printf("string: %s \n", reversed);
free(reversed);
}
/* Description : Calculate the sum of two integers which given as two strings
* Input : a & b -- input integer as string
* Output : ppsum -- the result of a plus b
* Note : since ppsum is allocated inside, so you need to free it
*/
int big_number_sum(char* a, char* b, char** ppsum)
{
if (NULL == a || NULL == b)
{
printf("Invalid param: a=%p, b=%p.\n", a, b);
return -1;
}
int a_len = strlen(a);
int b_len = strlen(b);
// alloc 2 more bytes for carry and '\0'
int sum_len = (a_len > b_len) ? a_len : b_len + 2;
char* sum = (char*)malloc(sum_len);
if (NULL == sum)
{
printf("alloc memory failed.\n");
return -1;
}
memset(sum, 0, sum_len);
int carry = 0;
for (int i = 0; i < sum_len-1; i++)
{
int left = (i < a_len) ? a[a_len-1-i] - '0' : 0;
int right = (i < b_len) ? b[b_len-1-i] - '0' : 0;
sum[i] = left + right + carry;
carry = sum[i] / 10;
sum[i] = sum[i] % 10 + '0';
}
if ('0' == sum[sum_len-2])
{
// if carry is '0', replace it '0' with '\0'
sum[sum_len-2] = '\0';
string_reverse(sum, sum_len-3);
}
else
{
string_reverse(sum, sum_len-2);
}
*ppsum = sum;
return 0;
}
// convert human readable UID to 128 bit fdx-b binary array
BOOL uid_to_hdx_bin(BYTE *bin, BYTE *uid)
{
BYTE tmp1[64], crc[8], i;
unsigned int country, crctag;
unsigned long long id;
memset(tmp1, 0x00, 64);
// set animal flag
if(uid[0] == 'A')
tmp1[0]= 0x01;
else
if(uid[0] != '0')
return FALSE;
// set data flag
if(uid[1] == 'D')
tmp1[15]= 0x01;
else
if(uid[1] != '0')
return FALSE;
// set country code - 4 hex digits -> 10 bits
country= bcdtouint(uid + 2, 4);
inttobinarray(tmp1 + 16, country, 10);
// set national ID - 12 hex digits -> 38 bits
id= bcdtoulonglong(uid + 6, 12);
ulonglongtobinarray(tmp1 + 26, id, 38);
// reverse binary
string_reverse(tmp1, 64);
// add header for over-the-air: 10 x 0x00 + 0x01
memset(bin, 0x00, 10);
// every 9th bit is 0x01, but we can just fill the rest with 0x01 and overwrite
memset(bin + 10, 0x01, 118);
//data is 8 blocks of 8 bits, plus obfuscation bit
for(i= 0 ; i < 8 ; ++i)
memcpy(bin + 11 + i * 9, tmp1 + i * 8, 8);
// calculate & append crc for 64 bits of data
for(i= 0 ; i < 8 ; ++i)
crc[i]= (BYTE) binarraytoint(tmp1 + i * 8, 8);
crctag= crc_ccitt(crc, 8);
inttobinarray(bin + 83, crctag >> 8, 8);
inttobinarray(bin + 92, crctag, 8);
// add trailer
for(i= 0 ; i < 3 ; ++i)
memset(bin + 101 + i * 9, 0x00, 8);
return TRUE;
}
// convert null-terminated hex UID (10 digits) to unique encoded 64 bit binary array
// which is the same as EM4X02 but with source hex arranged in a different order
BOOL hex_to_unique_bin(unsigned char *unique, unsigned char *hex)
{
unsigned char tmp1[10], tmp2[40];
if(strlen(hex) > 10)
return FALSE;
// pad to 10 hex digits
memset(tmp1, '0', 10);
memcpy(tmp1 + 10 - strlen(hex), hex, strlen(hex));
// juggle into correct nibble order
string_reverse(tmp1, 10);
string_byteswap(tmp1, 10);
// convert to binary
hextobinarray(tmp2, tmp1);
string_reverse(tmp2, 40);
// encode for em4x02
bin_to_em4x02_bin(unique, tmp2);
return TRUE;
}
void itoa(int n, char s[])
{
int i = 0, sign;
if ((sign = n) < 0)
n = -n;
do {
s[i++] = n % 10 + '0';
} while ((n/=10) > 0);
if (sign < 0)
s[i++] = '-';
s[i] = '\0';
string_reverse(s);
}
int main(int argc, char *argv[])
{
char *output;
if (argc != 2) {
printf("Enter a string to copy\n");
return -1;
}
printf("Input: %s\n", argv[1]);
string_reverse_in(argv[1]);
printf("Reverse: %s\n", argv[1]);
output = string_reverse(argv[1]);
printf("Another reverse: %s\n", output);
string_reverse_done(output);
return 0;
}
// copy raw UID to data blocks for re-transmission by target tag
void tag_raw_uid_to_data(BYTE *data, BYTE *uid, BYTE host_tagtype)
{
BYTE tmp[MAXUID + 1];
unsigned int i;
switch(host_tagtype)
{
// EM4X05 sends everything LSB, so reverse data
case TAG_TYPE_EM4X05:
hextobinarray(tmp, uid);
for(i= 0 ; i < HEXTOBITS(strlen(uid)) ; i += EM4X05_BLOCKSIZE)
string_reverse(tmp + i, EM4X05_BLOCKSIZE);
binarraytohex(data, tmp, HEXTOBITS(strlen(uid)));
break;
// for most tags a straight copy will do
default:
strcpy(data, uid);
break;
}
}
unsigned int bin_to_decimal (const QString &s)
{
unsigned int table[31];
unsigned int c = 1;
unsigned int result = 0;
QString sn = string_reverse (s);
table[0] = 1;
for (int i = 1; i < 32; i++)
{
c *= 2;
table[i] = c;
}
for (int i = 0; i < sn.size(); i++)
if (sn[i] == '1')
result += table[i];
return result;
}
int main()
{
char from[] = "hello";
char to[20];
char a[10] = {'1','2','3','4'};
char s[20] = "hai";
char t[6] = "world";
string_copy(to, from);
printf("to: %s - from: %s \n", to, from);
printf("length = to: %d - from: %d \n",
string_length(to), string_length(from));
printf("a[] = %s -- atoi = %d \n", a, atoi(a));
printf("lower: %c \n", lower('C'));
printf("upper: %c \n", upper('x'));
char name[20] = "sangeeth";
squeez(name, 'e');
printf("squeez(sangeeth) : %s \n", name);
printf("strcat(%s, %s): ", s, t);
string_concat(s, t);
printf("%s \n", s);
printf("strrev(%s): ", from);
string_reverse(from);
printf("%s \n", from);
int num = -1234;
char numc[10];
itoa(num, numc);
printf("itoa(%d): %s \n", num, numc);
return 0;
}
int sentence_reverse(char * sentence, int sentenceLength) {
int headIndex = 0;
int tailIndex = 0;
while (headIndex < sentenceLength && tailIndex < sentenceLength) {
if (sentence[tailIndex] == ' ') {
tailIndex++;
} else {
// we found the start of a word, find the end
while (headIndex + 1 < (sentenceLength) && sentence[headIndex + 1] != ' ' &&
sentence[headIndex + 1] != '\0') {
headIndex++;
} // we found the end of the word
// call string_rev on it
string_reverse(sentence + tailIndex, headIndex - tailIndex + 1);
tailIndex = headIndex + 1;
headIndex++;
}
}
return 0;
}
// convert fdxb 128 bit binary array to human readable UID
// format is ADCCCCIIIIIIIIIIII where A is 'A' or '0' for animal / non-animal,
// D is 'D' or '0' for Data block available / No data available,
// CCCC is ISO-3166 country code or ICAR.ORG manufacturer code
// IIIIIIIIIIII is national ID
BOOL hdx_hex_to_uid(BYTE *uid, BYTE *hex)
{
BYTE tmp[128];
unsigned int country;
unsigned long long id;
// strip headers etc.
if(!fdxb_hex_to_bin(tmp, hex))
return FALSE;
// reverse binary
string_reverse(tmp, 64);
// output animal flag
if(tmp[0])
uid[0]= 'A';
else
uid[0]= '0';
// output data flag
if(tmp[15])
uid[1]= 'D';
else
uid[1]= '0';
// output country/icar code
country= binarraytoint(&tmp[16], 10);
sprintf(&uid[2], "%04u", country);
// output national ID
id= binarraytoulonglong(&tmp[26], 38);
sprintf(&uid[6], "%012llu", id);
return TRUE;
}
//[[Rcpp::export]]
std::string string_reverse_single(std::string str){
return string_reverse(str);
}
//[[Rcpp::export]]
std::vector < std::string > string_reverse_vector(std::vector < std::string > strs){
return string_reverse(strs);
}
int main()
{
char s1[MAX], s2[MAX], choice;
int temp;
do
{
switch(display_menu())
{
case 1: //Compare 2 strings
read_string(s1);
read_string(s2);
temp = string_compare(s1,s2);
if(temp) //Strings are not equal
{
if(temp == 1)
printf("String 1: %s\nis greater than\nString 2: %s!\n",s1,s2);
else //temp == -1
printf("String 2: %s\nis greater than\nString 1: %s!\n",s2,s1);
}
else //temp == 0
{
printf("Both the strings are equal!\n");
}
break;
case 2: //Copy a string
read_string(s1);
string_copy(s2,s1);
printf("Original String: %s\nCopied String: %s\n",s1,s2);
break;
case 3: //Reverse string
read_string(s1);
string_reverse(s2,s1);
printf("Original String: %s\nReversed String: %s\n",s1,s2);
break;
case 4: //Check whether string is a palindrome
read_string(s1);
temp = string_palindrome(s1);
if(temp) //temp == 1, if palindrome
printf("The string \" %s \" is a palindrome.\n",s1);
else
printf("The string \" %s \" is not a palindrome.\n",s1);
break;
case 5: //Check substring
read_string(s1);
printf("Substring:\t");
read_string(s2);
temp = substring(s1,s2);
if(temp) //temp == 1 means substring present
printf("The substring \" %s \" is a part of \" %s \" .\nIt occurs %d times.\n",s2,s1,temp);
else //Not a substring, hence temp == 0
printf("The substring \" %s \" is NOT a part of \" %s \" .\n",s2,s1);
break;
}
printf("Do you want to run the program again? Press 'Y' or 'y' for yes. ");
scanf("%c",&choice);
}
while((choice == 'Y') || (choice == 'y'));
return 0;
}
String StringUtil::Reverse(CStrRef input) {
if (input.empty()) return input;
int len = input.size();
return String(string_reverse(input.data(), len), len, AttachString);
}
int main(void)
{
char *text = NULL;
size_t len = 0;
int count = 0;
char result[100];
int index = 0;
int check = 0;
char* wordsArr[cMaxNumberWords];
char* palindromes[cMaxNumberWords];
printf("text --> ");
getline(&text, &len, stdin);
wordsArr[count] = strtok(text, ", .?!");
while ((NULL != wordsArr[count]) && (count < cMaxNumberWords))
{
count++;
wordsArr[count] = strtok(NULL, ", .?!");
}
int i;
for (i = 0; i < count; i++)
{
int size = strlen(wordsArr[i]);
if ('\n' == wordsArr[i][size - 1])
{
wordsArr[i][size - 1] = '\0';
size--;
}
string_reverse(wordsArr[i], result, size);
if (0 == strcmp(wordsArr[i], result))
{
int j;
for (j = 0; j < index; j++)
{
if (0 == strcmp(wordsArr[i], palindromes[j]))
{
check = 1;
}
}
if (0 == check)
{
palindromes[index] = malloc(cMaxWordSize);
if(palindromes[index] == NULL)
{
exit -1;
}
strcpy(palindromes[index],wordsArr[i]);
index++;
}
}
}
sort(index, palindromes);
print(index, palindromes);
free(text);
return 0;
}