logo
Redian新闻
>未名空间
>Joke - 肚皮舞运动
>
Re: 高考报志愿！亲戚年头还有人坚持报生物，唉！！过来人表示(转载)
avatar
Re: 高考报志愿！亲戚年头还有人坚持报生物，唉！！过来人表示(转载)# Joke - 肚皮舞运动
G*A
1 楼
Given a stream of integers. The elements arrive one by one. Write code to
find the median of the most recent k elements. You can assume k is odd.
e.g., when k=3,
输入： 1，3，5，7，9，11 ...
输出： 3，5, 7，9 ...
[1,3,5] --> [3]
[3,5,7] --> [5]
[5,7,9] --> [7]
[7,9,11]--> [9]
avatar
h*z
2 楼
在本版学到的EB1A RFE经验,强CASE就不用看了(citation<80, 正经paper<7)
1. 在RL出现的重要东西, 也不要在PL中漏掉, RL和PL要相互呼应,RL还是很重要!
2.不明白为什么大牛不要找?我就找了两个,大牛还在RL中列出著作>350.YOUNG
INVESTIGATOR等禁忌语汇,关键是要证明你在你的领域是很牛滴.PL大量应用RL,对IO进
行地毯式轰炸.没有和什么FACULTY对比.朋友建议不要比, 没什么可比性,欣然采纳.
3.文章不牛,引用不多, 好像也不是问题,关键是讲出特色来,别人运用也是关键.小提了
一下我的领域TOTAL才380篇文章,40年间,indicating the field is far from mature
with much to learn... 而我短时间就发了5-6篇,也为继续做出贡献做铺垫.
4.所有会议和文章全放在一起号称有30, 就这么笼统提了一下.
5.用了Eigenfactor percentile, 然后引经据典,狠狠批判了极度单纯的IF计算方法,其
实你的文章如果有5-6分, 就可以上SMALL PERCENTAGE BY EIGENFACTOR.
4.没有分什么自引他引! 主要用GOOGLE SCHOLAR,只提了一次TOTAL CITATION在PL,还有
一次在EXHIBIT LIST.建议引用不多的就免提吧.引用多的当然可以玩不同的花式.
5.不强的证据拿掉, 前人有挥刀断臂论.
6.要坦诚,不要怕你的IF不高,我的照样列上<7, 还作了一个表,和EIGENFACTOR
PERCENTILE对比.注意这里不要把实际RANKING列出, 除非你是JBC, NATURE, PNAS, 大
家都知道JBC 的EIGENFACTOR 排名极度靠前.
7.其它什么NEWSRX, HIGHBEAM, DATABASE(NCBI, LABOME,UNIPROT)证据找了一堆, 很多
人对NEWSRX,HIGHBEAM很不已为然, 其实还是管用的.只在CONTRIBUTION里CLAIM.
8.最后一条建议有点CRAZY: CASE不强的不如先找个LAWYER胡乱给你CLAIM一气,然后准
备在RFE中绝地反击.前面要做得烂一点,才能衬托出你确实很牛,但也不要太过火了, 否
则全给你DENY也很麻烦, 至少前期要让IO承认2-3条吧.这也是"两步法".
最后,本版网友和现实中的朋友给我帮助极大,是他们的无私奉献让我受益匪浅.
avatar
n*t
3 楼
他家质量非常好吗？谢谢
avatar
p*c
4 楼
【 以下文字转载自 Biology 讨论区 】
发信人: penn001 (Time is money, friend!), 信区: Biology
标 题: Re: 高考报志愿！亲戚年头还有人坚持报生物，唉！！过来人表示苦劝
发信站: BBS 未名空间站 (Tue Jun 25 15:17:50 2013, 美东)
生物以后应该很有前途吧，现在所有专业的热门点都是生物呢。力学都研究生物力学，
连我们最土最木的土木专业，科研的热点也是生物材料，据说以后的水泥和沥青，石头
材料都要被可再生生物材料替代呢，想想以后的公路和桥梁都是植物做的我就激动不已
。我们高中老师说过：20年后大树下蛋呢不用再养母鸡了，她说得有一定道理!
avatar
c*b
5 楼
用indexable skiplist可以做到每次取median是O(lgk)
https://rhettinger.wordpress.com/tag/running-median/

