Problem: 2049B - pspspsps
Language: C++20 (GCC 13-64)

Previous submission (verdict: Wrong answer on test 2):
#include <iostream>

#include <cmath>

#include <vector>

#include <queue>

#include <set>

#include <algorithm>

#include <iterator>

#include <string>

#include <string.h>

#include <sstream>

#include <numeric>

#include <iomanip>

#include <cstdlib>

#include <cstdio>

#include <cstring>

#include <iostream>

#include <map>

#include <stack>



#define       forn(i, n)             for(int i=0;i<n;i++)

#define          all(v)              v.begin(), v.end()

#define         rall(v)              v.rbegin(),v.rend()

#define            pb                push_back

#define          sz(a)               (int)a.size()

#define            ll                long long

#define           ull                unsigned long long

#define            mp                make_pair



int dx[4] = { 0, 0, 1, -1 };

int dy[4] = { 1, -1, 0, 0 };

const double PI = 3.141592653589793238463;

ll mod = 1000000007;

int N = 200009;



using namespace std;

vector<ll>fact;



void print(ll num) {

	cout << num << endl;

}



ll pw(ll a, ll b) {

	ll r = 1;

	while(b > 0) {

		if(b & 1) r = (r * a) % mod;

		b /= 2;

		a = (a * a) % mod; 

	}

	return r;

}

ll C(ll n, ll k) {

	if(n < k) return 0LL;

	return (fact[n] * pw((fact[n - k] * fact[k]) % mod, mod - 2)) % mod;

}



void solve()

{

	int n;

	string s;

	cin >> n >> s;

	bool sp = false, ans = true;

	for (int i = 1; i < n; i++)

	{

		if (sp)

		{

			ans = false;

			break;

		}

		if (s[i] == 's' && s[i - 1] == 'p')

		{

			ans = false;

			break;

		}

		if (s[i] == 'p' && s[i - 1] == 's')

		{

			sp = true;

		}

	}



	if (ans)

		cout << "YES\n";

	else cout << "NO\n";

}



int main() {

	cout << setprecision(7) << std::fixed;

	int t = 1;

	cin >> t;

	//freopen("input.txt", "r", stdin);

	//freopen("output.txt", "w", stdout);

	while (t--)

	{

		solve();

	}

}

//long long gcd(long long f, long long g)//to get the greatest common divisor of two positive integers

//{

//	if (f % g == 0)

//		return g;

//	else return gcd(g, f % g);

//}

//**************************************************************************************************************************************************

// 

// 

// 

// 

//

//bool isPrime(int n)//to check primness of a number

//{

//	// Corner case

//	if (n <= 1)

//		return false;

//

//	// Check from 2 to n-1

//	for (int i = 2; i <= n / 2; i++)

//		if (n % i == 0)

//			return false;

//

//	return true;

//}

//**************************************************************************************************************************************************

// 

// 

// 

// 

// 

//int divisor(int number)//to return the highest divisor of a number (also checks primeness of the number)

//{

//	int i = sqrt(number);

//	if (i % 2 == 0)

//		i++;

//	for (; i >= 1; i--)

//	{

//		if (number % i == 0)

//		{

//			break;

//		}

//	}

//	return i;

//}

//**************************************************************************************************************************************************

// 

// 

// 

// 

// 

//long long Sum(long long f)//to get the sum of an positive integer

//{

//	long long sum = 0;

//	while (f > 0) {

//		sum += f % 10;

//		f /= 10;

//	}

//	return sum;

//}

//**************************************************************************************************************************************************

//

//

//

//

//

//string tobinary(int x)

//{

//	string ans;

//	for (int i = 0;; i++)

//	{

//		if (x % 2 == 0)

//			ans = '0' + ans;

//		else ans = '1' + ans;

//		x /= 2;

//		if (x == 0)

//			return ans;

//	}

//}

// 

// 

// 

// 

// 

//**************************************************************************************************************************************************

//int search(vector<pair<int, int>>y,int n,int j) {

//	int ans = y[j].first+y[j+1].first,key=1;

//	for (int i = j+2; i < n; i++)

//	{

//		if (ans > y[i].first)

//			ans += y[i].first;

//		else {

//			key = 0;

//			break;

//		}

//	}

