学习计划没写检讨-招聘街

一、学习计划没写检讨

在我们的生活中，制定学习计划是提高个人学习效率的重要环节之一。然而，很多人却常常忽视了学习计划的重要性。有的人视之为一种束缚，感觉没有自由；有的人觉得太麻烦，不愿意花时间去制定。但实际上，一个良好的学习计划可以帮助我们更好地规划时间，提高学习效率，培养良好的学习习惯。下面我将分享一些建议，帮助大家制定一个有效的学习计划。

明确学习目标

首先，制定学习计划之前，我们必须明确学习的目标。这个目标应该是具体、明确的，可以量化和评估的。举个例子，如果我们想提高英语口语水平，我们可以将目标设定为每天练习口语30分钟，每周背诵一篇英语短文，每月参加一次英语角活动。只有明确了目标，我们才能有针对性地制定学习计划。

分解学习任务

一旦明确了学习目标，接下来我们可以将这个目标分解为更小的学习任务。这样做的好处是，我们可以更清晰地知道要做什么，怎么做。我们可以根据自己的目标确定每天、每周、每月的学习任务，合理安排时间。例如，如果我们要备考某种证书，可以将复习内容分解为不同的模块，每天专门复习一到两个模块。这样做不仅可以帮助我们合理安排时间，还可以防止拖延症的发生。

制定学习日程

制定学习计划的下一步是制定学习日程。学习日程可以帮助我们更好地管理时间，避免浪费时间。我们可以将每天的学习时间分为不同的阶段，如早上、下午、晚上，为每个阶段设定特定的学习任务和时间。例如，早上可以用来背诵单词、看英语文章，下午可以用来做练习题，晚上可以用来复习当天的内容。制定学习日程时要注意的一点是，合理安排休息时间，避免过度疲劳。

制定学习方法

除了学习计划，学习方法也是非常重要的。没有有效的学习方法，学习计划也只是一纸空文。因此，我们在制定学习计划的同时，也要思考如何选择合适的学习方法。

首先，我们要根据自己的学习风格和学习目标选择相应的学习方法。有的人喜欢听力强化，那么可以选择多听英语材料。有的人喜欢阅读，可以选择大量阅读英语文章。有的人喜欢和他人交流，可以报名参加英语角活动。选择合适的学习方法能够让学习更加高效。

其次，我们要灵活运用不同的学习方法。有时候，同一个知识点可以用不同的角度去理解。我们可以尝试使用不同的学习方法，比如看视频、听音频、做练习题等，从不同的角度去掌握知识。这样做有助于提高学习的深度和广度。

制定学习评估体系

最后，一个完善的学习计划也需要有相应的评估体系。学习计划中的评估主要用于评估学习的效果和进度。我们可以设定一些具体的评估指标，比如每周测试一次，每月进行一次总结评估。评估的结果可以帮助我们及时发现不足，调整学习计划。

当然，制定学习计划只是第一步，更重要的是执行计划。我们要严格按照计划行动，遵守学习计划。计划外的事情要尽量避免，避免计划被打乱。如果在执行学习计划中遇到了困难和挫折，不要气馁，要坚持下去。因为只有付出了努力，才能取得好的学习效果。

总之，制定一个有效的学习计划对于提高学习效率是非常重要的。通过明确学习目标、分解学习任务、制定学习日程、选择适合的学习方法和建立评估体系，我们可以更好地规划时间、提高学习效果、养成良好的学习习惯。希望以上的分享可以对大家有所帮助，让我们一起制定一个好的学习计划，提高学习效率，取得更好的学业成绩！

二、借款没写借款合同

借款没写借款合同对双方都有潜在的风险和不确定性。无论是个人之间的借款还是私人与企业之间的借款，撰写借款合同是保护双方权益和避免纠纷的重要步骤。

借款是一种经济活动，一方向另一方暂时提供资金，并约定未来以同等或约定的利率和期限归还。当借款没有书面借款合同时，一方的权益可能会受到损害，而另一方则无法得到法律保护。

借款合同的重要性

借款合同是明确双方权益和义务的法律文件。它记录了借款的基本信息，包括借款金额、利率、期限、还款方式和其他相关条款。无论借款人是个人还是公司，借款合同都是确保双方权益、规避法律风险以及建立信任的关键。

以下是借款合同的一些重要性：

