带缓存的输入/输出(例子)

本文提供了一个使用Java进行文件读写的示例程序。该程序首先将一组字符串写入到指定路径下的文本文件中,然后从同一文件中读取这些字符串并将其打印出来。示例展示了如何使用FileWriter和BufferedWriter进行文件写入操作,以及如何利用FileReader和BufferedReader完成文件读取。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

代码


import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;

public class Student {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String content[]={"明日复明日","名日何其多","我生待明日","万事成蹉跎"};
		File file=new File("D:\\work.txt");
		try {
			FileWriter fWriter=new FileWriter(file);
			BufferedWriter bufferedWriter=new BufferedWriter(fWriter);
			for(int k=0;k<content.length;k++)
			{
				bufferedWriter.write(content[k]);
				bufferedWriter.newLine();
			}
			bufferedWriter.close();
			fWriter.close();
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		try {
			FileReader fReader=new FileReader(file);
			BufferedReader bufferedReader=new BufferedReader(fReader);
			String string=null;
			int i=0;
			while ((string=bufferedReader.readLine())!=null) {
				i++;
				System.out.println("第"+i+"行:"+string);
				
			}
		bufferedReader.close();
		fReader.close();                 
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}

	}

}

 

结果:

第1行:明日复明日
第2行:名日何其多
第3行:我生待明日
第4行:万事成蹉跎

 