//	if (key == 1)return j;

//	else return search(y, n,j+1);

//}

//**************************************************************************************************************************************************

//

//

//

//

//

//void dfs(long long n, vector<int>nums, vector<bool>vis, long long currnum)to get the lucky numbers

//{

//	if (ans != LLONG_MAX)

//		return;

//	string x;

//	stringstream ss;

//	ss << currnum;

//	ss >> x;

//	if (x.length() == nums.size())

//		if (currnum >= n && currnum < ans)

//			ans = currnum;

//		else return;

//	for (int i = 0; i < nums.size(); i++)

//	{

//		if (vis[i])

//			continue;

//		currnum = currnum * 10 + nums[i];

//		vis[i] = true;

//		dfs(n, nums, vis, currnum);

//		currnum /= 10;

//		vis[i] = false;

//	}

//}

//**************************************************************************************************************************************************

//

//

//

//

//

// int binarySearch(int arr[],int l,int r,intx)

//{

//	while(l<=r)

// {

//	int m=l+(r-l)/2;

// 

//	if(arr[m]==x)

//		return m;

// 

//	if(arr[m]<x)

//		l=m+1;

// 

//	if(arr[m]>x)

//		r=m-1;

//	}

//	return -1;

// }

//}

//int gcd(int a, int b) {

//return a;

//return gcd(b, a % b);

//}

//**************************************************************************************************************************************************

//

//

//

//

//

//قانون التوافيق = (factorial of total #elements)/(factorial of #choosed elements * factorial of difference between this two values)

//قانون التباديل = ( n − k )! * (prefix multiplication of thee numbers);

//sum of integers between two integers = ( big - small + 1) * ( big + small ) / 2;

//**************************************************************************************************************************************************

//

//

//

//

//

//vector<ll> getDivs(ll n)//to get the divisors of a long long

//{

//	vector<ll>v;

//	ll i = 1;

//	for (; i * i < n; i++)

//	{

//		if (n % i == 0)

//			v.pb(i), v.pb(n / i);

//	}

//	if (i * i == n)

//		v.pb(i);

//	return v;

//}

//**************************************************************************************************************************************************

//

//

//

//

//

//bool sortbyCond(const pair<int, int>& a,//used in sorting vector of pair like codeforces ranking

//	const pair<int, int>& b)

//{

//	if (a.first != b.first)

//		return (a.first < b.first);

//	else

//		return (a.second > b.second);

//}

//sort(x.begin(), x.end(), sortbyCond);//this is its calling

//**************************************************************************************************************************************************

//

//

//

//

//

//string toBinary(int n)//to convert an integer to binary

//{

//	string r;

//	while (n != 0) { r = (n % 2 == 0 ? "0" : "1") + r; n /= 2; }

//	return r;

//}

//**************************************************************************************************************************************************

//

//

//

//

//

//ll factorial(int n)

//{

//	if (n == 1 || n == 0)

//		return 1;

//	else return n * factorial(n - 1);

//}

//**************************************************************************************************************************************************

//

//

//

//

//

//int NCR(int n, int r)// best way to claculate number of NCR ( C = توافيق )

//{

//	if (r == 0) return 1;

//

//	if (r > n / 2) return NCR(n, n - r);

//

//	ll res = 1;

//

//	for (int k = 1; k <= r; ++k)

//	{

//		res *= n - k + 1;

//		res /= k;

//	}

//

//	return res;

//}

//**************************************************************************************************************************************************

//

//

//

//

//

//int comp_double(double a, double b)// for comparison between two doubles, returns 0 for a == b, 1 for a > b, -1 for b > a

//{

//	//if very small difference, then equal

//	if (fabs(a - b) <= 1e-10)

//		return 0;

//	return a > b ? 1 : -1;

//}

//**************************************************************************************************************************************************

//

//

//

//

//

//ll power(ll num, ll deg) #best way to calculate power of a number

//{

//	if (!deg)

//		return 1;

//

//	if (deg % 2)

//	{

//		ll curr = ((power(num, deg - 1) % mod) * 3) % mod;

//		return curr;

//	}

//	else {

//		ll curr = power(num, deg / 2) % mod;

//		return (curr * curr) % mod;

//	}

//}

//**************************************************************************************************************************************************