【在 G****A 的大作中提到】
: Given a stream of integers. The elements arrive one by one. Write code to
: find the median of the most recent k elements. You can assume k is odd.
: e.g., when k=3,
: 输入： 1，3，5，7，9，11 ...
: 输出： 3，5, 7，9 ...
: [1,3,5] --> [3]
: [3,5,7] --> [5]
: [5,7,9] --> [7]
: [7,9,11]--> [9]
avatar
j*p
6 楼
多谢分享
avatar
S*n
7 楼
fragomen
avatar
r*n
8 楼
用indexed priority_queue（2个，上半段+下半段）和一个counter（mod k）
(counter+1)%k可以得到expired的那个数的index，然后用
indexed_pq.update(idx，new_val)
把expired掉的那个数换成最新的数new_val
avatar
b*e
9 楼
第8条很有创意，Orz :)
thanks for sharing.

mature

【在 h*****z 的大作中提到】
: 在本版学到的EB1A RFE经验,强CASE就不用看了(citation<80, 正经paper<7)
: 1. 在RL出现的重要东西, 也不要在PL中漏掉, RL和PL要相互呼应,RL还是很重要!
: 2.不明白为什么大牛不要找?我就找了两个,大牛还在RL中列出著作>350.YOUNG
: INVESTIGATOR等禁忌语汇,关键是要证明你在你的领域是很牛滴.PL大量应用RL,对IO进
: 行地毯式轰炸.没有和什么FACULTY对比.朋友建议不要比, 没什么可比性,欣然采纳.
: 3.文章不牛,引用不多, 好像也不是问题,关键是讲出特色来,别人运用也是关键.小提了
: 一下我的领域TOTAL才380篇文章,40年间,indicating the field is far from mature
: with much to learn... 而我短时间就发了5-6篇,也为继续做出贡献做铺垫.
: 4.所有会议和文章全放在一起号称有30, 就这么笼统提了一下.
: 5.用了Eigenfactor percentile, 然后引经据典,狠狠批判了极度单纯的IF计算方法,其
avatar
w*u
10 楼
非常烂，能不用最好别用

