会计代理记账面试题非常常见。原因是，代理记账是一项需要专业技能和知识的工作，招聘单位通常会考察应聘者对财务会计的理论知识和实践经验是否丰富。此外，代理记账岗位需要应聘者具备较强的沟通协调能力和解决问题的能力，所以在面试中也会有相关的情景模拟环节和案例分析题目。作为应聘者，应该充分准备面试，包括对会计基础知识和相关政策法规的了解，具备丰富的实践经验和案例处理能力，同时也需要展示出自己的沟通协调能力。在面试中要注意表达清晰，条理分明，回答到点子上。只有充分准备才能在面试中发挥自己的优势，为成功获得工作机会打下坚实的基础。
会计面试的题目大致分为普遍性的问题以及专业性的问题，主要有以下结论经典试题：
1、一般纳税人可抵扣票证有哪些？纳税申报的流程如何？
2、客户扣款（已开具发票）如何进行会计处理？需要附哪些原始单据？
3、年终奖是如何计算缴纳个人所得税的？
4、财政年报和汇算清缴报表口径有什么差异？
5、公司购买装修材料用来装修租用的办公用房，如何进行会计处理？
6、公司开办费如何进行会计核算？所得税清缴时如何进行调整？
7、你为什么离开以前的公司？
8、你目前的工作是什么？说说你工作的流程。
9、你觉得费用支出如何处理？（一般为服务行业）
10、公司成本如何核算？（一般为制造企业）
11、请你谈谈毕业之后的工作经历。
12、你现在或最近所做的工作，其职责是什么？你担任什么职务？
13、你认为你在工作中的成就是什么？
14、在你主管的部门中，遇到过什么困难？你是如何处理或应付过去的？
15、请谈一下你在企业中职务升迁和收入变化情况。
1、会计的6大基本要素是什么?
答案：资产、负债、所有者权益、收入、费用和利润
2、会计的3大报表是什么?
答案：资产负债表，现金流量表，利润表(也称为损益表)
3、权益性支出与资本性支出的差异是什么?
答案：资本性支出：是用于购买或生产使用年限在一年以上的耐用品所需的支出，指企业单位发生、其效益及于两个或两个以上会计年度的各项支出，包括构成固定资产、无形资产、递延资产的支出。
收益性支出：也叫期间费用。是指企业单位在经营过程中发生、其效益仅与本会计年度相关、因而由本年收益补偿的各项支出。这些支出发生时，都应记入当年有关成本费用科目。
区别：收益性支出不同于资本性支出，前者全部由当年的营业收入补偿，后者先记作资产，通过计提折旧或摊销分年摊入各年成本费用。区分收益性支出和资本性支出，是为了正确计算各年损益和正确反映资产的价值。如把收益性支出作为资本性支出，结果是少计了当期费用，多计了资产价值，虚增利润;反之，则多计了当期费用，少计了资产价值，虚减利润。
4、固定资产折旧采用的方法有哪些?
答案：分为两类：直线法和加速折旧法
其中直线法包括：平均年限法和工作量法
加速折旧法包括：双倍余额递减法和年数总和法
5、固定资产账面价值在什么情况下会出现负值?
什么情况下都不应该出现负值，现在的准则不允许负资产的存在，包括负商誉。
理论上固定资产超龄服役继续计提折旧，或超价值计提减值准备等都可能造成固定资产出现负值，但这样做会使资产负债表上的资产总额减少，而实际上其他资产价值并没有减少，会误导信息使用者。所以所有资产出现负值时，最多在备查簿上予以记录。
6、新会计准则出台后，对企业的影响有哪些?
(1)新会计准则对企业业绩的影响;
(2)有利于提高企业的会计信息质量;
(3)有利于提高企业整体管理水平。
7、企业所得税的改革对国内企业的影响是什么?
日企招聘企业所得税税率改革前，企业所得税率是33%，新的规定一般企业所得税的税率为25%， 非居民企业在中国境内未设立机构、场所的，或者虽设立机构、场所但取得的所得与其所设机构、场所没有实际联系的，应当就其来源于中国境内的所得缴纳企业所得税，税率为20%。
符合条件的小型微利企业，减按20%的税率征收企业所得税。国家需要重点扶持的高新技术企业，减按15%的税率征收企业所得税。日企招聘企业所得税率的降低对国内企业来说有一个很好的推动作用，使得企业的竞争环境更加公平和有利。
8、企业应该如何面对金融危机?
(1)加大力度，催收货款。
(2)减人增效，降低成本，保本经营。
(3)稳定市场，站稳脚跟。
(4)降低库存，盘活资产。
9、面对金融风暴，作为一名管理人员，集体减薪和裁员你会选择哪一个?
这个问题主管因素比较多。我的回答是：我会选择集体减薪，原因是我认为企业是一个集体，只有大家齐心协力，才能度过难关，企业发展的好，自然多得，既然企业现在处于危机之中，大家更应该团结在一起，待企业度过难关后，一起分享集体加薪的欣悦也不愧为一种优秀的企业文化。
10、市场前景，加薪和升职，你更重视哪一个?
我选择职业前景，我始终坚信提高个人的专业素养和技能后，加薪和升职的机会只会多不会少。
项目会计面试题一般会问很多关于过往履历以及对未来工作有哪些职业规划，比如问在上家公司主要担任什么职务以及主要工作的工作内容是什么，在工作中取得哪些成就，再会问离开上家公司的原因是什么，最后会问你对这份工作的期望待遇如何以及职业规划是怎样的。
会计面试常见问题大全：
1、一般纳税人可抵扣票证有哪些?纳税申报的流程如何?
2、客户扣款(已开具发票)如何进行会计处理?需要附哪些原始单据?
3、年终奖是如何计算缴纳个人所得税的?
4、财政年报和汇算清缴报表口径有什么差异?
5、公司购买装修材料用来装修租用的办公用房，如何进行会计处理?
6、公司开办费如何进行会计核算?所得税清缴时如何进行调整?
7、你为什么离开以前的公司?
8、你目前的工作是什么?说说你工作的流程。
9、你觉得费用支出如何处理?(一般为服务行业)
10、公司成本如何核算?(一般为制造企业)
其实，在各种会计面试场合，有一些会计面试常见问题，比如会计招聘考官往往会问及工作经验方面的问题。如果你的工作经验非常丰富自然不成问题，而对于缺乏经验者(尤其是会计专业大学生)往往成为硬伤。
经典的面试题，没有特别为会计行业的，但是我作为外企的财务经理，面试人员合计没有五百，也有四百了，给你分享我经历的公司财务面试专业题是什么。
1.固定资产购买，折旧和处置的会计凭证
这个问题是我们面试全球Top30的名校实习生时的面试题，看起来简单，但是真正回答出来的，只有十分之一的人。(考验专业知识)
2.关于报销的问题，如果公司的某个大老板报销他的出差费用，但是他的有笔发票丢失了，他拿了替代的发票，请问你怎么做？(考验沟通+职场会计专业知识+实务操作）
3.请描述一下从购买原材料到款项支付所有涉及的会计账务处理。
这个考验了一条线，一个流程的业务数字程度和涉及的财务知识。
四大招的新人离职率太高的话，其HR会受到批评吗？
因为你去会计师事务所积累一些工作经验比较好，因为那各行各业的账务都有，而且每个公司运作的如何通过账目可以表现的很明白，对你应该是有很大的帮助的． 并且你在事务所呆几年后出去，再到工厂去应该是很受欢迎的。我也是走的这样的一条路线哦！好好一起加油哦！
在当今竞争激烈的就业市场中，拥有一份满意的工作恐怕不是一件容易的事情。而对于那些追求成本会计职位的人来说，面试可以说是获取这份工作的关键一步。因此，在面试之前，准备自己是非常重要的，特别是研究和掌握与成本会计相关的面试问题。
首先，面试官可能会问到你关于成本会计的基本知识。成本会计是一种用于记录、分析和报告组织成本信息的会计方法。它与管理会计密切相关，旨在为企业提供准确的成本数据，以便做出决策和控制成本的计划。
成本会计的主要目的是为了提供有关产品或服务的成本信息，支持企业的决策制定。它帮助企业确定产品定价、控制成本、评估业务绩效和制定预算。
成本会计有一些基本的原则，包括：
成本驱动型会计是一种成本计算方法，它将企业的成本分配给特定的活动、产品或服务。与传统的费用分配方法不同，ABC考虑到不同产品或服务之间的实际资源消耗差异。这种方法更加准确地追踪和分配成本。
作为一名成本会计，评估和控制企业的成本是你的重要任务之一。你可以通过以下方法来完成：
作业成本法是一种用于测算产品成本的方法，主要用于生产过程中数量较少、类型较多的产品。它将成本分配给不同的作业，并根据每个作业的实际消耗量进行计算。
成本差异是实际成本与标准成本之间的差异。在面试中，你可以提到你在过去的工作中如何处理这种情况。你可以描述你如何分析成本差异、确定原因并提出解决方案来控制成本。
这是一个个人经验和观点的问题，你可以提及你在成本会计职业生涯中遇到的最具挑战性的任务。例如，这可能是处理大规模项目的成本分析，或者在紧迫的时间表下完成复杂的成本预算。
作为一名专业的成本会计，你应该展示出你对行业发展和新技术的关注。你可以提到你加入会计协会、参加专业培训、阅读相关的书籍和文章，并积极参与行业会议和研讨会来不断学习和拓宽自己的知识。
通过准备以上的成本会计职位面试题，你将有更好的机会在面试中展现自己的知识和技能。记住，面试是一个展示自己的机会，与面试官进行积极的沟通，并展示你的专业背景和潜力。祝你在面试中取得成功并实现自己的职业目标！
之前看了Mahout官方示例 20news 的调用实现；于是想根据示例的流程实现其他例子。网上看到了一个关于天气适不适合打羽毛球的例子。
训练数据：
Day Outlook Temperature Humidity Wind PlayTennis
D1 Sunny Hot High Weak No
D2 Sunny Hot High Strong No
D3 Overcast Hot High Weak Yes
D4 Rain Mild High Weak Yes
D5 Rain Cool Normal Weak Yes
D6 Rain Cool Normal Strong No
D7 Overcast Cool Normal Strong Yes
D8 Sunny Mild High Weak No
D9 Sunny Cool Normal Weak Yes
D10 Rain Mild Normal Weak Yes
D11 Sunny Mild Normal Strong Yes
D12 Overcast Mild High Strong Yes
D13 Overcast Hot Normal Weak Yes
D14 Rain Mild High Strong No
检测数据：
sunny，hot，high，weak
结果：
Yes=》 0.007039
No=》 0.027418
于是使用Java代码调用Mahout的工具类实现分类。
基本思想：
1. 构造分类数据。
2. 使用Mahout工具类进行训练，得到训练模型。
3。将要检测数据转换成vector数据。
4. 分类器对vector数据进行分类。
接下来贴下我的代码实现=》
1. 构造分类数据：
在hdfs主要创建一个文件夹路径 /zhoujainfeng/playtennis/input 并将分类文件夹 no 和 yes 的数据传到hdfs上面。
数据文件格式，如D1文件内容： Sunny Hot High Weak
2. 使用Mahout工具类进行训练，得到训练模型。
3。将要检测数据转换成vector数据。
4. 分类器对vector数据进行分类。
这三步，代码我就一次全贴出来；主要是两个类 PlayTennis1 和 BayesCheckData = =》
package myTesting.bayes;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.util.ToolRunner;
import org.apache.mahout.classifier.naivebayes.training.TrainNaiveBayesJob;
import org.apache.mahout.text.SequenceFilesFromDirectory;
import org.apache.mahout.vectorizer.SparseVectorsFromSequenceFiles;
public class PlayTennis1 {
private static final String WORK_DIR = "hdfs://192.168.9.72:9000/zhoujianfeng/playtennis";
/*
* 测试代码
*/
public static void main(String[] args) {
//将训练数据转换成 vector数据
makeTrainVector();
//产生训练模型
makeModel(false);
//测试检测数据
BayesCheckData.printResult();
}
public static void makeCheckVector(){
//将测试数据转换成序列化文件
try {
Configuration conf = new Configuration();
conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));
String input = WORK_DIR+Path.SEPARATOR+"testinput";
String output = WORK_DIR+Path.SEPARATOR+"tennis-test-seq";
Path in = new Path(input);
Path out = new Path(output);
FileSystem fs = FileSystem.get(conf);
if(fs.exists(in)){
if(fs.exists(out)){
//boolean参数是，是否递归删除的意思
fs.delete(out, true);
}
SequenceFilesFromDirectory sffd = new SequenceFilesFromDirectory();
String[] params = new String[]{"-i",input,"-o",output,"-ow"};
ToolRunner.run(sffd, params);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("文件序列化失败！");
System.exit(1);
}
//将序列化文件转换成向量文件
try {
Configuration conf = new Configuration();
conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));
String input = WORK_DIR+Path.SEPARATOR+"tennis-test-seq";
String output = WORK_DIR+Path.SEPARATOR+"tennis-test-vectors";
Path in = new Path(input);
Path out = new Path(output);
FileSystem fs = FileSystem.get(conf);
if(fs.exists(in)){
if(fs.exists(out)){
//boolean参数是，是否递归删除的意思
fs.delete(out, true);
}
SparseVectorsFromSequenceFiles svfsf = new SparseVectorsFromSequenceFiles();
String[] params = new String[]{"-i",input,"-o",output,"-lnorm","-nv","-wt","tfidf"};
ToolRunner.run(svfsf, params);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("序列化文件转换成向量失败！");
System.out.println(2);
}
}
public static void makeTrainVector(){
//将测试数据转换成序列化文件
try {
Configuration conf = new Configuration();
conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));
String input = WORK_DIR+Path.SEPARATOR+"input";
String output = WORK_DIR+Path.SEPARATOR+"tennis-seq";
Path in = new Path(input);
Path out = new Path(output);
FileSystem fs = FileSystem.get(conf);
if(fs.exists(in)){
if(fs.exists(out)){
//boolean参数是，是否递归删除的意思
fs.delete(out, true);
}
SequenceFilesFromDirectory sffd = new SequenceFilesFromDirectory();
String[] params = new String[]{"-i",input,"-o",output,"-ow"};
ToolRunner.run(sffd, params);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("文件序列化失败！");
System.exit(1);
}
//将序列化文件转换成向量文件
try {
Configuration conf = new Configuration();
conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));
String input = WORK_DIR+Path.SEPARATOR+"tennis-seq";
String output = WORK_DIR+Path.SEPARATOR+"tennis-vectors";
Path in = new Path(input);
Path out = new Path(output);
FileSystem fs = FileSystem.get(conf);
if(fs.exists(in)){
if(fs.exists(out)){
//boolean参数是，是否递归删除的意思
fs.delete(out, true);
}
SparseVectorsFromSequenceFiles svfsf = new SparseVectorsFromSequenceFiles();
String[] params = new String[]{"-i",input,"-o",output,"-lnorm","-nv","-wt","tfidf"};
ToolRunner.run(svfsf, params);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("序列化文件转换成向量失败！");
System.out.println(2);
}
}
public static void makeModel(boolean completelyNB){
try {
Configuration conf = new Configuration();
conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));
String input = WORK_DIR+Path.SEPARATOR+"tennis-vectors"+Path.SEPARATOR+"tfidf-vectors";
String model = WORK_DIR+Path.SEPARATOR+"model";
String labelindex = WORK_DIR+Path.SEPARATOR+"labelindex";
Path in = new Path(input);
Path out = new Path(model);
Path label = new Path(labelindex);
FileSystem fs = FileSystem.get(conf);
if(fs.exists(in)){
if(fs.exists(out)){
//boolean参数是，是否递归删除的意思
fs.delete(out, true);
}
if(fs.exists(label)){
//boolean参数是，是否递归删除的意思
fs.delete(label, true);
}
TrainNaiveBayesJob tnbj = new TrainNaiveBayesJob();
String[] params =null;
if(completelyNB){
params = new String[]{"-i",input,"-el","-o",model,"-li",labelindex,"-ow","-c"};
}else{
params = new String[]{"-i",input,"-el","-o",model,"-li",labelindex,"-ow"};
}
ToolRunner.run(tnbj, params);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("生成训练模型失败！");
System.exit(3);
}
}
}
package myTesting.bayes;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.lang.StringUtils;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.fs.PathFilter;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.mahout.classifier.naivebayes.BayesUtils;
import org.apache.mahout.classifier.naivebayes.NaiveBayesModel;
import org.apache.mahout.classifier.naivebayes.StandardNaiveBayesClassifier;
import org.apache.mahout.common.Pair;
import org.apache.mahout.common.iterator.sequencefile.PathType;
import org.apache.mahout.common.iterator.sequencefile.SequenceFileDirIterable;
import org.apache.mahout.math.RandomAccessSparseVector;
import org.apache.mahout.math.Vector;
import org.apache.mahout.math.Vector.Element;
import org.apache.mahout.vectorizer.TFIDF;
import com.google.common.collect.ConcurrentHashMultiset;
import com.google.common.collect.Multiset;
public class BayesCheckData {
private static StandardNaiveBayesClassifier classifier;
private static Map<String, Integer> dictionary;
private static Map<Integer, Long> documentFrequency;
private static Map<Integer, String> labelIndex;
public void init(Configuration conf){
try {
String modelPath = "/zhoujianfeng/playtennis/model";
String dictionaryPath = "/zhoujianfeng/playtennis/tennis-vectors/dictionary.file-0";
String documentFrequencyPath = "/zhoujianfeng/playtennis/tennis-vectors/df-count";
String labelIndexPath = "/zhoujianfeng/playtennis/labelindex";
dictionary = readDictionnary(conf, new Path(dictionaryPath));
documentFrequency = readDocumentFrequency(conf, new Path(documentFrequencyPath));
labelIndex = BayesUtils.readLabelIndex(conf, new Path(labelIndexPath));
NaiveBayesModel model = NaiveBayesModel.materialize(new Path(modelPath), conf);
classifier = new StandardNaiveBayesClassifier(model);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println("检测数据构造成vectors初始化时报错。。。。");
System.exit(4);
}
}
/**
* 加载字典文件，Key: TermValue； Value：TermID
* @param conf
* @param dictionnaryDir
* @return
*/
private static Map<String, Integer> readDictionnary(Configuration conf, Path dictionnaryDir) {
Map<String, Integer> dictionnary = new HashMap<String, Integer>();
PathFilter filter = new PathFilter() {
@Override
public boolean accept(Path path) {
String name = path.getName();
return name.startsWith("dictionary.file");
}
};
for (Pair<Text, IntWritable> pair : new SequenceFileDirIterable<Text, IntWritable>(dictionnaryDir, PathType.LIST, filter, conf)) {
dictionnary.put(pair.getFirst().toString(), pair.getSecond().get());
}
return dictionnary;
}
/**
* 加载df-count目录下TermDoc频率文件，Key: TermID； Value：DocFreq
* @param conf
* @param dictionnaryDir
* @return
*/
private static Map<Integer, Long> readDocumentFrequency(Configuration conf, Path documentFrequencyDir) {
Map<Integer, Long> documentFrequency = new HashMap<Integer, Long>();
PathFilter filter = new PathFilter() {
@Override
public boolean accept(Path path) {
return path.getName().startsWith("part-r");
}
};
for (Pair<IntWritable, LongWritable> pair : new SequenceFileDirIterable<IntWritable, LongWritable>(documentFrequencyDir, PathType.LIST, filter, conf)) {
documentFrequency.put(pair.getFirst().get(), pair.getSecond().get());
}
return documentFrequency;
}
public static String getCheckResult(){
Configuration conf = new Configuration();
conf.addResource(new Path("/usr/local/hadoop/conf/core-site.xml"));
String classify = "NaN";
BayesCheckData cdv = new BayesCheckData();
cdv.init(conf);
System.out.println("init done...............");
Vector vector = new RandomAccessSparseVector(10000);
TFIDF tfidf = new TFIDF();
//sunny，hot，high，weak
Multiset<String> words = ConcurrentHashMultiset.create();
words.add("sunny",1);
words.add("hot",1);
words.add("high",1);
words.add("weak",1);
int documentCount = documentFrequency.get(-1).intValue(); // key=-1时表示总文档数
for (Multiset.Entry<String> entry : words.entrySet()) {
String word = entry.getElement();
int count = entry.getCount();
Integer wordId = dictionary.get(word); // 需要从dictionary.file-0文件（tf-vector）下得到wordID，
if (StringUtils.isEmpty(wordId.toString())){
continue;
}
if (documentFrequency.get(wordId) == null){
continue;
}
Long freq = documentFrequency.get(wordId);
double tfIdfValue = tfidf.calculate(count, freq.intValue(), 1, documentCount);
vector.setQuick(wordId, tfIdfValue);
}
// 利用贝叶斯算法开始分类,并提取得分最好的分类label
Vector resultVector = classifier.classifyFull(vector);
double bestScore = -Double.MAX_VALUE;
int bestCategoryId = -1;
for(Element element: resultVector.all()) {
int categoryId = element.index();
double score = element.get();
System.out.println("categoryId:"+categoryId+" score:"+score);
if (score > bestScore) {
bestScore = score;
bestCategoryId = categoryId;
}
}
classify = labelIndex.get(bestCategoryId)+"(categoryId="+bestCategoryId+")";
return classify;
}
public static void printResult(){
System.out.println("检测所属类别是："+getCheckResult());
}
}
