void ReversibleAudioSource::getNextAudioBlock (const AudioSourceChannelInfo& info)
{
if (isForwards)
{
input->getNextAudioBlock (info);
}
else
{
int64 nextReadPosition = input->getNextReadPosition() - (2 * info.numSamples);
if (nextReadPosition < 0 && input->isLooping())
nextReadPosition += input->getTotalLength();
input->setNextReadPosition (nextReadPosition);
input->getNextAudioBlock (info);
if (info.buffer->getNumChannels() == 1)
{
reverseArray (info.buffer->getSampleData (0), info.numSamples);
}
else if (info.buffer->getNumChannels() == 2)
{
reverseTwoArrays (info.buffer->getSampleData (0), info.buffer->getSampleData (1), info.numSamples);
}
else
{
for (int c = 0; c < info.buffer->getNumChannels(); c++)
reverseArray (info.buffer->getSampleData(c), info.numSamples);
}
}
}
std::string reverseSentense(std::string input) {
std::string::size_type start = 0;
for (std::string::size_type i = 0; i < input.size(); ++i) {
if (input.at(i) != ' ') continue;
if (start == i) {
// wrong format,do nothing
} else {
reverseArray(input, start, i);
}
start = i + 1;
}
if (start <= input.size()) reverseArray(input, start, input.size());
reverseArray(input, 0, input.size());
return input;
}
/*
* Problem_07._Reverse_Array
*
* Write a program that reverses an array of numbers. The numbers should be
* entered one at a line. On the first input line you will be given the count of
* the numbers.
*/
int main()
{
int n;
int i;
printf("Length of array = ");
scanf("%d", &n);
int *arr = malloc(n * sizeof(int));
for(i = 0; i < n; i++)
{
scanf("%d", &arr[i]);
}
reverseArray(arr, n);
printf("\n Output\n");
for(i = 0; i < n; i++)
{
printf("%d ", arr[i]);
}
printf("\n");
return (EXIT_SUCCESS);
}
void main()
{
static voidleftRotate(int arr[],int d)
{
int n=arr.length;
if(n>0)
{
if(d>n)
{
d=d%n;
}
reverseArray(arr,0,d-1);
reverseArray(arr,d,n-1);
revreseArray(arr,0,n-1);
}
}
void main()
{
int arr[5]={1,2,3,4,5};
cout<<"ok?"<<endl;
outArray(arr,5);
reverseArray(arr,5);
outArray(arr,5);
}
int main(){
int arr[] = {1, 2, 3, 4, 5};
printArray(arr, 5);
reverseArray(arr, 0, 4);
printf("Reversed array is \n");
printArray(arr, 5);
return 0;
}
void
Zoom::slotZoom (const char *val)
{
mag = reverseArray (atoi (val));
emit applyChange();
// okButton->setEnabled (false);
}
int main(void){
int idx = 0;
while ( number[++idx] != '\0' );
unsigned char result[(idx+1)/2];
char base64res[idx];
hexToBytes(number,idx,result);
bytesToBase64(result,(idx+1)/2,base64res);
reverseArray( base64res );
printf("%s %d \n", base64res, strcmp(base64res,answer));
return 0;
}
void nextPermutation(vector<int>& nums) {
// reverse scan array to locate the first out-of-order pair
int len = nums.size();
if (len == 0 || len == 1) return;
int i = len - 1;
while (i > 0) {
if (nums[i-1] < nums[i]) {
int j = len-1;
while (nums[j] <= nums[i-1]) {j--;}
//now nums[j] > nums[i-1], swap nums[i-1] with nums[j]
int tmp = nums[i-1];
nums[i-1] = nums[j];
nums[j] = tmp;
//reverse nums[i, ..., len-1]
reverseArray(nums, i, len-1);
return;
} else
i--;
}
//i == 0 now
reverseArray(nums, 0, len-1);
}
void ReversibleAudioSource::getNextAudioBlock (const AudioSourceChannelInfo& info)
{
if (isForwards)
{
input->getNextAudioBlock (info);
previousReadPosition = input->getNextReadPosition();
}
else
{
int64 nextReadPosition = previousReadPosition - info.numSamples;
if (nextReadPosition < 0 && input->isLooping())
nextReadPosition += input->getTotalLength();
input->setNextReadPosition (nextReadPosition);
input->getNextAudioBlock (info);
if (info.buffer->getNumChannels() == 1)
{
reverseArray (info.buffer->getWritePointer (0) + info.startSample, info.numSamples);
}
else if (info.buffer->getNumChannels() == 2)
{
reverseTwoArrays (info.buffer->getWritePointer (0) + info.startSample,
info.buffer->getWritePointer (1) + info.startSample,
info.numSamples);
}
else
{
for (int c = 0; c < info.buffer->getNumChannels(); c++)
reverseArray (info.buffer->getWritePointer (c) + info.startSample, info.numSamples);
}
previousReadPosition = nextReadPosition;
}
}
void print_integer(uint32_t n)
{
char num[20];
memset(num, 0, 20);
int i = 0;
do
{
num[i] = (n % 10) + '0';
n /= 10;
i++;
} while(n != 0);
reverseArray(num);
print_string(num);
}
void print_integer_hex(uint32_t n)
{
char hexChars[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
char num[20];
memset(num, 0, 20);
int i = 0;
do
{
num[i] = hexChars[n % 16];
n /= 16;
i++;
} while(n != 0);
reverseArray(num);
print_string_static("0x");
print_string(num);
}
void int_to_string(int value, char *result) {
int k = 0, rest;
bool negative = false;
if (value < 0) {
negative = true;
value *= -1;
}
while (value > 0) {
rest = value % 10;
value /= 10;
result[k++] = rest + '0';
}
if (negative) {
result[k++] = '-';
}
reverseArray(result, k);
result[k] = '\0';
}
char* itoa(int value, char * str, int base)
{
int sign;
if((sign = value) < 0) value = -value;
int i = 0;
do
{
str[i] = hexChars[value % base];
value /= base;
i++;
} while(value != 0);
if(sign < 0)
str[i] = '-';
str[i+1] = 0;
reverseArray(str);
str[i+1] = 0;
return str;
}
int main ()
{
int userSize;
printf( "Input size of an array: " );
scanf( "%d", & userSize );
if ( userSize <= 0 )
{
printf( "Expected a positive size\n" );
return -1;
}
int * pData = new int[ userSize ];
printf( "Input %d integer elements: \n", userSize );
scanArray( pData, userSize );
reverseArray( pData, userSize );
printArray( pData, userSize );
delete[] pData;
return 0;
}
void reverseArray(int *arr, int start, int end){
if(start >= end)
return;
swap(&arr[start], &arr[end]);
reverseArray(arr, start+1, end-1);
}
jobject createDataElement(JNIEnv *env, sdp_data_t *data) {
Edebug("createDataElement 0x%x", data->dtd);
jclass dataElementClass = (*env)->FindClass(env, "javax/bluetooth/DataElement");
jmethodID constructorID;
jobject dataElement = NULL;
switch (data->dtd) {
case SDP_DATA_NIL:
{
constructorID = getGetMethodID(env, dataElementClass, "<init>", "(I)V");
if (constructorID == NULL) {
break;
}
dataElement = (*env)->NewObject(env, dataElementClass, constructorID, DATA_ELEMENT_TYPE_NULL);
break;
}
case SDP_BOOL:
{
jboolean boolean = data->val.uint8;
constructorID = getGetMethodID(env, dataElementClass, "<init>", "(Z)V");
if (constructorID == NULL) {
break;
}
dataElement = (*env)->NewObject(env, dataElementClass, constructorID, boolean);
break;
}
case SDP_UINT8:
{
jlong value = (jlong)data->val.uint8;
constructorID = getGetMethodID(env, dataElementClass, "<init>", "(IJ)V");
if (constructorID == NULL) {
break;
}
dataElement = (*env)->NewObject(env, dataElementClass, constructorID, DATA_ELEMENT_TYPE_U_INT_1, value);
break;
}
case SDP_UINT16:
{
jlong value = (jlong)data->val.uint16;
constructorID = getGetMethodID(env, dataElementClass, "<init>", "(IJ)V");
if (constructorID == NULL) {
break;
}
dataElement = (*env)->NewObject(env, dataElementClass, constructorID, DATA_ELEMENT_TYPE_U_INT_2, value);
break;
}
case SDP_UINT32:
{
jlong value = (jlong)data->val.uint32;
constructorID = getGetMethodID(env, dataElementClass, "<init>", "(IJ)V");
if (constructorID == NULL) {
break;
}
dataElement = (*env)->NewObject(env, dataElementClass, constructorID, DATA_ELEMENT_TYPE_U_INT_4, value);
break;
}
case SDP_INT8:
{
jlong value = (jlong)data->val.int8;
constructorID = getGetMethodID(env, dataElementClass,"<init>","(IJ)V");
dataElement = (*env)->NewObject(env, dataElementClass, constructorID, DATA_ELEMENT_TYPE_INT_1, value);
break;
}
case SDP_INT16:
{
jlong value = (jlong)data->val.int16;
constructorID = getGetMethodID(env, dataElementClass, "<init>", "(IJ)V");
if (constructorID == NULL) {
break;
}
dataElement = (*env)->NewObject(env, dataElementClass, constructorID, DATA_ELEMENT_TYPE_INT_2, value);
break;
}
case SDP_INT32:
{
jlong value = (jlong)data->val.int32;
constructorID = getGetMethodID(env, dataElementClass, "<init>", "(IJ)V");
dataElement = (*env)->NewObject(env, dataElementClass, constructorID, DATA_ELEMENT_TYPE_INT_4, value);
break;
}
case SDP_INT64:
{
jlong value = (jlong)data->val.int64;
constructorID = getGetMethodID(env, dataElementClass, "<init>", "(IJ)V");
if (constructorID == NULL) {
break;
}
dataElement = (*env)->NewObject(env, dataElementClass, constructorID, DATA_ELEMENT_TYPE_INT_8, value);
break;
}
case SDP_UINT64:
{
Edebug("SDP_UINT64");
uint64_t value = data->val.uint64;
jbyte* bytes = (jbyte*)&value;
reverseArray(bytes, sizeof(value));
jbyteArray byteArray = (*env)->NewByteArray(env, sizeof(value));
(*env)->SetByteArrayRegion(env, byteArray, 0, sizeof(value), bytes);
constructorID = getGetMethodID(env, dataElementClass, "<init>", "(ILjava/lang/Object;)V");
if (constructorID == NULL) {
break;
}
dataElement = (*env)->NewObject(env, dataElementClass, constructorID, DATA_ELEMENT_TYPE_U_INT_8, byteArray);
break;
}
case SDP_UINT128:
{
Edebug("SDP_UINT128");
uint128_t value = data->val.uint128;
jbyte* bytes = (jbyte*)&value;
reverseArray(bytes, sizeof(value));
jbyteArray byteArray = (*env)->NewByteArray(env, sizeof(value));
(*env)->SetByteArrayRegion(env, byteArray, 0, sizeof(value), bytes);
constructorID = getGetMethodID(env, dataElementClass, "<init>", "(ILjava/lang/Object;)V");
if (constructorID == NULL) {
break;
}
dataElement = (*env)->NewObject(env, dataElementClass, constructorID, DATA_ELEMENT_TYPE_U_INT_16, byteArray);
break;
}
case SDP_INT128:
{
Edebug("SDP_INT128");
uint128_t value = data->val.int128;
jbyte* bytes = (jbyte*)&value;
reverseArray(bytes, sizeof(value));
jbyteArray byteArray = (*env)->NewByteArray(env, sizeof(value));
(*env)->SetByteArrayRegion(env, byteArray, 0, sizeof(value), bytes);
constructorID = getGetMethodID(env, dataElementClass, "<init>", "(ILjava/lang/Object;)V");
if (constructorID == NULL) {
break;
}
dataElement = (*env)->NewObject(env, dataElementClass, constructorID, DATA_ELEMENT_TYPE_INT_16, byteArray);
break;
}
case SDP_URL_STR_UNSPEC:
case SDP_URL_STR8:
case SDP_URL_STR16:
case SDP_URL_STR32:
{
Edebug("SDP_URL");
char* str = data->val.str;
constructorID = getGetMethodID(env, dataElementClass, "<init>", "(ILjava/lang/Object;)V");
if (constructorID == NULL) {
break;
}
jstring string = (*env)->NewStringUTF(env, str);
dataElement = (*env)->NewObject(env, dataElementClass, constructorID, DATA_ELEMENT_TYPE_URL, string);
break;
}
case SDP_TEXT_STR_UNSPEC:
case SDP_TEXT_STR8:
case SDP_TEXT_STR16:
case SDP_TEXT_STR32:
{
Edebug("SDP_TEXT");
char* str = data->val.str;
constructorID = getGetMethodID(env, dataElementClass, "<init>", "(ILjava/lang/Object;)V");
if (constructorID == NULL) {
break;
}
jstring string = (*env)->NewStringUTF(env, str);
dataElement = (*env)->NewObject(env, dataElementClass, constructorID, DATA_ELEMENT_TYPE_STRING, string);
break;
}
case SDP_UUID_UNSPEC:
case SDP_UUID16:
case SDP_UUID32:
case SDP_UUID128:
{
Edebug("SDP_UUID");
jobject javaUUID = createJavaUUID(env, data->val.uuid);
if (javaUUID == NULL) {
debug("fail to create UUID");
break;
}
constructorID = getGetMethodID(env, dataElementClass, "<init>", "(ILjava/lang/Object;)V");
if (constructorID == NULL) {
break;
}
dataElement = (*env)->NewObject(env, dataElementClass, constructorID, DATA_ELEMENT_TYPE_UUID, javaUUID);
break;
}
case SDP_SEQ_UNSPEC:
case SDP_SEQ8:
case SDP_SEQ16:
case SDP_SEQ32:
{
Edebug("SDP_SEQ");
sdp_data_t *newData = data->val.dataseq;
constructorID = getGetMethodID(env, dataElementClass, "<init>", "(I)V");
if (constructorID == NULL) {
break;
}
dataElement = (*env)->NewObject(env, dataElementClass, constructorID, DATA_ELEMENT_TYPE_DATSEQ);
jmethodID addElementID = getGetMethodID(env, dataElementClass, "addElement", "(Ljavax/bluetooth/DataElement;)V");
for(; newData; newData = newData->next) {
jobject newDataElement = createDataElement(env, newData);
if (newDataElement != NULL) {
(*env)->CallVoidMethod(env, dataElement, addElementID, newDataElement);
}
if ((*env)->ExceptionCheck(env)) {
break;
}
}
break;
}
case SDP_ALT_UNSPEC:
case SDP_ALT8:
case SDP_ALT16:
case SDP_ALT32:
{
Edebug("SDP_ALT");
sdp_data_t *newData = data->val.dataseq;
constructorID = getGetMethodID(env, dataElementClass, "<init>", "(I)V");
if (constructorID == NULL) {
break;
}
dataElement = (*env)->NewObject(env, dataElementClass, constructorID, DATA_ELEMENT_TYPE_DATALT);
jmethodID addElementID = getGetMethodID(env, dataElementClass, "addElement", "(Ljavax/bluetooth/DataElement;)V");
for(; newData; newData = newData->next) {
jobject newDataElement = createDataElement(env, newData);
if (newDataElement == NULL) {
break;
}
(*env)->CallVoidMethod(env, dataElement, addElementID, newDataElement);
if ((*env)->ExceptionCheck(env)) {
break;
}
}
break;
}
default:
{
debug("strange data type 0x%x", data->dtd);
constructorID = getGetMethodID(env, dataElementClass, "<init>", "(I)V");
if (constructorID == NULL) {
break;
}
dataElement = (*env)->NewObject(env, dataElementClass, constructorID, DATA_ELEMENT_TYPE_NULL);
break;
}
}
if (dataElement != NULL) {
Edebug("dataElement created 0x%x", data->dtd);
}
if ((*env)->ExceptionCheck(env)) {
ndebug("Exception in data element creation 0x%x", data->dtd);
}
return dataElement;
}
/* Function to right rotate arr[] of size n by d */
void rightRotate(int arr[], int d, int n)
{
reverseArray(arr, 0, n-1);
reverseArray(arr, 0, d-1);
reverseArray(arr, d, n-1);
}
void ArrayOps::reverseArray(unsigned char* src, int len) {
reverseArray((char*)src, len);
}