Submission (verdict: Wrong answer on test 2):
#include <iostream>

#include <cmath>

#include <vector>

#include <queue>

#include <set>

#include <algorithm>

#include <iterator>

#include <string>

#include <string.h>

#include <sstream>

#include <numeric>

#include <iomanip>

#include <cstdlib>

#include <cstdio>

#include <cstring>

#include <iostream>

#include <map>

#include <stack>



#define       forn(i, n)             for(int i=0;i<n;i++)

#define          all(v)              v.begin(), v.end()

#define         rall(v)              v.rbegin(),v.rend()

#define            pb                push_back

#define          sz(a)               (int)a.size()

#define            ll                long long

#define           ull                unsigned long long

#define            mp                make_pair



int dx[4] = { 0, 0, 1, -1 };

int dy[4] = { 1, -1, 0, 0 };

const double PI = 3.141592653589793238463;

ll mod = 1000000007;

int N = 200009;



using namespace std;

vector<ll>fact;



void print(ll num) {

	cout << num << endl;

}



ll pw(ll a, ll b) {

	ll r = 1;

	while(b > 0) {

		if(b & 1) r = (r * a) % mod;

		b /= 2;

		a = (a * a) % mod; 

	}

	return r;

}

ll C(ll n, ll k) {

	if(n < k) return 0LL;

	return (fact[n] * pw((fact[n - k] * fact[k]) % mod, mod - 2)) % mod;

}



void solve()

{

	int n;

	string s;

	cin >> n >> s;

	bool sp = false, ans = true, p = false;

	forn(i, n)

	{

		if (sp)

		{

			ans = false;

			break;

		}

		if (s[i] == 'p')

			p = true;

		if (i == 0)

			continue;

		if (s[i] == 's' && p)

		{

			ans = false;

			break;

		}

		if (s[i] == 'p' && s[i - 1] == 's' && i >= 2)

		{

			sp = true;

		}

	}



	if (ans)

		cout << "YES\n";

	else cout << "NO\n";

}



int main() {

	cout << setprecision(7) << std::fixed;

	int t = 1;

	cin >> t;

	//freopen("input.txt", "r", stdin);

	//freopen("output.txt", "w", stdout);

	while (t--)

	{

		solve();

	}

}

//long long gcd(long long f, long long g)//to get the greatest common divisor of two positive integers

//{

//	if (f % g == 0)

//		return g;

//	else return gcd(g, f % g);

//}

//**************************************************************************************************************************************************

// 

// 

// 

// 

//

//bool isPrime(int n)//to check primness of a number

//{

//	// Corner case

//	if (n <= 1)

//		return false;

//

//	// Check from 2 to n-1

//	for (int i = 2; i <= n / 2; i++)

//		if (n % i == 0)

//			return false;

//

//	return true;

//}

//**************************************************************************************************************************************************

// 

// 

// 

// 

// 

//int divisor(int number)//to return the highest divisor of a number (also checks primeness of the number)

//{

//	int i = sqrt(number);

//	if (i % 2 == 0)

//		i++;

//	for (; i >= 1; i--)

//	{

//		if (number % i == 0)

//		{

//			break;

//		}

//	}

//	return i;

//}

//**************************************************************************************************************************************************

// 

// 

// 

// 

// 

//long long Sum(long long f)//to get the sum of an positive integer

//{

//	long long sum = 0;

//	while (f > 0) {

//		sum += f % 10;

//		f /= 10;

//	}

//	return sum;

//}

//**************************************************************************************************************************************************

//

//

//

//

//

//string tobinary(int x)

//{

//	string ans;

//	for (int i = 0;; i++)

//	{

//		if (x % 2 == 0)

//			ans = '0' + ans;

//		else ans = '1' + ans;

//		x /= 2;

//		if (x == 0)

//			return ans;

//	}

//}

// 

// 

// 

// 

// 

//**************************************************************************************************************************************************

//int search(vector<pair<int, int>>y,int n,int j) {

//	int ans = y[j].first+y[j+1].first,key=1;

//	for (int i = j+2; i < n; i++)

//	{

//		if (ans > y[i].first)

//			ans += y[i].first;

//		else {

//			key = 0;

//			break;

//		}

//	}

