海事局面试题目每个地方都一样吗？-招聘街

一、海事局面试题目每个地方都一样吗？

国考海事局面试题目每个地方都一样。

国家海事局面试近几年并未出现单独命题的情况，题型主要材料题和非材料题两种形式。题型主要包括综合分析、计划组织协调、情景应变、人际关系、自我认知、言语表达等相关题型，解题方法具体见基础理论讲义。

二、2015海事局职位

2015年度海事局职位评审结果公布

针对2015海事局职位的评审结果近日正式公布，此次评审涵盖了各个层级的职位，为前来应聘的众多海事从业者带来了期待已久的答案。本次评审由海事局专家组成的评审委员会负责，他们依据严格的标准和程序对每位申请者的资历、经验以及专业技能进行了细致的审核。

作为2015年度海事局职位的应聘者，他们经历了一系列严格的筛选流程，包括资格初审、笔试、面试等环节。最终，经过层层选拔，那些拥有过硬实力和丰富经验的申请者脱颖而出，成功获得了各自期望的工作岗位。

在此次评审中，不仅考察了申请者的专业能力，更注重他们的团队合作精神、创新能力以及未来发展潜力。通过评审流程，海事局希望选拔并录用那些既能胜任当前工作，又具备未来发展潜力的优秀人才，为海事行业的不断发展注入新鲜血液。

在公布评审结果后，海事局将根据录用人员的不同职位安排培训计划，以便让他们更快速地适应并融入工作环境。此外，也将对于未能入选的申请者提供有针对性的反馈意见，帮助他们不断提升自身能力，为今后的职位竞争做好准备。

通过此次2015年度海事局职位的评审，海事行业不仅吸引了大量优秀人才的加入，也提升了整个行业的专业素质和竞争力。未来，相信有这样一支富有活力和创新精神的团队，海事行业将会迎来更加璀璨的发展前景。

三、海事局怎么考

海事局怎么考？—— 一步一步了解中国海事局国家考试流程

海事局国家考试是中国海事局举办的一项重要考试，是获得海事从业资格的关键。对于那些希望从事海事相关职业的人来说，了解海事局考试的流程和要求是至关重要的。本文将带您一步一步了解中国海事局国家考试的全过程，让您对考试有一个清晰的认识。

第一步：报名参加考试

海事局国家考试每年都会举办，考试时间通常在每年的固定日期内。首先，您需要登录中国海事局的官方网站，查看考试的报名时间和要求。在报名时，您需要填写个人信息，并选择想要参加的考试科目。根据您的职业需求和目标，您可以选择不同的考试科目，例如航海技术与管理、港口与海岸工程等。

在报名时，务必确保填写的个人信息准确无误，以免影响后续的考试和认证流程。您还需要缴纳相应的报名费用，并按照要求提交相关的证明文件。一旦报名成功，您将获得一份报名确认函，确认您已成功报名参加海事局国家考试。

第二步：备考考试科目

一旦您成功报名参加海事局国家考试，您需要开始备考考试科目。每个考试科目涵盖的知识范围都不相同，因此您需要根据考试大纲和参考书目来制定备考计划。

海事局的官方网站提供了详细的考试大纲和参考书目，您可以根据这些信息选择适合自己的学习材料。在备考过程中，您可以参加培训班、参考过往的考试试题和参考书籍，以增加您的备考效果。

为了更好地备考，建议您制定一个详细的学习计划，并遵守计划的执行。合理安排时间，将重点放在对知识点的理解和掌握上，而不是简单地死记硬背。同时，切忌临时抱佛脚，只有真正掌握了知识，才能在考试中游刃有余。

第三步：参加考试

一切准备就绪后，到了参加考试的时间。请确保您提前到达考试地点，带齐身份证明、考试准考证和必要的文具。进入考场后，请认真听从监考人员的安排和要求，准备开始考试。

海事局国家考试通常采用笔试的形式，考试时间根据科目的不同而有所差别，但一般在数小时内完成。在考试过程中，您需要仔细阅读试题，并根据自己的理解和知识进行作答。请确保您的答案清晰、准确，并按照要求填写在答题卡或试卷上。

请注意，考试期间不得使用任何形式的通信工具或参考资料。任何在考场内违规行为，都可能导致您的考试结果被取消或遭受其他惩罚。因此，请一定要遵守考试纪律，杜绝作弊行为。

第四步：获得考试结果

完成考试后，您需要耐心等待考试结果的公布。海事局通常会在一定时间内公布考试的成绩和合格名单。您可以登录中国海事局的官方网站，查询考试成绩和认证情况。

如果您通过了考试，恭喜您！您将获得相应考试科目的合格证书，该证书将作为您从事相关职业的重要资格证明。如果您未能通过考试，不必灰心。您可以在下一次考试中重新参加，并针对未通过的科目进行有针对性的备考。

总结

海事局国家考试是获得海事从业资格的关键，了解考试流程和要求是必要的。首先，在官方网站上查看考试时间和要求，并按要求报名参加考试。其次，备考考试科目，制定详细的学习计划，并遵守计划的执行。然后，认真参加考试，遵守考试纪律，积极作答。最后，耐心等待考试结果的公布，根据结果做出相应的调整。

无论您是刚刚踏入海事行业，还是已经从事了一段时间的海事工作，通过中国海事局的国家考试可以帮助您提升职业能力和从业水平，为自己的职业发展铺平道路。

四、江苏海事局属于长江海事局吗？

江苏海事局属于长江海事局。

长江流域3家直属海事局(上海、江苏、长江海事局)和11家(云南、贵州、四川、重庆、湖北、湖南、江西、安徽、江苏、上海、河南)省(市)地方海事局在武汉召开海事管理机构联席会议，确认14家海事机构将实现联动执法，此举标志着长江黄金水道海事管理联动机制正式启动。

五、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能够更加智能化、个性化，为用户提供更好的地理信息服务，助力各行各业的决策和发展。