If you ordered the OTS package, you don’t need installation so you can skip next chapter. When booting, MME and eNB are automatically started within a screen. If you are not familiar with screen here is what you must know: • To have access to consoles, log on the machine with root access, then type: screen -r • To access MME monitor: CTRL-A + 0 • To access eNB monitor: CTRL-A + 1 • To exit screen: CTRL-A + d

这段文字提供了一些关于 OTS 包的信息以及关于 screen 的使用方法。如果你已经订购了 OTS 包，那么你不需要进行安装，可以跳过下一章节。在启动时，MME 和 eNB 会自动在一个 screen 中启动。如果你不熟悉 screen，你需要知道以下几点：

- 要访问控制台，请使用 root 权限登录到机器上，然后输入：screen -r。
- 要访问 MME 监视器，请按下 CTRL-A + 0。
- 要访问 eNB 监视器，请按下 CTRL-A + 1。
- 要退出 screen，请按下 CTRL-A + d。

这些快捷键可以让你在 screen 中轻松地切换控制台和退出 screen。

相关问题

There are several other sorting algorithms besides selection sort that makesense at your level of programming knowledge. Unfortunately, those algorithms donot offer any advantages over selection sort in terms of their algorithmperformance. Even so, coding these algorithms gives you more practice usingarrays.For example, you can sort an integer array from lowest to highest by applyingthe following procedure. Start by going through the array, looking at adjacent pairsof values. If the values forming the pair are correctly ordered, do nothing; if thevalues are out of order, swap them. In either case, move on the next pair ofvalues. The pairs overlap as you move through the list so that the second elementin one pair becomes the first element of the next pair. Repeat this operation untilyou make a complete pass in which you do not need to exchange any integers.This algorithm is called bubble sort, because the values seem to “bubble up” totheir eventual positions.Reimplement the SortIntegerArray function using the bubble sort algorithm.

Sure, I can help you with that. Here's the implementation of the SortIntegerArray function using the bubble sort algorithm:

void SortIntegerArray(int arr[], int size) {
  for (int i = 0; i < size - 1; i++) {
    for (int j = 0; j < size - i - 1; j++) {
      if (arr[j] > arr[j+1]) {
        int temp = arr[j];
        arr[j] = arr[j+1];
        arr[j+1] = temp;
      }
    }
  }
}

This function takes an integer array and its size as input, and then sorts the array using the bubble sort algorithm. The outer loop runs from 0 to size-1, and the inner loop runs from 0 to size-i-1. In each iteration of the inner loop, we compare adjacent pairs of values and swap them if they are out of order. This process is repeated until we make a complete pass in which we do not need to exchange any integers.

I hope this helps! Let me know if you have any further questions.

Binary search is a common search approach for a list of values. For binary search to work, the elements in the array must already be ordered. Assume that the array is in ascending order. The binary search first compares the key with the element in the middle of the array. Consider the following three cases: ■ If the key is less than the middle element, you need to continue to search for the key only in the first half of the array. ■ If the key is equal to the middle element, the search ends with a match. ■ If the key is greater than the middle element, you need to continue to search for the key only in the second half of the array. Implement the binary search using Language C. And write a program to test whether it can work or not.

Here is a sample implementation of binary search in C:

#include <stdio.h>

int binarySearch(int arr[], int left, int right, int key) {
    while (left <= right) {
        int mid = (left + right) / 2;
        if (arr[mid] == key) {
            return mid;
        }
        else if (arr[mid] < key) {
            left = mid + 1;
        }
        else {
            right = mid - 1;
        }
    }
    return -1;
}

int main() {
    int arr[] = { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 };
    int n = sizeof(arr) / sizeof(arr[0]);
    int key = 12;
    int index = binarySearch(arr, 0, n - 1, key);
    if (index == -1) {
        printf("Element not found\n");
    }
    else {
        printf("Element found at index %d\n", index);
    }
    return 0;
}

In this implementation, `binarySearch()` takes four arguments: the array to search `arr`, the left and right indices of the subarray to search `left` and `right`, and the key to search for `key`. It returns the index of the key in the array if it is found, or `-1` if it is not found.

The function works by repeatedly dividing the subarray in half using the middle index `mid`, comparing the key to the element at `arr[mid]`, and adjusting the left and right indices accordingly until the key is found or the subarray is exhausted.

In the `main()` function, we test the `binarySearch()` function by searching for the key `12` in the array `arr`. If the key is found, we print its index; otherwise, we print a message indicating that the element was not found.