3 another typo fix

# Shenzen IO (Assembler) ,83 76 bytes, noncompeting

Shenzen io is a puzzle game where you can code you code in a special assembler-ish language.

Unfortunately, you can only use integers between -999 and 999 as inputs or outputs, and there is no way to tell if an array has ended. So i assumed that the array was written on a ROM that wraps around after reading the last cell. This means that only even arrays can be used, which is the reason for it being noncompeting.

Code:

@mov x0 dat
@mov x0 acc
teq x0 dat
+teq x0 acc
b:
+mov 1 p1
-mov 0 p1
-jmp b


Explanation:

  # calling for x0 will cause rom to move 1 cell forward
# (slx does not count).

@ mov x0 dat # Moves value to variable dat (only run once)
@ mov x0 acc # Moves rom position forward and moves x0 to acc
teq x0 dat  # See if dat equals x0
+ teq x0 acc  # If last expression was true, see x0 equals acc
b:            # Label for jumps (GOTO)
+ mov 1 p1    # Set output (p1) to 1 (same case as previous line)
- mov 0 p1    # if any expression was false, set output to 0
- jmp b       # jump to b: (same case as prev line)


Sorry if any of this is confusing, this is my first code-golf answer.

EDIT: removed 7 bytes by replacing loops by run-once code

# Shenzen IO (Assembler) ,83 76 bytes, noncompeting

Shenzen io is a puzzle game where you can code you code in a special assembler-ish language.

Unfortunately, you can only use integers between -999 and 999 as inputs or outputs, and there is no way to tell if an array has ended. So i assumed that the array was written on a ROM that wraps around after reading the last cell. This means that only even arrays can be used, which is the reason for it being noncompeting.

Code:

@mov x0 dat
@mov x0 acc
teq x0 dat
+teq x0 acc
b:
+mov 1 p1
-mov 0 p1
-jmp b


Explanation:

  # calling for x0 will cause rom to move 1 cell forward
# (slx does not count).

@ mov x0 dat # Moves value to variable dat (only run once)
@ mov x0 acc # Moves rom position forward and moves x0 to acc
teq x0 dat  # See if dat equals x0
+ teq x0 acc  # If last expression was true, see x0 equals acc
b:            # Label for jumps (GOTO)
+ mov 1 p1    # Set output (p1) to 1 (same case as previous line)
- mov 0 p1    # if any expression was false, set output to 0
- jmp b       # jump to b: (same case as prev line)


Sorry if any of this is confusing, this is my first code-golf answer.

EDIT: removed 7 bytes by replacing loops by run-once code

# Shenzen IO (Assembler) ,83 76 bytes, noncompeting

Shenzen io is a puzzle game where you can code you code in a special assembler-ish language.

Unfortunately, you can only use integers between -999 and 999 as inputs or outputs, and there is no way to tell if an array has ended. So i assumed that the array was written on a ROM that wraps around after reading the last cell. This means that only even arrays can be used, which is the reason for it being noncompeting.

Code:

@mov x0 dat
@mov x0 acc
teq x0 dat
+teq x0 acc
b:
+mov 1 p1
-mov 0 p1
-jmp b


Explanation:

  # calling for x0 will cause rom to move 1 cell forward

@ mov x0 dat # Moves value to variable dat (only run once)
@ mov x0 acc # Moves rom position forward and moves x0 to acc
teq x0 dat  # See if dat equals x0
+ teq x0 acc  # If last expression was true, see x0 equals acc
b:            # Label for jumps (GOTO)
+ mov 1 p1    # Set output (p1) to 1 (same case as previous line)
- mov 0 p1    # if any expression was false, set output to 0
- jmp b       # jump to b: (same case as prev line)


Sorry if any of this is confusing, this is my first code-golf answer.

EDIT: removed 7 bytes by replacing loops by run-once code

Shenzen IO (Assembler) ,83 bytes, noncompeting

# Shenzen IO (Assembler) ,83 76 bytes, noncompeting

Shenzen io is a puzzle game where you can code you code in a special assembler-ish language.

Unfortunately, you can only use integers between -999 and 999 as inputs or outputs, and there is no way to tell if an array has ended. So i assumed that the array was written on a ROM that wraps around after reading the last cell. This means that only even arrays can be used, which is the reason for it being noncompeting.

Code:

mov@mov x0 dat
mov@mov x0 acc
a:
teq x0 dat
+teq x0 acc
b:
+mov 1 p1
-mov 0 p1
-jmp b
jmp a


