Mirror a String in Place

Question

Write a program that takes a string as input and modifies it by reversing the string in its place by mirroring the position. The first position goes to last, second to second last and so it goes on. In simple words, the string would be mirrored.

"In Place" means the program should use \$O(1)\$ additional memory regardless of the length of the string

Test Cases

Input: "Hello, World!" Output: "!dlroW ,olleH"

Input: "Hello" Output: "olleH"

Input: "A man a plan a canal Panama" Output: "amanaP lanac a nalp a nam A"

Input: "123456789" Output: "987654321"

Input: "" Output: ""

Answer 1

x86 assembly (Linux) - 42 26 bytes

F6 D6 29 D4 B0 03 89 E1 CD 80 01 C1 43 89 DA 49 39 E1 7C 06 B0 04 CD 80 EB F5

This is my first Assembly program. Reads from stdin, then outputs to stdout in reverse order. Try it online.

not dh       ; sys_read count = edx = 65280
sub esp,edx  ; allocate 65280 bytes on stack

mov al,3     ; 0x03 = "read" syscall
mov ecx,esp  ; sys_read buf = ecx = stack pointer
int 0x80     ; eax = sys_read(stdin, esp, 65280)

add ecx,eax  ; add read bytes to stack pointer

inc ebx      ; sys_write fd = 1 = stdout
mov edx,ebx  ; sys_write count = 1

reverse:
dec ecx      ;
cmp ecx,esp  ; check if we've gone too far
jl done      ;

mov al,4     ; 0x04 = "write" syscall
int 0x80     ; eax = sys_write(stdout, ecx, 1)

jmp reverse

done:

Disassembly

0:  f6 d6                   not    dh
2:  29 d4                   sub    esp,edx
4:  b0 03                   mov    al,0x3
6:  89 e1                   mov    ecx,esp
8:  cd 80                   int    0x80
a:  01 c1                   add    ecx,eax
c:  43                      inc    ebx
d:  89 da                   mov    edx,ebx
0000000f <reverse>:
f:  49                      dec    ecx
10: 39 e1                   cmp    ecx,esp
12: 7c 06                   jl     1a <done>
14: b0 04                   mov    al,0x4
16: cd 80                   int    0x80
18: eb f5                   jmp    f <reverse>

Answer 2

C (gcc), 139 134 132 bytes

#define C strlen(a[1])
main(int n,char**a){for(n=0;n<C/2;){*(a[1]+n)^=**a=*(a[1]+n)^*(a[1]+C-n-1);*(a[1]+C-n++-1)^=**a;}puts(a[1]);}

Try it online!

Thanks for the "you can use puts suggestion from Neil that saved 2 bytes...

OK, assuming I understand the goal (which is big assumption), I think this one does the right thing... It reverses the string passed as the first commandline argument, then prints it. No additional storage is allocated to effect the reversal.

It works by XOR'ing each character of the string with the one it should be swapped with, then XOR'ing that composite value with each of the original characters. The temporary storage needed to complete the work are a char for holding the XOR composite, and an int string offset. The code overloads variables the compiler created for other purposes to avoid allocating additional memory for those temporary variables.

#define C strlen(a[1])       - just a shortcut to save space
main(int n,char**a){ ... }   - standard "this is a C program" stuff
for(n=0;n<C/2;){ ... }       - loop C/2 times (half the length of the string)
**a=*(a[1]+n)^*(a[1]+C-n-1); - set "*a[0]" to a composite of current swap chars
*(a[1]+n)^=**a...            - use composite to swap first char (w/ XOR)
*(a[1]+C-n++-1)^=**a;        - and repeat with the second char, increment "n"
puts(a[1]);                  - output the reversed string

If the rules allow for temporary variables, this could be shorter.

Answer 3

Factor, 8 bytes

reverse!

Try it online!

Builtin. The documentation (and source code) for reverse! corroborates its O(1) additional memory usage beyond the string itself.

Answer 4

Perl 5, 57 bytes

for$l(0...5*length){s/.{$l}\K(.)(.*)(.)(.{$l})/$3$2$1$4/}

Try it online!

Answer 5

JavaScript, 14 bytes

s=>s.reverse()

Try it:

f=s=>s.reverse()

;[
  'Hello, World!',
  'Hello',
  'A man a plan a canal Panama',
  '123456789',
  ''
].forEach(s=>console.log(f([...s]).join``))