【在 n*****t 的大作中提到】
: 他家质量非常好吗？谢谢
avatar
R*i
11 楼
这个题目建议用红黑树做可能最快捷有效。红黑树每一次插入，删除都是log(k),求平
均值非常简单，就是根部的那个节点。所以总的计算量是O(nlog(k))。
以下是c/c++代码（需要修改数组，以便一个一个输入）。
#include
#include
#include
#define INDENT_STEP 4
enum rbtree_node_color {RED, BLACK};
typedef struct rbtree_node_t {
int value;
struct rbtree_node_t* left;
struct rbtree_node_t* right;
struct rbtree_node_t* parent;
enum rbtree_node_color color;
} *rbtree_node;
typedef rbtree_node node;
typedef enum rbtree_node_color color;
typedef struct rbtree_t {
rbtree_node root;
} *rbtree;
typedef int (*compare_func) (int left, int right);
static node grandparent(node n);
static node sibling(node n);
static node uncle(node n);
static void verify_properties(rbtree t);
static void verify_property_1(node root);
static void verify_property_2(node root);
static color node_color(node n);
static void verify_property_4(node root);
static void verify_property_5(node root);
static void verify_property_5_helper(node n, int black_count, int* black_
count_path);
rbtree rbtree_create();
static node new_node(int value, color node_color, node left, node right);
static node lookup_node(rbtree t, int value, compare_func compare);
static void rotate_left(rbtree t, node n);
static void rotate_right(rbtree t, node n);
static void replace_node(rbtree t, node oldn, node newn);
void rbtree_insert(rbtree t, int value, compare_func compare);
static void insert_case1(rbtree t, node n);
static void insert_case2(rbtree t, node n);
static void insert_case3(rbtree t, node n);
static void insert_case4(rbtree t, node n);
static void insert_case5(rbtree t, node n);
void rbtree_delete(rbtree t, int value, compare_func compare);
static node maximum_node(node root);
static void delete_case1(rbtree t, node n);
static void delete_case2(rbtree t, node n);
static void delete_case3(rbtree t, node n);
static void delete_case4(rbtree t, node n);
static void delete_case5(rbtree t, node n);
static void delete_case6(rbtree t, node n);
static int compare_int(int left, int right);
static void print_tree(rbtree t);
static void print_tree_helper(rbtree_node n, int indent);
color node_color(node n){
return n==NULL ? BLACK : n->color;
}
node grandparent(node n) {
assert (n != NULL);
assert (n->parent != NULL); /* Not the root node */
assert (n->parent->parent != NULL); /* Not child of root */
return n->parent->parent;
}
node sibling(node n) {
assert (n != NULL);
assert (n->parent != NULL); /* Root node has no sibling */
if (n == n->parent->left)
return n->parent->right;
else
return n->parent->left;
}
node uncle(node n) {
assert (n != NULL);
assert (n->parent != NULL); /* Root node has no uncle */
assert (n->parent->parent != NULL); /* Children of root have no uncle */
return sibling(n->parent);
}
void verify_property_1(node n){
assert(node_color(n) == RED || node_color(n) == BLACK);
if (n==NULL) return;
verify_property_1(n->left);
verify_property_1(n->right);
}
void verify_property_2(node root){
assert(node_color(root) == BLACK);
}
void verify_property_4(node n){
if(node_color(n) == RED) {
assert(node_color(n->left) == BLACK);
assert(node_color(n->right) == BLACK);
assert(node_color(n->parent) == BLACK);
}
if(n==NULL) return;
verify_property_4(n->left);
verify_property_4(n->right);
}
void verify_property_5_helper(node n, int black_count, int* path_black_count
){
if(node_color(n) == BLACK) {
black_count++;
}
if(n==NULL){
if (*path_black_count == -1) {
*path_black_count = black_count;
}else{
assert (black_count == *path_black_count);
}
return;
}
verify_property_5_helper(n->left, black_count, path_black_count);
verify_property_5_helper(n->right, black_count, path_black_count);
}
void verify_property_5(node root){
int black_count_path = -1;
verify_property_5_helper(root, 0, &black_count_path);
}
void verify_properties(rbtree t){
verify_property_1(t->root);
verify_property_2(t->root);
//property 3 is implicit
verify_property_4(t->root);
verify_property_5(t->root);
}
rbtree rbtree_create(){
rbtree t = (rbtree)malloc(sizeof(struct rbtree_t));
t->root = NULL;
verify_properties(t);
return t;
}
node new_node(int value, color node_color, node left, node right){
node result = (node)malloc(sizeof(struct rbtree_node_t));
result->value = value;
result->color = node_color;
result->left = left;
result->right = right;
if(left != NULL) left->parent = result;
if(right != NULL) right->parent = result;
result->parent = NULL;
return result;
}
node lookup_node(rbtree t, int value, compare_func compare){
node n = t->root;
while (n!= NULL){
int comp_result = compare(value, n->value);
if(comp_result == 0) {
return n;
}else if(comp_result<0){
n=n->left;
}else {
assert(comp_result>0);
n=n->right;
}
}
return 0;
}
void replace_node(rbtree t, node oldn, node newn) {
if (oldn->parent == NULL) {
t->root = newn;
} else {
if (oldn == oldn->parent->left)
oldn->parent->left = newn;
else
oldn->parent->right = newn;
}
if (newn != NULL) {
newn->parent = oldn->parent;
}
}
void rotate_left(rbtree t, node n){
node r = n->right;
replace_node(t, n, r);
n->right = r->left;
if(r->left != NULL){
r->left->parent = n;
}
r->left = n;
n->parent = r;
}
void rotate_right(rbtree t, node n) {
node L = n->left;
replace_node(t, n, L);
n->left = L->right;
if (L->right != NULL) {
L->right->parent = n;
}
L->right = n;
n->parent = L;
}
void rbtree_insert(rbtree t, int value, compare_func compare) {
node inserted_node = new_node(value, RED, NULL, NULL);
if (t->root == NULL) {
t->root = inserted_node;
} else {
node n = t->root;
while (1) {
int comp_result = compare(value, n->value);
if (comp_result == 0) {
free (inserted_node);
return;
} else if (comp_result < 0) {
if (n->left == NULL) {
n->left = inserted_node;
break;
} else {
n = n->left;
}
} else {
assert (comp_result > 0);
if (n->right == NULL) {
n->right = inserted_node;
break;
} else {
n = n->right;
}
}
}
inserted_node->parent = n;
}
insert_case1(t, inserted_node);
verify_properties(t);
}
void insert_case1(rbtree t, node n) {
if (n->parent == NULL)
n->color = BLACK;
else
insert_case2(t, n);
}
void insert_case2(rbtree t, node n) {
if (node_color(n->parent) == BLACK)
return; /* Tree is still valid */
else
insert_case3(t, n);
}
void insert_case3(rbtree t, node n) {
if (node_color(uncle(n)) == RED) {
n->parent->color = BLACK;
uncle(n)->color = BLACK;
grandparent(n)->color = RED;
insert_case1(t, grandparent(n));
} else {
insert_case4(t, n);
}
}
void insert_case4(rbtree t, node n) {
if (n == n->parent->right && n->parent == grandparent(n)->left) {
rotate_left(t, n->parent);
n = n->left;
} else if (n == n->parent->left && n->parent == grandparent(n)->right) {
rotate_right(t, n->parent);
n = n->right;
}
insert_case5(t, n);
}
void insert_case5(rbtree t, node n) {
n->parent->color = BLACK;
grandparent(n)->color = RED;
if (n == n->parent->left && n->parent == grandparent(n)->left) {
rotate_right(t, grandparent(n));
} else {
assert (n == n->parent->right && n->parent == grandparent(n)->right);
rotate_left(t, grandparent(n));
}
}
void rbtree_delete(rbtree t, int value, compare_func compare) {
node child;
node n = lookup_node(t, value, compare);
if (n == NULL) return; /* Key not found, do nothing */
if (n->left != NULL && n->right != NULL) {
/* Copy value from predecessor and then delete it instead */
node pred = maximum_node(n->left);
n->value = pred->value;
n = pred;
}
assert(n->left == NULL || n->right == NULL);
child = n->right == NULL ? n->left : n->right;
if (node_color(n) == BLACK) {
n->color = node_color(child);
delete_case1(t, n);
}
replace_node(t, n, child);
if (n->parent == NULL && child != NULL)
child->color = BLACK;
free(n);
verify_properties(t);
}
void delete_case1(rbtree t, node n) {
if (n->parent == NULL)
return;
else
delete_case2(t, n);
}
void delete_case2(rbtree t, node n) {
if (node_color(sibling(n)) == RED) {
n->parent->color = RED;
sibling(n)->color = BLACK;
if (n == n->parent->left)
rotate_left(t, n->parent);
else
rotate_right(t, n->parent);
}
delete_case3(t, n);
}
void delete_case3(rbtree t, node n) {
if (node_color(n->parent) == BLACK &&
node_color(sibling(n)) == BLACK &&
node_color(sibling(n)->left) == BLACK &&
node_color(sibling(n)->right) == BLACK)
{
sibling(n)->color = RED;
delete_case1(t, n->parent);
}
else
delete_case4(t, n);
}
void delete_case4(rbtree t, node n) {
if (node_color(n->parent) == RED &&
node_color(sibling(n)) == BLACK &&
node_color(sibling(n)->left) == BLACK &&
node_color(sibling(n)->right) == BLACK)
{
sibling(n)->color = RED;
n->parent->color = BLACK;
}
else
delete_case5(t, n);
}
void delete_case5(rbtree t, node n) {
if (n == n->parent->left &&
node_color(sibling(n)) == BLACK &&
node_color(sibling(n)->left) == RED &&
node_color(sibling(n)->right) == BLACK)
{
sibling(n)->color = RED;
sibling(n)->left->color = BLACK;
rotate_right(t, sibling(n));
}
else if (n == n->parent->right &&
node_color(sibling(n)) == BLACK &&
node_color(sibling(n)->right) == RED &&
node_color(sibling(n)->left) == BLACK)
{
sibling(n)->color = RED;
sibling(n)->right->color = BLACK;
rotate_left(t, sibling(n));
}
delete_case6(t, n);
}
void delete_case6(rbtree t, node n) {
sibling(n)->color = node_color(n->parent);
n->parent->color = BLACK;
if (n == n->parent->left) {
assert (node_color(sibling(n)->right) == RED);
sibling(n)->right->color = BLACK;
rotate_left(t, n->parent);
}
else
{
assert (node_color(sibling(n)->left) == RED);
sibling(n)->left->color = BLACK;
rotate_right(t, n->parent);
}
}
static node maximum_node(node n) {
assert (n != NULL);
while (n->right != NULL) {
n = n->right;
}
return n;
}
void print_tree_helper(rbtree_node n, int indent) {
int i;
if (n == NULL) {
fputs("", stdout);
return;
}
if (n->right != NULL) {
print_tree_helper(n->right, indent + INDENT_STEP);
}
for(i=0; ifputs(" ", stdout);
if (n->color == BLACK)
printf("%d\n", n->value);
else
printf("\n", n->value);
if (n->left != NULL) {
print_tree_helper(n->left, indent + INDENT_STEP);
}
}
void print_tree(rbtree t) {
print_tree_helper(t->root, 0);
puts("");
}
int compare_int(int left, int right) {
if (left < right)
return -1;
else if (left > right)
return 1;
else {
assert (left == right);
return 0;
}
}
int main(){
const int w = 3;
int A[] = {1, 3, 5, 7, 9, 11, 13, 15};
int n = sizeof(A)/sizeof(A[0]);
int i;
rbtree r = rbtree_create();
for(i=0; irbtree_insert(r, A[i], compare_int);
}
//printf("%d", maximum_node(r->root)->value);
printf("%d", r->root->value);
for(i=w; irbtree_delete(r, A[i-3], compare_int);
rbtree_insert(r, A[i], compare_int);
//printf("\n%d", maximum_node(r->root)->value);
printf("%d", r->root->value);
}
return 0;
}
avatar
b*e
12 楼
orz

mature

【在 h*****z 的大作中提到】
: 在本版学到的EB1A RFE经验,强CASE就不用看了(citation<80, 正经paper<7)
: 1. 在RL出现的重要东西, 也不要在PL中漏掉, RL和PL要相互呼应,RL还是很重要!
: 2.不明白为什么大牛不要找?我就找了两个,大牛还在RL中列出著作>350.YOUNG
: INVESTIGATOR等禁忌语汇,关键是要证明你在你的领域是很牛滴.PL大量应用RL,对IO进
: 行地毯式轰炸.没有和什么FACULTY对比.朋友建议不要比, 没什么可比性,欣然采纳.
: 3.文章不牛,引用不多, 好像也不是问题,关键是讲出特色来,别人运用也是关键.小提了
: 一下我的领域TOTAL才380篇文章,40年间,indicating the field is far from mature
: with much to learn... 而我短时间就发了5-6篇,也为继续做出贡献做铺垫.
: 4.所有会议和文章全放在一起号称有30, 就这么笼统提了一下.
: 5.用了Eigenfactor percentile, 然后引经据典,狠狠批判了极度单纯的IF计算方法,其
avatar
e*t
13 楼
I doubt RB tree will always give you the median at the root.
http://en.wikipedia.org/wiki/Red%E2%80%93black_tree
"The balancing of the tree is not perfect but it is good enough to allow it
to guarantee searching in O(log n) time"
You need a perfectly balanced binary search tree to get the median at the ro
ot.

【在 R*****i 的大作中提到】
: 这个题目建议用红黑树做可能最快捷有效。红黑树每一次插入，删除都是log(k),求平
: 均值非常简单，就是根部的那个节点。所以总的计算量是O(nlog(k))。
: 以下是c/c++代码（需要修改数组，以便一个一个输入）。
: #include
: #include
: #include
: #define INDENT_STEP 4
: enum rbtree_node_color {RED, BLACK};
: typedef struct rbtree_node_t {
: int value;
avatar
i*n
14 楼
我也一直在考虑是不是要故意留个漏洞吸引IO的火力，隐藏自己的弱点，然后RFE的时
候放出重磅来震一把。
avatar
S*g
16 楼
很多人是感想不敢干
但是感觉很有操作性

【在 i****n 的大作中提到】
: 我也一直在考虑是不是要故意留个漏洞吸引IO的火力，隐藏自己的弱点，然后RFE的时
: 候放出重磅来震一把。
avatar
G*A
17 楼
谢谢。有没有更intuitive的解法？
给了2个暗示：1）k很小(<=5); 2)用最基本的逻辑和数据结构，不要用stack/queue/
hash等
ADT.
我当时就说，如果k=3,那干脆直接看3个值大小，需要compare至多3次找到median，
complexity就是O(n),where n is the size of stream.面试官说可以，让我写code，
要求考虑全所有的cases.不知道他想考察考哪方面

【在 r*********n 的大作中提到】
: 用indexed priority_queue（2个，上半段+下半段）和一个counter（mod k）
: (counter+1)%k可以得到expired的那个数的index，然后用
: indexed_pq.update(idx，new_val)
: 把expired掉的那个数换成最新的数new_val
avatar
L*S
18 楼
恩，有意思。第八条。
以前也在想，可以不可以故意露出一个破ding，故意招RFE，以掩饰其他方面的不足
avatar
d*n
19 楼
vector median(vector & v, int k) {
vector::iterator iter;
vector median;
iter=v.begin();
while((iter+k-1)!=v.end()) {
vector temp(iter,iter+k);
sort(temp.begin(),temp.end());
median.push_back(temp[k/2]);
iter++;
}
return median;
}
这个比较简单，也没有用stack,queue,hash.

【在 G****A 的大作中提到】
: 谢谢。有没有更intuitive的解法？
: 给了2个暗示：1）k很小(<=5); 2)用最基本的逻辑和数据结构，不要用stack/queue/
: hash等
: ADT.
: 我当时就说，如果k=3,那干脆直接看3个值大小，需要compare至多3次找到median，
: complexity就是O(n),where n is the size of stream.面试官说可以，让我写code，
: 要求考虑全所有的cases.不知道他想考察考哪方面
avatar
f*e
20 楼
恭喜!
avatar
r*n
21 楼
既然k很小，直接存到circular array里面，每次都把整个array扫一边，取出中数。

