Liuser's OJ 首页 题库 作业 训练 比赛 评测 讨论
更多
排名 赛程 对比 暗色
登录 注册
讨论
题解
Hello World

正确做法 审核通过

lyhmbr CSP-J2二等 2023-10-11 17:32:32 94 
#include <bits/stdc++.h>
using namespace std;

int a[10000007];
int n;


int to_(string abc){
n = abc.size();
for(int i = 0 ; i < n ; i++){
//		if(abc[i] >= 'A' && abc[i] <= 'Z' ){
//			a[i] = abc[i] - 'A';
//		} else if(abc[i] >= 'a' && abc[i] <='z'){
////			a[i] = abc[i];
//		}
		a[i] = abc[i];
}
}


int pd(int a){
return 0;
if(a >= 'A' && a <= 'Z'){
return 1;
}else if(a >= 'a' && a <= 'z'){
return 2;
} else{
return 0;
}
}


void print(){
int len = n;
for(int i = 0 ; i < len ; i++){
char t;
//		if(a[i] != ' ' || a[i] != '!'){
//			t += a[i] + 'A';
//			cout<<t;
//		}else{
//			a[i] == ' ' ? cout<<" " : cout<<"!";
//		}
		int tt = pd(a[i]);
if(tt == 1){
t += a[i] +'A';
}
if(tt == 2){
t += a[i] + 'a';
}
if(tt == 0){
t = a[i];
}
//		cout<<a[i]<<" ";
		cout<<t;
}
}


int main(){
to_("Hello World");
print();


<span class="hl-keyword hl-control hl-c++">return</span> <span class="hl-constant hl-numeric hl-c++">0</span><span class="hl-punctuation hl-terminator hl-c++">;</span>

}

用NOIc++测

{{ vote && vote.total.up }}

共 15 条回复

wchzm 蛋仔派对 蛋小黑
2024-11-10 10:30:31

我的才是正确做法

