Create and write to a file

Question

Challenge

Create a new file and write the string Hello World to it.

Restrictions

• Your challenge must write to a file on disk, in the file system.

• The file may not be a log file generated during normal operation of the interpreter.

• The file must contain only the string Hello World. It is allowed to contain a trailing newline or minimal whitespace. No other content.

• No command-line flags/pipes (etc) allowed, except when necessary to run the program. (e.g. perl -p)

Notes

• This is code-golf, so shortest program in bytes wins.

• Follow the spirit, not the letter, of the rules.

Answer 1

Python 2, 32 bytes

print>>open(*"ww"),"Hello World"

Yes, this is valid python.

Answer 2

Haskell, 25 bytes

writeFile"o""Hello World"

Answer 3

zsh, 17 bytes

<<<Hello\ World>x

Outputs to a file called x.

Answer 4

Vyxal 2.5.3, 32 bytes

kh→@|;@+open(*"ww").write(VAR_)#

Vyxal can't really do anything with external files, which would normally render this challenge impossible. However, in Vyxal 2.5.3 and prior, there was an ACE exploit allowing for arbitrary Python execution. Yep, I found another one.

---

The ACE:

Vyxal is a transpiled language, so every Vyxal command is translated to some Python code, and then all of the translated commands are executed. Previously, I found that you could escape a string to insert any Python commands you wanted into the transpiled code. It turns out that you can do something similar with function names.

When defining a function in Vyxal, the resulting python looks something like this:

def FN_func(parameter_stack, arity=None):
    ...setup stuff...
    ...commands...
    ...finishing stuff...
    return stack

When calling a function in Vyxal, the resulting Python code looks something like this:

stack += FN_func(stack)

The thing is, when parsing the name of a function, the strategy was to just read characters until reaching a :, |, or ;, which are the delimiters of different parts of the function declaration/call. This meant that you could put any characters you wanted into the name, and it would attempt to transpile it the same way.

In this case, I used a + in the function name when I called it. That results in this transpiled code:

stack += FN_+open(*"ww").write(VAR_)#(stack)

This code will error when ran, because it tries to add together a function and the None that is returned from the open command. However, even though it errors, the open command still runs, meaning that we have executed arbitrary Python. If you wanted to write longer sections of Python code, you could replace the + with ([]) and add a newline after it.

---

The program:

In this program, the payload (the arbitrary Python code) is the following:

open(*"ww").write(VAR_)

The basis of this code is the open().write() command, which creates a file named w if it doesn't exist, then writes the contents of VAR_ to it.

The VAR_ variable is set at the beginning of the Vyxal program with kh→. This pushes the builtin Hello World and saves it to the nameless variable. All variable names are prepended with VAR_ internally, so the variable VAR_ is created and contains Hello World, which is written to the newly created file. Even though this has the overhead of the ACE setup, it ends up being shorter than the Python solutions due to the builtin.

This ACE has not been fixed in the repo, but it had a patch applied server-side for the online interpreter. It was also fixed in the rewrite and subsequent 2.6 release. If you want to try out this program for yourself, you can download the 2.5.3 version here.

Answer 5

Ruby, 26 bytes

Writes to file f.

open(?f,?w)<<"Hello World"

Answer 6

Batch, 18 bytes

echo Hello World>f

Answer 7

Batch, 19 bytes

@echo Hello World>o

Answer 8

Vim, 15 + 2 == 17 bytes

iHello World<esc>ZZ

+2 bytes for launching this with vim f instead of vim. Additionally, this version works to:

iHello World<C-o>ZZ

If launching vim like this is not allowed, there is also:

Vim, 18 bytes

iHello World<esc>:w f<cr>

Side note: this is a polyglot. The same thing works in V, except that it is one byte shorter (since the <cr> at the end is implicit.)

Answer 9

C, 44 bytes

main(){fputs("Hello World",fopen("o","w"));}

Answer 10

Dyalog APL, 19 bytes

⎕NPUT⍨'Hello World'

Creates a file with the name and contents "Hello World".

Answer 11

PowerShell, 15 bytes

"Hello World">o

> redirects the string to a file called o in the current directory.

