3 another typo fix
source | link

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

2 fixed typos, header
source | link

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)
  jmp a      # jump to a:

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)
  jmp a      # jump to a:

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
source | link

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)
  jmp a      # jump to a:

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