#ifndef _GLIBCXX_IOSTREAM
#define _GLIBCXX_IOSTREAM 1
#pragma GCC system_header
#include <bits/c++config.h>
#ifndef _GLIBCXX_OSTREAM
#define _GLIBCXX_OSTREAM 1
#include <ios>
#include <bits/ostream_insert.h>
namespace std _GLIBCXX_VISIBILITY(default)
{
	_GLIBCXX_BEGIN_NAMESPACE_VERSION
	template<typename _CharT, typename _Traits>
	class basic_ostream : virtual public basic_ios<_CharT, _Traits>
	{
		public:
			typedef _CharT			 		char_type;
			typedef typename _Traits::int_type 		int_type;
			typedef typename _Traits::pos_type 		pos_type;
			typedef typename _Traits::off_type 		off_type;
			typedef _Traits			 		traits_type;
			typedef basic_streambuf<_CharT, _Traits> 		__streambuf_type;
			typedef basic_ios<_CharT, _Traits>		__ios_type;
			typedef basic_ostream<_CharT, _Traits>		__ostream_type;
			typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
			__num_put_type;
			typedef ctype<_CharT>	      			__ctype_type;
			explicit
			basic_ostream(__streambuf_type* __sb)
			{
				this->init(__sb);
			}
			virtual
			~basic_ostream() { }
			class sentry;
			friend class sentry;
			__ostream_type&
			operator<<(__ostream_type& (*__pf)(__ostream_type&))
			{
				return __pf(*this);
			}
			__ostream_type&
			operator<<(__ios_type& (*__pf)(__ios_type&))
			{
				__pf(*this);
				return *this;
			}
			__ostream_type&
			operator<<(ios_base& (*__pf) (ios_base&))
			{
				__pf(*this);
				return *this;
			}
			__ostream_type&
			operator<<(long __n)
			{
				return _M_insert(__n);
			}
			__ostream_type&
			operator<<(unsigned long __n)
			{
				return _M_insert(__n);
			}
			__ostream_type&
			operator<<(bool __n)
			{
				return _M_insert(__n);
			}
			__ostream_type&
			operator<<(short __n);
			__ostream_type&
			operator<<(unsigned short __n)
			{
				return _M_insert(static_cast<unsigned long>(__n));
			}
			__ostream_type&
			operator<<(int __n);
			__ostream_type&
			operator<<(unsigned int __n)
			{
				return _M_insert(static_cast<unsigned long>(__n));
			}
#ifdef _GLIBCXX_USE_LONG_LONG
			__ostream_type&
			operator<<(long long __n)
			{
				return _M_insert(__n);
			}
			__ostream_type&
			operator<<(unsigned long long __n)
			{
				return _M_insert(__n);
			}
#endif
			__ostream_type&
			operator<<(double __f)
			{
				return _M_insert(__f);
			}
			__ostream_type&
			operator<<(float __f)
			{
				return _M_insert(static_cast<double>(__f));
			}
			__ostream_type&
			operator<<(long double __f)
			{
				return _M_insert(__f);
			}
			__ostream_type&
			operator<<(const void* __p)
			{
				return _M_insert(__p);
			}
			__ostream_type&
			operator<<(__streambuf_type* __sb);
			__ostream_type&
			put(char_type __c);
			void
			_M_write(const char_type* __s, streamsize __n)
			{
				const streamsize __put = this->rdbuf()->sputn(__s, __n);
				if (__put != __n)
					this->setstate(ios_base::badbit);
			}
			__ostream_type&
			write(const char_type* __s, streamsize __n);
			__ostream_type&
			flush();
			pos_type
			tellp();
			__ostream_type&
			seekp(pos_type);
			__ostream_type&
			seekp(off_type, ios_base::seekdir);
		protected:
			basic_ostream()
			{
				this->init(0);
			}
			template<typename _ValueT>
			__ostream_type&
			_M_insert(_ValueT __v);
	};
	template <typename _CharT, typename _Traits>
	class basic_ostream<_CharT, _Traits>::sentry
	{
			bool 				_M_ok;
			basic_ostream<_CharT, _Traits>& 	_M_os;
		public:
			explicit
			sentry(basic_ostream<_CharT, _Traits>& __os);
			~sentry()
			{
				if (bool(_M_os.flags() & ios_base::unitbuf) && !uncaught_exception())
				{
					if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() == -1)
						_M_os.setstate(ios_base::badbit);
				}
			}
#if __cplusplus >= 201103L
			explicit
#endif
			operator bool() const
			{
				return _M_ok;
			}
	};
	template<typename _CharT, typename _Traits>
	inline basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c)
	{
		return __ostream_insert(__out, &__c, 1);
	}
	template<typename _CharT, typename _Traits>
	inline basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __out, char __c)
	{
		return (__out << __out.widen(__c));
	}
	template <class _Traits>
	inline basic_ostream<char, _Traits>&
	operator<<(basic_ostream<char, _Traits>& __out, char __c)
	{
		return __ostream_insert(__out, &__c, 1);
	}
	template<class _Traits>
	inline basic_ostream<char, _Traits>&
	operator<<(basic_ostream<char, _Traits>& __out, signed char __c)
	{
		return (__out << static_cast<char>(__c));
	}
	template<class _Traits>
	inline basic_ostream<char, _Traits>&
	operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c)
	{
		return (__out << static_cast<char>(__c));
	}
	template<typename _CharT, typename _Traits>
	inline basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
	{
		if (!__s)
			__out.setstate(ios_base::badbit);
		else
			__ostream_insert(__out, __s,
			                 static_cast<streamsize>(_Traits::length(__s)));
		return __out;
	}
	template<typename _CharT, typename _Traits>
	basic_ostream<_CharT, _Traits> &
	operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s);
	template<class _Traits>
	inline basic_ostream<char, _Traits>&
	operator<<(basic_ostream<char, _Traits>& __out, const char* __s)
	{
		if (!__s)
			__out.setstate(ios_base::badbit);
		else
			__ostream_insert(__out, __s,
			                 static_cast<streamsize>(_Traits::length(__s)));
		return __out;
	}
	template<class _Traits>
	inline basic_ostream<char, _Traits>&
	operator<<(basic_ostream<char, _Traits>& __out, const signed char* __s)
	{
		return (__out << reinterpret_cast<const char*>(__s));
	}
	template<class _Traits>
	inline basic_ostream<char, _Traits> &
	operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s)
	{
		return (__out << reinterpret_cast<const char*>(__s));
	}
	template<typename _CharT, typename _Traits>
	inline basic_ostream<_CharT, _Traits>&
	endl(basic_ostream<_CharT, _Traits>& __os)
	{
		return flush(__os.put(__os.widen('\n')));
	}
	template<typename _CharT, typename _Traits>
	inline basic_ostream<_CharT, _Traits>&
	ends(basic_ostream<_CharT, _Traits>& __os)
	{
		return __os.put(_CharT());
	}
	template<typename _CharT, typename _Traits>
	inline basic_ostream<_CharT, _Traits>&
	flush(basic_ostream<_CharT, _Traits>& __os)
	{
		return __os.flush();
	}