Answer 12

Node.js, 42 bytes

require("fs").writeFile('o','Hello World')

i don't think this needs explanation

Node.js REPL, 31 bytes

fs.writeFile('o','Hello World')

for some reason in repl you dont need to include fs

Answer 13

Bash, 18 bytes

echo Hello World>a

Answer 14

Pyth, 14 bytes

.w"Hello World

Outputs to a file called o.txt.

Answer 15

ed, 19 characters

i
Hello World
.
w o

Sample run:

bash-4.3$ ed <<< $'i\nHello World\n.\nw o'
12

bash-4.3$ cat o
Hello World

Answer 16

MATL, 15 bytes

'Hello World'Z#

This creates a file called inout and writes the string to it.

Answer 17

K, 20 Bytes

    `:f 0:,"Hello World"
    `:f

Confirmation;

    mmm@chromozorz:~/q$ cat f.txt 
    Hello World

Answer 18

Clojure, 23 bytes

#(spit"x""Hello World")

Anonymous function which creates file called x and writes Hello World there.

Answer 19

C#, 93 77 76 bytes

using System.IO;namespace N{class C{static void M(){File.WriteAllText("f", "Hello World");}}}

class C{static void Main(){System.IO.File.WriteAllText("f", "Hello World");}}

class C{static void Main(){System.IO.File.WriteAllText("f","Hello World");}}

See it work, with an exception for unauthorized file access.

Changelog

Rev2

• Removed unnecessary namespace
• Changed function name to Main (because otherwise it won't be detected as main function)
• Removed using directive (thanks Jean Lourenço)

Rev3

• Removed space that sneaked in.

C# (without boilerplate), 47 bytes

void M(){File.WriteAllText("f","Hello World");}

Answer 20

R, 38 36 35 bytes

sink(" ");cat("Hello World");sink()

I like how the created file has no name ! It's just .txt anything, in fact !

-2 bytes thanks to @PEAR remark !
-1 bytes thanks to @BartvanNierop !

This code will produce a file with no name.

Answer 21

Python, 34 bytes

open("h","w").write("Hello World")

Outputs to a file called h.

Answer 22

APLX, 15 bytes

'Hello World'⍈1

Creates an APL component file containing just one component; the desired string. It can be read back with:

      'Hello World'⍇1
Hello World

Answer 23

Gema, 28 characters

\A=@write{o;Hello World}@end

Sample run:

bash-4.3$ gema '\A=@write{o;Hello World}@end'

bash-4.3$ cat o
Hello World

Answer 24

Racket, 43 bytes

(display"Hello World"(open-output-file"f"))

Answer 25

Julia, 47 bytes

f=open("o","w");write(f,"Hello World");close(f)

I tried using writedlm, but it didn't work out.

Answer 26

C, 37 bytes

main(){system("echo Hello World>o");}

Answer 27

Perl 6,  27  23 bytes

'o'.IO.spurt: 'Hello World'
spurt 'o','Hello World'

Answer 28

Java 7, 100 95 bytes

void f()throws Exception{java.io.Writer p=new java.io.PrintWriter("x");p.print("Hello World");}

Or if you want to close the writer after using it (101 bytes):

void f()throws Exception{try(java.io.Writer p=new java.io.PrintWriter("x")){p.print("Hello World");}}

Ungolfed:

class Main{
  static void f() throws Exception{
    try(java.io.Writer p = new java.io.PrintWriter("x")){
      p.print("Hello World");
    }
  }

  public static void main(String[] a){
    try{
      f();
    } catch(Exception ex){
    }
  }
}

Usage:

java -jar Main.jar

Answer 29

eacal, 26 bytes

write a string Hello World

This writes a string Hello World to file a, creating it if not present. Basically:

write <fileName> <exec>

and

string <params to convert to string>

Run the program as:

λ node eacal.js writeFile

Answer 30

J, 21 bytes

'Hello World'1!:3<'o'

This writes to a file o in the current directory, or, if not called from a file, in your j64-804 file. 1!:3 is the write foreign, and <'o' is the boxed filename (filenames need to be boxed). The LHS is the string to write.