确保借款人和出借人权益。借款合同阐明了双方的利益，明确了借款人需要承担的责任和义务，包括还款方式、时间和金额等。对于出借人来说，借款合同确保了借款的利益和还款的安全性。
明确借款条款和条件。借款合同明确了借款的基本条款和条件，防止出现误解和争议。例如，合同中可以规定还款利息、罚息、提前还款和违约金等，保证双方在借贷过程中的权益平等。
法律保护和可执行性。合法的借款合同在法律上具备可执行性，一旦发生违约行为，受害方可以通过法律手段维护自己的权益。合同可以作为法庭审理和判决的依据，确保借款双方都有法律保护。
增加借款信用度和声誉。有书面借款合同可以证明借款人的信用度，并建立借款人的良好声誉。当借款人需要再次借款时，良好的信用记录和声誉将会给出借方带来更多的信任和机会。

没有借款合同可能带来的风险

借款没有书面借款合同可能导致以下风险和不确定性：

无法证明借款事实。没有借款合同，双方无法提供书面证据来证明借款发生的事实和细节。这可能给追索借款带来麻烦，甚至导致借款无法追回。
纠纷和争议的风险增加。缺乏明确的借款合同，双方之间容易产生误解和争议，尤其是在利率、还款方式、期限等方面。一旦出现纠纷，缺乏书面合同会给解决问题增加难度。
无法追索借款和利息。当借款没有书面合同时，借款人可能会违约或拖欠还款，而出借人无法通过法律手段追索借款和利息。
法律保护的缺失。没有借款合同，出借人无法通过法律途径来保护自己的权益。当借款人拒绝还款或发生其他纠纷时，出借人将无法得到法律的支持。

如何撰写借款合同

无论是个人借款还是企业借款，撰写借款合同都应该是一个规范而严谨的过程。以下是撰写借款合同的一些建议：

明确借款双方身份和联系信息。借款合同应该明确标明借款人和出借人的身份信息，包括姓名、联系方式和身份证号码等。
详细描述借款金额和利率。合同中应该详细描述借款的金额和利率，确保双方在借贷过程中的权益平等。
规定明确的还款方式和期限。合同中应该明确规定借款的还款方式和期限，包括每期还款金额和还款日，以避免争议和误解。
约定违约责任和补偿。合同中应该明确约定违约责任和补偿方式，以确保出借人在借款违约时可以得到合理的补偿。
法律条款的适用。合同中应该明确规定适用的法律条款和争议解决方式，提高合同的可执行性和法律保护。

撰写借款合同应该遵循法律规定和合同的常见要素，以保护双方的权益和确保借款的安全性。即使是亲戚和朋友之间的借款，写一份合同也是明智之举。

总结

借款合同对于借贷双方都至关重要。它明确了双方的权益和责任，减少了纠纷和争议的风险，增加了借款的可执行性和安全性。

无论是个人借款还是企业借款，撰写借款合同应该是一个严谨的过程。合同中应该明确规定借款的基本信息、还款方式和期限等重要事项。

因此，在借款时务必与对方签订书面借款合同，以保护自己的权益和确保借款的安全性。不要掉以轻心，只有在双方都有借款合同作为依据时，才能避免出现纠纷和争议。

三、违停罚单没写金额没写扣分怎么处理？

违章停车的罚单其实只是一个违章行为的通知单，所以不会直接体现处罚多少钱，更没有说明扣分多少。被贴罚单不要紧张，按照要求主动处理，吸取教训，下次尽量避免。违章停车的处罚，法规规定只有罚款50元以上200元以下，不用扣分的。

1.一般情况下，机动车被贴罚单存在两种情况，一是交通警察(交警队)发出的违法停车处罚通知单，另一种是城市监察大队(城管局)发出的违法停车处罚通知单。

2.交警队发出的违法停车处罚通知单，用于机动车在城市道路范围内违反车辆停放规定作出的处罚，城管局发出的违法停车处罚通知单用于机动车在城市非机动车和人行道范围内违反车辆停放规定作出的处罚。

有些地方在同一个地方办理，大多数地方不在同一个地方处理。一般情况下，通知单上有详细的处理地点和工作时间，在接受处罚时候需要看清楚。