#if __cplusplus >= 201103L
	template<typename _CharT, typename _Traits, typename _Tp>
	inline basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>&& __os, const _Tp& __x)
	{
		return (__os << __x);
	}
#endif
	_GLIBCXX_END_NAMESPACE_VERSION
}
#include <bits/ostream.tcc>
#endif
#ifndef _GLIBCXX_ISTREAM
#define _GLIBCXX_ISTREAM 1
namespace std _GLIBCXX_VISIBILITY(default)
{
	_GLIBCXX_BEGIN_NAMESPACE_VERSION
	template<typename _CharT, typename _Traits>
	class basic_istream : virtual public basic_ios<_CharT, _Traits>
	{
		public:
			typedef _CharT			 		char_type;
			typedef typename _Traits::int_type 		int_type;
			typedef typename _Traits::pos_type 		pos_type;
			typedef typename _Traits::off_type 		off_type;
			typedef _Traits			 		traits_type;
			typedef basic_streambuf<_CharT, _Traits> 		__streambuf_type;
			typedef basic_ios<_CharT, _Traits>		__ios_type;
			typedef basic_istream<_CharT, _Traits>		__istream_type;
			typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
			__num_get_type;
			typedef ctype<_CharT>	      			__ctype_type;
		protected:
			streamsize 		_M_gcount;
		public:
			explicit
			basic_istream(__streambuf_type* __sb)
				: _M_gcount(streamsize(0))
			{
				this->init(__sb);
			}
			virtual
			~basic_istream()
			{
				_M_gcount = streamsize(0);
			}
			class sentry;
			friend class sentry;
			__istream_type&
			operator>>(__istream_type& (*__pf)(__istream_type&))
			{
				return __pf(*this);
			}
			__istream_type&
			operator>>(__ios_type& (*__pf)(__ios_type&))
			{
				__pf(*this);
				return *this;
			}
			__istream_type&
			operator>>(ios_base& (*__pf)(ios_base&))
			{
				__pf(*this);
				return *this;
			}
			__istream_type&
			operator>>(bool& __n)
			{
				return _M_extract(__n);
			}
			__istream_type&
			operator>>(short& __n);
			__istream_type&
			operator>>(unsigned short& __n)
			{
				return _M_extract(__n);
			}
			__istream_type&
			operator>>(int& __n);
			__istream_type&
			operator>>(unsigned int& __n)
			{
				return _M_extract(__n);
			}
			__istream_type&
			operator>>(long& __n)
			{
				return _M_extract(__n);
			}
			__istream_type&
			operator>>(unsigned long& __n)
			{
				return _M_extract(__n);
			}
#ifdef _GLIBCXX_USE_LONG_LONG
			__istream_type&
			operator>>(long long& __n)
			{
				return _M_extract(__n);
			}
			__istream_type&
			operator>>(unsigned long long& __n)
			{
				return _M_extract(__n);
			}
#endif
			__istream_type&
			operator>>(float& __f)
			{
				return _M_extract(__f);
			}
			__istream_type&
			operator>>(double& __f)
			{
				return _M_extract(__f);
			}
			__istream_type&
			operator>>(long double& __f)
			{
				return _M_extract(__f);
			}
			__istream_type&
			operator>>(void*& __p)
			{
				return _M_extract(__p);
			}
			__istream_type&
			operator>>(__streambuf_type* __sb);
			streamsize
			gcount() const
			{
				return _M_gcount;
			}
			int_type
			get();
			__istream_type&
			get(char_type& __c);
			__istream_type&
			get(char_type* __s, streamsize __n, char_type __delim);
			__istream_type&
			get(char_type* __s, streamsize __n)
			{
				return this->get(__s, __n, this->widen('\n'));
			}
			__istream_type&
			get(__streambuf_type& __sb, char_type __delim);
			__istream_type&
			get(__streambuf_type& __sb)
			{
				return this->get(__sb, this->widen('\n'));
			}
			__istream_type&
			getline(char_type* __s, streamsize __n, char_type __delim);
			__istream_type&
			getline(char_type* __s, streamsize __n)
			{
				return this->getline(__s, __n, this->widen('\n'));
			}
			__istream_type&
			ignore(streamsize __n, int_type __delim);
			__istream_type&
			ignore(streamsize __n);
			__istream_type&
			ignore();
			int_type
			peek();
			__istream_type&
			read(char_type* __s, streamsize __n);
			streamsize
			readsome(char_type* __s, streamsize __n);
			__istream_type&
			putback(char_type __c);
			__istream_type&
			unget();
			int
			sync();
			pos_type
			tellg();
			__istream_type&
			seekg(pos_type);
			__istream_type&
			seekg(off_type, ios_base::seekdir);
		protected:
			basic_istream()
				: _M_gcount(streamsize(0))
			{
				this->init(0);
			}
			template<typename _ValueT>
			__istream_type&
			_M_extract(_ValueT& __v);
	};
	template<>
	basic_istream<char>&
	basic_istream<char>::
	getline(char_type* __s, streamsize __n, char_type __delim);
	template<>
	basic_istream<char>&
	basic_istream<char>::
	ignore(streamsize __n);
	template<>
	basic_istream<char>&
	basic_istream<char>::
	ignore(streamsize __n, int_type __delim);
#ifdef _GLIBCXX_USE_WCHAR_T
	template<>
	basic_istream<wchar_t>&
	basic_istream<wchar_t>::
	getline(char_type* __s, streamsize __n, char_type __delim);
	template<>
	basic_istream<wchar_t>&
	basic_istream<wchar_t>::
	ignore(streamsize __n);
	template<>
	basic_istream<wchar_t>&
	basic_istream<wchar_t>::
	ignore(streamsize __n, int_type __delim);
#endif
	template<typename _CharT, typename _Traits>
	class basic_istream<_CharT, _Traits>::sentry
	{
			bool _M_ok;
		public:
			typedef _Traits 					traits_type;
			typedef basic_streambuf<_CharT, _Traits> 		__streambuf_type;
			typedef basic_istream<_CharT, _Traits> 		__istream_type;
			typedef typename __istream_type::__ctype_type 	__ctype_type;
			typedef typename _Traits::int_type		__int_type;
			explicit
			sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
#if __cplusplus >= 201103L
			explicit
#endif
			operator bool() const
			{
				return _M_ok;
			}
	};
	template<typename _CharT, typename _Traits>
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c);
	template<class _Traits>
	inline basic_istream<char, _Traits>&
	operator>>(basic_istream<char, _Traits>& __in, unsigned char& __c)
	{
		return (__in >> reinterpret_cast<char&>(__c));
	}
	template<class _Traits>
	inline basic_istream<char, _Traits>&
	operator>>(basic_istream<char, _Traits>& __in, signed char& __c)
	{
		return (__in >> reinterpret_cast<char&>(__c));
	}
	template<typename _CharT, typename _Traits>
	basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s);
	template<>
	basic_istream<char>&
	operator>>(basic_istream<char>& __in, char* __s);
	template<class _Traits>
	inline basic_istream<char, _Traits>&
	operator>>(basic_istream<char, _Traits>& __in, unsigned char* __s)
	{
		return (__in >> reinterpret_cast<char*>(__s));
	}
	template<class _Traits>
	inline basic_istream<char, _Traits>&
	operator>>(basic_istream<char, _Traits>& __in, signed char* __s)
	{
		return (__in >> reinterpret_cast<char*>(__s));
	}
	template<typename _CharT, typename _Traits>
	class basic_iostream
		: public basic_istream<_CharT, _Traits>,
	  public basic_ostream<_CharT, _Traits>
	{
		public:
			typedef _CharT			 		char_type;
			typedef typename _Traits::int_type 		int_type;
			typedef typename _Traits::pos_type 		pos_type;
			typedef typename _Traits::off_type 		off_type;
			typedef _Traits			 		traits_type;
			typedef basic_istream<_CharT, _Traits>		__istream_type;
			typedef basic_ostream<_CharT, _Traits>		__ostream_type;
			explicit
			basic_iostream(basic_streambuf<_CharT, _Traits>* __sb)
				: __istream_type(__sb), __ostream_type(__sb) { }
			virtual
			~basic_iostream() { }
		protected:
			basic_iostream()
				: __istream_type(), __ostream_type() { }
	};
	template<typename _CharT, typename _Traits>
	basic_istream<_CharT, _Traits>&
	ws(basic_istream<_CharT, _Traits>& __is);
