国风诗句？-招聘街

一、国风诗句？

国风有关诗句，例如：

国风千载务重华，须逐浮云背若耶。——唐·谭用之《别江上一二友生》

国风雅泰民欢乐，只这和瘟大丈夫。——释印肃《移五瘟出市心》

国风此去无多子，关捩挑来秪等闲。——杨万里《答徐子材谈绝句》

国风惆怅黍离离，只有周郎五字诗。——李石《送周行可》

二、国风网名？

星垂晓雾（取自杜甫的“星垂平野阔，月涌大江流”）

尘缘易绝（取自纳兰容若“无那尘缘容易绝，燕子依然，软踏帘钩说”）

莫放相思（取自纳兰的“花月不曾闲，莫放相思醒。”）

白衣裳（取自“白衣裳凭朱栏立,凉月西,点鬓霜微,岁晏知君归不归?）

燕宿雕粱（取自”谢家庭院残更立,燕宿雕粱,月度银墙,不辨花丛那瓣香.）

君忆蓝桥（取自“浆向蓝桥易乞，药成碧海难奔”）

梦回无据（取自“更夜深、细听空阶雨滴，梦回无据。）

三、国风品牌？

一、李宁

运动潮流与传统文化的紧密结合

2020十大崛起国潮品牌，年轻代的传统文化自信都在这了

如果把李宁视为国潮的鼻祖，应该一点也不为过。这并不仅仅因为李宁恰好搭上了国潮的时代列车，还源于品牌本身对消费者需求和文化环境变化的深刻洞察。2020年8月，李宁联合天猫和敦煌博物馆打造了“李宁三十而立·丝路探行主题派对”，在沙漠中举办了一场文化交流与碰撞的时尚秀场。

敦煌作为自古以来中国通向世界的一个历史窗口，是中国文化走向世界的出发点。这种文化交流与融合的精神力量，转而激励着当下的国货品牌探索更多的可能性。李宁与“敦煌博物馆”合作，将运动潮流与中国文化紧密融合。对于品牌来说，也更容易在帮助年轻人寻找文化共鸣与认同的同时，拉近与年轻人的距离。

二、青岛啤酒

经典与时尚碰撞的跨时代干杯

2020十大崛起国潮品牌，年轻代的传统文化自信都在这了

青岛啤酒自1903年成立以来，已在市场上屹立百年之久。这依靠的不仅仅是优良的品质，其顺应时代潮流不断调整营销模式也是重要原因之一。2020年，青岛啤酒又推出新版青岛啤酒1903国潮罐，并联手GQ杂志邀请华晨宇拍摄了一支时尚大片，巧妙地把不同时代的潮流与现代文化融合碰撞，打造了一场奇妙的“跨时代干杯”。另一方面，青岛啤酒邀请李艺彤作客品牌直播间，与粉丝畅聊，分享推出2020年新版青岛啤酒1903国潮罐的初衷和包装设计，又一次让经典与时尚有力碰撞。

通过这次跨界国潮营销，青岛啤酒新版国潮罐的话题声量一炮打响，不仅巩固了品牌在当代年轻人心中的形象和地位，更顺应时代潮流方向，让青岛啤酒百年国潮品牌的文化影响力更加多元而深远

四、国风词汇？

1、水墨丹青：中国画中以墨色为主，以丹青色彩为辅

2、如诗如画：好像诗和画一样美丽

3、烟波浩渺：烟波雾霭苍茫的水面浩淼，水面辽阔，形容烟雾笼罩的江湖，水面广阔无边

4、落花流水：原形容暮春景色衰败。后来用来比喻被打得大败

5、象箸玉杯：形容生活奢侈

6、李郭仙舟：常用为友人相亲之典

7、通幽洞冥：通晓，洞察幽明之事

8、文期酒会：旧时文人定期举行的诗酒集会

9、情孚意合：形容双方思想感情融洽合得来

10、君子固穷：指君子能够安贫乐道，不失节操

五、国风段子？

江南水乡，垂柳依依，一道白衣女子静立水边，眉眼如画，倾国倾城。

她轻吟低唱，曼妙的歌声如同溪水一般悠悠荡荡，让人心神荡漾。

不远处，一位青衫少年在小舟上划动着双桨，眼中闪烁着兴奋的光芒，仿佛看到了什么宝贝。

他靠近女子，仔细聆听她的歌声，一时间忘却了时间和空间。瞬间，他想到了一句话：“若说此生无悔，便是与君相遇。”

此情此景，美不胜收，让人感叹古风之美，也感悟到了一份深情的美好。

六、国风语录？

唯美的国风古风句子 :

　　1、宁为秋霜，勿为犬羊。

　　2、昔我往矣,杨柳依依.今我来思,雨雪霏霏。

　　3、今生原为戏中死，余世何如一梦中。

　　4、上邪！我欲与君相知，长命无绝衰。山无陵，江水为竭，冬雷震震，夏雨雪，天地合，乃敢与君绝！

　　5、我为你入了魔，就罚你倾这一世来渡我。

七、国风歌词？

1. 为你再拾红妆收起行囊掩饰一身光芒。此心堕入情网人世荒唐前尘过往，转瞬沧桑。

　　2. 他说天下有敌，沽名何必。江湖夜雨十年心，枕剑半酣醉看月明。【枕剑听雨】

　　3. 血染江山的画，怎敌你眉间一点朱砂。覆了天下也罢，始终不过一场繁华。碧血染就桃花，只想再见你泪如雨下，听刀剑喑哑，高楼奄奄一息倾塌。

　　4. 玲珑骰子安红豆，入骨相思知不知。【玲珑】

　　5. 原来缘分是用来阐明，你忽然不爱我这件事情。

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