3.接受处罚时候，请带上违法停车的机动车行驶证和违法停车驾驶员(或者经办人)的驾驶证。通知单上一般有15天以内主动处罚的要求，这个是可以不用担心的，超过时间接受处罚不会加大处罚力度也不会增加处罚金额。

4.不管是去交警队的处罚还是去城管局的处罚，违章停车的处罚统一是不扣分，罚款50-200元的标准，一般情况下，都是150元的处罚金额。

5.特殊情况下，第一时间赶到交警队或者城管局，找到执法的经办人，主动承认错误，虚心接受处罚，一般会有从轻处罚50元的可能。

四、mahout面试题？

之前看了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());

}

五、webgis面试题？

1. 请介绍一下WebGIS的概念和作用，以及在实际应用中的优势和挑战。

WebGIS是一种基于Web技术的地理信息系统，通过将地理数据和功能以可视化的方式呈现在Web浏览器中，实现地理空间数据的共享和分析。它可以用于地图浏览、空间查询、地理分析等多种应用场景。WebGIS的优势包括易于访问、跨平台、实时更新、可定制性强等，但也面临着数据安全性、性能优化、用户体验等挑战。

2. 请谈谈您在WebGIS开发方面的经验和技能。

我在WebGIS开发方面有丰富的经验和技能。我熟悉常用的WebGIS开发框架和工具，如ArcGIS API for JavaScript、Leaflet、OpenLayers等。我能够使用HTML、CSS和JavaScript等前端技术进行地图展示和交互设计，并能够使用后端技术如Python、Java等进行地理数据处理和分析。我还具备数据库管理和地理空间数据建模的能力，能够设计和优化WebGIS系统的架构。

3. 请描述一下您在以往项目中使用WebGIS解决的具体问题和取得的成果。

在以往的项目中，我使用WebGIS解决了许多具体问题并取得了显著的成果。例如，在一次城市规划项目中，我开发了一个基于WebGIS的交通流量分析系统，帮助规划师们评估不同交通方案的效果。另外，在一次环境监测项目中，我使用WebGIS技术实现了实时的空气质量监测和预警系统，提供了准确的空气质量数据和可视化的分析结果，帮助政府和公众做出相应的决策。

4. 请谈谈您对WebGIS未来发展的看法和期望。

我认为WebGIS在未来会继续发展壮大。随着云计算、大数据和人工智能等技术的不断进步，WebGIS将能够处理更大规模的地理数据、提供更丰富的地理分析功能，并与其他领域的技术进行深度融合。我期望未来的WebGIS能够更加智能化、个性化，为用户提供更好的地理信息服务，助力各行各业的决策和发展。

六、freertos面试题？

这块您需要了解下stm32等单片机的基本编程和简单的硬件设计，最好能够了解模电和数电相关的知识更好，还有能够会做操作系统，简单的有ucos，freeRTOS等等。最好能够使用PCB画图软件以及keil4等软件。希望对您能够有用。

七、paas面试题？

1.负责区域大客户/行业客户管理系统销售拓展工作，并完成销售流程；

2.维护关键客户关系，与客户决策者保持良好的沟通；

3.管理并带领团队完成完成年度销售任务。

八、面试题类型？

你好，面试题类型有很多，以下是一些常见的类型：

1. 技术面试题：考察候选人技术能力和经验。

2. 行为面试题：考察候选人在过去的工作或生活中的行为表现，以预测其未来的表现。

3. 情境面试题：考察候选人在未知情境下的决策能力和解决问题的能力。

4. 案例面试题：考察候选人解决实际问题的能力，模拟真实工作场景。

5. 逻辑推理题：考察候选人的逻辑思维能力和分析能力。

6. 开放性面试题：考察候选人的个性、价值观以及沟通能力。

7. 挑战性面试题：考察候选人的应变能力和创造力，通常是一些非常具有挑战性的问题。

九、cocoscreator面试题？

需要具体分析因为cocoscreator是一款游戏引擎，面试时的问题会涉及到不同的方面，如开发经验、游戏设计、图形学等等，具体要求也会因公司或岗位而异，所以需要根据实际情况进行具体分析。如果是针对开发经验的问题，可能会考察候选人是否熟悉cocoscreator常用API，是否能够独立开发小型游戏等等；如果是针对游戏设计的问题，则需要考察候选人对游戏玩法、关卡设计等等方面的理解和能力。因此，需要具体分析才能得出准确的回答。