#if __cplusplus >= 201103L
	template<typename _CharT, typename _Traits, typename _Tp>
	inline basic_istream<_CharT, _Traits>&
	operator>>(basic_istream<_CharT, _Traits>&& __is, _Tp& __x)
	{
		return (__is >> __x);
	}
#endif
	_GLIBCXX_END_NAMESPACE_VERSION
}
#include <bits/istream.tcc>
#endif
namespace std _GLIBCXX_VISIBILITY(default)
{
	_GLIBCXX_BEGIN_NAMESPACE_VERSION
	extern istream cin;
	extern ostream cout;
	extern ostream cerr;
	extern ostream clog;
#ifdef _GLIBCXX_USE_WCHAR_T
	extern wistream wcin;
	extern wostream wcout;
	extern wostream wcerr;
	extern wostream wclog;
#endif
	static ios_base::Init __ioinit;
	_GLIBCXX_END_NAMESPACE_VERSION
}
#endif
using namespace std;
int main()
{
	cout<<"Hello, World!";
	return 0;
}
caisen
2024-08-09 10:00:50

正确做法我也有(doge)

#include <iostream>
#include <algorithm>
#include <math.h>
#include <cmath>
#include<string>
#include<cstring>
#include<list>
#include<map>
#include<queue>
#include<iterator>
#include<stack>
#include <windows.h>
using namespace std;
typedef long long LL;
typedef double DB;
typedef int IT;
typedef long double LDB;
typedef long L;
typedef short S;
#pragma GCC optimize ("O0")
void h(int hss, char hs)
{
	hss = 72;
	hs = hss;
	cout << hs;
}
void e(int ess, char es)
{
	ess = 101;
	es = ess;
	cout << es;
}
void l(int lss, char ls)
{
	lss = 108;
	ls = lss;
	cout << ls;
}
void o(int oss, char os)
{
	oss = 111;
	os = oss;
	cout << os;
}
void w(int wss, char ws)
{
	wss = 87;
	ws = wss;
	cout << ws;
}
void r(int rss, char rs)
{
	rss = 114;
	rs = rss;
	cout << rs;
}
void d(int dss, char ds)
{
	dss = 100;
	ds = dss;
	cout << ds;
}
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout << "H";
        Sleep(10);
	cout << "e";
        Sleep(10);
	cout << "l";
        Sleep(10);
	cout << "l";
        Sleep(10);
	cout << "o";
        Sleep(10);
	cout << " ";
        Sleep(10);
	cout << "W";
        Sleep(10);
	cout << "o";
        Sleep(10);
	cout << "r";
        Sleep(10);
	cout << "l";
        Sleep(10);
	cout << "d";
        Sleep(10);
	 return 0;
}
mmz1207
2024-08-06 23:03:33

好一个正确做法

wyh15 Minecraft
2024-05-17 18:29:05

return 0;

lyhxwc
2024-03-17 19:35:59

dafen

kj123
2024-03-15 23:00:16

这有亿点长了吧！！！

txz 一打七
2024-03-03 20:13:25

6

tctm221
2024-02-24 11:47:46

6

6

6

wchzm 蛋仔派对 蛋小黑
2024-02-01 12:40:55

我愿称之为史上最短

wchzm 蛋仔派对 蛋小黑
2024-02-01 12:40:27

666666666666666666666