1c:I[80045,["/_next/static/chunks/2yhmxtopi2usz.js","/_next/static/chunks/3gqtnop-0t-xp.js","/_next/static/chunks/3530kiensk2qd.js","/_next/static/chunks/04q-sbs8mzomz.js","/_next/static/chunks/1grs5bh5plbcu.js"],"SiteProvider"] 1d:I[2594,["/_next/static/chunks/2yhmxtopi2usz.js","/_next/static/chunks/3gqtnop-0t-xp.js","/_next/static/chunks/3530kiensk2qd.js","/_next/static/chunks/04q-sbs8mzomz.js","/_next/static/chunks/1grs5bh5plbcu.js"],"AuthProvider"] 1e:I[24252,["/_next/static/chunks/2yhmxtopi2usz.js","/_next/static/chunks/3gqtnop-0t-xp.js","/_next/static/chunks/3530kiensk2qd.js","/_next/static/chunks/04q-sbs8mzomz.js","/_next/static/chunks/1grs5bh5plbcu.js"],"NotificationProvider"] 1f:I[72180,["/_next/static/chunks/2yhmxtopi2usz.js","/_next/static/chunks/3gqtnop-0t-xp.js","/_next/static/chunks/3530kiensk2qd.js","/_next/static/chunks/04q-sbs8mzomz.js","/_next/static/chunks/1grs5bh5plbcu.js"],"PresenceProvider"] 20:I[26819,["/_next/static/chunks/2yhmxtopi2usz.js","/_next/static/chunks/3gqtnop-0t-xp.js","/_next/static/chunks/3530kiensk2qd.js","/_next/static/chunks/04q-sbs8mzomz.js","/_next/static/chunks/1grs5bh5plbcu.js"],"MusicProvider"] 21:I[25631,["/_next/static/chunks/2yhmxtopi2usz.js","/_next/static/chunks/3gqtnop-0t-xp.js","/_next/static/chunks/3530kiensk2qd.js","/_next/static/chunks/04q-sbs8mzomz.js","/_next/static/chunks/1grs5bh5plbcu.js"],"NavigationHistoryProvider"] 22:I[48005,["/_next/static/chunks/2yhmxtopi2usz.js","/_next/static/chunks/3gqtnop-0t-xp.js","/_next/static/chunks/3530kiensk2qd.js","/_next/static/chunks/04q-sbs8mzomz.js","/_next/static/chunks/1grs5bh5plbcu.js"],"ZeDevConsole"] 34:I[27201,["/_next/static/chunks/0ehjiuuxbbhq9.js"],"IconMark"] 23:T2493,These are my step-by-step notes from a five-day network engineering lab. I usually wrote them after returning to the dorm, so the explanations follow the order in which I completed each exercise. > Historical note: this lab used Red Hat Enterprise Linux 8.2 in 2021. Package versions, security defaults, and recommended administration practices may differ on current systems. Commands that disable SELinux or the firewall are reproduced from the isolated classroom environment and should not be copied into production without a proper security policy. ## Day 1: local software repositories ### 1. Install the virtual machine Create a Red Hat virtual machine and name it `server`. ### 2. Configure a local YUM repository First, locate the mounted installation media: ```bash df ``` The mount path may differ between machines. Copy the path shown on your system, then create the repository definition: ```ini cd /etc/yum.repos.d/ vim myrepos.repo [app] name = app enabled = 1 gpgcheck = 0 baseurl = file:///run/media/zaunekko/RHEL-8-2-0-BaseOS-x86_64/AppStream [base] name = base enabled = 1 gpgcheck = 0 baseurl = file:///run/media/zaunekko/RHEL-8-2-0-BaseOS-x86_64/BaseOS ``` Replace both paths with the mount path from your own machine, then rebuild the cache: ```bash yum makecache ``` ![The mounted installation media](/media/download/image/web/07.png) ![Local YUM repository configured successfully](/media/download/image/web/08.png) ### 3. Create a snapshot Create a VM snapshot before continuing so this clean base can be restored for later exercises. ## Day 2: DHCP server ### 1. Prepare two clients Create two more Red Hat virtual machines named `client1` and `client2`. Cloning is fine, but make sure their MAC addresses are different. ### 2. Configure the virtual network Attach all three machines to the same custom virtual network. In this lab I used VMnet5; VMnet0, VMnet1, and VMnet8 were avoided because VMware commonly reserves them for bridged, host-only, and NAT networking. ![VMware virtual network selection](/media/download/image/web/09.png) ### 3. Configure the server Set the server network configuration as shown below: ![Server network configuration](/media/download/image/web/10.png) Install the DHCP service and copy its example configuration: ```bash setenforce 0 systemctl stop firewalld.service yum install dhcp-server.x86_64 -y cp /usr/share/doc/dhcp-server/dhcpd.conf.example /etc/dhcp/dhcpd.conf vim /etc/dhcp/dhcpd.conf ``` Remove or comment out the earlier sample subnet blocks, then add this subnet: ```conf subnet 1.1.1.0 netmask 255.255.255.0 { range 1.1.1.2 1.1.1.3; option domain-name-servers 1.1.1.1; option domain-name "zaunekko.example.org"; option routers 1.1.1.1; default-lease-time 600; max-lease-time 7200; } ``` Restart the service: ```bash systemctl restart dhcpd.service ``` ### 4. Verify address assignment on the clients Restore both clients to their snapshots and reconnect their wired interfaces. They should receive `1.1.1.2` and `1.1.1.3` from the server. ### 5. Assign a fixed address The next requirement was to give the client currently using `1.1.1.3` the fixed address `1.1.1.100`. Ping it first so its MAC address appears in the ARP cache: ```text # arp -a ? (1.1.1.3) at 00:0c:29:5f:2a:44 [ether] on ens160 ? (1.1.1.2) at 00:0c:29:7c:aa:c9 [ether] on ens160 ``` Add a host entry to `/etc/dhcp/dhcpd.conf` using the MAC address you found: ```conf host fantasia { hardware ethernet 00:0c:29:5f:2a:44; fixed-address 1.1.1.100; } ``` Restart DHCP again, reconnect the client, and confirm that it now receives `1.1.1.100`. ![The client receiving its fixed address](/media/download/image/web/11.png) ## Day 2 extra: add a DHCP relay Move `server` and `client1` to VMnet10, move `client2` to VMnet15, and add a second adapter on `client1` connected to VMnet15. `client1` will route and relay DHCP traffic between the two networks. ### 1. Update the server ![Updated server network configuration](/media/download/image/web/12.png) Use `client1` as the server's gateway and define both subnets: ```bash route add default gw 1.1.1.2 vim /etc/dhcp/dhcpd.conf ``` ```conf subnet 1.1.1.0 netmask 255.255.255.0 { range 1.1.1.2 1.1.1.3; option domain-name-servers 1.1.1.2; option domain-name "zaunekko.example.org"; option routers 1.1.1.2; default-lease-time 600; max-lease-time 7200; } subnet 100.100.100.0 netmask 255.255.255.0 { range 100.100.100.2 100.100.100.3; option domain-name-servers 100.100.100.1; option domain-name "zaunekko.example.org"; option routers 100.100.100.1; default-lease-time 600; max-lease-time 7200; } ``` ```bash systemctl restart dhcpd.service ``` ### 2. Configure the relay on client1 Reconnect the first interface, then enable and configure the second one: ![client1 first interface](/media/download/image/web/13.png) ![client1 second interface configuration](/media/download/image/web/14.png) ![Both client1 interfaces active](/media/download/image/web/15.png) Enable IPv4 forwarding in `/etc/sysctl.conf`: ```conf net.ipv4.ip_forward = 1 ``` Apply it and install the relay service: ```bash sysctl -p cat /proc/sys/net/ipv4/ip_forward yum install dhcp-relay.x86_64 cp /lib/systemd/system/dhcrelay.service /etc/systemd/system/ vim /etc/systemd/system/dhcrelay.service ``` Configure the service to forward requests from both interfaces to the DHCP server at `1.1.1.1`: ```ini [Unit] Description=DHCP Relay Agent Daemon Documentation=man:dhcrelay(8) Wants=network-online.target After=network-online.target [Service] Type=notify ExecStart=/usr/sbin/dhcrelay -d --no-pid 1.1.1.1 -i ens160 -i ens224 StandardError=null [Install] WantedBy=multi-user.target ``` ```bash systemctl --system daemon-reload systemctl restart dhcrelay.service ``` Reconnect `client2` and confirm that it obtains an address through the relay. ![client2 receiving an address through the relay](/media/download/image/web/16.png) ## Day 3: DNS with BIND Set the server address and gateway to `192.168.1.1`, then install BIND: ```bash yum install bind.x86_64 -y vim /etc/named.conf named-checkconf /etc/named.conf vim /etc/named.rfc1912.zones ``` Create and validate the forward and reverse zone files: ```bash cd /var/named/ cp named.localhost shida.com.zone vim shida.com.zone named-checkzone shida.com /var/named/shida.com.zone cp shida.com.zone 192.168.1.zone vim 192.168.1.zone named-checkzone 1.168.192.in-addr.arpa /var/named/192.168.1.zone ``` Start the service, make it persistent, and update the resolver configuration: ```bash systemctl restart named.service systemctl enable named.service chmod +r /var/named/* vim /etc/resolv.conf ``` Finally, use `nslookup` to verify forward records, aliases, and reverse lookup: ```text > syb.shida.com Name: syb.shida.com Address: 192.168.1.1 > 192.168.1.1 1.1.168.192.in-addr.arpa name = syb.shida.com. > www.shida.com www.shida.com canonical name = station2.shida.com. Name: station2.shida.com Address: 192.168.1.2 ``` ## Day 4: Apache HTTP Server Install Apache and create a basic home page: ```bash yum install httpd.x86_64 -y vim /etc/httpd/conf/httpd.conf echo "welcome to gongyedaxue" >> /var/www/html/index.html systemctl restart httpd.service ``` Create a second content directory and configure it as a virtual directory: ```bash mkdir -p /gongye/yuyue echo "my name is yuyue" >> /gongye/yuyue/index.html vim /etc/httpd/conf.d/vdir.conf ``` Give the directory the SELinux context Apache expects, then restart the service: ```bash semanage fcontext -a -t httpd_sys_content_t '/gongye(/.*)?' restorecon -Rv /gongye/ systemctl restart httpd.service ``` ## Day 5: FTP with vsftpd ### 1. Configure anonymous access on the server Install and enable vsftpd, then create a shared file: ```bash yum install vsftpd.x86_64 -y systemctl enable vsftpd.service --now mkdir -p /ftp/share echo "anonymous user" > /ftp/share/test.txt vim /etc/vsftpd/vsftpd.conf systemctl restart vsftpd.service ``` Apply the public-content SELinux context: ```bash semanage fcontext -a -t public_content_t '/ftp/share(/.*)?' restorecon -Rv /ftp/share/ ``` ### 2. Verify anonymous access from client1 Install the FTP client, connect as `ftp`, list the directory, and download the test file: ```text # yum install ftp.x86_64 -y # ftp 192.168.1.1 Name: ftp Password: 230 Login successful. ftp> ls -rw-r--r-- 1 0 0 16 Jul 02 04:14 test.txt ftp> get test.txt 226 Transfer complete. ftp> exit ``` ### 3. Configure a local FTP user Create a local user and a file in that user's home directory: ```bash useradd yuyue echo redhat123 | passwd --stdin yuyue su - yuyue echo "welcome to gongyedaxue" >> yuyue.txt ``` Return to `root`, adjust `/etc/vsftpd/vsftpd.conf`, restart the service, and allow the required SELinux access for this lab: ```bash systemctl restart vsftpd.service getsebool -a | grep ftp setsebool -P ftpd_full_access on ``` ### 4. Verify local-user access Connect from `client1` as `yuyue` and download the file: ```text # ftp 192.168.1.1 Name: yuyue Password: 230 Login successful. ftp> ls -rw-rw-r-- 1 1001 1001 23 Jul 02 04:27 yuyue.txt ftp> get yuyue.txt 226 Transfer complete. ftp> exit ``` That completed the five-day lab: local repositories, DHCP and relay routing, DNS, Apache, and both anonymous and local-user FTP access.24:Tdec,# Shortest Paths with Breadth-First Search The previous graph note discussed minimum spanning trees. Shortest paths answer a different question: instead of connecting the whole graph as cheaply as possible, we want the cheapest route from one place to another. Imagine cities `A` through `E`, with `A` as a production center. Finding the shortest delivery route from `A` to every other city is a **single-source shortest-path** problem. Finding the shortest route for every pair of cities is an **all-pairs shortest-path** problem. ![Shortest-path categories](/media/download/image/bfs/2.png) Different algorithms apply to different graph types: ![Algorithm applicability](/media/download/image/bfs/1.png) ## BFS for an unweighted graph Breadth-first search visits a graph layer by layer. An unweighted graph can also be viewed as a weighted graph in which every edge has weight 1, so the first time BFS reaches a vertex it has found a minimum-edge path from the source. For the example graph, starting from vertex 2: - first layer: vertices 1 and 6; - second layer: vertices 5, 3, and 7; - third layer: vertices 4 and 8. ![BFS layers](/media/download/image/bfs/3.png) ![BFS traversal](/media/download/image/bfs/4.png) ## Implementation ```c void BFS_MIN_Distance(Graph G, int source) { for (int i = 0; i < G.vexnum; ++i) { d[i] = INFINITY; // unreachable until discovered path[i] = -1; // no predecessor yet visited[i] = FALSE; } d[source] = 0; visited[source] = TRUE; EnQueue(Q, source); while (!isEmpty(Q)) { int u; DeQueue(Q, u); for (int w = FirstNeighbor(G, u); w >= 0; w = NextNeighbor(G, u, w)) { if (!visited[w]) { d[w] = d[u] + 1; path[w] = u; visited[w] = TRUE; EnQueue(Q, w); } } } } ``` The three important pieces of state are: - `visited[v]`: whether `v` has already been discovered; - `d[v]`: the minimum number of edges from the source to `v`; - `path[v]`: the predecessor of `v` on the discovered shortest path. The queue preserves layer order. ## Walking through the example Initialize all vertices as unvisited, all distances as unreachable, and all predecessors as `-1`. Then mark source vertex 2, set `d[2] = 0`, and enqueue it. ### Dequeue vertex 2 Its unvisited neighbors are 1 and 6: ```text queue: 1, 6 d[1] = 1, path[1] = 2 d[6] = 1, path[6] = 2 ``` ### Dequeue vertex 1 Vertex 2 is already visited. Discover vertex 5: ```text queue: 6, 5 d[5] = 2, path[5] = 1 ``` ### Dequeue vertex 6 Discover vertices 3 and 7: ```text queue: 5, 3, 7 d[3] = 2, path[3] = 6 d[7] = 2, path[7] = 6 ``` ### Continue by queue order Vertex 5 adds nothing new. Vertex 3 discovers vertex 4, and vertex 7 discovers vertex 8. The final arrays are: | Vertex | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | | `d` | 1 | 0 | 2 | 3 | 2 | 1 | 2 | 3 | | `path` | 2 | -1 | 6 | 3 | 1 | 2 | 6 | 7 | The queue is now empty, so traversal is complete. ## Reconstructing a path For vertex 4: ```text d[4] = 3 path[4] = 3 path[3] = 6 path[6] = 2 ``` Following predecessors backward gives `4 ← 3 ← 6 ← 2`. Reverse that sequence to obtain the shortest route: ```text 2 → 6 → 3 → 4 ``` Its length is three edges, matching `d[4]`. BFS solves this cleanly because every edge has equal cost. Weighted graphs require algorithms such as Dijkstra or Floyd, which are separate topics.25:T738,# RSA for Exams: Solving for the Private Exponent This note focuses on the calculation pattern commonly required in network-security exams. It does not attempt a full treatment of RSA or number theory; the goal is to show a reliable way to solve for the private exponent. ## Example Given: ```text e = 31 n = 3599 d = ? ``` ## 1. Recover `p` and `q`, then compute φ(n) RSA uses: ```text n = p × q ``` Factor 3599: ```text 3599 = (60 + 1)(60 - 1) = 61 × 59 ``` Therefore: ```text p = 61 q = 59 φ(n) = (p - 1)(q - 1) = 60 × 58 = 3480 ``` ## 2. Solve `ed - kφ(n) = 1` We need `d` such that: ```text ed ≡ 1 (mod φ(n)) ``` Write the equation as: ```text 31d + 3480y = 1 ``` where `y = -k`. Use the Euclidean algorithm until the remainder is 1: ```text 3480 = 31 × 112 + 8 31 = 8 × 3 + 7 8 = 7 × 1 + 1 ``` Rewrite each remainder: ```text 8 = 3480 - 31 × 112 (3) 7 = 31 - 8 × 3 (2) 1 = 8 - 7 (1) ``` Substitute equation (2) into equation (1): ```text 1 = 8 - (31 - 8 × 3) = 8 × 4 - 31 ``` Now substitute equation (3): ```text 1 = (3480 - 31 × 112) × 4 - 31 = 3480 × 4 + 31 × (-449) ``` Comparing this result with `31d + 3480y = 1` gives: ```text d = -449 y = 4 ``` The private exponent is taken as a positive representative modulo 3480: ```text d = -449 + 3480 = 3031 ``` So the answer is: ```text d = 3031 ``` ## Compact exam solution ```text n = 3599 = 59 × 61 φ(n) = 58 × 60 = 3480 31d + 3480y = 1 3480 = 31 × 112 + 8 31 = 8 × 3 + 7 8 = 7 × 1 + 1 1 = 8 - 7 = 8 - (31 - 8 × 3) = 8 × 4 - 31 = (3480 - 31 × 112) × 4 - 31 = 3480 × 4 + 31 × (-449) d = -449 ≡ 3031 (mod 3480) ``` Once this sequence is familiar, practice it with another set of values so the extended-Euclidean back-substitution becomes automatic during the exam.26:Tf7a,# Minimum Spanning Trees: Prim and Kruskal Minimum spanning trees are a standard graph topic with practical applications such as connecting towns while minimizing road-construction cost. For the postgraduate 408 exam, understanding how the algorithms evolve step by step is more important than memorizing code, but the underlying data structures still matter. ## Spanning trees and minimum spanning trees For a connected undirected graph, a **spanning tree** is a minimal connected subgraph containing every vertex: - Removing any tree edge disconnects it. - Adding another graph edge creates a cycle. - A spanning tree with `n` vertices contains exactly `n - 1` edges. ![A spanning tree](/media/download/image/MST/1.jpg) When edges have weights, a **minimum spanning tree** (MST) is a spanning tree whose total edge weight is as small as possible. An MST is not necessarily unique. The running example asks how to connect every town while spending as little as possible. The dashed-edge labels represent construction cost. ![Road-building example](/media/download/image/MST/2.jpg) ## Prim's algorithm Prim grows one connected tree. Start from any vertex, then repeatedly add the cheapest edge that connects the current tree to a vertex outside it. Stop when every vertex has joined. ![Prim's algorithm](/media/download/image/MST/3.jpg) One implementation uses two arrays: - `isJoin[v]` records whether vertex `v` is already in the tree. - `lowCost[v]` records the cheapest known cost for connecting `v` to the current tree. Starting from `C`: | Vertex | C | A | B | D | E | F | | --- | ---: | ---: | ---: | ---: | ---: | ---: | | `isJoin` | 1 | 0 | 0 | 0 | 0 | 0 | | `lowCost` | 0 | 1 | 5 | 4 | 6 | 4 | The minimum non-zero cost is 1, so connect `A` to `C`. | Vertex | C | A | B | D | E | F | | --- | ---: | ---: | ---: | ---: | ---: | ---: | | `isJoin` | 1 | 1 | 0 | 0 | 0 | 0 | | `lowCost` | 0 | 0 | 5 | 4 | 6 | 4 | The next minimum is 4. Choose `F`, then update costs using edges from `F`. In particular, `D` can now join through `F` for cost 2 instead of through `C` for cost 4: | Vertex | C | A | B | D | E | F | | --- | ---: | ---: | ---: | ---: | ---: | ---: | | `isJoin` | 1 | 1 | 0 | 0 | 0 | 1 | | `lowCost` | 0 | 0 | 5 | 2 | 6 | 0 | Continue the same process: ```text C-A: 1 C-F: 4 F-D: 2 C-B: 5 B-E: 3 ``` The total MST weight is: ```text 1 + 4 + 2 + 5 + 3 = 15 ``` Prim is therefore best understood as maintaining the cheapest boundary from one growing connected component to the rest of the graph. ## Kruskal's algorithm Kruskal approaches the same problem from the edges rather than from one growing vertex set. Sort all edges by weight, then scan them from cheapest to most expensive. Accept an edge only when its endpoints currently belong to different connected components. ![Kruskal's algorithm](/media/download/image/MST/4.jpg) The sorted edges are: | Weight | Endpoint 1 | Endpoint 2 | | ---: | --- | --- | | 1 | A | C | | 2 | D | F | | 3 | B | E | | 4 | D | C | | 4 | C | F | | 5 | A | D | | 5 | B | C | | 6 | A | B | | 6 | C | E | | 6 | E | F | Use a disjoint-set union structure to track the components: 1. Accept `A-C` → `{AC}, {B}, {D}, {E}, {F}`. 2. Accept `D-F` → `{AC}, {DF}, {B}, {E}`. 3. Accept `B-E` → `{AC}, {DF}, {BE}`. 4. Accept `D-C` because `{DF}` and `{AC}` differ → `{ACDF}, {BE}`. 5. Reject `C-F`; both endpoints are already in `{ACDF}`. 6. Reject `A-D` for the same reason. 7. Accept `B-C`, joining the final two components → `{ABCDEF}`. The chosen edges again have total weight 15. ## Prim versus Kruskal - **Prim** repeatedly chooses the cheapest vertex connection across the boundary of one growing tree. - **Kruskal** repeatedly chooses the cheapest globally available edge that does not form a cycle. Both produce a minimum spanning tree. Keeping their selection rules distinct is important before moving on to shortest-path algorithms, which answer a different question.27:T10e8,# KMP and Its `nextval` Optimization KMP is a string-matching algorithm. This note uses the one-based convention commonly seen in 408 exam material: - Pattern positions begin at 1. - `next[1] = 0`. - For `j > 1`, `next[j]` equals one plus the length of the longest equal proper prefix and suffix of the pattern segment before position `j`. Some sources use zero-based positions and therefore produce values shifted by one. Both conventions can be correct; do not mix the table from one convention with code written for the other. ## Why KMP is needed Suppose the text is `abababcdef` and the pattern is `ababc`. A naive matcher restarts one text position later after every mismatch, repeating comparisons it has already learned from. KMP keeps the text position and moves the pattern using information encoded in `next`. ```c int Index_KMP(SString S, SString T, int next[]) { int i = 1, j = 1; while (i <= S.length && j <= T.length) { if (j == 0 || S.ch[i] == T.ch[j]) { ++i; ++j; } else { j = next[j]; } } if (j > T.length) { return i - T.length; } return 0; } ``` When `j == 0`, incrementing `j` returns it to the first pattern position and incrementing `i` advances the text. ![Normal KMP movement](/media/download/image/kmp/1.jpg) ![The j = 0 case](/media/download/image/kmp/2.jpg) ## Prefixes, suffixes, and the `next` array - A **proper prefix** starts at the first character but does not contain the final character of the string. - A **proper suffix** ends at the final character but does not contain the first character. If comparison fails at pattern position `j`, inspect the substring formed by positions `1` through `j - 1`. Under this note's convention: ```text next[j] = longest equal proper-prefix/suffix length + 1 next[1] = 0 ``` For pattern `ababaa`: | Position `j` | 1 | 2 | 3 | 4 | 5 | 6 | | --- | --- | --- | --- | --- | --- | --- | | Pattern | a | b | a | b | a | a | | `next[j]` | 0 | 1 | 1 | 2 | 3 | 4 | Why is `next[6] = 4`? Before position 6, the segment is `ababa`. Its prefixes include `a`, `ab`, `aba`, and `abab`; its suffixes include `a`, `ba`, `aba`, and `baba`. The longest equal pair is `aba`, whose length is 3, so the one-based fallback position is `3 + 1 = 4`. `next[2]` must be 1 because the segment before position 2 contains only one character and has no non-empty proper prefix/suffix pair. The same reasoning gives `next[3] = 1` for segment `ab`. ## The redundant-comparison problem Consider: ```text Text: abcababaa Pattern: ababaa ``` If a mismatch occurs at pattern position 3, `next[3] = 1`. Both pattern positions 3 and 1 contain `a`. If `a` at position 3 just failed against the current text character, retrying the same `a` from position 1 is guaranteed to fail again. That retry is redundant. ## Computing `nextval` `nextval` collapses those repeated-character fallback chains: ```c for (int j = 2; j <= T.length; j++) { if (T.ch[next[j]] == T.ch[j]) { nextval[j] = nextval[next[j]]; } else { nextval[j] = next[j]; } } ``` For `ababaa`: | Position `j` | 1 | 2 | 3 | 4 | 5 | 6 | | --- | --- | --- | --- | --- | --- | --- | | Pattern | a | b | a | b | a | a | | `next[j]` | 0 | 1 | 1 | 2 | 3 | 4 | | `nextval[j]` | 0 | 1 | 0 | 1 | 0 | 4 | Step by step: 1. At `j = 2`, `T[next[2]]` is `a` and `T[2]` is `b`. They differ, so `nextval[2] = next[2] = 1`. 2. At `j = 3`, both characters are `a`. Reuse the optimized fallback from position 1: `nextval[3] = nextval[1] = 0`. 3. At `j = 4`, both compared characters are `b`, so `nextval[4] = nextval[2] = 1`. 4. Position 5 similarly collapses to 0. 5. At position 6 the characters differ along the fallback, so the value remains 4. ## Practice Compute both arrays for pattern `aaaab`: | Position `j` | 1 | 2 | 3 | 4 | 5 | | --- | --- | --- | --- | --- | --- | | Pattern | a | a | a | a | b | | `next[j]` | 0 | 1 | 2 | 3 | 4 | | `nextval[j]` | 0 | 0 | 0 | 0 | 4 | The repeated `a` fallback chain collapses to zero, while the final `b` keeps the useful fallback position 4. For exam questions, first identify the indexing convention, then compute the longest prefix/suffix matches consistently. Once `next` is correct, `nextval` follows directly from the character comparison rule.28:T15d3,## C++ Primer Chapter 2 — first-half answers These are my working answers while studying C++ systematically. They cover the first part of Chapter 2; the remaining exercises were still in progress when this note was written. ## Exercises 2.1 and 2.2 Integer types differ in size and therefore in the range of values they can represent. Unsigned types use every bit for the magnitude, while signed types also represent negative values. `float` and `double` differ mainly in precision; `double` is generally the better default for values such as interest rates, principal, and payments. ## Exercises 2.3 and 2.4 ```cpp #include int main() { unsigned u = 10, u2 = 42; std::cout << u2 - u << std::endl; // 32 std::cout << u - u2 << std::endl; // wraps modulo the unsigned range int i = 10, i2 = 42; std::cout << i2 - i << std::endl; // 32 std::cout << i - i2 << std::endl; // -32 std::cout << i - u << std::endl; // 0 std::cout << u - i << std::endl; // 0 } ``` ## Exercises 2.5–2.7: literal types ```cpp // (a) 'a', L'a', "a", L"a" // char, wide character, string, wide string // (b) 10, 10u, 10L, 10uL, 012, 0xC // int, unsigned int, long, unsigned long, octal, hexadecimal // (c) 3.14, 3.14f, 3.14L // double, float, long double // (d) 10, 10u, 10., 10e-2 // int, unsigned int, double, double ``` `int month = 09;` is invalid because a leading zero denotes an octal integer and octal digits stop at 7. ```cpp // "Who goes with F\145rhus?\012" // \145 is the octal code for 'e'; \012 is a newline. // 3.14e1L -> long double value 31.4 // 1024f -> float value 1024.0 // 3.14L -> long double value 3.14 ``` ## Exercise 2.8 ```cpp #include int main() { std::cout << "2M\n" << std::endl; std::cout << "2\tM\n" << std::endl; } ``` ## Exercises 2.9 and 2.10: initialization ```cpp #include #include std::string global_str; int global_int; int main() { // std::cin >> int input_value; // invalid: declare the variable first // int i = {3.14}; // invalid narrowing list initialization // double salary = wage = 9999.99; // invalid if wage is not declared int i = 3.14; // valid; i becomes 3 int local_int; // uninitialized std::string local_str; // empty string std::cout << global_str << '\n' << global_int << '\n' << local_int << '\n' << local_str << std::endl; } ``` Global variables receive default initialization; a local built-in type such as `local_int` does not. ## Exercise 2.11: declarations and definitions ```cpp extern int ix = 1024; // definition; an initializer makes it a definition int iy; // definition extern int iz; // declaration only ``` An initialized `extern` definition belongs at namespace scope, not inside a function. ## Exercise 2.12: identifiers ```cpp // int double = 3.14; // invalid: keyword int _; // valid inside a function // int and = 2; // invalid: alternative operator token // int catch-22; // invalid: hyphen // int 1_or_2 = 1; // invalid: starts with a digit double Double = 3.14; // valid: C++ is case-sensitive ``` Names reserved to the implementation—such as those containing double underscores or beginning with an underscore followed by an uppercase letter—should be avoided. ## Exercises 2.13 and 2.14: scope ```cpp #include int i = 42; int main() { int i = 100; int j = i; // uses the local i, so j is 100 std::cout << j << std::endl; } ``` ```cpp #include int main() { int i = 100, sum = 0; for (int i = 0; i != 10; ++i) { sum += i; } std::cout << i << ' ' << sum << std::endl; } ``` The loop variable is separate from the outer `i`; the final output is `100 45`. ## Exercises 2.15–2.17: references ```cpp int ival = 1.01; // valid conversion to int // int &rval1 = 1.01; // invalid: non-const int reference cannot bind here int &rval2 = ival; // int &rval3; // invalid: a reference must be initialized ``` ```cpp int i = 0, &r1 = i; double d = 0, &r2 = d; r2 = 3.14159; // assigns d r2 = r1; // assigns i to d i = r2; // converts d to int r1 = d; // assigns d to i through r1 ``` ```cpp int i; int &ri = i; i = 5; ri = 10; // i and ri both now observe the value 10. ``` ## Exercises 2.18–2.24: pointers ```cpp int i = 42; int *p = &i; *p = 52; // changes i p = nullptr; // p no longer points to i ``` A pointer can later point to a different object. A reference remains bound to the object used at initialization. ```cpp int i = 42; int *p1 = &i; *p1 = *p1 * *p1; // i becomes 1764 ``` Pointer types must match the pointed-to object: ```cpp int i = 0; // double *dp = &i; // invalid type // int *ip = i; // invalid: i is a value, not an address int *p = &i; // valid ``` Testing `p` checks whether the pointer is null. Testing `*p` checks the pointed-to value and is only valid after establishing that `p` is non-null. ```cpp int i = 42; void *p = &i; // a void pointer can hold an object address // long *lp = &i; // invalid type mismatch ``` ## Exercise 2.25: reading declarations ```cpp int *ip, i, &r = i; // ip: pointer to int; i: int; r: reference to i int i2, *p2 = nullptr; // i2: int; p2: null pointer to int int *ip2, ip3; // ip2: pointer to int; ip3: int ``` The key is to read each declarator separately: `*` and `&` belong to the variable being declared, not globally to the base type.29:T1c84,# C++ Primer, Fifth Edition — Chapter 1 Answers These are my working answers to the Chapter 1 exercises. The examples are intentionally basic; later chapters add more detailed explanations as the language features become more interesting. ## Exercises 1.1 and 1.2 The smallest valid program returns success: ```cpp int main() { return 0; } ``` Returning `-1` is also valid, although the operating system observes it as a non-zero failure status: ```cpp int main() { return -1; } ``` ## Exercise 1.3 ```cpp #include int main() { std::cout << "Hello, World" << std::endl; return 0; } ``` ## Exercises 1.4 and 1.5 Read two integers and print their product: ```cpp #include int main() { int left = 0, right = 0; std::cin >> left >> right; std::cout << "The product of " << left << " * " << right << " is " << left * right << std::endl; return 0; } ``` Exercise 1.5 produces the same result using several separate output statements instead of one chained expression. ## Exercises 1.6–1.8: output and comments Every continued insertion expression needs a stream on its left. A new statement beginning with `<<` is invalid because there is no left-hand operand. C-style block comments cannot be nested. Comment delimiters inside string literals are ordinary characters: ```cpp std::cout << "/*"; // valid std::cout << "*/"; // valid ``` The book's deliberately awkward expressions demonstrate that the compiler distinguishes lexical comments from quoted text. ## Exercise 1.9: sum from 50 through 100 ```cpp #include int main() { int sum = 0, value = 50; while (value <= 100) { sum += value; ++value; } std::cout << "The sum from 50 through 100 is " << sum << std::endl; } ``` ## Exercise 1.10: countdown ```cpp int value = 10; while (value >= 0) { std::cout << value << std::endl; --value; } ``` ## Exercises 1.11 and 1.19: print a range in either direction ```cpp #include int main() { int first = 0, second = 0; std::cin >> first >> second; if (first <= second) { while (first <= second) { std::cout << first++ << std::endl; } } else { while (first >= second) { std::cout << first-- << std::endl; } } } ``` ## Exercise 1.12 The sum of every integer from -100 through 100 is zero: ```cpp int sum = 0; for (int value = -100; value <= 100; ++value) { sum += value; } ``` ## Exercise 1.13 Rewrite the earlier `while` exercises as `for` loops. Initialization, condition, and increment can all live in the `for` header, but any field may be omitted when the state is managed elsewhere. ```cpp int sum = 0; for (int value = 50; value <= 100; ++value) { sum += value; } ``` ## Exercise 1.14: `for` versus `while` - A `for` loop keeps initialization and increment close to the condition, which is concise when the iteration count is known. - A `while` loop often reads more naturally when repetition ends because of an external condition such as input success. - The two forms are functionally equivalent and can be rewritten into each other. ## Exercise 1.15: common compiler diagnostics The exercise demonstrates three broad categories: 1. syntax errors; 2. type errors; 3. declaration errors. ## Exercise 1.16: sum an unknown number of values Stream extraction itself can be the loop condition. Input stops on end-of-file or invalid data. ```cpp #include int main() { int sum = 0, value = 0; while (std::cin >> value) { sum += value; } std::cout << "The sum is " << sum << std::endl; } ``` ## Exercises 1.17 and 1.18: count consecutive values ```cpp #include int main() { int current = 0, value = 0; if (std::cin >> current) { int count = 1; while (std::cin >> value) { if (value == current) { ++count; } else { std::cout << current << " occurs " << count << " times\n"; current = value; count = 1; } } std::cout << current << " occurs " << count << " times\n"; } } ``` If every input value is equal, one group is printed. If no adjacent values match, each group has count 1. ## Exercise 1.20: echo `Sales_item` values ```cpp #include #include "Sales_item.h" int main() { Sales_item book; while (std::cin >> book) { std::cout << book << std::endl; } } ``` ## Exercise 1.21: add two transactions ```cpp Sales_item first, second; std::cin >> first >> second; if (first.isbn() == second.isbn()) { std::cout << first + second << std::endl; return 0; } std::cerr << "The ISBN values must match" << std::endl; return -1; ``` ## Exercise 1.22: sum several matching transactions Read the first transaction into `total`, then add each following transaction while the ISBN remains the same. ```cpp Sales_item total; if (std::cin >> total) { Sales_item transaction; while (std::cin >> transaction) { if (total.isbn() == transaction.isbn()) { total += transaction; } else { std::cout << total << std::endl; total = transaction; } } std::cout << total << std::endl; } ``` ## Exercise 1.23: count transactions per ISBN The structure is the same as counting consecutive integers: keep the current ISBN and a count, print the group when the ISBN changes, then reset. ```cpp Sales_item current; if (std::cin >> current) { int count = 1; Sales_item transaction; while (std::cin >> transaction) { if (current.isbn() == transaction.isbn()) { ++count; } else { std::cout << current.isbn() << " occurs " << count << " times\n"; current = transaction; count = 1; } } std::cout << current.isbn() << " occurs " << count << " times\n"; } ``` ## Exercise 1.24: file redirection The counting program can read from a file and write to another file without changing its C++ stream code: ```bat type book_sales.txt 1.24.exe < book_sales.txt > 1.24.txt type 1.24.txt ``` Shell redirection connects the files to standard input and standard output. ## Exercise 1.25: the bookstore program The complete program groups consecutive transactions by ISBN, prints the accumulated item whenever the ISBN changes, and reports an error if no input is available. ```cpp #include #include "Sales_item.h" int main() { Sales_item total; if (std::cin >> total) { Sales_item transaction; while (std::cin >> transaction) { if (total.isbn() == transaction.isbn()) { total += transaction; } else { std::cout << total << std::endl; total = transaction; } } std::cout << total << std::endl; return 0; } std::cerr << "No data" << std::endl; return -1; } ``` The companion `Sales_item.h` file comes from the official *C++ Primer* exercise materials. At this stage it is enough to use its stream, ISBN, addition, and accumulation operations; the class implementation is explained in later chapters.2a:Tbc6,## A small Java collections project with playing cards After a fast introduction to classes and collections, I wanted to reinforce the ideas through code rather than memorization. This exercise models a deck for **Dou Dizhu**: build the cards, shuffle them, deal them, and display each hand. There are two requirements: - Each player's hand should already be sorted, just as a player normally arranges cards before planning a move. - Three cards must remain as the bottom cards for the eventual landlord. The program stores each card under a numeric key in a `HashMap`. Those numeric keys encode the card order. After shuffling the keys in an `ArrayList`, each hand is dealt into a `TreeSet`, which restores the desired sort order automatically. ```java package com.zaunekko.blog.project; import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; import java.util.TreeSet; public class PokerDemo { public static void main(String[] args) { // Map each sortable numeric key to its card. HashMap cards = new HashMap<>(); ArrayList deck = new ArrayList<>(); String[] suits = {"♦", "♣", "♥", "♠"}; String[] ranks = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"}; int index = 0; for (String rank : ranks) { for (String suit : suits) { cards.put(index, suit + rank); deck.add(index); index++; } } cards.put(index, "Small Joker"); deck.add(index++); cards.put(index, "Big Joker"); deck.add(index); Collections.shuffle(deck); TreeSet playerOne = new TreeSet<>(); TreeSet playerTwo = new TreeSet<>(); TreeSet playerThree = new TreeSet<>(); TreeSet bottomCards = new TreeSet<>(); for (int i = 0; i < deck.size(); i++) { int card = deck.get(i); if (i >= deck.size() - 3) { bottomCards.add(card); } else if (i % 3 == 0) { playerOne.add(card); } else if (i % 3 == 1) { playerTwo.add(card); } else { playerThree.add(card); } } printHand("TXX", playerOne, cards); printHand("FYB", playerTwo, cards); printHand("YY", playerThree, cards); printHand("Bottom cards", bottomCards, cards); } private static void printHand( String name, TreeSet hand, HashMap cards ) { System.out.print(name + ": "); for (Integer key : hand) { System.out.print(cards.get(key) + " "); } System.out.println(); } } ``` Because each hand is a `TreeSet`, iteration follows the numeric rank-and-suit order established when the deck was created. ![Program output](/media/download/image/blog02/01.png)2b:T14b0,# Java GUI Practice Although I was ill for a few days, I continued learning Java GUI programming and followed a small Snake project. The original course source is available from [KuangStudy](https://gitee.com/kuangstudy/openclass?_from=gitee_search). You can also download [my annotated Snake project](/media/download/blog/javaGui/snake.zip) and the broader [GUI exercise package](/media/download/blog/javaGui/gui.zip). The interesting part is not complex game logic; it is learning how Swing painting, layouts, keyboard events, and timers fit together. Configure the project character encoding correctly before generating JavaDoc so comments render properly. ## Application entry point The entry point creates a fixed-size `JFrame`, installs the game panel, and closes the application with the window. ```java package com.zaunekko.gui.game.snake; import javax.swing.*; public class StartGame { public static void main(String[] args) { JFrame frame = new JFrame(); frame.setBounds(50, 50, 915, 738); frame.setResizable(false); frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); frame.add(new GamePanel()); frame.setVisible(true); } } ``` ## Game state and timing `GamePanel` extends `JPanel` and implements both `KeyListener` and `ActionListener`. The panel keeps: - arrays for every snake segment's `x` and `y` position; - random food coordinates; - current length and score; - current direction; - flags for running and failed states; - one Swing `Timer` that advances the game every 500 ms. The timer must be initialized only once. Recreating it from the reset method would leave multiple timers running after a death and restart. ```java Timer timer = new Timer(500, this); public GamePanel() { init(); setFocusable(true); addKeyListener(this); timer.start(); } ``` `init()` resets the three starting segments, creates a random food position on the 25-pixel grid, resets the score, points the snake right, and clears the running/failure flags. ## Painting the game `paintComponent` clears the panel, paints the header and play area, draws food, chooses a head sprite for the current direction, and draws the remaining body segments. It also prints length and score and overlays either the start prompt or the failure prompt. ```java @Override protected void paintComponent(Graphics g) { super.paintComponent(g); setBackground(Color.WHITE); Data.header.paintIcon(this, g, 25, 0); g.fillRect(25, 75, 850, 600); Data.food.paintIcon(this, g, foodX, foodY); switch (direction) { case "R" -> Data.right.paintIcon(this, g, snakeX[0], snakeY[0]); case "L" -> Data.left.paintIcon(this, g, snakeX[0], snakeY[0]); case "U" -> Data.up.paintIcon(this, g, snakeX[0], snakeY[0]); case "D" -> Data.down.paintIcon(this, g, snakeX[0], snakeY[0]); } for (int i = 1; i < length; i++) { Data.body.paintIcon(this, g, snakeX[i], snakeY[i]); } } ``` ## Keyboard controls Space starts or pauses the game. After failure it resets the state. Arrow keys change direction only after the game has started, preventing the initial direction from changing while the start prompt is still visible. ```java @Override public void keyPressed(KeyEvent event) { int keyCode = event.getKeyCode(); if (keyCode == KeyEvent.VK_SPACE) { if (isFail) { init(); } else { isStart = !isStart; } repaint(); } else if (isStart && keyCode == KeyEvent.VK_UP) { direction = "U"; } else if (isStart && keyCode == KeyEvent.VK_DOWN) { direction = "D"; } else if (isStart && keyCode == KeyEvent.VK_LEFT) { direction = "L"; } else if (isStart && keyCode == KeyEvent.VK_RIGHT) { direction = "R"; } } ``` ## Advancing one game tick On each timer event: 1. If the head reaches food, increase the length and score and choose another food position. 2. Move each body segment to the previous segment's old position. 3. Move the head by one 25-pixel cell. 4. Wrap the head at each play-area boundary. 5. Compare the head with every body segment; a match ends the game. 6. Repaint the panel. ```java for (int i = length - 1; i > 0; i--) { snakeX[i] = snakeX[i - 1]; snakeY[i] = snakeY[i - 1]; } for (int i = 1; i < length; i++) { if (snakeX[0] == snakeX[i] && snakeY[0] == snakeY[i]) { isFail = true; break; } } repaint(); ``` ## Loading image resources The `Data` class resolves packaged PNG files relative to the class and exposes an `ImageIcon` for the header, four head directions, food, and body. ```java public static URL headerURL = Data.class.getResource("header.png"); public static URL upURL = Data.class.getResource("up.png"); public static URL downURL = Data.class.getResource("down.png"); public static URL leftURL = Data.class.getResource("left.png"); public static URL rightURL = Data.class.getResource("right.png"); public static URL foodURL = Data.class.getResource("food.png"); public static URL bodyURL = Data.class.getResource("body.png"); ``` Together these three classes demonstrate the basic Swing game loop: input changes state, a timer advances state, and `paintComponent` renders that state.2c:Tee4,> **Historical note:** This guide records a Visual Studio 2019 and MSVC 14.28/14.29 setup from May 2021. Paths and EasyX installation behavior can differ in current versions, so compare them with the latest official documentation. # VS Code, MSVC, and EasyX EasyX did not support the MinGW toolchain used by many VS Code C++ setups, so the solution was to launch VS Code inside an initialized MSVC environment and link the EasyX libraries explicitly. ## 1. Configure the MSVC build environment Microsoft's [official VS Code MSVC guide](https://code.visualstudio.com/docs/cpp/config-msvc) is the primary reference. ### Install Visual Studio C++ desktop development In Visual Studio Installer, select **Desktop development with C++**. This installs the MSVC compiler and Windows development tools. ![Visual Studio workload](/media/download/image/vscode-msvc/easyx-workload.png) ### Launch VS Code from a Developer Command Prompt Open **Developer Command Prompt for Visual Studio** and confirm that `cl.exe` is available: ```bat cl.exe ``` Then open the target folder from that same prompt: ```bat code D:\testEasyx\demo ``` Launching VS Code this way passes the MSVC environment variables to its integrated tasks. ### Compile a first MSVC program Create `easyxdemo.cpp`: ```cpp #include #include #include using namespace std; int main() { vector message { "Hello", "C++", "World", "from", "VS Code", "and the C++ extension!" }; for (const string &word : message) { cout << word << ' '; } cout << endl; } ``` Press `Ctrl+F5`, choose the Windows C++ environment, and then select `cl.exe`. VS Code creates `.vscode/tasks.json`; this file becomes important when EasyX is linked later. ## 2. Install EasyX Download EasyX from the [official site](https://easyx.cn/) and install it for Visual Studio. In the original Visual Studio 2019 layout, EasyX placed files under directories such as: ```text VC\Auxiliary\VS\lib\x64 VC\Auxiliary\VS\lib\x86 VC\Auxiliary\VS\include ``` The working configuration copied: - `EasyXa.lib` and `EasyXw.lib` into the matching MSVC `lib\x64` and `lib\x86` directories; - `easyx.h` and `graphics.h` into the active MSVC `include` directory. For example, the active compiler directory was similar to: ```text VC\Tools\MSVC\14.28.29910\ ``` Use the actual version directory installed on your machine rather than copying this historical version literally. ## 3. Link EasyX from VS Code Test that the header resolves with a small EasyX program, such as a graphical clock using `graphics.h`, `initgraph`, `GetLocalTime`, and line drawing. Header completion alone is not enough; the linker still needs the Windows libraries. Change the generated task type from `cppbuild` to `shell` and add the required `.lib` arguments: ```jsonc { "tasks": [ { "type": "shell", "label": "C/C++: cl.exe build active file", "command": "cl.exe", "args": [ "/Zi", "/EHsc", "kernel32.lib", "gdi32.lib", "winspool.lib", "comdlg32.lib", "advapi32.lib", "shell32.lib", "ole32.lib", "oleaut32.lib", "uuid.lib", "odbc32.lib", "odbccp32.lib", "user32.lib", "/nologo", "/Fe:", "${fileDirname}\\${fileBasenameNoExtension}.exe", "${file}" ], "options": { "cwd": "${fileDirname}" }, "problemMatcher": ["$msCompile"], "group": { "kind": "build", "isDefault": true } } ], "version": "2.0.0" } ``` Run again with `Ctrl+F5`. If compilation succeeds but linking fails, verify that the current `cl.exe` architecture, EasyX library architecture, and copied library directory all match.2d:Tde3,After working through the material up to arrays in one day, I used a few small programs to consolidate the basics. ## Printing a triangle This example uses nested loops to print a centered triangle. The first commented implementation is a simpler shortcut; the active version prints both halves of each row. ```java public class Triangle { public void triangle() { /* for (int i = 0; i < 9; i++) { for (int j = 9; j > i; j--) { System.out.print(" "); } for (int j = 0; j < i; j++) { System.out.print("* "); } System.out.println(); } */ for (int i = 0; i < 9; i++) { for (int j = 9; j > i; j--) { System.out.print(" "); } for (int j = 0; j < i; j++) { System.out.print("* "); } for (int j = i - 1; j > 0; j--) { System.out.print("* "); } System.out.println(); } } } ``` ## Printing the 9×9 multiplication table The inner loop runs only as far as the current row, producing the familiar triangular table. ```java public class Multiplication { public void multiplication() { for (int i = 1; i <= 9; i++) { for (int j = 1; j <= i; j++) { System.out.print(i + "*" + j + "=" + i * j + "\t"); } System.out.println(); } } } ``` ## Converting a normal array to a sparse array The first row records the original row count, column count, and number of non-zero values. Each remaining row stores one non-zero cell as `row`, `column`, and `value`. ```java public class SparseArray { public int[][] sparseArray(int[][] source) { int count = 0; for (int i = 0; i < source.length; i++) { for (int j = 0; j < source[i].length; j++) { if (source[i][j] != 0) { count++; } } } int[][] sparse = new int[count + 1][3]; sparse[0][0] = source.length; sparse[0][1] = source[0].length; sparse[0][2] = count; count = 0; for (int i = 0; i < source.length; i++) { for (int j = 0; j < source[i].length; j++) { if (source[i][j] != 0) { count++; sparse[count][0] = i; sparse[count][1] = j; sparse[count][2] = source[i][j]; } } } return sparse; } } ``` ## Restoring the original array Allocate an array using the dimensions stored in the first sparse row, then place each recorded value back at its saved coordinates. ```java public class RestoreArrays { public int[][] restoreArrays(int[][] sparse) { int[][] restored = new int[sparse[0][0]][sparse[0][1]]; for (int i = 1; i < sparse.length; i++) { restored[sparse[i][0]][sparse[i][1]] = sparse[i][2]; } return restored; } } ``` ## Printing a two-dimensional array ```java public class OutArrays { public void outArrays(int[][] values) { for (int i = 0; i < values.length; i++) { for (int j = 0; j < values[i].length; j++) { System.out.print(values[i][j] + "\t"); } System.out.println(); } } } ``` The resulting conversion and restoration can be checked visually: ![Sparse-array output](/media/download/image/javaDemo1.png)2e:Tf71,> **Historical note:** This article records a CentOS 7/8 setup from May 2021. Several repositories and package versions are now obsolete. Treat the commands as an archived learning reference, verify current vendor documentation, and use strong unique credentials on any real server. - Linux used in the original setup: **CentOS 8.2** - Package manager: **yum / dnf** ## Installing Apache The Apache package is named `httpd` on CentOS 7 and 8: ```bash yum install httpd systemctl start httpd ``` Confirm the installation by opening the server's public address in a browser. If the Apache page does not appear, check whether another service already occupies port 80. Apache configuration lives under `/etc/httpd`, including `conf/httpd.conf`. The default document root is: ```text /var/www/html ``` Upload the site's files there, for example with WinSCP. Apache serves `index.html` as the default page. ## Installing MySQL on CentOS 8 Install the repository package, update package metadata, and install the server: ```bash rpm -ivh mysql-community-release-el8-1.noarch.rpm yum update yum install mysql-server systemctl start mysqld.service ``` Log in with: ```bash mysql -u root -p ``` The original article used this SQL only as a simple example: ```sql ALTER USER 'root'@'localhost' IDENTIFIED BY 'replace-with-a-strong-password'; ``` During secure installation, MySQL asks whether to: - remove anonymous users; - disallow remote root login; - remove the test database and access to it; - reload privilege tables. For a production system, removing anonymous users and the test database, reloading privileges, and keeping remote root login disabled are the safer defaults. Create a separate least-privileged user for remote application access. ## Installing MySQL on CentOS 7 The archived CentOS 7 sequence was: ```bash rpm -Uvh https://repo.mysql.com/mysql57-community-release-el7-11.noarch.rpm yum --enablerepo=mysql80-community install mysql-community-server systemctl start mysqld.service ``` CentOS 7 installations commonly generated a temporary password. Retrieve it with: ```bash grep "A temporary password" /var/log/mysqld.log ``` Then run: ```bash mysql_secure_installation mysql -u root -p ``` ## Remote database connections The original setup checked connectivity with a desktop MySQL client. A successful connection confirms that the server, user grants, firewall, and cloud security-group rules line up. Do not expose the MySQL port broadly to the internet. Restrict access to known addresses, prefer a VPN or SSH tunnel, and never enable remote root login merely for convenience. ## Installing PHP on CentOS 8 The 2021 setup added EPEL and Remi repositories: ```bash rpm -Uvh https://dl.fedoraproject.org/pub/epel/epel-release-latest-8.noarch.rpm rpm -Uvh http://rpms.remirepo.net/enterprise/remi-release-8.rpm dnf -y install dnf-utils yum search php74\* yum install php74-php ``` The original service commands were: ```bash service php-fpm start service php-fpm stop service php-fpm restart ps -A | grep -i php ``` To test PHP integration, create `/var/www/html/index.php`: ```php ``` Open the server address and confirm that PHP renders the information page. Remove this diagnostic file afterward because it exposes environment details. ## Installing PHP on CentOS 7 The archived CentOS 7 sequence used Webtatic packages: ```bash rpm -Uvh https://mirror.webtatic.com/yum/el7/epel-release.rpm rpm -Uvh https://mirror.webtatic.com/yum/el7/webtatic-release.rpm yum list php\* yum install php72w-fpm php72w-mysql php72w-mysqli php72w php72w-opcache php72w-gd php72w-intl php72w-mbstring php72w-exif php72w-mcrypt php72w-openssl systemctl restart httpd ``` At that point the original learning environment had Apache, MySQL, and PHP connected. For a current deployment, replace these end-of-life distributions and packages with supported releases before following an equivalent setup.2f:T5c1,# Learning Markdown ## Headings Create a first-level heading with `#` followed by a space and the heading text: ```markdown # First-level heading ## Second-level heading ### Third-level heading ``` Continue adding `#` characters for deeper heading levels. ## Text emphasis ```markdown *Hello, World!* **Hello, World!** ***Hello, World!*** ~~Hello, World!~~ ``` The marker characters must touch the text; the spaces in explanatory examples should be removed. ## Block quotes Prefix the line with `>` and a space: > This is a quotation. ## Horizontal rules Three hyphens create a horizontal rule: ```markdown --- ``` ## Images ```markdown ![Screenshot](/media/markdown.jpg) ``` The text inside square brackets is the image description. The parentheses contain a local file path or a web URL. ## Links ```markdown [Visit my blog](https://www.zaunekko.com/) ``` ## Lists Ordered and unordered lists look like this: ```markdown 1. First 2. Second - Item A - Item B ``` ## Tables ```markdown | Name | Gender | Birthday | | ----- | ------ | -------- | | Zhang | Male | 2000.0.0 | ``` When editing the source, remove unnecessary spaces if your Markdown editor does not render the table as expected. ## Code blocks Use three backticks and optionally name the language: ```java public ``` The language name, such as `java` or `cpp`, enables syntax highlighting.1b:["$","$L1c",null,{"site":{"name":"ZaunEkko's Blog","description":"Welcome to ZaunEkko's personal website. Time is not about how much you have, but how you use it~~||欢迎来到ZaunEkko的个人网站,时间不在于你拥有多少,而在于你怎样使用~~","url":"https://blog.zaunekko.com","announcement":"欢迎来到 ZaunEkko's Blog，站点内容仍在持续整理中。","announcementEnabled":true,"icp":"辽ICP备2021005136号","rssTitle":"","defaultDescriptionZh":"","defaultDescriptionEn":"","trustedDomains":["zaunekko.com"],"stats":{"articles":16,"publicArticleComments":10,"publicGuestbookMessages":15,"currentArticleViews":203,"links":4,"todayVisitors":9,"visitorDays":693,"onlineVisitors":0},"musicPlayer":{"enabled":true,"playlistUrl":"https://music.163.com/#/playlist?id=18093481709","autoplay":true,"random":true,"showLyrics":true,"autoShowLyrics":true},"notifications":{"enabled":true,"welcomeEnabled":true,"welcomeMessageZh":"欢迎回来，慢慢看看今天想读的内容。","welcomeMessageEn":"Welcome back. Take your time and see what catches your eye.","showVisitorContext":true,"durationSeconds":6},"rankingCarousel":{"enabled":true,"intervalSeconds":6},"socialLinks":[{"platform":"github","label":"GitHub","url":"https://github.com/ZaunEkko"},{"platform":"bilibili","label":"Bilibili","url":"https://space.bilibili.com/46849942"},{"platform":"psn","label":"PSN","url":"https://psnprofiles.com/ZaunEkko_777"},{"platform":"steam","label":"Steam","url":"https://steamcommunity.com/id/zaunekko/"}],"articleCopyAttributionEnabled":true,"articleCopyAttributionTemplateZh":"作者：{author}\n文章标题：{title}\n原文链接：{url}","articleCopyAttributionTemplateEn":"Author: {author}\nArticle title: {title}\nOriginal URL: {url}","articleCopyAttributionPlacement":"MIDDLE"},"children":["$","$L1d",null,{"children":["$","$L1e",null,{"settings":"$1b:props:site:notifications","children":["$","$L1f",null,{"initialOnlineVisitors":0,"children":["$","$L20",null,{"settings":"$1b:props:site:musicPlayer","children":["$","$L21",null,{"children":["$","$L22",null,{"posts":[{"legacyCid":27,"slug":"network-engineering-lab-notes","title":"Network Engineering Lab Notes","category":"旧站","categorySlug":"old-site","publishedAt":"2021-06-29T07:03:00Z","modifiedAt":"2021-07-05T09:27:11Z","summary":"A five-day Red Hat lab log covering local YUM repositories, DHCP, relay routing, DNS, Apache, and FTP services.","tags":["云服务器配置"],"tagReferences":[{"slug":"cloud-server","name":"云服务器配置"}],"views":8498,"source":"Cabin import","allowComment":true,"pinned":false,"visibility":"PUBLIC","minimumAccessLevel":0,"minimumLevel":-1,"publishedLabel":"Jun 29, 2021","contentLanguage":"en","translationAvailable":true,"bodyMarkdown":"$23"},{"legacyCid":26,"slug":"posting-break","title":"A Short Posting Break","category":"旧站","categorySlug":"old-site","publishedAt":"2021-06-19T13:57:10Z","modifiedAt":"2021-06-19T13:57:10Z","summary":"I need to review Microcomputer Principles tomorrow, so I will make up for the missed post with two updates next week.","tags":["blog"],"tagReferences":[{"slug":"blog","name":"blog"}],"views":6911,"source":"Cabin import","allowComment":true,"pinned":false,"visibility":"PUBLIC","minimumAccessLevel":0,"minimumLevel":-1,"publishedLabel":"Jun 19, 2021","contentLanguage":"en","translationAvailable":true,"bodyMarkdown":"I need to review Microcomputer Principles tomorrow, so I will pause the blog for a moment and make up for it with two posts next week."},{"legacyCid":25,"slug":"shortest-path-and-bfs-notes","title":"Shortest Paths with BFS: 408 Reasoning and Implementation","category":"旧站","categorySlug":"old-site","publishedAt":"2021-06-14T01:56:17Z","modifiedAt":"2021-06-14T01:56:17Z","summary":"A step-by-step single-source shortest-path walkthrough for an unweighted graph using BFS, distance, predecessor, visited, and queue state.","tags":["数据结构"],"tagReferences":[{"slug":"data-structures","name":"数据结构"}],"views":7386,"source":"Cabin import","allowComment":true,"pinned":false,"visibility":"PUBLIC","minimumAccessLevel":0,"minimumLevel":-1,"publishedLabel":"Jun 14, 2021","contentLanguage":"en","translationAvailable":true,"bodyMarkdown":"$24"},{"legacyCid":24,"slug":"rsa-encryption-exam-notes","title":"RSA for Exams: Solving for the Private Exponent","category":"旧站","categorySlug":"old-site","publishedAt":"2021-06-04T08:33:00Z","modifiedAt":"2021-06-04T08:40:53Z","summary":"An exam-focused RSA walkthrough that factors n, computes Euler's totient, and uses the extended Euclidean algorithm to find d.","tags":["考试"],"tagReferences":[{"slug":"exams","name":"考试"}],"views":17042,"source":"Cabin import","allowComment":true,"pinned":false,"visibility":"PUBLIC","minimumAccessLevel":0,"minimumLevel":-1,"publishedLabel":"Jun 04, 2021","contentLanguage":"en","translationAvailable":true,"bodyMarkdown":"$25"},{"legacyCid":14,"slug":"prim-kruskal-minimum-spanning-tree","title":"Minimum Spanning Trees: Prim and Kruskal for the 408 Exam","category":"旧站","categorySlug":"old-site","publishedAt":"2021-05-30T09:36:00Z","modifiedAt":"2021-06-02T07:27:53Z","summary":"A visual explanation of minimum spanning trees, Prim's vertex-growing method, and Kruskal's edge-sorting method with disjoint sets.","tags":["数据结构"],"tagReferences":[{"slug":"data-structures","name":"数据结构"}],"views":11664,"source":"Cabin import","allowComment":true,"pinned":false,"visibility":"PUBLIC","minimumAccessLevel":0,"minimumLevel":-1,"publishedLabel":"May 30, 2021","contentLanguage":"en","translationAvailable":true,"bodyMarkdown":"$26"},{"legacyCid":13,"slug":"kmp-next-nextval-explained","title":"KMP Explained: Computing next and nextval Arrays","category":"旧站","categorySlug":"old-site","publishedAt":"2021-05-23T12:43:00Z","modifiedAt":"2021-06-02T06:42:33Z","summary":"A 408-oriented explanation of KMP string matching, the one-based next-array convention, and the nextval optimization that skips redundant comparisons.","tags":["数据结构"],"tagReferences":[{"slug":"data-structures","name":"数据结构"}],"views":14942,"source":"Cabin import","allowComment":true,"pinned":false,"visibility":"PUBLIC","minimumAccessLevel":0,"minimumLevel":-1,"publishedLabel":"May 23, 2021","contentLanguage":"en","translationAvailable":true,"bodyMarkdown":"$27"},{"legacyCid":12,"slug":"personal-blog-syndication","title":"Syndicating My Personal Blog","category":"旧站","categorySlug":"old-site","publishedAt":"2021-05-18T14:25:00Z","modifiedAt":"2022-04-08T05:22:28Z","summary":"My C++ Primer exercises, daily Java study notes, and algorithm posts are also mirrored to CNBlogs and CSDN.","tags":["个人博客"],"tagReferences":[{"slug":"personal-blog","name":"个人博客"}],"views":105853,"source":"Cabin import","allowComment":true,"pinned":false,"visibility":"PUBLIC","minimumAccessLevel":0,"minimumLevel":-1,"publishedLabel":"May 18, 2021","contentLanguage":"en","translationAvailable":true,"bodyMarkdown":"I also publish and synchronize selected notes through [CNBlogs](https://www.cnblogs.com/zaunekko/) and [CSDN](https://blog.csdn.net/YY_hide_on_bush).\n\nThe material includes after-class exercises from *C++ Primer*, daily Java study notes, algorithms, and anything else I happen to be learning. Updates follow my own pace."},{"legacyCid":11,"slug":"cpp-primer-chapter-two-exercises","title":"C++ Primer, Chapter 2: Answers for the First Half","category":"旧站","categorySlug":"old-site","publishedAt":"2021-05-18T14:22:00Z","modifiedAt":"2021-06-02T06:42:44Z","summary":"Notes and sample answers for early Chapter 2 exercises on primitive types, literals, initialization, declarations, references, pointers, and scope.","tags":["c"],"tagReferences":[{"slug":"c","name":"c"}],"views":7110,"source":"Cabin import","allowComment":true,"pinned":false,"visibility":"PUBLIC","minimumAccessLevel":0,"minimumLevel":-1,"publishedLabel":"May 18, 2021","contentLanguage":"en","translationAvailable":true,"bodyMarkdown":"$28"},{"legacyCid":10,"slug":"cpp-primer-chapter-one-exercises","title":"C++ Primer, Chapter 1: Exercise Answers","category":"旧站","categorySlug":"old-site","publishedAt":"2021-05-17T23:41:00Z","modifiedAt":"2021-06-02T06:42:48Z","summary":"Working answers for Chapter 1 exercises covering compilation, streams, loops, comments, input validation, and the Sales_item transaction examples.","tags":["c"],"tagReferences":[{"slug":"c","name":"c"}],"views":8100,"source":"Cabin import","allowComment":true,"pinned":false,"visibility":"PUBLIC","minimumAccessLevel":0,"minimumLevel":-1,"publishedLabel":"May 18, 2021","contentLanguage":"en","translationAvailable":true,"bodyMarkdown":"$29"},{"legacyCid":9,"slug":"java-collections-card-game-practice","title":"Java Collections Practice: Dealing a Dou Dizhu Deck","category":"旧站","categorySlug":"old-site","publishedAt":"2021-05-16T13:03:00Z","modifiedAt":"2021-06-02T06:42:51Z","summary":"A small Java collections exercise that builds, shuffles, sorts, and deals a 54-card Dou Dizhu deck to three players with three bottom cards.","tags":["Java"],"tagReferences":[{"slug":"java","name":"Java"}],"views":9686,"source":"Cabin import","allowComment":true,"pinned":false,"visibility":"PUBLIC","minimumAccessLevel":0,"minimumLevel":-1,"publishedLabel":"May 16, 2021","contentLanguage":"en","translationAvailable":true,"bodyMarkdown":"$2a"},{"legacyCid":8,"slug":"java-gui-practice","title":"Java GUI Practice: Building a Snake Game with Swing","category":"旧站","categorySlug":"old-site","publishedAt":"2021-05-15T22:54:00Z","modifiedAt":"2021-06-02T06:42:54Z","summary":"A Swing practice project covering JFrame setup, custom JPanel painting, keyboard input, timers, sprite resources, movement, food, scoring, and collision detection.","tags":["Java"],"tagReferences":[{"slug":"java","name":"Java"}],"views":7715,"source":"Cabin import","allowComment":true,"pinned":false,"visibility":"PUBLIC","minimumAccessLevel":0,"minimumLevel":-1,"publishedLabel":"May 16, 2021","contentLanguage":"en","translationAvailable":true,"bodyMarkdown":"$2b"},{"legacyCid":7,"slug":"vscode-msvc-easyx-setup","title":"Configuring VS Code with MSVC and EasyX (2021)","category":"旧站","categorySlug":"old-site","publishedAt":"2021-05-13T07:41:00Z","modifiedAt":"2021-06-02T06:42:57Z","summary":"A historical setup guide for compiling C++ with MSVC in VS Code and linking the EasyX graphics library through tasks.json.","tags":["环境配置"],"tagReferences":[{"slug":"environment","name":"环境配置"}],"views":15897,"source":"Cabin import","allowComment":true,"pinned":false,"visibility":"PUBLIC","minimumAccessLevel":0,"minimumLevel":-1,"publishedLabel":"May 13, 2021","contentLanguage":"en","translationAvailable":true,"bodyMarkdown":"$2c"},{"legacyCid":6,"slug":"sick-day","title":"Taking Time Off to Recover","category":"旧站","categorySlug":"old-site","publishedAt":"2021-05-11T14:23:00Z","modifiedAt":"2021-06-02T06:43:00Z","summary":"I am pausing updates while I recover, then I will return with recent exercises, C++ Primer practice, and Java GUI notes.","tags":[],"tagReferences":[],"views":6027,"source":"Cabin import","allowComment":true,"pinned":false,"visibility":"PUBLIC","minimumAccessLevel":0,"minimumLevel":-1,"publishedLabel":"May 11, 2021","contentLanguage":"en","translationAvailable":true,"bodyMarkdown":"I am going to pause updates for a while and focus on recovering. Once I am better, I will publish the recent exercises I have been working through, including the C++ practice set from *C++ Primer* and more Java GUI material."},{"legacyCid":5,"slug":"java-basics-notes","title":"Java Fundamentals: Small Practice Programs","category":"旧站","categorySlug":"old-site","publishedAt":"2021-05-10T14:38:00Z","modifiedAt":"2021-06-02T06:43:03Z","summary":"Several compact Java exercises covering nested loops, a multiplication table, sparse-array conversion, restoration, and two-dimensional array output.","tags":["Java"],"tagReferences":[{"slug":"java","name":"Java"}],"views":6126,"source":"Cabin import","allowComment":true,"pinned":false,"visibility":"PUBLIC","minimumAccessLevel":0,"minimumLevel":-1,"publishedLabel":"May 10, 2021","contentLanguage":"en","translationAvailable":true,"bodyMarkdown":"$2d"},{"legacyCid":4,"slug":"apache-mysql-php-server-setup","title":"Installing Apache, MySQL, and PHP on a CentOS Cloud Server","category":"旧站","categorySlug":"old-site","publishedAt":"2021-05-09T05:56:00Z","modifiedAt":"2021-08-04T02:45:17Z","summary":"A historical 2021 walkthrough for building an Apache, MySQL, and PHP environment on CentOS 7 or 8 with yum-based packages.","tags":["云服务器配置"],"tagReferences":[{"slug":"cloud-server","name":"云服务器配置"}],"views":9924,"source":"Cabin import","allowComment":true,"pinned":false,"visibility":"PUBLIC","minimumAccessLevel":0,"minimumLevel":-1,"publishedLabel":"May 09, 2021","contentLanguage":"en","translationAvailable":true,"bodyMarkdown":"$2e"},{"legacyCid":3,"slug":"markdown-learning-notes","title":"Learning Markdown","category":"旧站","categorySlug":"old-site","publishedAt":"2021-05-07T14:32:00Z","modifiedAt":"2021-06-02T06:43:09Z","summary":"A compact introduction to Markdown headings, emphasis, quotations, separators, images, links, lists, tables, and fenced code blocks.","tags":["个人博客"],"tagReferences":[{"slug":"personal-blog","name":"个人博客"}],"views":6480,"source":"Cabin import","allowComment":true,"pinned":false,"visibility":"PUBLIC","minimumAccessLevel":0,"minimumLevel":-1,"publishedLabel":"May 07, 2021","contentLanguage":"en","translationAvailable":true,"bodyMarkdown":"$2f"}],"categories":[{"slug":"development","name":"开发","code":"development","description":"","order":10,"parentSlug":"technology","showInNav":true,"archived":false,"postCount":0,"source":"BLOG","version":0},{"slug":"technology","name":"技术","code":"technology","description":"","order":10,"showInNav":true,"archived":false,"postCount":0,"source":"BLOG","version":0},{"slug":"operations","name":"运维","code":"operations","description":"","order":20,"parentSlug":"technology","showInNav":true,"archived":false,"postCount":0,"source":"BLOG","version":0},{"slug":"essays","name":"随笔","code":"essays","description":"","order":20,"showInNav":true,"archived":false,"postCount":0,"source":"BLOG","version":0},{"slug":"old-site","name":"旧站","code":"old-site","description":"","order":30,"showInNav":true,"archived":false,"postCount":16,"source":"BLOG","version":0}],"site":"$1b:props:site","children":["$L30","$L31","$L32","$L33"]}]}]}]}]}]}]}] 8:null d:[["$","title","0",{"children":"Blog — ZaunEkko"}],["$","meta","1",{"name":"description","content":"Articles, project notes, and preserved writing from ZaunEkko Cabin."}],["$","meta","2",{"name":"application-name","content":"ZaunEkko's Blog"}],["$","meta","3",{"name":"author","content":"ZaunEkko"}],["$","link","4",{"rel":"canonical","href":"https://blog.zaunekko.com/en/blog"}],["$","link","5",{"rel":"alternate","hrefLang":"zh-CN","href":"https://blog.zaunekko.com/blog"}],["$","link","6",{"rel":"alternate","hrefLang":"en","href":"https://blog.zaunekko.com/en/blog"}],["$","link","7",{"rel":"alternate","hrefLang":"x-default","href":"https://blog.zaunekko.com/blog"}],["$","meta","8",{"property":"og:title","content":"Blog"}],["$","meta","9",{"property":"og:description","content":"Articles, project notes, and preserved writing from ZaunEkko Cabin."}],["$","meta","10",{"property":"og:url","content":"https://blog.zaunekko.com/en/blog"}],["$","meta","11",{"property":"og:site_name","content":"ZaunEkko's Blog"}],["$","meta","12",{"property":"og:locale","content":"en_US"}],["$","meta","13",{"property":"og:image","content":"https://blog.zaunekko.com/opengraph-image"}],["$","meta","14",{"property":"og:image:width","content":"1200"}],["$","meta","15",{"property":"og:image:height","content":"630"}],["$","meta","16",{"property":"og:image:alt","content":"ZaunEkko's Blog"}],["$","meta","17",{"property":"og:locale:alternate","content":"zh_CN"}],["$","meta","18",{"property":"og:type","content":"website"}],["$","meta","19",{"name":"twitter:card","content":"summary_large_image"}],["$","meta","20",{"name":"twitter:title","content":"Blog"}],["$","meta","21",{"name":"twitter:description","content":"Articles, project notes, and preserved writing from ZaunEkko Cabin."}],["$","meta","22",{"name":"twitter:image","content":"https://blog.zaunekko.com/opengraph-image"}],["$","meta","23",{"name":"twitter:image:alt","content":"ZaunEkko's Blog"}],["$","meta","24",{"name":"twitter:image:width","content":"1200"}],["$","meta","25",{"name":"twitter:image:height","content":"630"}],["$","link","26",{"rel":"icon","href":"/favicon.ico?favicon.3wgiqdmzsibr9.ico","sizes":"256x256","type":"image/x-icon"}],["$","link","27",{"rel":"icon","href":"/brand/zaunekko-avatar.png"}],["$","link","28",{"rel":"apple-touch-icon","href":"/brand/zaunekko-avatar.png"}],["$","$L34","29",{}]]