睡觉万岁

std:unordered_map<int,int> map;
//key 存数字 value存index
for(int i = 0 ;i < nums.size(); i++){
	auto iter= map.find(target-nums[i]);
	if(iter!=map.end()){
		return{iter->second,i};
	}
	map.insert(pair<int,int>(nums[i],i));
}
	return {};

unordered_map<int,int> map;
for(int i = 0 ; i <nums.size();i++){
	unordered_map<int,int>::iterator iter=map.find(target-nums[i]);
    if(iter!=map.end()){
        return {iter->second,i};
    }
    map.insert(pair<int,int>(nums[i],i));
}
return {};

int getSum(int n){
    int sum=0;
    while(n){
        sum+=(n%10)*(n%10);
        n/=10;
    }
    return sum;
}
bool isHappy(int n){
    unordered_set<int> set;
    while(1){
        int sum=getSum(n);
        if(sum==1){
            return true;
        }
         // 如果这个sum曾经出现过，说明已经陷入了无限循环了，立刻return false
        if(set.find(sum)!=set.end()){
            return false;
        }
        else{
            set.insert(sum);
        }
        n=sum;
    }
}

vector<int> intersection(vector<int>& nums1,vector<int>& nums2){
    unordered_set<int> result_set;//存放结果，给结果去重
    unordered_set<int> nums_set(nums1.begin(),nums1.end());
    for(int num: nums2){
        //发现nums2的元素，在nums_set里又出现过
        //nums_set.end() 表示 std::unordered_set 中最后一个元素的下一个位置的迭代器
        if(nums_set.find(num)!=nums_set.end()){
            result_set.insert(num);
        }
    }
    return vector<int>(result_set.begin(),result.end());
}

vector<int> intersection(vector<int>& nums1,vector<int>& nums2){
    unordered_set<int> result_set; //save result
    int hash[1005]={0};//默认0
    for(int num:nums1){//出现过的字母在hash数组中做记录
        hash[num]=1;
    }
    for(int num:num2){//nums2中出现的话，result记录
		if(hash[num]==1){
        	result_set.inset(num);
   		 }
    }
    return vector<int>(result_set.begin(),result_sey.end());
}

bool isAnagram(string s,string t){
		int record[26]={0};
		for(int i = 0 ;i<s.size();i++){
		 // 并不需要记住字符a的ASCII，只要c求出一个相对数值就可以了
			record[s[i]-'a']++;
		}
		for(int i =0 ;i <t.size();i++){
			record[t[i]-'a']--;
		}
		for(int i = 0 ;i <26;i++){
			if(record[i]!=0){
			return flase;
			}
		}
		return true;
}

class Solution {
public:
    bool isAnagram(string s, string t) {
            int record[26]={0};
            for(int i=0;i<s.size();i++){
                record[s[i]-'a']++;
            }
            for(int i = 0 ; i<t.size();i++){
                record[t[i]-'a']--;
            }
            for(int i = 0 ; i <26;i++){
                if(record[i]!=0)
                return false;
            }
            return true;
    }
};

#include<iostream>
using namespace std;
int main(){
	string a,b;
	cin>>a;
	cin>>b;
	int A[60000];
	int B[60000];
	for(int i = 0 ; i < a.size();i++){
		A[a[i]]=A[a[i]]+1;
	}
	
	for(int i = 0 ; i < b.size();i++){
			if(A[b[i]]==A[a[i]]){
				A[a[i]]--;
		}
	}
	int flag=0;
	for(int i = 0 ; i <a.size();i++){
		if(A[a[i]]!=0){
			flag=1;
		}
		
	}
	if (flag==0){
		cout<<"niubi";
	}
	else{
		cout<<"goushi";
	}

	return 0;
}

ListNode* fast =head;
ListNode* slow=head;
while(fast!=NULL&&fast->next!=NULL){
    slow=slow->next;
    fast=fast->next->next;
    if(slow==fast){
        ListNode* index1=fast;
        ListNode* index2=head;
        while(index1!=index2){
            index1=index1->next;
            index2=index2->next;
        }
        return inedx2;
    }
    return NULL;
}

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode *fast=head;
        ListNode *slow=head;
        while(fast!=NULL&&fast->next!=NULL){ 
            fast=fast->next->next;//走两部
            slow=slow->next;//走一步
            if(fast==slow){ //当快==慢时候(为什么不直返回slow呢？因为fast 不只走了一圈)
                ListNode* index1=fast;  //所以直接找它的地址再的地方
                ListNode* index2=head;  //从头数fast在哪
                while(index1!=index2){	
                    index1=index1->next;
                    index2=index2->next;
                }
                return index2;
            }
            
        }
        return NULL;
    }
};

