1.你为什么想做销售工作？ 这个问题对于工业专业出身的人来说有些不好回答，但是更重要的是你的实习经验，公司其实也没有必要回到学校请mba来做这个职位。尽量让你的回答具体，最好用举例子的方法列举你以前的成功经验。并且让招聘方认为你具有做好这个工作的潜质。
2.你认为本身最大的长处是什么？ 这里你需要回答你如何与同伴合作，你是一个销售人员，需要有动力爆发力和前进的精神。这些都是这个工作所必不成少的基本技能。如果你有别的方面销售天赋，那只能说你就天生是用来做销售的。
3.你认为本身最大的弱点是什么？ 在这种面试的情况下，请你不要说出本身有特别明显的缺点，或者说不要说出你应聘的职位最需要的缺点，可以谈一些不足，或者本身做不好的一些例子，但是不要因为谦虚，让招聘方认为你是一无可取的。这是最最重要的一点。
4.如何评价你本身？ 这个问题是招聘方考察你的个人表达能力和认识能力的问题。你可以突出本身的一些优点，但是不要说得过于直白，同时要强调本身的能力比力适合做销售工作，这里技巧很重要。同时说话要机智，也可以适当加些小幽默，显示你天生有与人交际的能力，这对于销售工作来说是很重要的。
5.你认为你具备什么样的技能适应这份工作？ 其实这个问题和上一个问题很相似，但是你回答不能雷同，虽然要表达的可能是同一个意思，但是决不能一模一样，要适当的有变化，来表现你的应变能力。能应付好招聘方的人对于销售工作也能做得不错。同时，这也在考查你的耐心，因为可能顾客的要求要麻烦得多，多次解释或者换一个角度解释也是必备能力之一。
6.工资对你有多重要？ 不要说得很重要，因为如果做到必然的份额，工资自然会很高，但是也不要完全不在乎，因为销售是做生意，必然程度上有钱的意识也是必要的。可以先问一下公司可以提供的，本身只要看能否接受就可以，或者说适量就可以。
7.请你讲一个好笑的笑话？ 这是一个看似很简单的问题，但是你会发现关键时刻能讲一个好笑的笑话也是一件很难的事情。这个问题，其实也是在考察你与人交际的能力。良好的客户意识和满足客户需要的能力，是这个问题的回答要点。讲不达时宜的冷笑话和又不好色彩的笑话是这个问题的大忌，不管它们有多好笑，都会使他们对你的品行产生不好的影响。所以千万要小心的讲看似轻松的笑话。
8.为什么你对销售工作比其他职位更有兴趣？ 这个问题需要从两方面回答。一个是从销售本身来说，你认为它有什么优势或者令你着迷的地方，你会专心致志的投入这个工作，但是切忌不能说别的职位就不好，这会让招聘方表情步愉快，并且你有可能会被调配，所以谓了不丧失工作机会，要三思而后言。另一个方面就是你个人的特点，因为个人能力和兴趣，更适合销售工作，这样会给招聘方留下相当良好的印象，收到事半功倍的效果。
9.如果每天让你给客户突然打销售电话你会怎么办？ 没有人愿意每天给客户突然打销售电话，因为这样收到冷遇的情况很多。
什么瑕疵？这个瑕疵是因为样品的折旧导致的，还是产品本身的问题？如果是产品本身有瑕疵，那你就给客户介绍另外一款产品没有瑕疵的产品。做销售的本质是帮客户解决问题，不是做一锤子买卖。如果是样品的折旧问题，你告诉客户，这个样品有这个瑕疵是折旧问题，全新的产品绝对不会这样，你可以在给客户的收款收据注明，如果新产品出现这种瑕疵，全额退款，还免费送他一个新的，然后让他赶紧去交钱。发货前自己检查一次，再拍个美美的照片给客户，下次客户还会找你
你好！只要遇到这样的面试，我建议你扭头就走，原因如下：
1、销售辨证力是长期锻炼的过程，这个能力是基于产品功能或服务价值的基础，如果太刻意追求这个，只能说明这个企业的产品很恶心，或者说这个企业的营销布局很低能！
2、类似风格是直接把外国的思想带进中国市场的做法，和上面一样，问题本身缺乏变通，这样面试出来的人，能说不会做。销售思想和销售实战是两回事。这个面试官是外行！
3、如果想练练脑子，不防可以从花的主要特征来反映。不同的花对应不同的群体，花本身反映的是人的修养、心态、爱好；同时，花也是风水摆件的重要组成部分。
让面试官先喝了,再问他收钱,不然打死他.反正售500元/瓶和搭劫没区别.先劫个千百块,有时间再劫个色.
针对招聘销售人员，面试者可以根据所应聘的具体职位准备相应的表现题，如：
1. 你何时开始担任销售工作？
2. 你是如何保持销售业绩的？
3. 在客户提出投诉时，你会怎么做？
4. 你有何特色服务和技能？
5. 你在工作中有何不同的拓展方法来增加销售业绩？等等。
首先我们需要了解面试者销售能力，如果是做过销售的人，这个时候可以通过了解他们的过往业绩，去判断他们的销售能力，也能够从而判断出是否符合公司需求。销售的沟通能力、语言能力是不可缺的，HR在面试过程中，可以多给他们设置一些问题，通过这些问题的回答，可以判断出这个面试者的沟通能力。
销售人员须具备较强的客户服务意识、灵活的沟通技巧、较强的销售能力和工作积极主动等素质，
1.请举例说明一下你的最好销售业绩。
2.你认为带领一个销售团队进步的最重要事情是什么？
3.请举例说明什么是有效的客户渠道？
4.你手机通讯录和微信有多少客户？
5.如果客户拒绝你的推销，怎么办？
6.请说说五一促销计划如何实施达到最佳业绩？
在如今竞争激烈的房地产市场，作为一名房产销售人员，要想在面试中脱颖而出，除了对于基本的销售技巧和房地产相关知识的掌握外，应变能力也是一个非常重要的因素。在这篇文章中，我们将为您介绍一些常见的房产销售应变类面试题，并给出解答的建议，帮助您在面试中更好地展示自己的能力。
面对客户对于房产价格的质疑，作为销售人员，我们需要以专业的态度和知识给出合理的解答。首先，我们可以通过介绍房屋的优势和价值来为价格辩解，比如房屋的地理位置、社区配套设施、装修品质等。同时，我们还可以提供市场的比价分析，将房屋的价格与周边相似房屋的价格进行比较，从而让客户更加了解市场行情和房屋的实际价值。
在房地产销售中，客户对于房屋环境的担忧是一个非常常见的问题，作为销售人员，我们需要给予客户足够的信任和安全感。首先，我们可以通过介绍小区的环境、绿化率、周边设施等来消除客户的顾虑。此外，如果可能的话，我们还可以带上客户实地参观房屋，让他们亲自感受房屋的环境和周边的生活氛围，进一步增强他们的信任和满意度。
面对客户对于房屋问题的询问，我们需要坦诚以对并且提供专业的解决方案。首先，我们可以对客户提出的问题进行认真的分析和研究，明确问题的原因和解决方法。然后，结合我们自身的经验和专业知识，给出客户一个满意的答复，并且提供解决问题的方案。同时，我们还可以向客户介绍一些成功的案例，让他们了解到我们的专业能力和解决问题的经验。
在房产销售中，客户情绪的波动是一个非常普遍的现象，作为销售人员，我们需要以冷静和耐心的态度来应对。首先，我们要做到全程倾听，让客户充分发泄情绪，同时保持冷静和理智。然后，我们需要正确理解客户的需求和关注点，通过积极沟通和解释，帮助他们理性地分析问题，并找到合适的解决方案。最后，我们要给予客户足够的关怀和支持，让他们感受到我们的诚意和真诚，从而缓解他们的情绪波动。
在房地产销售过程中，客户可能会对于签订合同有所犹豫，这时作为销售人员，我们需要引导客户做出决策。首先，我们可以针对客户的疑虑和担忧进行解答，让他们了解到签订合同的重要性和优势。同时，我们还可以提供一些相关的证据和数据，让客户明确房屋的价值和潜在的收益。此外，我们还可以引用一些客户的成功案例，让他们看到签订合同的好处和成功的可能性，从而鼓励他们做出决策。
房产销售应变类面试题是一个考验销售人员综合能力的重要环节。在面试中，我们需要展现出自己的专业知识和销售技巧，同时也要体现出自己良好的应变能力和沟通能力。通过合理的解答和有效的沟通，我们可以给面试官留下深刻的印象并提高自己的竞争力。希望以上内容对于您在房产销售面试中有所帮助。
我觉得销售是一个可以锻炼人的工作，可以把自己的优势充分发挥出来，很有挑战的工作，销售可以帮公司以及自己实现人生目标的价值，为公司直接带来经济利益，也为我带来对等的回报，现在销售行业竞争激烈，现在做销售也是在做服务，服务做好了就有了人脉，人脉才是销售的关键！所以，做销售一定要先学会做人，只有这样才能是一个成功的销售！有前途的销售！
之前看了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());
}
}
