MOV x, dx = sin( c );5) In intel assembly, how would you get the instruction pointer into the EAX register?come'on coders .. don't let ME solve everything!!
7) Reset the least significant 1 bit in a 32 bit value to 0. If the value is 0 (all 32 bits are 0) then the output should be 0. The must be done brance free. (Again, no jumps/branches/calls). If you answer this in a high level language, it must be done in a way that's guaranteed not to compile to jumps/branches/calls.I'm not sure this is the most efficient code, but then again, you dont want me to use jumps or branches, so how efficient can you get ?
Ex. 1: (for 8 bits)
Input: 01001101
Output: 01001100
Ex. 2: (for 8 bits)
Input: 01011000
Output: 01010000
Edit: This last challenge is meant to be read as: The least significant bit that is set to a 1 needs to be reset to 0. As in, the first 1 bit from the right. Not the LSB.
; initialization
MOV CX,0
MOV EAX,input
; bit processing - repeat these lines 32 times
SHR EAX,1
RCL BL,1
MOV CH,BL
AND BL,CL
SHR BL,1
RCR output,1
OR CL,CHI'm not sure this is the most efficient code, but then again, you dont want me to use jumps or branches, so how efficient can you get ?It's not. :P
So, a question now would be, how is this done better?and i leave that up to you.
MOV EAX,input
MOV ECX,0
PUSH EAX
RCL EAX,1
RCL ECX,1
POP EAX
PUSH ECX
NEG ECX
XOR EAX,ECX
POP ECX
ADD EAX,ECX
MOV output,EAXchar *s[]={
"#include <stdio.h>",
"#include <string.h>",
"char *translate(char *s)",
"{",
" int x=0;",
" while (s[x])",
" {",
" switch (s[x])",
" {",
" case 38: s[x]=34; break;",
" case 47: s[x]=92; break;",
" case 36: s[x]=37; break;",
" }",
" ++x;",
" }",
" return s;",
"}",
"void main()",
"{",
" int i=-1,j=-1;",
" char ss[80];",
" printf(&char *s[]={/n&);",
" while (s[++i]!=0) printf(&/&$s/&,/n&,s[i]);",
" printf(&0/n};/n&);",
" while (++j<i) { strcpy(ss,s[j]); printf(&$s/n&,translate(ss)); }",
"}",
0
};
#include <stdio.h>
#include <string.h>
char *translate(char *s)
{
int x=0;
while (s[x])
{
switch (s[x])
{
case 38: s[x]=34; break;
case 47: s[x]=92; break;
case 36: s[x]=37; break;
}
++x;
}
return s;
}
void main()
{
int i=-1,j=-1;
char ss[80];
printf("char *s[]={\n");
while (s[++i]!=0) printf("\"%s\",\n",s[i]);
printf("0\n};\n");
while (++j<i) { strcpy(ss,s[j]); printf("%s\n",translate(ss)); }
}5) In intel assembly, how would you get the instruction pointer into the EAX register?Doesn't anybody know the answer to this simple one ?
POP EAX
PUSH EAX
RET
QUOTE
So, a question now would be, how is this done better?
and i leave that up to you.
The question was to DO it, and not to do it efficiently, or fast, or small code or whatever.
You want small, efficient code, use branches!
char buff[64];
snprintf(buff, 64, "Writing data to a buffer you've defined!"); // Against the rules!
printf("Hello World!"); // Nothing wrong with this
char string1 = "This is a string";
printf("%s", string1); // Nothing wrong with this either
char *string2 = CopyString(string1); // Against the rules
string2[1] = "\n"; // Clearly against the above rules about writing to data through a pointer you've defined.
char *string3 = CopyAndTranslate(string1); // Also against the rulesAs for #8. I think it needs a fair bit of rethinking. Probably not so easy to mod the code you already have. But hey, maybe you know of some ingenious way I haven't thought of.as i said: modify it just slightly.. i should've done this earlier. I was thinking about it, but i thought it was too much work, for just a simple coding test, that you designed. But since you put so much weight on it - i did it anyway: change all text into bytes :P It saves the 'translate' function altogether, and sticks to your rules. Plus it circumvents the MS compiler "bug" as i call it :P
char *s="\x23\x69\x6E\x63\x6C\x75\x64\x65\x20\x3C\x73\x74\x64\x69\x6F\x2E\x68\x3E\x0A\x76\x6F\x69\x64\x20\x6D\x61\x69\x6E\x28\x29\x0A\x7B\x0A\x20\x69\x6E\x74\x20\x69\x3D\x2D\x31\x3B\x0A\x20\x70\x72\x69\x6E\x74\x66\x28\x22\x63\x68\x61\x72\x20\x2A\x73\x3D\x5C\x22\x22\x29\x3B\x0A\x20\x77\x68\x69\x6C\x65\x20\x28\x73\x5B\x2B\x2B\x69\x5D\x21\x3D\x30\x29\x20\x70\x72\x69\x6E\x74\x66\x28\x22\x5C\x5C\x78\x25\x30\x32\x58\x22\x2C\x73\x5B\x69\x5D\x29\x3B\x0A\x20\x70\x72\x69\x6E\x74\x66\x28\x22\x5C\x22\x3B\x5C\x6E\x25\x73\x22\x2C\x73\x29\x3B\x0A\x7D";
#include <stdio.h>
void main()
{
int i=-1;
printf("char *s=\"");
while (s[++i]!=0) printf("\\x%02X",s[i]);
printf("\";\n%s",s);
}So, do you really want me to answer #10? Or should I leave it an open question for now?(...)
9) Solve challenge #6 with at most 5 assembly instructions. (You *should* need less than this).
int absolute(int input)
{
_asm
{
MOV EAX,input
SHR EAX,31
SUB input,EAX
NEG EAX
XOR input,EAX
};
return input;
}CDQ
SUB EAX, EDX
XOR EAX, EDXCALL dummyLabel
dummyLabel:
POP EAXi = i & (i-1);LEA EDX, [EAX - 1]
AND EAX, EDXMOV EDX, EAX
DEC EDX
AND EAX, EDXAnswer 11 is correct. Again, good job. (Note: this one was answered before but the post was lost.)..and he remembered not 100%, it is addition, not multiplication :P
int i=0;
int z=0;
for(z=0;z<6;z++)
{
i = ++i + 1;
}
printf ("The return is: %1d \n", i);
return 0;
#include "stdafx.h"
int main(int argc, char* argv[])
{
int i=0;
int z=0;
int w=0;
for(z=0;z<1000;z++)
{
i = ++i + 1;
}
printf ("The return is: %1d \n", i);
i=0;
for (w=0;w<1000;w++)
{
i= i + 2;
}
printf ("The return is: %1d \n", i);
return 0;
}
The return is: 2000
The return is: 2000
Press any key to continue
This is a coding challenge, after all. Any free C compiler will produce the same result. Even code compiled in Java or under a linux machine will still produce the same result.Not necessarily.
2) In C++, the result of:Undefined! :P
i = ++i + 1;
is ...?
i = ++i + 1; // the behavior is unspecified
4 Except where noted, the order of evaluation of operands of individualAnother example which more clearly illustrates the problem that was given is:
operators and subexpressions of individual expressions, and the order
in which side effects take place, is unspecified. Between the previ-
ous and next sequence point a scalar object shall have its stored
value modified at most once by the evaluation of an expression. Fur-
thermore, the prior value shall be accessed only to determine the
value to be stored. The requirements of this paragraph shall be met
for each allowable ordering of the subexpressions of a full expres-
sion; otherwise the behavior is undefined.
i = v[i++]; // the behavior is unspecifiedDoes the i++ change the value of i before or after the assignment?
j = i = 5;i = i++ + ++ i;i = 0;
j = i++ + i++ + i++;i = 0;
j = ++i + ++i + ++i;i = 0;
j = i++ + ++i + ++i;i = 0;
j = ++i + i++ + ++i;i = 0;
j = i++ + i++ + ++i;j = ++i++;j = ++(i++);j = (++i)++;i = 0;
j = (++i + ++i) + ++i;i = 0;
j = ++i + (++i + ++i);i = 0;
j = ++i = ++i + ++i;
i = 0;
j = ++i = (++i + ++i);
i = 0;
j = (++i = ++i) + ++i;
'sides, the only way I'd want to kill ya is if you completely destroyed everything that is Outpost... so... :-P
#include "stdio.h"
// "0" 48 (0x30) 00110000 - "9" 57 (0x39) 00111001
// "A" 65 (0x41) 01000001 - "Z" 90 (0x5A) 01011010 - "F" 70 (0x46) 01000110
// "a" 97 (0x61) 01100001 - "z" 122 (0x7A) 01111010 - "f" 102 (0x66) 01100110
int HexConvert(char *hexString)
{
int retValue;
__asm
{
// Load the string address
MOV EDX, hexString
XOR EAX, EAX // Clear return value to 0
// Convert the first digit
MOV AL, [EDX] // Load the character
// Convert letters to 10+
MOV CL, AL
SHL CL, 1
SAR CL, 8
SUB AL, CL
SHL CL, 3
SUB AL, CL
// Cut off non numeric bits
AND AL, 0x0F
// At this point in AL, numebrs 0-9 should produce 0-9 and letters A-F and a-f should produce 10-15.
// Process a second digit (if the first wasn't a null terminator)
MOV CL, [EDX] // Load the character
CMP CL, 0
SETNE CL
MOVSX ECX, CL
ADD EDX, ECX
SHL EAX, 12 // Store previous result in upper nibble of AH
// Convert the first digit
MOV AL, [EDX] // Load the character
// Convert letters to 10+
MOV CL, AL
SHL CL, 1
SAR CL, 8
SUB AL, CL
SHL CL, 3
SUB AL, CL
// Cut off non numeric bits
AND AL, 0x0F
// At this point in AL, numebrs 0-9 should produce 0-9 and letters A-F and a-f should produce 10-15.
// Ignore result if terminating NULL and use a single digit
MOV CL, [EDX] // Load the character
CMP CL, 0
SETE CL
SHL CL, 2
SHR EAX, CL // (If CL == 0) Move upper nibble of AH to lower nibble, lower nibble of AL is 0
// Combine nibblein AH with nibble in AL
OR AL, AH // Value is now in AL
XOR AH, AH // Clear AH
MOV retValue, EAX
}
return retValue;
}
void main()
{
char *text = "2A";
printf("%X\n", HexConvert(text));
}short Multiply(char factor1,char factor2)short Divide(char divisor,char divider)short result=Divide(11,5);
char quotient=result & 0x00FF;
char remainder=result >> 8;#include <stdio.h>
void main()
{
char *escape = "\\"; char *enter = "\n"; char *quote = "\"";
char *string = "#include <stdio.h>%s%svoid main()%s{%schar *escape = %s%s%s%s; char *enter = %s%sn%s; char *quote = %s%s%s%s;%schar *string = %s%s%s;%sprintf(string, enter, enter, enter, enter, quote, escape, escape, quote, quote, escape, quote, quote, escape, quote, quote, enter, quote, string, quote, enter, enter, enter);%s}%s";
printf(string, enter, enter, enter, enter, quote, escape, escape, quote, quote, escape, quote, quote, escape, quote, quote, enter, quote, string, quote, enter, enter, enter);
}The only memory writing should occur deep within printf to variables I have no control ot access to.Just to be picky since it would be fun :P
push ...
push ...
.. etc for all other parameters ..
call _printf#13 Base Converter#13 isn't so bad... Hint: Instead of say 1,10,100,1000... you'de have -1,10,-100,1000... and thus some negative decimal numbers become positive in base -10 and also the other way around.
Write a converter to express numbers in a different base b.
For each base b, make the following output:
A. A table listing the representations in base b of the numbers from 0 to 15.
B. A table listing the usual representation of numbers for the first 16 encodings of base b numbers. (Sorta like the reverse of table A).
Challenge: Do this for the following bases:
I. b = -2
II. b = -1 + i (where i = sqrt(-1))
Note: Both systems are expressible in binary. (i.e., the with the digits 0 and 1).
Have fun. :lol:
Note: Both systems are expressible in binary. (i.e., the with the digits 0 and 1).
1/b=0.00123456 then p=1.23456 and q=10^-3Note that this is subject to rounding errors. The value of 1/b might not be expressible in such an easy format. Think about repeating decimals, or ones that are long enough to overflow the precision of the registers. Try expression 1/3 in binary for example.
So the bit strings would be as follows:
00: 0 * (-1 + i) + 0 * (1) = 0
01: 0 * (-1 + i) + 1 * (1) = 1
10: 1 * (-1 + i) + 0 * (1) = -1 + i
11: 1 * (-1 + i) + 1 * (1) = i