w00t! I like merging. Merging is fun. Say "merging" ten thousand times really fast. Whoa, weird!

int i;
for (i = 0; i < 10000; ++i) puts("merging");

:For(x,1,10000
:Disp "Merging"
:End

var
X:integer;
begin
for X:= 1 to 10000 do writeln('Merging');
end.

Woot for the mighty Pascal

FOR A=1 TO 1000 STEP 1
PRINT "Merging"
NEXT A

Ahhhh, BASIC, my old friend.

Technically the "STEP 1" is not needed, but I used it for old time's sake.

I used to know basic...

void _main(){
int a;
clrcsr();
for (a=1;a<=1000;a++){
printf("MERGING!");//Did I spell that right?
}
}

Now I know C.

for (int i = 0; i < 1000; i++)
{cout << "MERGING";}

Hey, that's C++!

public class no_one_2000_{
public static void main(String[] args){
System.out.println("MERGE");//Java is obsolete :(
}
}

Javascript

<SCRIPT><!--
function merge(){
for(a=1;a<=10000;a++){
document.write("MERGE!<BR>");
}
}
merge();
//--></SCRIPT>

asm 82!
.include CRASH82.INC
Merging:
.db "Merging",0
ld bc,1000
ld hl,0
ld (CURSOR_POS),HL
loop:
ld hl,Merging
ROMCALL(D_ZT_STR)
djnz loop
dec b
dec c
jr nz,loop
ret


or somthing...

you don't need the a after next either

gawk is w00t:

BEGIN {
for(i = 0; i < 10000; i++)
print "merging";
}

8085 assembly is the best way to go. :)

LXI H,TEXTDATA
MVI D,(TEXTDATA+7) AND 255
MOV E,L
LXI B,10000
LOOP:
MOV A,M
OUT 15 ; Okay, let's suppose screen is
INX H ; connected to port 15 :)
MOV A,L
CMP D
JNZ CONTINUE
MOV A,E
CONTINUE:
MOV L,A
DCX B
MOV A,B
ORA C
JNZ LOOP
HALT

TEXTDATA:
DB "MERGING"

This code is actually erroneous. Who can guess out what the problem is? :)

Your TEXTDATA string doesn't have a 0 byte at the end.

Won't it display like this?:
MERGINGMERGINGME
RGINGMERGINGMERG
INGMERGINGMERGIN
GMERGINGMERGINGM
...
?
At least on the 83s... I think.
w00t!

While X=5
Disp "w00t!
End

The null terminator (zero byte) is to tell functions like puts or printf that it's the end of the string of characters. A newline would be '\n', which is value 10.

That's in C, not asm, I think.

yes, the newline is in c

ThIs Is A c CoMaNd

printf("hi\n")

GeT tHe PiCtUrE

There's no reason it can't be used in assembly too, is there now?

so you want it to be able to be:
ld hl,mergetxt
...
mergetxt:
.db "merging\n",0
.end
END

???

Nope, that's not an error. Actually separation between two "MERGING"'s wasn't mentioned in the specification of the problem. However, if you look closely, you can see that the output will be incorrect if the textdata is on a 256-byte boundary, i. e. register H should change somewhere in the text.

The 0 is not to separate the "MERGING"'s but to indicate the end of the string. In this program, it appears that it knows the length of the string (7) instead of checking for a terminator. You are right in that it's not an error. I prefer the mnemonics that are typically used in Z80 assembly over these. They just seem more logical to me.

Here's the typical Z80 equivalent, which is a simple and direct translation of mnemonics:

LD HL,TEXTDATA
LD D,(TEXTDATA+7) AND 255
LD E,L
LD BC,10000
LOOP:
LD A,(HL)
OUT (15),A ; Okay, let's suppose screen is
INC HL ; connected to port 15 :)
LD A,L
CMP D
JR NZ,CONTINUE
LD A,E
CONTINUE:
LD L,A
DEC BC
LD A,B
OR C
JR NZ,LOOP
HALT

TEXTDATA:
.DB "MERGING"

I already know Z80, but thanks anyway. :) I just wrote 8085 code, because I need to practice for the upcoming digital technology test, as this language is quite new to me (I just learnt the mnemonics yesterday). But what would you have done if I had used SIM instead of a port? :))) Actually I also find the Z80 assembly much more logical; I don't really understand why they have so many different names for LD on the 8085. Probably they didn't want to use special characters for memory references.

BTW If you really want to use equivalents, you should write JP instead of JR, as relative jumps do not exist on the 8085... And "CMP D" should be "CP D". And it was another mistake by me: I accidentally wrote "HALT" instead of "HLT". :)

Oh my gosh, this is so freaky. That 8058 (whatever the number) assembly is FREAKY!

Oh, you baby! It's not THAT bad. Let's order you a waah-burger and some French cries! (j/k ;)

Yeah, you're right about the CMP. That's also the instruction in 68k asm. Good luck with the test though.

I've seen these mnemonics used for the Z80 mp once. It was a chess game named Sargon. The book it was in also had a conversion table of the instructions. I've also seen similar instructions for the Motorola 6502 (that's in Commodore 64's), in that it had separate mnemonics for the same operation, such as load. To load a value to the accumulator, one would do LDA (value). To store the accumulator to memory, one would do STA (address). To me, those instructions also made less sense to me. I don't think it has an add or subtract instruction, other than adc and sbc (add/sub w/ carry), so you'd have to clear the carry flag to perform a normal operation.

That's my $0.02

I always thought C64's ran with 6510.

They do, actually, but the 6510 is nearly identical to the 6502. Small technicality.

Actually I have an instruction table for the 6502. It's quite easy to determine what instructions do from their names, so somehow it does make sense (funny they call "jumps" "branches"). I think one's taste depends very much on what he is used to. I don't think I could easily adapt to the inverse operand order of the motorola assembly either... At least I would need more time to get into it than learning this 8085 stuff.

begin:
bcall(_homeup)
ld a,0
ld b,0
merge:
ld hl,mergetxt
bcall(_puts)
inc a
cp 200
call z,yay
ld a,b
cp 6
ret z
jp merge
yay:
inc b
ret
mergetxt:
.db "Merge!",0

END

ld hl,w00t
ld bc,10000
loop:
push bc
push hl
call _puts
call _newline
pop hl
pop bc
dec bc
ld a,b
or c
jr nz,loop
ret

w00t:
.db "merging",0

'i' before 'e' except after 'c', or in 'ay', such as 'neighbor' or 'weigh', or... 'weird'?

English is weird (!) in this way.

Other examples are "science" and "height".

my friend wrote a comic about rice fields... but he wrote it feilds... so I said he must have feild English class.
it makes sense if you pronounce 'ei' as 'ay'...

Haha I get it! :)

I get it, too!
Haha!
w00tw00t!

WoOoOOo()ooOo()oOOo()t!

:-|B

Well, science is easy because the i and e are part of separate syllables.

for(i = 1, i = 10000, i++) {
document.write("Merging");
}

// Yes, I know JavaScript is evil, but it's the most advanced
// language I know right now (but I'm learning C).

This is going to be the future superadvanced language (somebody knows 'English'?)

"Display 'Merging' a thousand times"