ListNode* curA=headA;
ListNode* curB=headB;
int lenA=0,lenB=0;
while(curA!=NULL){
    lenA++;//A长度
    curA=curA->next;
}
while(curB!=NULL){
    lenB++;//B长度
    curB=curB->next;
}
curA=headA;
curB=headB;
//curA become max ,lenA is its length
if(lenB>lenA){
    swap(lenA,lenB);
    swap(curA,curB);
}
//求长度差
int gap= lenA-lenB;
while(gap--){
    curA=curA->next;
}
//遍历curA和curB 遇到相同则直接返回
while(curA!=NULL){
    if(curA==curB){
		return curA;
    }
    curA=curA->next;
    curB=curB->next;
}
return NULL;

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* curA=headA;
        ListNode* curB=headB;
        int lenA=0,lenB=0;
        while(curA!=NULL){
            lenA++;
            curA=curA->next;
        }
        while(curB!=NULL){
            lenB++;
            curB=curB->next;
        }
        //为什么还要再次赋值，因为上面next到了NULL，懂否，傻子
        curA = headA;
        curB = headB;
        if(lenB>lenA){
            swap(lenA,lenB);
            swap(curA,curB);
        }
        int gap=lenA-lenB;
        //移动
        while(gap){
            curA=curA->next;
            gap--;
        }
        while(curA!=NULL){
            if(curA==curB){
                return curA;
            }
            curA=curA->next;
            curB=curB->next;
        }
        return  NULL;

    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyHead=new ListNode(0);
        dummyHead->next=head;
        ListNode* fast=dummyHead;
        ListNode* slow=dummyHead;
        while(n&&fast->next!=NULL){
            fast=fast->next;
            n--;
        }
        fast=fast->next;
        while(fast!=NULL){
            fast=fast->next;
            slow=slow->next;
        }
        slow->next=slow->next->next;
        return dummyHead->next;
    }

};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyHead=new ListNode(0);
        dummyHead->next=head;
        int length=0;
        while(head!=NULL){
            length++;
            head=head->next;
        }
        ListNode* cur=dummyHead;
        for(int i = 1 ;i<=length-n;i++){
            cur=cur->next;
        }
        cur->next=cur->next->next;
        return dummyHead->next;
    }

};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
    ListNode *dummyHead=new ListNode(0);
    dummyHead->next=head;
    ListNode *cur=dummyHead;
    while(cur->next!=NULL&&cur->next->next!=NULL){
        ListNode* temp=cur->next;
        ListNode* temp1=cur->next->next->next;
        cur->next=cur->next->next;
        cur->next->next=temp;
        cur->next->next->next=temp1; //顺着思路比较好毕竟已经改变了cur->next的值，直接顺下比较清楚

        cur=cur->next->next;
    }
    return dummyHead->next;
    }
};

ListNode* reverseList(ListNode* head){
	ListNode* temp;   //保存cur的下一个结点   
	ListNode* cur=head;
	ListNode* pre =NULL;
	while(cur){
		tmp=cur->next;  //保存cur的下一个结点，因为接下来要改变cur->next
		cur->next=pre;  //反转 
		pre=cur;		//更新pre
		cur=temp;		//再更新cur
	}
	return pre;
}

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* pre=NULL;
        ListNode* cur=head;
        ListNode* tmp;
        while(cur){
            tmp=cur->next;
            cur->next=pre;
            pre=cur;
            cur=tmp;
        }
        return pre;
    }
};

class Solution {
public:
    ListNode* reverse(ListNode* pre,ListNode* cur){
        if(cur == NULL) return pre;
        ListNode* temp = cur->next;
        cur->next = pre;
        // 可以和双指针法的代码进行对比，如下递归的写法，其实就是做了这两步
        // pre = cur;
        // cur = temp;
        return reverse(cur,temp);
    }
    ListNode* reverseList(ListNode* head) {
        // 和双指针法初始化是一样的逻辑
        // ListNode* cur = head;
        // ListNode* pre = NULL;
        return reverse(NULL, head);
    }

};