Explanation:

  # calling for x0 will cause rom to move 1 cell forward
# (slx does not count).

@ mov x0 dat # Moves value to variable dat (only run once)
@ mov x0 acc # Moves rom position forward and moves valuex0 to acc
a:           # Label for jumps (GOTO)
teq x0 dat  # See if dat equals x0
+ teq x0 acc  # If last expression was true, see x0 equals acc
b:            # Label for jumps (GOTO)
+ mov 1 p1    # Set output (p1) to 1 (same case as previous line)
- mov 0 p1    # if any expression was false, set output to 0
- jmp b       # jump to b: (same case as prev line)


Sorry if any of this is confusing, this is my first code-golf answer.

EDIT: removed 7 bytes by replacing loops by run-once code

Shenzen IO (Assembler) ,83 bytes, noncompeting

Shenzen io is a puzzle game where you can code you code in a special assembler-ish language.

Unfortunately, you can only use integers between -999 and 999 as inputs or outputs, and there is no way to tell if an array has ended. So i assumed that the array was written on a ROM that wraps around after reading the last cell. This means that only even arrays can be used, which is the reason for it being noncompeting.

Code:

mov x0 dat
mov x0 acc
a:
teq x0 dat
+teq x0 acc
b:
+mov 1 p1
-mov 0 p1
-jmp b
jmp a


Explanation:

  # calling for x0 will cause rom to move 1 cell forward
# (slx does not count)

mov x0 dat # Moves value to variable dat
mov x0 acc # Moves rom position forward and moves value to acc
a:           # Label for jumps (GOTO)
teq x0 dat # See if dat equals x0
+ teq x0 acc # If last expression was true, see x0 equals acc
b:
+ mov 1 p1   # Set output (p1) to 1 (same case as previous line)
- mov 0 p1   # if any expression was false, set output to 0
- jmp b      # jump to b: (same case as prev line)


Sorry if any of this is confusing, this is my first code-golf answer

# Shenzen IO (Assembler) ,83 76 bytes, noncompeting

Shenzen io is a puzzle game where you can code you code in a special assembler-ish language.

Unfortunately, you can only use integers between -999 and 999 as inputs or outputs, and there is no way to tell if an array has ended. So i assumed that the array was written on a ROM that wraps around after reading the last cell. This means that only even arrays can be used, which is the reason for it being noncompeting.

Code:

@mov x0 dat
@mov x0 acc
teq x0 dat
+teq x0 acc
b:
+mov 1 p1
-mov 0 p1
-jmp b


Explanation:

  # calling for x0 will cause rom to move 1 cell forward
# (slx does not count).

@ mov x0 dat # Moves value to variable dat (only run once)
@ mov x0 acc # Moves rom position forward and moves x0 to acc
teq x0 dat  # See if dat equals x0
+ teq x0 acc  # If last expression was true, see x0 equals acc
b:            # Label for jumps (GOTO)
+ mov 1 p1    # Set output (p1) to 1 (same case as previous line)
- mov 0 p1    # if any expression was false, set output to 0
- jmp b       # jump to b: (same case as prev line)


Sorry if any of this is confusing, this is my first code-golf answer.

EDIT: removed 7 bytes by replacing loops by run-once code

1

Shenzen IO (Assembler) ,83 bytes, noncompeting

Shenzen io is a puzzle game where you can code you code in a special assembler-ish language.

Unfortunately, you can only use integers between -999 and 999 as inputs or outputs, and there is no way to tell if an array has ended. So i assumed that the array was written on a ROM that wraps around after reading the last cell. This means that only even arrays can be used, which is the reason for it being noncompeting.

Code:

mov x0 dat
mov x0 acc
a:
teq x0 dat
+teq x0 acc
b:
+mov 1 p1
-mov 0 p1
-jmp b
jmp a


Explanation:

  # calling for x0 will cause rom to move 1 cell forward
# (slx does not count)

mov x0 dat # Moves value to variable dat
mov x0 acc # Moves rom position forward and moves value to acc
a:           # Label for jumps (GOTO)
teq x0 dat # See if dat equals x0
+ teq x0 acc # If last expression was true, see x0 equals acc
b:
+ mov 1 p1   # Set output (p1) to 1 (same case as previous line)
- mov 0 p1   # if any expression was false, set output to 0
- jmp b      # jump to b: (same case as prev line)