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

Pyth, 14 bytes

.w"Hello World

Outputs to a file called o.txt.

Answer 2

Python 2, 32 bytes

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

Yes, this is valid python.

Answer 3

Haskell, 25 bytes

writeFile"o""Hello World"

Answer 4

zsh, 17 bytes

<<<Hello\ World>x

Outputs to a file called x.

Answer 5

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 6

Ruby, 26 bytes

Writes to file f.

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

Answer 7

Batch, 18 bytes

echo Hello World>f

Answer 8

Batch, 19 bytes

@echo Hello World>o

Answer 9

C, 44 bytes

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

Answer 10

PowerShell, 15 bytes

"Hello World">o

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

Answer 11

Dyalog APL, 19 bytes

⎕NPUT⍨'Hello World'

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

Answer 12

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 13

MATL, 15 bytes

'Hello World'Z#

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

Answer 14

K, 20 Bytes

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

Confirmation;

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

Answer 15

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 16

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 17

Clojure, 23 bytes

#(spit"x""Hello World")

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

Answer 18

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 19

Bash, 18 bytes

echo Hello World>a

Answer 20

Tcl, 28 bytes

puts [open T w] Hello\ World

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

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 25

Racket, 43 bytes

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

Answer 26

C#, 118 112 98 bytes

---

Golfed

void M(){var f=new FileInfo("_");var s=f.CreateText();s.Write("Hello World");s.Flush();s.Close();}

---

Ungolfed

public void M() {
    var f = new FileInfo( "_" );
    var s = f.CreateText();

    s.Write( "Hello World" );
    s.Flush();
    s.Close();
}

---

Full explicit code

using System.IO;

namespace N {
    class C {
        public void M() {
            // A file name is required
            FileInfo f = new FileInfo( "_" );

            // Obtain the Stream to later write on it
            StreamWriter s = f.CreateText();

            // Write 'Hello World' to the Stream
            s.Write( "Hello World" );

            // Flush it to the file
            s.Flush();

            // Close the Stream, for security and integrity reasons.
            s.Close();
        }
    }
}

---

Releases

• v1.2 - -14 bytes - Changed to vars. Shoutout to Jean Lourenço.
• v1.1 -  -6 bytes - Simplified names.
• v1.0 - 118 bytes - Initial solution.

---

---

---

I'll leave a version down below that only uses the Console to write on th file. Just because I can.

---

C# Console Version, 39 bytes

---

Golfed

void M(){Console.Write("Hello World");}

---

Ungolfed

public void M() {
    Console.Write("Hello World");
}

---

Full code

using System;

namespace N {
    class C {
        public void M() {
            // Write 'Hello World' to the output handler
            Console.Write("Hello World");
        }
    }
}

---

Usage

<Exe. file name>.exe > FileToOutput.txt

---

Releases

• v1.0 - 39 bytes - Initial solution.

Answer 27

Julia, 47 bytes

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

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

Answer 28

C, 37 bytes

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

Answer 29

Perl 6,  27  23 bytes

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

Answer 30

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 31

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.

Answer 32

Java

public class H
{
    public static void main(String[] a)
        throws IOException
    {
        FileWriter o = new FileWriter("x");
        o.write("Hello World");
        o.close();
    }
}

Simple I/O with no exception handling.

Corrected

Corrected the original code to write the correct string (Hello World).

Answer 33

JavaScript, 89 bytes

This code was tested in Chrome. In other browsers, the element must be in the document for the click method to work.

a=document.createElement("a");a.href="data:text/plain,Hello World";a.download=1;a.click()

Answer 34

HTML, 83 bytes

This code was tested in Chrome. It relies on the image failing to load, then it clicks itself, triggering the anchor tag which is a download link.

<a href="data:text/plain,Hello World" download><img src onerror="this.click()"></a>

Answer 35

QBasic, 39 bytes

OPEN"f"FOR OUTPUT AS#1
?#1,"Hello World

Opens a file named f (creating it if it doesn't exist, wiping it if it does) and gives it the file handle #1. Then prints (?) to file #1 the string Hello World (with a trailing newline).

Answer 36

Bash script, 20 18 bytes

echo Hello World>o

Save this as a file write.sh and run it: `bash o.sh

Answer 37

AutoIT, 43 40 bytes

FileWrite(FileOpen("a",1),"Hello World")

Explanation

FileOpen takes two parameters and returns the handle of the file. Mode must be 1 for writing (appending) text.

FileOpen ( "filename" [, mode = 0] )

FileWrite takes two parameters, a handle and the text to write

FileWrite ( "filehandle/filename", "text/data" )

If a file does not exist, AutoIT will create it. Note that in my example it will not have any file extension associated (filename: a), but can still be opened with any text editor.

AutoIT is a Windows only scripting language.

Script-Example.com has an online AutoIT compiler that can verify the solution.

Answer 38

Php, 38 bytes

file_put_contents('a', 'Hello World');

Answer 39

Nim, 28 26 bytes

"o".writeFile"Hello World"

Yes, Nim has a function in the system module for opening a file, writing a string to it, then closing it again.

Answer 40

PHP, 34 bytes

fputs(fopen(7,'c'),'Hello World');

Answer 41

Mathematica, 27 bytes

".txt"~Export~"Hello World"

Answer 42

Perl, 20 bytes

`echo Hello World>o`

Perl will execute anything in backticks (`) as a system command.

Answer 43

ListSharp, 37 bytes

OUTP="Hello World" HERE[<here>+"\\a"]

simply writes Hello World to a file called "a"(not even a text file) in the script execution environment,

Answer 44

PHP, 27 bytes

exec('echo Hello World>o');

PHP, 20 bytes

`echo Hello World>o`

Answer 45

C#, 50 bytes

s=>System.IO.File.WriteAllText("f","Hello World");

An anonymous function that takes in an unused argument and outputs the file.

Alternatively and cheating slightly this one:

s=>System.IO.File.WriteAllText("f",s);

That takes in a string and works assuming the string contains the text: Hello World, for 38 bytes.

Answer 46

Common Lisp, 69 bytes

Lauded for being incredibly expressive, it's not the best golfing language...

(with-open-file (f "f" :direction :output) (format f "Hello, world"))

See it work, with permission denied.

Answer 47

Awk, 29 characters

BEGIN{print"Hello World">"o"}

(No, not another output redirection. Just Awk's syntax is similar.)

Sample run:

bash-4.3$ awk 'BEGIN{print"Hello World">"o"}'

bash-4.3$ cat o
Hello World

Answer 48

Groovy, 28 characters

new File("o")<<"Hello World"

Sample run:

bash-4.3$ groovy -e 'new File("o")<<"Hello World"'

bash-4.3$ cat o
Hello World

Answer 49

Sed, 20 characters

(19 characters code + 1 character dummy input.)

s/^/Hello World/
wo

Seems the side effect of also displaying the string to STDOUT after the file was created is not prohibited.

Requires dummy input to work as per Are languages like sed exempt from “no input” rules?

Sample run:

bash-4.3$ sed $'s/^/Hello World/;wo' <<< ''
Hello World

bash-4.3$ cat o
Hello World

Answer 50

BASH, 13 bytes

When we asume that the filename is part of the contents of a file:

>Hello\ World