--------------------------------
int main()
{
printf("TWO\n");
return 0;
}
---------------------------------
Add any code above or below the lines so that the output is
ONE
TWO
THREE
Give 10 different ways to do this and which of them are specific to C++?
: just comment it out (already mentioned)
#include <iostream>
int main() { std::cout << "ONE\nTWO\nTHREE\n"; return 0; }
/*
...
*/
2: use #if or #ifdef
#include <iostream>
#ifdef foo
...
#else
int main() { std::cout << "ONE\nTWO\nTHREE\n"; return 0; }
#endif
3: redefine printf (already mentioned)
#include <iostream>
#define printf(foo) std::cout << "ONE\n" << foo << "THREE\n";
...
4: overload printf (already mentioned, c++ specific)
void printf(const char * s);
...
#include <iostream>
void printf(const char * s) { std::cout << "ONE\n" << s << "THREE\n"; }
5: template printf (c++ specific)
void foo(const char * s);
template<typename T> void printf(T s) { foo(s); }
...
#include <iostream>
void foo(const char * s) { std::cout << "ONE\n" << s << "THRE\n"; }
6: redefine main
#include <iostream>
int foo();
int main() {std::cout << "ONE\n"; foo(); std::cout << "THREE\n"; return 0; }
#define main foo
...
7: put main in a namespace (c++ specific)
#include <iostream>
namespace foo {
...
};
int main() { std::cout << "ONE\n"; foo::main(); std::cout << "THREE\n"; return 0; }
8: put main in a class or struct (c++ specific)
#include <iostream>
struct foo {
...
};
int main() { foo bar; std::cout << "ONE\n"; bar.main(); std::cout << "THREE\n"; return 0; }
9: use #define to remove keywords
#include <iostream>
int main() {
printf("ONE\n");
#define main() do
#define return
#define int
...
while (!printf("THREE\n"));
#undef return
return 0;
}
10: abuse a class or struct constructor (c++ specific)
struct printf { printf(const char * s); };
...
#include <iostream>
printf::printf(const char * s) { std::cout << "ONE\n" << s << "THREE\n"; }
]]>
#include <iostream>
#import <msxml4.dll>
void SendData(std::wstring url, std::wstring username, std::wstring password)
{
HRESULT hr;
MSXML2::IXMLHTTPRequestPtr pIXMLHTTPRequest;
MSXML2::IXMLDOMDocumentPtr pXMLDoc;
std::wstring wvarQuery(L"username=");
wvarQuery.append(username);
wvarQuery.append(L"&password=");
wvarQuery.append(password);
_variant_t vartQueryFields(wvarQuery.c_str());
try
{
CoInitialize(NULL);
hr=pIXMLHTTPRequest.CreateInstance(__uuidof(MSXML2::XMLHTTP));
SUCCEEDED(hr) ? 0 : throw hr;
hr=pIXMLHTTPRequest->open("POST", url.c_str(),
false);
SUCCEEDED(hr) ? 0 : throw hr;
//濡傛灉瑕佸悜鏈嶅姟鍣╬ost鏁版嵁錛岃繖涓湴鏂逛竴瀹氳璁劇疆涓篴pplication/x-www-form-urlencoded
pIXMLHTTPRequest->setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
hr = pIXMLHTTPRequest->send( vartQueryFields );
SUCCEEDED(hr) ? 0 : throw hr;
//鎷垮埌榪斿洖鏉ョ殑xml鏁版嵁
pXMLDoc=pIXMLHTTPRequest->responseXML;
//鍚庨潰灝辨槸瀵規嬁鍥炴潵鐨剎ml鏁版嵁榪涜瑙ｆ瀽錛屼富瑕佹槸dom鏂規硶
}
catch(
){
if(pIXMLHTTPRequest)
pIXMLHTTPRequest.Release();
if(pXMLDoc)
pXMLDoc.Release();
CoUninitialize();
}
}
int main()
{
SendData(L"http://localhost/login.php", L"kenwell", L"kenwell");
}
]]>
聽
緙栫▼鐜錛歏C++6
鑰冭瘯鏃墮棿錛?灝忔椂
鑰冭瘯鏃墮棿錛?灝忔椂
Problem A.Fibonacci
Input:聽聽聽聽聽聽聽聽聽 聽fib.in
Output:聽聽聽聽聽聽聽 Standard Output
Time limit:聽聽聽 聽5 second
Memory limit: 64 megabytes
Offerd by 錛毬犅?http://spaces.msn.com/davidblogs/
Input:聽聽聽聽聽聽聽聽聽 聽fib.in
Output:聽聽聽聽聽聽聽 Standard Output
Time limit:聽聽聽 聽5 second
Memory limit: 64 megabytes
Offerd by 錛毬犅?http://spaces.msn.com/davidblogs/
聽
The Fibonacci Numbers{0,1,1,2,3,5,8,13,21,34,55...} are defined by the recurrence:
F0=0 F1=1 Fn=Fn-1+Fn-2,n>=2
Write a program to calculate the Fibonacci Numbers.
F0=0 F1=1 Fn=Fn-1+Fn-2,n>=2
Write a program to calculate the Fibonacci Numbers.
聽
Input
The input file contains a number n and you are expected to calculate Fn.(0<=n<=30)
The input file contains a number n and you are expected to calculate Fn.(0<=n<=30)
Output
Print a number Fn on a separate line,which means the nth Fibonacci Number.
聽
Example
fib.in聽聽聽聽聽聽 Standard Output
1聽聽聽聽聽聽聽聽聽聽聽 1
2聽聽聽聽聽聽聽聽聽聽聽 1
3聽聽聽聽聽聽聽聽聽聽聽 2
4聽聽聽聽聽聽聽聽聽聽聽 3
5聽聽聽聽聽聽聽聽聽聽聽 5
6聽聽聽聽聽聽聽聽聽聽聽 8
fib.in聽聽聽聽聽聽 Standard Output
1聽聽聽聽聽聽聽聽聽聽聽 1
2聽聽聽聽聽聽聽聽聽聽聽 1
3聽聽聽聽聽聽聽聽聽聽聽 2
4聽聽聽聽聽聽聽聽聽聽聽 3
5聽聽聽聽聽聽聽聽聽聽聽 5
6聽聽聽聽聽聽聽聽聽聽聽 8
聽
Problem B.WERTYU
Input:聽聽聽聽聽聽聽聽聽 聽wertyu.in
Output:聽聽聽聽聽聽 聽 Standard Output
Time limit:聽聽聽聽 聽5 second
Memory limit:聽 64 megabytes
Offerd by 錛毬犅?http://spaces.msn.com/davidblogs/
聽
A common typing error is to place the hands on the keyboard one
row to the right of the correct position.So "Q" is typed as "W" and "J"
is typed as "K" and so on.You are to decode a message typed in this
manner.
聽
` 1 2 3 4 5 6 7 8 9 0 - = BackSp
Tab Q W E R T Y U I O P [ ] \
A S D F G H J K L ; ' Enter
Z聽 X聽 C聽 V聽 B聽 N聽 M聽 ,聽 .聽 /
Control Alt聽 Space聽 Alt Control
Tab Q W E R T Y U I O P [ ] \
A S D F G H J K L ; ' Enter
Z聽 X聽 C聽 V聽 B聽 N聽 M聽 ,聽 .聽 /
Control Alt聽 Space聽 Alt Control
聽
Input
The input file consist of several lines of text.Each line may contain digits,spaces,upper case letters(except Q,A,Z),or punctuation shown above(except back-quote(') which is left to the key "1").Keys labelled with words [Tab,BackSp,Control,etc.] are not represented in the input.
The input file consist of several lines of text.Each line may contain digits,spaces,upper case letters(except Q,A,Z),or punctuation shown above(except back-quote(') which is left to the key "1").Keys labelled with words [Tab,BackSp,Control,etc.] are not represented in the input.
聽
Output
You are to replace each letter or punctuation symbol by the one immediately to its left on the QWERTY keyboard shown above.Spaces in the input should be echoed in the output.
You are to replace each letter or punctuation symbol by the one immediately to its left on the QWERTY keyboard shown above.Spaces in the input should be echoed in the output.
聽
Example
wertyu.in聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 聽Standard Output
O S, GOMR YPFSU/聽聽聽聽聽聽聽 I AM FINE TODAY.
wertyu.in聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 聽Standard Output
O S, GOMR YPFSU/聽聽聽聽聽聽聽 I AM FINE TODAY.
聽
聽
Problem C.String Matching
Input:聽聽聽聽聽聽聽聽聽 聽聽matching.in
Output:聽聽聽聽聽聽 聽 Standard Output
Time limit:聽聽聽聽 聽5 second
Memory limit:聽 64 megabytes
Offerd by 錛毬犅?http://spaces.msn.com/davidblogs/
Input:聽聽聽聽聽聽聽聽聽 聽聽matching.in
Output:聽聽聽聽聽聽 聽 Standard Output
Time limit:聽聽聽聽 聽5 second
Memory limit:聽 64 megabytes
Offerd by 錛毬犅?http://spaces.msn.com/davidblogs/
聽
Finding all occurrences of a pattern in a text is a problem that
arises frequently in text-editing programs.Typically,the text is a
document being edited,and the pattern searched for is a particular word
supplied by the user.
聽
We assume that the text is an array T[1..n] of length n and that
the pattern is an array P[1..m] of length m<=n.We further assume
that the elements of P and T are all alphabets(鈭?{a,b...,z}).The
character arrays P and T are often called strings of characters.
聽
We say that pattern P occurs with shift s in the text T if
0<=s<=n and T[s+1..s+m] = P[1..m](that is if T[s+j]=P[j],for
1<=j<=m).
聽
If P occurs with shift s in T,then we call s a valid shift;otherwise,we call s a invalid shift.
Your task is to calculate the number of vald shifts for the given text T and pattern P.
聽
Input
In the input file,there are two strings T and P on a line,separated by a single space.You may assume both the length of T and P will not exceed 10^6.
In the input file,there are two strings T and P on a line,separated by a single space.You may assume both the length of T and P will not exceed 10^6.
聽
Output
You should output a number on a separate line,which indicates the number of valid shifts for the given text T and pattern P.
You should output a number on a separate line,which indicates the number of valid shifts for the given text T and pattern P.
聽
Example
matching.in聽聽聽聽聽 聽Standard Output
aaaaaa a聽聽聽聽聽聽聽聽聽 聽聽6
abababab abab聽聽 3
abcdabc abdc聽聽聽 聽0
matching.in聽聽聽聽聽 聽Standard Output
aaaaaa a聽聽聽聽聽聽聽聽聽 聽聽6
abababab abab聽聽 3
abcdabc abdc聽聽聽 聽0
聽
Problem D.Exponential Form
Input:聽聽聽聽聽聽聽聽聽 聽 form.in
Output:聽聽聽聽聽聽聽聽聽Standard Output
Time limit:聽聽聽聽聽 5 second
Memory limit:聽 64 megabytes
Offerd by 錛毬犅?http://spaces.msn.com/davidblogs/
Input:聽聽聽聽聽聽聽聽聽 聽 form.in
Output:聽聽聽聽聽聽聽聽聽Standard Output
Time limit:聽聽聽聽聽 5 second
Memory limit:聽 64 megabytes
Offerd by 錛毬犅?http://spaces.msn.com/davidblogs/
聽
Every positive number can be presented by the exponential form.For example,
137 = 2^7 + 2^3 + 2^0
137 = 2^7 + 2^3 + 2^0
Let's present a^b by the form a(b).Then 137 is presented by 2(7)+2(3)+2(0).
Since 7 = 2^2 + 2 + 2^0 and 3 = 2 + 2^0 , 137 is finally presented by 2(2(2)+2+2(0))+2(2+2(0))+2(0).
Since 7 = 2^2 + 2 + 2^0 and 3 = 2 + 2^0 , 137 is finally presented by 2(2(2)+2+2(0))+2(2+2(0))+2(0).
聽
Given a positive number n,your task is to present n with the exponential form which only contains the digits 0 and 2.
聽
Input
The input file contains a positive integer n (n<=20000).
The input file contains a positive integer n (n<=20000).
聽
Output
You should output the exponential form of n an a single line.Note that,there should not be any additional white spaces in the line.
You should output the exponential form of n an a single line.Note that,there should not be any additional white spaces in the line.
聽
Example
form.in
137
Stardard Output
2(2(2)+2+2(0))+2(2+2(0))+2(0)
form.in
1315
Stardard Output
2(2(2+2(0))+2)+2(2(2+2(0)))+2(2(2)+2(0))+2+2(0)
form.in
137
Stardard Output
2(2(2)+2+2(0))+2(2+2(0))+2(0)
form.in
1315
Stardard Output
2(2(2+2(0))+2)+2(2(2+2(0)))+2(2(2)+2(0))+2+2(0)
]]>
va_arg:
typeva_arg(
聽聽 va_listarg_ptr,
聽聽 type
);
va_arg returns the current argument; va_start and va_end do not return values
The va_arg, va_end, and va_start macros provide a portable way to access the arguments to a function when the function takes a variable number of arguments. Two versions of the macros are available: The macros defined in STDARG.H conform to the ANSI C standard, and the macros defined in VARARGS.H are compatible with the UNIX System V definition. The macros are:
The ANSI C standard macros, defined in STDARG.H, are used as follows:
- All required arguments to the function are declared as parameters in the usual way. va_dcl is not used with the STDARG.H macros.
- va_start sets arg_ptr to the first optional argument in the list of arguments passed to the function. The argument arg_ptr must have va_list type. The argument prev_param is the name of the required parameter immediately preceding the first optional argument in the argument list. If prev_param is declared with the register storage class, the macro's behavior is undefined. va_start must be used before va_arg is used for the first time.
- va_arg retrieves a value of type from the location given by arg_ptr and increments arg_ptr to point to the next argument in the list, using the size of type to determine where the next argument starts. va_arg can be used any number of times within the function to retrieve arguments from the list.
The example:
//聽crt_va.c
/**//*聽The聽program聽below聽illustrates聽passing聽a聽variable
聽*聽number聽of聽arguments聽using聽the聽following聽macros:聽*聽聽聽聽聽聽va_start聽聽聽聽聽聽聽聽聽聽聽聽va_arg聽聽聽聽聽聽聽聽聽聽聽聽聽聽va_end聽*聽聽聽聽聽聽va_list聽聽聽聽聽聽聽聽聽聽聽聽聽va_dcl聽(UNIX聽only)
聽*/#include聽<stdio.h>#define聽ANSI聽聽聽聽聽聽聽聽聽聽聽聽/*聽Comment聽out聽for聽UNIX聽version聽聽聽聽聽*/#ifdef聽ANSI聽聽聽聽聽聽聽聽聽聽聽聽聽/**//*聽ANSI聽compatible聽version聽聽聽聽聽聽聽聽聽聽*/#include聽<stdarg.h>int聽average(聽int聽first,聽
聽);#else聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽/*聽UNIX聽compatible聽version聽聽聽聽聽聽聽聽聽聽*/#include聽<varargs.h>int聽average(聽va_list聽);#endifint聽main(聽void聽){
聽聽聽/**//*聽Call聽with聽3聽integers聽(-1聽is聽used聽as聽terminator).聽*/聽聽聽printf(聽"Average聽is:聽%d\n",聽average(聽2,聽3,聽4,聽-1聽)聽);聽聽聽/**//*聽Call聽with聽4聽integers.聽*/聽聽聽printf(聽"Average聽is:聽%d\n",聽average(聽5,聽7,聽9,聽11,聽-1聽)聽);聽聽聽/**//*聽Call聽with聽just聽-1聽terminator.聽*/聽聽聽printf(聽"Average聽is:聽%d\n",聽average(聽-1聽)聽);}/**//*聽Returns聽the聽average聽of聽a聽variable聽list聽of聽integers.聽*/#ifdef聽ANSI聽聽聽聽聽聽聽聽聽聽聽聽聽/**//*聽ANSI聽compatible聽version聽聽聽聽*/int聽average(聽int聽first,聽聽){聽聽聽int聽count聽=聽0,聽sum聽=聽0,聽i聽=聽first;聽聽聽va_list聽marker;聽聽聽va_start(聽marker,聽first聽);聽聽聽聽聽/**//*聽Initialize聽variable聽arguments.聽*/聽聽聽while(聽i聽!=聽-1聽)聽聽聽{聽聽聽聽聽聽sum聽+=聽i;聽聽聽聽聽聽count++;聽聽聽聽聽聽i聽=聽va_arg(聽marker,聽int);
聽聽聽}聽聽聽va_end(聽marker聽);聽聽聽聽聽聽聽聽聽聽聽聽聽聽/**//*聽Reset聽variable聽arguments.聽聽聽聽聽聽*/聽聽聽return(聽sum聽?聽(sum聽/聽count)聽:聽0聽);}#else聽聽聽聽聽聽聽/*聽UNIX聽compatible聽version聽must聽use聽old-style聽definition.聽聽*/int聽average(聽va_alist聽)va_dcl{聽聽聽int聽i,聽count,聽sum;聽聽聽va_list聽marker;聽聽聽va_start(聽marker聽);聽聽聽聽聽聽聽聽聽聽聽聽/**//*聽Initialize聽variable聽arguments.聽*/聽聽聽for(聽sum聽=聽count聽=聽0;聽(i聽=聽va_arg(聽marker,聽int))聽!=聽-1;聽count++聽)聽聽聽聽聽聽sum聽+=聽i;聽聽聽va_end(聽marker聽);聽聽聽聽聽聽聽聽聽聽聽聽聽聽/**//*聽Reset聽variable聽arguments.聽聽聽聽聽聽*/聽聽聽return(聽sum聽?聽(sum聽/聽count)聽:聽0聽);}#endif
鏈涓昏鐨勬槸average 鍑芥暟
寮濮嬫椂鐢蟲槑涓涓獀a_list marker
鍚庢潵璋冪敤va_start(marker);
鍐嶅悗鏉ヨ皟鐢╲a_arg(marker, int)
鏈鍚庣粨鏉熸椂璋冪敤va_end(marker):
]]>
緇欏嚭涓涓墠搴忛亶鍘嗭紝緇欏嚭涓涓腑搴忛亶鍘嗭紝瑕佹眰鎶婃爲杈撳嚭緇欏嚭綆楁硶絳旀濡備笅錛?br />main()
{Datatype聽preorder[n],聽inorder[n];Struct聽link
*
BT;
if
(n聽
>
聽
0
)BT聽
=
聽creatBT(
0
,聽n
-
1
,聽
0
,聽n聽
-
聽
1
);
return
(BT);}
struct
聽link
*
聽createBT(
int
聽prestart,聽
int
聽preend,聽
int
聽instart,聽
int
聽inend)
{p聽
=
聽(
struct
聽link
*
)malloc(
sizeof
(
struct
聽link);p
->
lchild聽
=
聽
null
;p
->
rchild聽
=
聽
null
;p
->
data聽
=
聽preorder[prestart];
if
(prestart聽
>
聽preend)
{聽聽聽
for
(
int
聽i聽
=
聽instart;聽inorder[i]聽
!=
聽preorder[start];聽i
++
);聽
if
(i聽
>
聽instart)聽聽聽p
->
lchild聽
=
聽createBT(prestart聽
+
聽
1
,聽prestart
-
聽instart聽
+
聽
1
,聽instart,聽i聽
-
聽
1
);聽
if
(i聽
<
聽inend)聽聽p
->
rchild聽
=
聽createBT(prestart聽
-
聽instart聽
+
聽i聽
+
聽
1
,聽preend,聽i聽
+
聽
1
,聽inend);聽聽聽聽聽聽聽聽}
聽聽聽
return
聽(p):}
]]>