//	if (key == 1)return j;

//	else return search(y, n,j+1);

//}

//**************************************************************************************************************************************************

//

//

//

//

//

//void dfs(long long n, vector<int>nums, vector<bool>vis, long long currnum)to get the lucky numbers

//{

//	if (ans != LLONG_MAX)

//		return;

//	string x;

//	stringstream ss;

//	ss << currnum;

//	ss >> x;

//	if (x.length() == nums.size())

//		if (currnum >= n && currnum < ans)

//			ans = currnum;

//		else return;

//	for (int i = 0; i < nums.size(); i++)

//	{

//		if (vis[i])

//			continue;

//		currnum = currnum * 10 + nums[i];

//		vis[i] = true;

//		dfs(n, nums, vis, currnum);

//		currnum /= 10;

//		vis[i] = false;

//	}

//}

//**************************************************************************************************************************************************

//

//

//

//

//

// int binarySearch(int arr[],int l,int r,intx)

//{

//	while(l<=r)

// {

//	int m=l+(r-l)/2;

// 

//	if(arr[m]==x)

//		return m;

// 

//	if(arr[m]<x)

//		l=m+1;

// 

//	if(arr[m]>x)

//		r=m-1;

//	}

//	return -1;

// }

//}

//int gcd(int a, int b) {

//return a;

//return gcd(b, a % b);

//}

//**************************************************************************************************************************************************

//

//

//

//

//

//قانون التوافيق = (factorial of total #elements)/(factorial of #choosed elements * factorial of difference between this two values)

//قانون التباديل = ( n − k )! * (prefix multiplication of thee numbers);

//sum of integers between two integers = ( big - small + 1) * ( big + small ) / 2;

//**************************************************************************************************************************************************

//

//

//

//

//

//vector<ll> getDivs(ll n)//to get the divisors of a long long

//{

//	vector<ll>v;

//	ll i = 1;

//	for (; i * i < n; i++)

//	{

//		if (n % i == 0)

//			v.pb(i), v.pb(n / i);

//	}

//	if (i * i == n)

//		v.pb(i);

//	return v;

//}

//**************************************************************************************************************************************************

//

//

//

//

//

//bool sortbyCond(const pair<int, int>& a,//used in sorting vector of pair like codeforces ranking

//	const pair<int, int>& b)

//{

//	if (a.first != b.first)

//		return (a.first < b.first);

//	else

//		return (a.second > b.second);

//}

//sort(x.begin(), x.end(), sortbyCond);//this is its calling

//**************************************************************************************************************************************************

//

//

//

//

//

//string toBinary(int n)//to convert an integer to binary

//{

//	string r;

//	while (n != 0) { r = (n % 2 == 0 ? "0" : "1") + r; n /= 2; }

//	return r;

//}

//**************************************************************************************************************************************************

//

//

//

//

//

//ll factorial(int n)

//{

//	if (n == 1 || n == 0)

//		return 1;

//	else return n * factorial(n - 1);

//}

//**************************************************************************************************************************************************

//

//

//

//

//

//int NCR(int n, int r)// best way to claculate number of NCR ( C = توافيق )

//{

//	if (r == 0) return 1;

//

//	if (r > n / 2) return NCR(n, n - r);

//

//	ll res = 1;

//

//	for (int k = 1; k <= r; ++k)

//	{

//		res *= n - k + 1;

//		res /= k;

//	}

//

//	return res;

//}

//**************************************************************************************************************************************************

//

//

//

//

//

//int comp_double(double a, double b)// for comparison between two doubles, returns 0 for a == b, 1 for a > b, -1 for b > a

//{

//	//if very small difference, then equal

//	if (fabs(a - b) <= 1e-10)

//		return 0;

//	return a > b ? 1 : -1;

//}

//**************************************************************************************************************************************************

//

//

//

//

//

//ll power(ll num, ll deg) #best way to calculate power of a number

//{

//	if (!deg)

//		return 1;

//

//	if (deg % 2)

//	{

//		ll curr = ((power(num, deg - 1) % mod) * 3) % mod;

//		return curr;

//	}

//	else {

//		ll curr = power(num, deg / 2) % mod;

//		return (curr * curr) % mod;

//	}

//}

//**************************************************************************************************************************************************