【在 G****A 的大作中提到】
: 谢谢。有没有更intuitive的解法？
: 给了2个暗示：1）k很小(<=5); 2)用最基本的逻辑和数据结构，不要用stack/queue/
: hash等
: ADT.
: 我当时就说，如果k=3,那干脆直接看3个值大小，需要compare至多3次找到median，
: complexity就是O(n),where n is the size of stream.面试官说可以，让我写code，
: 要求考虑全所有的cases.不知道他想考察考哪方面
avatar
k*o
22 楼
呵呵，超级感谢。我是超级弱case，正在对抗RFE。
如醍醐灌顶~~~
请问一下，highbeam的报道自己不是一作，也可以用吗？
还有，highbeam全文是怎么拿到的，free trail7天吗，好不好cancel呢。
多谢分享，恭喜恭喜。
avatar
r*n
23 楼
这是杀鸡用牛刀吧
我个人觉得red-black tree的delete method非常难写。

【在 R*****i 的大作中提到】
: 这个题目建议用红黑树做可能最快捷有效。红黑树每一次插入，删除都是log(k),求平
: 均值非常简单，就是根部的那个节点。所以总的计算量是O(nlog(k))。
: 以下是c/c++代码（需要修改数组，以便一个一个输入）。
: #include
: #include
: #include
: #define INDENT_STEP 4
: enum rbtree_node_color {RED, BLACK};
: typedef struct rbtree_node_t {
: int value;
avatar
S*8
24 楼
全文可以到大学数据库进行下载。
我刚刚开始对抗RFE

【在 k*****o 的大作中提到】
: 呵呵，超级感谢。我是超级弱case，正在对抗RFE。
: 如醍醐灌顶~~~
: 请问一下，highbeam的报道自己不是一作，也可以用吗？
: 还有，highbeam全文是怎么拿到的，free trail7天吗，好不好cancel呢。
: 多谢分享，恭喜恭喜。
avatar
R*i
25 楼
http://richardhartersworld.com/cri/2011/winmedian.html
Conclusions
Well written array implementations are preferable for small windows. Judging
from similar problems, the breakpoint is probably for window sizes of
around 20-30. For larger window sizes the double heap algorithm is simple
and has guaranteed performance. There may be better alternatives but
establishing them will require significant amounts of testing and analysis.
avatar
S*8
26 楼
全文可以到大学数据库进行下载。
我刚刚开始对抗RFE

【在 k*****o 的大作中提到】
: 呵呵，超级感谢。我是超级弱case，正在对抗RFE。
: 如醍醐灌顶~~~
: 请问一下，highbeam的报道自己不是一作，也可以用吗？
: 还有，highbeam全文是怎么拿到的，free trail7天吗，好不好cancel呢。
: 多谢分享，恭喜恭喜。
avatar
a*n
27 楼
thanks for sharing
avatar
e*r
28 楼
谢分享～

mature

【在 h*****z 的大作中提到】
: 在本版学到的EB1A RFE经验,强CASE就不用看了(citation<80, 正经paper<7)
: 1. 在RL出现的重要东西, 也不要在PL中漏掉, RL和PL要相互呼应,RL还是很重要!
: 2.不明白为什么大牛不要找?我就找了两个,大牛还在RL中列出著作>350.YOUNG
: INVESTIGATOR等禁忌语汇,关键是要证明你在你的领域是很牛滴.PL大量应用RL,对IO进
: 行地毯式轰炸.没有和什么FACULTY对比.朋友建议不要比, 没什么可比性,欣然采纳.
: 3.文章不牛,引用不多, 好像也不是问题,关键是讲出特色来,别人运用也是关键.小提了
: 一下我的领域TOTAL才380篇文章,40年间,indicating the field is far from mature
: with much to learn... 而我短时间就发了5-6篇,也为继续做出贡献做铺垫.
: 4.所有会议和文章全放在一起号称有30, 就这么笼统提了一下.
: 5.用了Eigenfactor percentile, 然后引经据典,狠狠批判了极度单纯的IF计算方法,其
avatar
l*6
29 楼
mark
avatar
h*b
30 楼
呵呵，写得不错

mature

【在 h*****z 的大作中提到】
: 在本版学到的EB1A RFE经验,强CASE就不用看了(citation<80, 正经paper<7)
: 1. 在RL出现的重要东西, 也不要在PL中漏掉, RL和PL要相互呼应,RL还是很重要!
: 2.不明白为什么大牛不要找?我就找了两个,大牛还在RL中列出著作>350.YOUNG
: INVESTIGATOR等禁忌语汇,关键是要证明你在你的领域是很牛滴.PL大量应用RL,对IO进
: 行地毯式轰炸.没有和什么FACULTY对比.朋友建议不要比, 没什么可比性,欣然采纳.
: 3.文章不牛,引用不多, 好像也不是问题,关键是讲出特色来,别人运用也是关键.小提了
: 一下我的领域TOTAL才380篇文章,40年间,indicating the field is far from mature
: with much to learn... 而我短时间就发了5-6篇,也为继续做出贡献做铺垫.
: 4.所有会议和文章全放在一起号称有30, 就这么笼统提了一下.
: 5.用了Eigenfactor percentile, 然后引经据典,狠狠批判了极度单纯的IF计算方法,其
avatar
x*y
31 楼
赞！
avatar
a*y
32 楼
精简
相关阅读
唉...这朋友... (转载)演员金凯瑞入党了？上帝也在挖坑收到一个巨猛的电话SURVEYBreaking News:王小丫已经被列入了敏感词 (转载)朝韩之变 macrowave夏姐...有人转过没？7k以下二手车，日车绝对是唯一的选择！！[头次买车的新手们看过 (转载)句句都是辛酸！房价破4万后一北京姑娘的20年感言（zz）绵恒和海峰谁的学术水平高？转漫画大家看 0409我终于想明白了为什么非洲人没驯化（斑）马可以一边洗澡一边看ipad吗？ (转载)Re: 归根到底还是老邢大波内裤被扒光-历史版规学习心得 (转载)我还是个姑娘！！！Re: 印度红军 (转载)那人，那山，那狗 。那人，那胸，那臀 (转载)挖个坑---问问已婚的都是如何协调健身和LD的关系的.zt 赵本山恶搞丰田（转）恶搞笑
logo
联系我们隐私协议©2024 redian.news
Redian新闻
Redian.news刊载任何文章，不代表同意其说法或描述，仅为提供更多信息，也不构成任何建议。文章信息的合法性及真实性由其作者负责，与Redian.news及其运营公司无关。欢迎投稿，如发现稿件侵权，或作者不愿在本网发表文章，请版权拥有者通知本网处理。