<think>好的,我现在需要解决这个问题,找出n以内所有满足条件的合数。条件是这个合数的各位数字之和等于它所有质因数的各位数字之和。例如题目中的例子483,数字和是15,分解质因数是3×7×23,质因数的数字和也是3+7+2+3=15。所以这样的数需要被找出。 首先,我得明确几个关键点: 1. **合数的定义**:合数是除了1和它本身之外还有其他因数的自然数,所以排除了质数和1。因此,在遍历的时候,需要判断该数是否是合数,也就是是否有除了1和自身之外的因数。 2. **分解质因数后的处理**:每个合数需要分解质因数,然后将每个质因数的各位数字相加,总和等于原数的各位数字之和。需要注意的是,质因数可能有多个,比如483分解成3、7、23三个质因数,每个都要处理。 接下来,我需要逐步拆解问题,确定实现的步骤: **步骤一:判断一个数是否为合数** 首先,我需要一个函数来判断一个数是否是合数。对于给定的数num,如果它不是质数,并且大于1,那么就是合数。所以,我需要先实现判断质数的函数。质数的判断可以用试除法,检查从2到sqrt(num)是否有能整除的数。 **步骤二:计算一个数的各位数字之和** 这应该比较简单,例如,将数转换为字符串,然后每一位相加,或者用取模运算循环处理。例如,483的各位和是4+8+3=15。同样,质因数分解后的每个质因数的各位和也要计算,然后相加总和。 **步骤三:分解质因数** 分解质因数的步骤是,给定一个数,找到所有质因数,并记录下来。例如,分解483得到3、7、23。需要注意的是,分解质因数时,同一个质因数可能出现多次,比如12=2×2×3,这时候每个2都要被计入。比如,如果原数是8,分解质因数是2×2×2,所以数字和为2+2+2=6,而原数8的各位和是8。这时候可能不符合条件,所以需要正确分解质因数。 **步骤四:比较总和** 将原数的各位和与分解后的质因数的各位和的总和进行比较,相等的话就满足条件。 现在,我需要将这些步骤转化为具体的代码实现。 **具体实现思路:** 1. **遍历所有可能的数**:从4开始到n(因为最小的合数是4),对每个数进行判断。 2. **判断是否为合数**:对于每个数,先判断是否是合数。如果是,则继续处理;否则跳过。 3. **计算原数的数字和**:例如,对于数num,计算其各位数字之和sum_num。 4. **分解质因数**:将num分解为质因数,注意处理重复的质因数。例如,分解12得到2,2,3。这时候每个质因数都要计算数字和,然后总和相加。 5. **计算质因数的数字和总和sum_factors**:例如,分解后的质因数是3、7、23,那么sum_factors=3+7+2+3=15。 6. **比较sum_num和sum_factors**:如果相等,就将该数加入结果列表。 **现在需要考虑的细节问题:** - 分解质因数时,如何处理重复的质因数?例如,4=2×2,这时候质因数的各位和是2+2=4,而原数4的各位和是4,符合条件吗?这时候需要测试一下。比如,4是否是符合条件的数? 根据题目中的示例,输入100时,输出包含4。这说明4是符合条件的。例如,4的数字和为4。分解质因数是2×2,质因数的各位和为2+2=4,所以符合条件。所以,在分解质因数时,必须包括重复的质因数,每个都要计入总和。 - 如何分解质因数?例如,对于数num,分解质因数的过程是从小到大试除,直到商为1。例如,分解num=12: 12 ÷ 2 =6 → 余0,所以质因数2。此时商6继续分解。 6 ÷2=3 → 余0,质因数2。商3。 3 ÷3=1 → 质因数3。所以质因数是2,2,3。他们的数字和为2+2+3=7。原数12的各位和是1+2=3。所以不相等。所以12不在符合条件的列表中。 但根据题目中的输入输出例子,当n=100时,输出中有4。那么,4的分解质因数是2×2,数字和为2+2=4。原数4的各位和是4,所以符合条件。 因此,分解质因数时,必须将每个质因数的实例都算进去,不管是否重复。 **现在,如何分解质因数?** 例如,函数返回的是所有质因数的列表,包括重复的。比如,分解8得到[2,2,2],分解12得到[2,2,3]。 分解质因数的算法步骤: 初始化一个空列表factors。 从2开始到sqrt(num)进行试除: 对于每个i,当i能整除num时,不断除以i,直到不能整除为止,同时将i添加到factors中。 当i超过sqrt(num)之后,如果剩下的num大于1,则将其加入factors。 例如,分解483: 初始num=483。i=2,不能整除。i=3,483 ÷3=161,余0。所以factors添加3,num变为161。现在i继续从3开始,但此时可能i的平方大于当前num?或者需要调整i的范围? 或者,正确的分解质因数方法应该是: num=483,从i=2开始: i=2:483不能被2整除。i=3:483 ÷3=161,余0。所以factors加3。然后num=161。现在i继续从3开始,检查是否i可以整除161。3的平方是9,而161的平方根约是12.7。所以i到13? 此时,i=3,无法整除161。i增加到4,但4不是质数,可以跳过吗?或者应该循环i,但此时i可能需要是质数? 其实,分解质因数的算法并不需要i是质数,因为当处理到i=4时,此时num已经被分解后的部分已经不再能被4整除。例如,当分解到i=4时,num已经被分解到无法被2整除,因此也不会被4整除。所以在分解过程中,即使i不是质数,但此时num已经被分解到无法被更小的质数整除,所以i只能取质数的值。这可能是一个优化的点,但为了正确性,通常的做法是试除所有可能的i,从小到大,而不管i是否是质数。因为例如,当i=4时,如果num能被4整除,说明在之前的步骤中已经被分解过2的因子,所以此时num中已经没有因子2,因此无法被4整除。所以,正确的分解质因数的算法应该能正确得到所有质因数,即使i不是质数。 比如,分解num=12: i从2开始: i=2时,12%2==0,分解后得到2,num=6。继续除以2得到3,分解后的factors是[2,2],此时num=3。接着i增加到3,3<=sqrt(3)=1.732?此时i=3已经超过sqrt(num),所以检查num是否>1,即3>1,所以将3加入factors。所以factors是[2,2,3]。正确。 分解num=8: i=2,8%2==0,除以2得到4,继续除以2得到2,继续除以2得到1。factors是[2,2,2]。正确。 分解num=483: i=3,分解得到3,剩下的num=161。i增加到4,检查是否i<=sqrt(161)=约12.69。i从4到12: i=4,不能整除161。i=5,不能整除。i=6,不能。i=7:161 ÷7=23,余0。所以将7加入factors,num变为23。现在i继续增加到8,此时sqrt(23)≈4.795,所以i=8超过,所以检查num=23是否>1,是,加入factors。所以factors是3,7,23。总和正确。 所以分解质因数的算法是正确的。 现在,我需要编写分解质因数的函数,返回所有质因数的列表,包括重复的。 接下来,每个质因数的各位数字相加的总和,例如3→3,7→7,23→2+3=5。总和是3+7+5=15,与原数的各位和相同。 所以,分解质因数之后,遍历每个质因数,计算它们的各位和的总和。 现在,编写这个过程的代码。 **可能的代码结构:** 主程序的大致流程: n = int(input()) result = [] for num in range(4, n+1): if not is_composite(num): continue sum_num = digit_sum(num) factors = prime_factors(num) sum_factors = sum(digit_sum(f) for f in factors) if sum_num == sum_factors: result.append(num) 然后,按照每行5个输出。 现在,需要实现各个函数: 1. is_composite(num): 判断是否是合数。即,该数不是质数,且大于1. 判断是否是合数的函数,可以调用is_prime函数,返回not is_prime(num) and num >1. 而is_prime(num)函数,对于num<=1返回False。对于num=2返回True,对于其他数,检查是否能被2到sqrt(num)之间的数整除。 但是,在分解质因数的时候,当num是合数的话,分解出来的质因数可能有多个,所以这个判断必须正确。 另外,注意,当num=1时,不是合数,也不会被处理,因为循环从4开始。 所以,is_composite函数可以这样写: def is_composite(num): if num <=1: return False if num ==2 or num ==3: return False for i in range(2, int(math.sqrt(num)) +1): if num%i ==0: return True return False 或者更高效的方式:如果存在除了1和自身的因数,则是合数。 例如,如果num是质数,那么返回False,否则返回True。 或者,更正确的方式:先判断是否是质数。如果是质数,则不是合数。否则,如果是大于1,则是合数。 所以,is_composite函数可以改写为: def is_composite(num): if num <=1: return False return not is_prime(num) 然后,is_prime(num)函数的实现: def is_prime(num): if num <=1: return False if num ==2: return True if num%2 ==0: return False for i in range(3, int(math.sqrt(num)) +1, 2): if num%i ==0: return False return True 这样更正确。例如,num=4,is_prime返回False,所以is_composite返回True。 接下来,digit_sum函数: 计算一个数的各位数字之和。例如,483→4+8+3=15. 实现方式: def digit_sum(n): s =0 while n>0: s +=n%10 n =n//10 return s 或者,转换为字符串: def digit_sum(n): return sum(int(c) for c in str(n)) 两种方法都可以。可能用取模的方式效率更高,但差别不大。 然后是分解质因数的函数prime_factors: def prime_factors(n): factors = [] if n ==1: return factors # 处理2的因子 while n%2 ==0: factors.append(2) n =n//2 # 处理奇数因子 i=3 while i*i <=n: while n%i ==0: factors.append(i) n =n//i i +=2 if n>1: factors.append(n) return factors 这个函数能够正确分解所有质因数,包括重复的。例如,8分解为[2,2,2],483分解为[3,7,23]。 现在,将这些函数组合起来,再遍历每个数,判断是否符合条件。 但有一个问题:当分解质因数时,是否必须将重复的质因数都算进去?例如,4分解为[2,2],其和为2+2=4,等于原数的各位和4。所以,正确。因此,分解质因数的函数是正确的。 现在,测试几个案例: 测试num=4: sum_num=4. 分解质因数得到[2,2]. sum_factors=2+2=4→相等。所以符合条件。 测试num=22: 原数各位和2+2=4. 分解质因数22=2×11→sum_factors=2+1+1=4→相等。所以符合条件。 测试num=27: 各位和2+7=9. 分解质因数3×3×3→sum_factors=3+3+3=9→符合条件。 测试num=58: 5+8=13. 分解质因数58=2×29→2+2+9=13→符合条件。 测试num=85: 8+5=13.分解为5×17→5+1+7=13→符合条件。 所以,这几个测试案例都正确,符合条件。 现在,如何确保程序的正确性? 可能的错误点: 1. 在判断合数的时候,可能将质数错误地判断为合数,或者反之。 例如,num=4是合数,会被正确判断。而质数如5会被排除。 2. 分解质因数是否正确。例如,当分解的数本身是质数时,会被分解为自身,但此时该数不是合数,所以会被排除。例如,假设有一个质数num=23,它会被is_composite函数判断为False,不会被处理。所以不会有问题。 所以,在分解质因数的步骤中,只有合数才会被处理,所以分解后的质因数列表长度至少有两个元素?或者不是?例如,合数的定义是至少有一个因数除了1和自身,所以分解质因数后的列表可能包含多个质因数,或者一个质因数出现多次(比如4=2×2)。 例如,合数的质因数分解必须得到至少两个质因数?比如,9=3×3,所以分解后的质因数列表是[3,3],此时sum_factors=3+3=6。原数9的各位和是9→6≠9,所以9不符合条件,不会被选中。 因此,分解后的质因数列表可能包含多个元素,或者一个元素的多次出现,但此时原数必须是合数,即分解后的质因数个数至少有两个(比如,当原数是质数的平方时,如4=2×2,此时质因数列表有两个元素)。 所以,分解质因数的函数正确性没有问题。 现在,整个程序的流程是否正确? 测试样例输入100,输出4、22、27、58、85、94。注意,样例的输出是每行5个,例如输入100的输出是: 4 22 27 58 85 94 但可能输出格式需要每行5个,用空格分隔,最后一行可能不足5个。例如样例的输出是六个数,所以分为两行:第一行五个,第二行一个? 但原题中的输出例子显示输入100的输出为: 4 22 27 58 85 94 但可能原题的输出描述可能有误?或者可能输出中的六个数字被分为两行:第一个五个,第二个一个? 比如,问题描述的输出例子是: 输入/输出例子1 输入: 100 输出: 4 22 27 58 85 94 这样每行5个,按顺序排列。那么当符合条件的数有六个时,第一行5个,第二行1个。 所以在代码中,处理结果列表时,需要每五个元素输出一行,元素之间用空格分隔,每个元素占用的宽度可能要看是否有要求,但题目没有特别说明,只要用空格隔开即可。例如,输出时,将结果列表中的元素按顺序,每五个组成一个子列表,然后输出每个子列表中的元素用空格连接。 例如,对于结果列表中的元素,每次取五个,然后输出。 现在,编写输出部分的代码: 在Python中,可以将结果列表分块,每5个一组。例如: for i in range(0, len(result), 5): chunk = result[i:i+5] print(' '.join(map(str, chunk))) 这样就可以按每行五个输出。 现在,测试整个流程是否正确。 现在,针对输入n=100的情况,程序是否能正确找到这些数? 让我们逐个检查: 4:合数,各位和4。质因数为2,2。sum_factors=2+2=4→符合条件。所以被选中。 22:合数,各位和2+2=4。质因数分解2,11。sum_factors=2+1+1=4→符合条件。 27:各位和2+7=9。分解为3,3,3。sum是3+3+3=9→符合条件。 58:5+8=13。分解为2×29→2+2+9=13→符合条件。 85:8+5=13。分解为5×17→5+1+7=13→符合条件。 94:9+4=13。分解为2×47→2+4+7=13→符合条件。所以这六个数字会被选中。 那输出时,第一行五个:4,22,27,58,85,第二行94。所以输出正确。 现在,确认其他可能的测试情况。 比如,n=4时,输入是4,输出4?但根据题目中的输入条件n>=10。所以输入的n是10的话,输出可能有4吗?例如,当n=10时,应该输出4吗? 比如,当n=10时,所有符合条件的合数包括4(符合)和可能其他数? 比如,4的各位和4,分解质因数2+2=4。符合条件。所以当n=10时,输出4吗? 但根据题目中的输入例子,当n=100时,输出包括4,所以这说明当n≥4时,4会被选中。所以程序是正确的。 现在,程序是否能正确遍历所有数? 综上,整个程序的逻辑是正确的。 但需要注意,分解质因数的函数在处理num=1时返回空列表,但这不会影响,因为num从4开始。 现在,需要考虑可能的优化问题,因为n可以是30000,那么对于每个数,分解质因数可能需要较多时间。例如,对于n=30000,需要遍历3万个数字,每个数字进行质因数分解,这会比较耗时。需要优化吗? 例如,对于较大的n,如3万,这样的算法是否可行? 例如,试想,当n=3万时,最大的数是30000。分解质因数的时间可能较长。例如,对于每个数,分解质因数的时间取决于其质因数的大小。例如,分解一个质数作为合数的情况不可能发生,因为is_composite函数已经排除了质数。所以,只有合数才会被分解质因数。 例如,假设最大的合数是30000,分解质因数可能需要多次循环。例如,分解29999(假设是合数),可能比较耗时。但实际29999是否是合数?例如,29999= 131 × 229 →是的?所以,分解质因数可能需要较多的步骤。 但根据问题中的限制,n最大是3万,这样的规模可能在Python中处理时间较长,但或许可以接受。例如,当测试时,n=3万的测试点是否会在时间限制内? 为了优化,可以考虑预先生质数表,或者使用更高效的质因数分解方法,例如预处理所有质数,或者使用试除法优化。 不过,在Python中,对于3万的规模,可能这个算法还是可以接受的。例如,每个数的处理分解质因数可能最多需要试除到sqrt(n)次。假设平均每个分解质因数需要100次循环,那么3万个数的话,总共有3e4 × 1e2 =3e6次操作,这在Python中可能还是可以处理的。 因此,程序的时间复杂度可能在可接受的范围内。例如,当n=3万时,每个合数的处理可能平均需要约O(sqrt(k))的时间,其中k是当前处理的数。 但可能这样的程序在n=3万时运行时间较长。例如,对于较大的数,例如3万,分解质因数可能需要较多的步骤。 有没有可能的优化方法? 例如,可以预生成质数表,或者缓存质因数分解结果? 或者,可以考虑预处理每个数的质因数之和? 或者,可以观察到,对于每个合数,其质因数的数字和总和等于原数的数字和。那么,是否可以通过某些数学规律来快速判断? 目前没有想到这样的规律,所以可能需要按照步骤来处理。 另一个可能的优化是预处理每个数的数字和。例如,预先计算所有数的数字和,存储在一个字典或列表中。例如,digit_sums数组,digit_sums[i]存储i的各位数字之和。这样,在后续计算时可以快速获取,而不需要每次都重新计算。 这在Python中可以轻松实现,例如: digit_sums = [0]*(n+1) for i in range(n+1): digit_sums[i] = sum(int(c) for c in str(i)) 或者,用取模的方式: def digit_sum(n): s =0 while n>0: s +=n%10 n =n//10 return s digit_sums = [digit_sum(i) for i in range(n+1)] 这样,当需要获取digit_sum时,可以直接查表,节省时间。 另外,分解质因数时,质因数的数字和也可以通过查表得到,这样节省时间。 这可能是一个优化点。 此外,在分解质因数时,可以预先缓存质数,减少重复判断质数的时间。比如,先生成质数表,然后在分解质因数时,只试除质数。 例如,使用筛法生成质数列表,然后在分解时只用质数来试除。这可能减少分解质因数的时间,但需要额外的空间。 例如,先生成小于等于sqrt(n_max)的质数列表,其中n_max是3万。sqrt(3e4)约是173,所以质数列表需要到173的质数。这可以很快生成。 生成质数表后,分解质因数时,只需要试除这些质数,这可能减少时间。 不过,这可能增加代码复杂度,但可以尝试。 但考虑到时间限制可能允许直接采用试除法,所以可能不需要这样的优化。 综上,现在的思路是正确的,可以编写代码。 现在,编写完整的Python代码: 需要注意,分解质因数的函数是否正确,以及各个函数的正确性。 例如,对于num=94: 分解质因数:94=2×47→质因数是2和47。sum_factors=2+4+7=13。原数的数字和是9+4=13→符合条件。 所以,94会被选中。 另一个测试案例:num=22=2×11→sum_factors=2+1+1=4→原数2+2=4→符合条件。 综上,代码的逻辑是正确的。 现在,编写代码: 首先,导入必要的库,例如math。 然后,编写各个函数: import math def is_prime(num): if num <=1: return False if num ==2: return True if num%2 ==0: return False for i in range(3, int(math.sqrt(num)) +1, 2): if num%i ==0: return False return True def is_composite(num): if num <=1: return False return not is_prime(num) def digit_sum(n): s =0 while n>0: s +=n%10 n =n//10 return s def prime_factors(n): factors = [] # 处理2的因子 while n % 2 == 0: factors.append(2) n = n //2 # 处理奇数因子 i =3 while i*i <=n: while n %i ==0: factors.append(i) n =n//i i +=2 if n>1: factors.append(n) return factors n = int(input()) result = [] for num in range(4, n+1): if not is_composite(num): continue sum_num = digit_sum(num) factors = prime_factors(num) sum_factors = sum(digit_sum(f) for f in factors) if sum_num == sum_factors: result.append(num) # 输出结果,每行5个 for i in range(0, len(result),5): line = result[i:i+5] print(' '.join(map(str, line))) 现在,测试这个代码是否正确。 当输入100时,输出应该是4 22 27 58 85和94吗? 运行这个代码,输入100,得到的输出是否与样例一致? 测试: 当num=4时,is_composite(4)返回True。sum_num=4。分解质因数得到[2,2],sum_factors=2+2=4→符合条件。 num=22:分解为[2,11]。sum_factors=2+1+1=4。sum_num=2+2=4→符合条件。 num=27:分解为3,3,3。sum_factors=3+3+3=9。sum_num=2+7=9→符合条件。 num=58:分解为2×29。sum_factors=2+2+9=13。sum_num5+8=13→符合条件。 num=85:分解为5×17。sum_factors5+1+7=13。sum_num8+5=13→符合条件。 num=94:分解为2×47。sum_factors2+4+7=13。sum_num9+4=13→符合条件。 所以,在输入100时,这六个数会被加入result列表。代码在输出时会分成两行:第一行五个,第二行一个。 因此,输出结果应与样例一致。 综上,代码是正确的。</think>要解决这个问题,我们需要找出所有小于等于n的合数,这些合数的各位数字之和等于其质因数各位数字之和的总和。以下是详细的解决步骤: ### 方法思路 1. **判断合数**:合数是指除了1和自身之外还有其他因数的自然数。我们需要排除质数和1。 2. **计算数字和**:对于每个数,计算其各位数字之和。 3. **分解质因数**:将合数分解为质因数,并计算每个质因数的各位数字之和。 4. **比较和**:如果合数的各位数字之和等于其质因数各位数字之和的总和,则记录该数。 ### 解决代码 ```python import math def is_prime(num): if num <= 1: return False if num == 2: return True if num % 2 == 0: return False for i in range(3, int(math.sqrt(num)) + 1, 2): if num % i == 0: return False return True def is_composite(num): if num <= 1: return False return not is_prime(num) def digit_sum(n): s = 0 while n > 0: s += n % 10 n = n // 10 return s def prime_factors(n): factors = [] while n % 2 == 0: factors.append(2) n = n // 2 i = 3 while i * i <= n: while n % i == 0: factors.append(i) n = n // i i += 2 if n > 1: factors.append(n) return factors n = int(input()) result = [] for num in range(4, n + 1): if not is_composite(num): continue sum_num = digit_sum(num) factors = prime_factors(num) sum_factors = sum(digit_sum(f) for f in factors) if sum_num == sum_factors: result.append(num) for i in range(0, len(result), 5): print(' '.join(map(str, result[i:i+5]))) ``` ### 代码解释 1. **is_prime函数**:判断一个数是否为质数。通过试除法,检查从2到其平方根之间的所有可能因数。 2. **is_composite函数**:判断一个数是否为合数。通过调用is_prime函数来排除质数。 3. **digit_sum函数**:计算一个数的各位数字之和。 4. **prime_factors函数**:分解一个数的质因数,返回所有质因数的列表(包括重复的质因数)。 5. **主循环**:遍历4到n的所有数,判断是否为合数,并计算其各位数字之和及其质因数的各位数字之和的总和。若相等,则记录该数。 6. **输出结果**:将结果按每行5个数的格式输出。 通过上述步骤,我们可以有效地找到所有符合条件的合数,并按要求格式输出
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值