 从字符串中提取最后的 n 个字符

How can I get the last n characters from a string in R? Is there a function like SQL's RIGHT?
转载于:https://stackoverflow.com/questions/7963898/extractingthelastncharactersfromastringinr
I'm not aware of anything in base R, but it's straightforward to make a function to do this using substr
and nchar
:
x < "some text in a string"
substrRight < function(x, n){
substr(x, nchar(x)n+1, nchar(x))
}
substrRight(x, 6)
[1] "string"
substrRight(x, 8)
[1] "a string"
This is vectorised, as @mdsumner points out. Consider:
x < c("some text in a string", "I really need to learn how to count")
substrRight(x, 6)
[1] "string" " count"
If you don't mind using the stringr
package, str_sub
is handy because you can use negatives to count backward:
x < "some text in a string"
str_sub(x,6,1)
[1] "string"
Or, as Max points out in a comment to this answer,
str_sub(x, start= 6)
[1] "string"
 localhost I believe stringr had been remade using stringi as a backend, so should work with NAs etc. now.
 4 年多之前 回复
 ℡Wang Yan stringr doesn't work well with NA's value and all encoding. I strongly reccomend stringi package :)
 6 年多之前 回复
 必承其重  欲带皇冠 also, str_sub(x,start=n) gets n last characters.
 接近 9 年之前 回复
Use stri_sub
function from stringi
package.
To get substring from the end, use negative numbers.
Look below for the examples:
stri_sub("abcde",1,3)
[1] "abc"
stri_sub("abcde",1,1)
[1] "a"
stri_sub("abcde",3,1)
[1] "cde"
You can install this package from github: https://github.com/Rexamine/stringi
It is available on CRAN now, simply type
install.packages("stringi")
to install this package.
str = 'This is an example'
n = 7
result = substr(str,(nchar(str)+1)n,nchar(str))
print(result)
> [1] "example"
>
UPDATE: as noted by mdsumner, the original code is already vectorised because substr is. Should have been more careful.
And if you want a vectorised version (based on Andrie's code)
substrRight < function(x, n){
sapply(x, function(xx)
substr(xx, (nchar(xx)n+1), nchar(xx))
)
}
> substrRight(c("12345","ABCDE"),2)
12345 ABCDE
"45" "DE"
Note that I have changed (nchar(x)n)
to (nchar(x)n+1)
to get n
characters.
Another reasonably straightforward way is to use regular expressions and sub
:
sub('.*(?=.$)', '', string, perl=T)
So, "get rid of everything followed by one character". To grab more characters off the end, add however many dots in the lookahead assertion:
sub('.*(?=.{2}$)', '', string, perl=T)
where .{2}
means ..
, or "any two characters", so meaning "get rid of everything followed by two characters".
sub('.*(?=.{3}$)', '', string, perl=T)
for three characters, etc. You can set the number of characters to grab with a variable, but you'll have to paste
the variable value into the regular expression string:
n = 3
sub(paste('.+(?=.{', n, '})', sep=''), '', string, perl=T)
An alternative to substr
is to split the string into a list of single characters and process that:
N < 2
sapply(strsplit(x, ""), function(x, n) paste(tail(x, n), collapse = ""), N)
A simple base R solution using the substring()
function (who knew this function even existed?):
RIGHT = function(x,n){
substring(x,nchar(x)n+1)
}
This takes advantage of basically being substr()
underneath but has a default end value of 1,000,000.
Examples:
> RIGHT('Hello World!',2)
[1] "d!"
> RIGHT('Hello World!',8)
[1] "o World!"
I use substr
too, but in a different way. I want to extract the last 6 characters of "Give me your food." Here are the steps:
(1) Split the characters
splits < strsplit("Give me your food.", split = "")
(2) Extract the last 6 characters
tail(splits[[1]], n=6)
Output:
[1] " " "f" "o" "o" "d" "."
Each of the character can be accessed by splits[[1]][x]
, where x is 1 to 6.
someone before uses a similar solution to mine, but I find it easier to think as below:
> text<"some text in a string" # we want to have only the last word "string" with 6 letter
> n<5 #as the last character will be counted with nchar(), here we discount 1
> substr(x=text,start=nchar(text)n,stop=nchar(text))
This will bring the last characters as desired.
从字符串中提取最后的 n 个字符_course
20111101<div class="posttext" itemprop="text"> <p>How can I get the last n characters from a string in R? Is there a function like SQL's RIGHT?</p> </div> <p>转载于:https://stackoverflow.com/questions/7963898/extractingthelastncharactersfromastringinr</p>
判断是否是substring的一个问题，怎么利用C程序的语言的程序设计的代码去实现判断的_course
20190602Problem Description You hava a nonempty string which consists of lowercase English letters and may contain at most one '?'. Let's choose nonempty substring G from S (it can be G = S). A substring of a string is a continuous subsequence of the string. if G contains '?' then '?' can be deleted or replaced by one of lowercase english letters. After that if each letter occurs even number of times in G then G is a good substring. Find number of all good substrings. Input The input consists of an integer T, followed by T lines, each containing a nonempty string. The length of the string doesn't exceed 20000. [Technical Specification] 1 <= T <= 100 Output For each test case, print a single integer which is the number of good substrings of a given string. Sample Input 3 abc?ca aabbcc aaaaa Sample Output 7 6 6
Match 的计算_course
20191120Problem Description Given three strings, find the length of the longest string which is a substring of each of the three input strings. In this problem "substring" has the usual definition. A string X is a substring of a string Y if and only if string X can be created from string Y by deleting zero or more consecutive characters from the start of string Y, and deleting zero or more consecutive characters from the end of string Y. Input The first line of the input is the number of test cases (less than 3000). For each case there is three lines each contains a string. The string only contains 'a''z' and up to 1000 characters long. There is a blank line before each test case. Output For each test case output the answer on a line. Sample Input 3 aebcd ebcaddwerd fdsalebcser sdafawerrsdfsdfwe erfasdfafsd egreetsdwere aaaaa aaaaa aaaaa Sample Output 3 2 5
Kth类型的问题，计算字符串的配对，用C语言怎么实现？_course
20181227Problem Description One day, Lord gave you a string S. Let’s define the pair(x, p) represent the substring S[px+1,px+2,…,p]. The index of S counts from 0. Then, Lord will tell you some information about this string. There are three types of the information: 1. Lord will give you a pair(x, p) and then says I think the substring is good.(Only consider the substring (x, p) is good, not include the substring of (x, p)) 2. Lord will give you a pair(x, p) and then says I think the substring is not good. 3. Lord will give you a pair(x, p) and a integer K, then you should answer the length of the Kth good string. The Kth good string means that if you list all the distinct good strings which contain pair(x, p) as suffix, then sort them by their length in ascending order, the Kth string is Kth good string. Now, can you hold the information from Lord? Yon can consider all the substring is not good initially. Input First line is a integer T, means the number of test case, T<=10. In every test case, there is a string S in the first line, composed by lowercase letters, S<=100000. An integer q in the second line (q<=200000), and q lines follow. Every line has an integer t, means the type of the message. If t equals 3, then three integers x, p, K follow, else two integers x, p follow. The pair (x, p) will always represent a substring of S. Output For each case, output “Case #k:” one line first, where k means the case number count from 1. For every message of type 3, print the answer one line. If there is no such Kth good string, print 1. Sample Input 1 aaaaa 4 2 1 0 1 3 2 3 2 4 1 3 4 3 1 Sample Output Case #1: 3 1
KMP序列匹配算法的一个实现原理问题，采用C语言方式的编程计算_course
20190314Problem Description When the problem to match S string in T string is mentioned, people always put KMP, AhoCorasick and Suffixarray forward. But Mr Liu tells Canoe that there is an algorithm called Burrows–Wheeler Transform(BWT) which is quite amazing and highefficiency to solve the problem. But how does BWT work to solve the matching SinT problem? Mr Liu tells Canoe the firstly three steps of it. Firstly, we append the ‘$’ to the end of T and for convenience, we still call the new string T. And then for every suffix of T string which starts from i, we append the prefix of T string which ends at (i – 1) to its end. Secondly, we sort these new strings by the dictionary order. And we call the matrix formed by these sorted strings Burrows Wheeler Matrix. Thirdly, we pick characters of the last column to get a new string. And we call the string of the last column BWT(T). You can get more information from the example below. Then Mr Liu tells Canoe that we only need to save the BWT(T) to solve the matching problem. But how and can it? Mr Liu smiles and says yes. We can find whether S strings like “aac” are substring of T string like “acaacg” or not only knowing the BWT(T)! What an amazing algorithm BWT is! But Canoe is puzzled by the tricky method of matching S strings in T string. Would you please help Canoe to find the method of it? Given BWT(T) and S string, can you help Canoe to figure out whether S string is a substring of string T or not? Input There are multiple test cases. First Line: the BWT(T) string (1 <= length(BWT(T)) <= 100086). Second Line: an integer n ( 1 <=n <= 10086) which is the number of S strings. Then n lines comes. There is a S string (n * length(S) will less than 2000000, and all characters of S are lowercase ) in every line. Output For every S, if S string is substring of T string, then put out “YES” in a line. If S string is not a substring of T string, then put out “NO” in a line. Sample Input gc$aaac 2 aac gc Sample Output YES NO
如何截取字符串最后几位?_course
20131017比如我想截取字符串最后6位,这个语句应该如何写?
Just a String 字符串的一个问题_course
20200127Problem Description A substring of a string is a successive part of the string. Given a string your task is to find out the Kth alphabet order substring of the original string. For example, the string "ABC" contains six substrings: "A" "AB" "ABC" "B" "BC" "C" (in alphabet order) and string "BBC" also contains six substrings: "B" "B" "BB" "BBC" "BC" "C" (in alphabet order) Input The input contains several test cases, the first line of input contains the number of test cases. For each test case, there is only one line contains the string S of length N, followed by a integer K. (1 <= K <= N*(N+1)/2, 1 <= N <= 100000, S contains only letters and digits) Output For each test cases, output the Kth alphabet order substring. Sample Input 2 ABC 2 BBC 3 Sample Output Case 1: AB Case 2: BB
Maximum repetition substring 字符串的问题_course
20191227Problem Description The repetition number of a string is defined as the maximum number R such that the string can be partitioned into R same consecutive substrings. For example, the repetition number of "ababab" is 3 and "ababa" is 1. Given a string containing lowercase letters, you are to find a substring of it with maximum repetition number. Input The input consists of multiple test cases. Each test case contains exactly one line, which gives a nonempty string consisting of lowercase letters. The length of the string will not be greater than 100,000. The last test case is followed by a line containing a '#'. Output For each test case, print a line containing the test case number( beginning with 1) followed by the substring of maximum repetition number. If there are multiple substrings of maximum repetition number, print the lexicographically smallest one. Sample Input ccabababc daabbccaa # Sample Output Case 1: ababab Case 2: aa
Cooccurrence Search _course
20170224A huge amount of information is being heaped on WWW. Albeit it is not wellorganized, users can browse WWW as an unbounded source of uptodate information, instead of consulting established but a little outofdate encyclopedia. However, you can further exploit WWW by learning more about keyword search algorithms. For example, if you want to get information on recent comparison between Windows and UNIX, you may expect to get relevant description out of a big bunch of Web texts, by extracting texts that contain both keywords "Windows" and "UNIX" close together. Here we have a simplified version of this cooccurrence keyword search problem, where the text and keywords are replaced by a string and key characters, respectively. A character string S of length n (1 <= n <= 1,000,000) and a set K of k distinct key characters a1, ..., ak (1 <= k <= 50) are given. Find every shortest substring of S that contains all of the key characters a1, ..., ak. Input The input is a text file which contains only printable characters (ASCII codes 21 to 7E in hexadecimal) and newlines. No white space such as space or tab appears in the input. The text is a sequence of the shortest string search problems described above. Each problem consists of character string Si and key character set Ki (i=1, 2, ..., p). Every Si and Ki is followed by an empty line. However, any single newline between successive lines in a string should be ignored; that is, newlines are not part of the string. For various technical reasons, every line consists of at most 72 characters. Each key character set is given in a single line. The input is terminated by consecutive empty lines; p is not given explicitly. Output All of p problems should be solved and their answers should be output in order. However, it is not requested to print all of the shortest substrings if more than one substring is found in a problem, since found substrings may be too much to check them all. Only the number of the substrings together with their representative is requested instead. That is, for each problem i, the number of the shortest substrings should be output followed by the first (or the leftmost) shortest substring si1, obeying the following format: the number of the shortest substrings for the ith problem empty line the first line of si1 the second line of si1 ... the last line of si1 empty line for the substring termination where each line of the shortest substring si1 except for the last line should consist of exactly 72 characters and the last line (or the single line if the substring is shorter than or equal to 72 characters, of course) should not exceed 72 characters. If there is no such substring for a problem, the output will be a 0 followed by an empty line; no more successive empty line should be output because there is no substring to be terminated. Sample Input Thefirstexampleistrivial. mfv AhugeamountofinformationisbeingheapedonWWW.Albeititisnot wellorganized,userscanbrowseWWWasanunboundedsourceof uptodateinformation,insteadofconsultingestablishedbutalittle outofdateencyclopedia.However,youcanfurtherexploitWWWby learningmoreaboutkeywordsearchalgorithms.Forexample,ifyou wanttogetinformationonrecentcomparisonbetweenWindowsandUNIX, youmayexpecttogetrelevantdescriptionoutofabigbunchofWeb texts,byextractingtextsthatcontainbothkeywords"Windows"and"UNIX" closetogether. bWn 3.1415926535897932384626433832795028841971693993751058209749445923078164 pi Wagner,Bach,Beethoven,Chopin,Brahms,Hindemith,Ives,Suk,Mozart,Stravinsky Weary ASCIIcharacterssuchas+,*,[,#,<,},_arenotexcludedinagivenstringas thisexampleillustratesbyitself.Youshouldnotforgetthem.Onemorefact youshouldnoticeisthatuppercaselettersandlowercaselettersare distinguishedinthisproblem.Don'tidentify"g"and"G",forexmaple. However,weareafraidthatthisexamplegivesyoutoomuchhint! ![GsC_l ETAONRISHDLFCMUGYPWBVKXJQZ ABCDEFGHIJKLMNOPQRSTUVWXYZ Sample Output 1 firstexampleistriv 7 nWWW.Alb 0 1 Wagner,Bach,Beethoven,Chopin,Brahms,Hindemith,Ives,Suk,Mozart,Stravinsky 1 CIIcharacterssuchas+,*,[,#,<,},_arenotexcludedinagivenstringasthisexampl eillustratesbyitself.Youshouldnotforgetthem.Onemorefactyoushouldnoticeis thatuppercaselettersandlowercaselettersaredistinguishedinthisproblem.Don 'tidentify"g"and"G",forexmaple.However,weareafraidthatthisexamplegivesyo utoomuchhint! 1 ETAONRISHDLFCMUGYPWBVKXJQZ
如何重复输出这里的数字的序列的，采用C程序的语言的设计的办法_course
20190411Problem Description Cloud gets a string which contains only lowercase letters from Miceren as a birthday gift. Since Cloud hates repeating, if a substring can be divided into several equal strings, she will be very disgusted. For example, "abcabcabc" is very disgusting for her, but "abca" is just ok. Now, Cloud wants to know how many nonempty substring would not disgust her. As you know, Miceren is not good at counting, can you help him? Input The first line contains a single integer T, indicating the number of test cases. Each test case contains only one line, containing the string. T is about 10. The length of string will not exceed 100100. Output For each test case, print the answer. Sample Input 1 abcabc Sample Output 20
BWT问题的求解的一个过程问题_course
20190825Problem Description When the problem to match S string in T string is mentioned, people always put KMP, AhoCorasick and Suffixarray forward. But Mr Liu tells Canoe that there is an algorithm called Burrows–Wheeler Transform(BWT) which is quite amazing and highefficiency to solve the problem. But how does BWT work to solve the matching SinT problem? Mr Liu tells Canoe the firstly three steps of it. Firstly, we append the ‘$’ to the end of T and for convenience, we still call the new string T. And then for every suffix of T string which starts from i, we append the prefix of T string which ends at (i – 1) to its end. Secondly, we sort these new strings by the dictionary order. And we call the matrix formed by these sorted strings Burrows Wheeler Matrix. Thirdly, we pick characters of the last column to get a new string. And we call the string of the last column BWT(T). You can get more information from the example below. Then Mr Liu tells Canoe that we only need to save the BWT(T) to solve the matching problem. But how and can it? Mr Liu smiles and says yes. We can find whether S strings like “aac” are substring of T string like “acaacg” or not only knowing the BWT(T)! What an amazing algorithm BWT is! But Canoe is puzzled by the tricky method of matching S strings in T string. Would you please help Canoe to find the method of it? Given BWT(T) and S string, can you help Canoe to figure out whether S string is a substring of string T or not? Input There are multiple test cases. First Line: the BWT(T) string (1 <= length(BWT(T)) <= 100086). Second Line: an integer n ( 1 <=n <= 10086) which is the number of S strings. Then n lines comes. There is a S string (n * length(S) will less than 2000000, and all characters of S are lowercase ) in every line. Output For every S, if S string is substring of T string, then put out “YES” in a line. If S string is not a substring of T string, then put out “NO” in a line. Sample Input gc$aaac 2 aac gc Sample Output YES NO
Just a String 字符串的问题_course
20200818Problem Description A substring of a string is a successive part of the string. Given a string your task is to find out the Kth alphabet order substring of the original string. For example, the string "ABC" contains six substrings: "A" "AB" "ABC" "B" "BC" "C" (in alphabet order) and string "BBC" also contains six substrings: "B" "B" "BB" "BBC" "BC" "C" (in alphabet order) Input The input contains several test cases, the first line of input contains the number of test cases. For each test case, there is only one line contains the string S of length N, followed by a integer K. (1 <= K <= N*(N+1)/2, 1 <= N <= 100000, S contains only letters and digits) Output For each test cases, output the Kth alphabet order substring. Sample Input 2 ABC 2 BBC 3 Sample Output Case 1: AB Case 2: BB
如何在字符串中找到倒数第二个字符？_course
20090615<div class="posttext" itemprop="text"> <p>如果可能，仅使用标准的PHP函数，例如substr（）、strrpos（）、strpos（）等。</p> </div>
编程的字母的问题，BWT_course
20190827Problem Description When the problem to match S string in T string is mentioned, people always put KMP, AhoCorasick and Suffixarray forward. But Mr Liu tells Canoe that there is an algorithm called Burrows–Wheeler Transform(BWT) which is quite amazing and highefficiency to solve the problem. But how does BWT work to solve the matching SinT problem? Mr Liu tells Canoe the firstly three steps of it. Firstly, we append the ‘$’ to the end of T and for convenience, we still call the new string T. And then for every suffix of T string which starts from i, we append the prefix of T string which ends at (i – 1) to its end. Secondly, we sort these new strings by the dictionary order. And we call the matrix formed by these sorted strings Burrows Wheeler Matrix. Thirdly, we pick characters of the last column to get a new string. And we call the string of the last column BWT(T). You can get more information from the example below. Then Mr Liu tells Canoe that we only need to save the BWT(T) to solve the matching problem. But how and can it? Mr Liu smiles and says yes. We can find whether S strings like “aac” are substring of T string like “acaacg” or not only knowing the BWT(T)! What an amazing algorithm BWT is! But Canoe is puzzled by the tricky method of matching S strings in T string. Would you please help Canoe to find the method of it? Given BWT(T) and S string, can you help Canoe to figure out whether S string is a substring of string T or not? Input There are multiple test cases. First Line: the BWT(T) string (1 <= length(BWT(T)) <= 100086). Second Line: an integer n ( 1 <=n <= 10086) which is the number of S strings. Then n lines comes. There is a S string (n * length(S) will less than 2000000, and all characters of S are lowercase ) in every line. Output For every S, if S string is substring of T string, then put out “YES” in a line. If S string is not a substring of T string, then put out “NO” in a line. Sample Input gc$aaac 2 aac gc Sample Output YES NO
The Number of Palindromes_course
20190823Problem Description Now, you are given a string S. We want to know how many distinct substring of S which is palindrome. Input The first line of the input contains a single integer T(T<=20), which indicates number of test cases. Each test case consists of a string S, whose length is less than 100000 and only contains lowercase letters. Output For every test case, you should output "Case #k:" first in a single line, where k indicates the case number and starts at 1. Then output the number of distinct substring of S which is palindrome. Sample Input 3 aaaa abab abcd Sample Output Case #1: 4 Case #2: 4 Case #3: 4
计算地K个字母表上的子字符串的顺序，怎么用C语言的程序的编写的代码来实现寻找这个字符串的_course
20190618Problem Description A substring of a string is a successive part of the string. Given a string your task is to find out the Kth alphabet order substring of the original string. For example, the string "ABC" contains six substrings: "A" "AB" "ABC" "B" "BC" "C" (in alphabet order) and string "BBC" also contains six substrings: "B" "B" "BB" "BBC" "BC" "C" (in alphabet order) Input The input contains several test cases, the first line of input contains the number of test cases. For each test case, there is only one line contains the string S of length N, followed by a integer K. (1 <= K <= N*(N+1)/2, 1 <= N <= 100000, S contains only letters and digits) Output For each test cases, output the Kth alphabet order substring. Sample Input 2 ABC 2 BBC 3 Sample Output Case 1: AB Case 2: BB
Finding string 字符串的查找_course
20200215Problem Description Richard is a smart data analyst in a famous company. One of his daily boring work is to find how many times does a pattern string occur in a very long string. Luckily, Richard notices that there are many consecutive repeated substrings in this very long string, so he uses the following compression algorithm to make the string shorter: a). Find a noncompressed consecutive repeated substring of the original string, e.g. “ab” in “cabababd”. b). Replace the repeating part with the bracketed repetend, followed by the times the repetend appears in the original string. e.g. Write “cabababd” as “c[ab]3d”. Note she can also write it as “c[ab]1ababd” or “ca[ba]2bd” and so on, although these string are not compressed as well as the first one is. c). Repeat a) and b) several times until the string is short enough. However, Richard finds it still a bit hard for him to do his work after the compression. So he orders you to write a program to make his work easier. Can you help him? Input The input contains several test cases, terminated by EOF. The number of test cases does not exceed 10000. Each test case contains two lines, denote the compressed text and pattern string. The decompressed text and pattern string contain lowercase letter only. The first line contains only lowercase letters (az), square brackets ([]) and numbers (09), and the second line contains only lowercase letters (az). The brackets must be followed with an integer t(1≤t≤2311)indicating the times the string in the brackets repeat. The brackets won't be nested. You can assume the length of the compressed string and pattern string won't exceed 500. Please note that for most test cases, the length of the pattern string is relatively very small. Output For each test case, print a single line containing the times this pattern string occurs in the very long string. Sample Input [ab]10aaba ba Sample Output 11
关于一个字符数组的问题_course
20150708假如我定义了一个char name[40],跟据书中的描述，一个字符串是以'\0'结尾， 我的问题是，这个\0也要占一个字节，那么这个\0是在40数组中的最后一个呢？也就是 说实际上程序只允许我有39个字符，还是放在我定义的字符数组以外呢？
MySQL基础入门视频课程
20181127本课程从零开始，以通俗易懂的方式讲解MySQL技术，手把手教你掌握每一个知识点。课程中使用的所有英文单词都会逐一查询并记录，真正做到零基础入门学习，适合初学者的教程！ 课程内容包括： 1.MySQL简介、安装MySQL 2.查询操作 3.聚合函数和分组统计 4.更新操作 5.表和库的管理 6.约束 7.用户和权限管理 8.事务处理 教学全程采用笔记+代码案例的形式讲解，通俗易懂！！！
 3.64MB
Xshell6完美破解版，亲测可用
20181226Xshell6破解版，亲测可用，分享给大家。直接解压即可使用
Java进阶高手课Java基础编程提升
20200427课程聚焦Java基础编程提升的核心知识点，以真实场景项目实战为导向，循序渐进，深入浅出的了解Java基础编程，讲解Java这门使用广泛的编程语言，助你能够游刃有余地游走在这些技术之中。
Linux系统编程：入门篇视频教程
20181016Linux系统编程视频课程为《Linux系统编程》入门篇，主要针对零基础的Linux开发学员科普Linux系统编程的概念以及需要掌握的各种技能，掌握Linux命令编写、Linux学习路线并熟悉嵌入式设备编程的方法。为后续的Linux系统编程深入学习打下良好的基础。
手把手带你学会Python
20200303当下最火的计算机语言，难道你还只停留知道的阶段吗？快跟着老司机一起起飞吧~ 零基础开始学，只要跟着视频一步一步来，多思考，多练习，我相信你会有质的飞越。 学习路上会很苦，也会很累。但是这些等你学会以后，会发现这些都是值得。 还在等什么？快来学习吧~
 学院 软件测试之测试模型及方法概论
 学院 【数据分析】 量化交易策略模型
 博客 Javaweb——(day07)EL与JSTL
 博客 研究生生活断代史（三）
 下载 太阳能光伏发电原理应用及发展前景
 下载 详解Node.js如何开发命令行工具
 下载 ASP.NET MVC5网站开发之业务逻辑层的架构和基本功能 （四）
 博客 容器基础——Namespace
 下载 高效微型太阳能逆变器测试方法
 博客 并发理论基础
 学院 UI自动化测试全家桶
 下载 Android使用Netty网络框架实践（客户端、服务端）
 下载 基础电子中的维库小知识：场效应管的识别与检测
 下载 无线测量应用解析
 下载 通信与网络中的基于串口服务器的指纹网络考勤系统
 下载 蓝牙局域网接入点的嵌入式实现
 学院 Vue3.0实战豆瓣评分项目
 学院 系统学习Linux命令
 学院 RabbitMQ实战，解决java高并发，MQ企业选型
 学院 亿图图示10.1灵活运用课程
 博客 学习通超星刷课插件chrom脚本实现自动填答案
 下载 基于TCP/IP的网关转串口通讯
 下载 JavaScript 中有关数组对象的方法(详解)
 博客 A2A B2B?
 学院 手把手教你手写Spring框架(附源码)
 下载 大功率可调稳压电源设计
 下载 吴恩达机器学习中英对照目录
 学院 JavaWeb校园图书购物商城毕业设计 大学生毕业设计教学视频
 博客 Easyrecovery14免费秘钥如何恢复电脑C盘丢失的文件教程
 下载 笔记本电池保养的五大错误观念