Print some JSON

Question

This challenge is straightforward, but hopefully, there are plenty of avenues you can approach it:

You need to print/return a valid JSON object of at least 15 characters, not counting unessential whitespace. Your program should work without any input.

In the interest of clarity, a JSON object starts and ends with curly braces {}, and contains zero or more key:value pairs separated by commas. The full JSON specification can be found at json.org, and the output of your code must pass this validator.

Therefore, any of the following would not be valid:

4                               //Too short, not an object
"really, really long string"    //A string, not an object
["an","array","of","values"]    //An array is not a JSON object
{"this":4      }                //You can't count unessential whitespace
{"1":1,"2":3}                   //Too short
{"a really long string"}        //Not valid JSON, it needs a value
{'single-quoted':3}             //JSON requires double-quotes for strings

However, the following would be valid:

{"1":1,"2":2,"3":3,"4":4}       //Long enough
{"whitespace      ":4}          //This whitespace isn't unessential

Non-programming languages are allowed on this challenge. You may return a string from a function, or print it out. This is a code-golf, so answer it with as little code as possible!

Answer 1

Python 2, 14 bytes

print{`str`:1}

Outputs:

{"<type 'str'>": 1}

The backticks get the string representation in Python 2. Usually, this outputs inside creates single quotes, which Python recognizes as delimiting a string, but JSON doesn't. But Sp3000 observes that when stringifying a type, the type description already contains single quotes, which forces the outer quotes to be double quotes.

Answer 2

jq, 6 characters

(3 characters code + 3 characters command-line option.)

env

CW because I am sure this is not the kind of answer you intended to allow.

Sample run:

bash-4.3$ jq -n 'env'
{
  "GIT_PS1_SHOWDIRTYSTATE": "1",
  "TERM": "xterm",
  "SHELL": "/bin/bash",
  "GIT_PS1_SHOWUNTRACKEDFILES": "1",
  "XTERM_LOCALE": "en_US.UTF-8",
  "XTERM_VERSION": "XTerm(322)",
  "GIT_PS1_SHOWSTASHSTATE": "1",
  "GIT_PS1_SHOWUPSTREAM": "auto",
  "_": "/usr/bin/jq"
}

(Output obviously shortened.)

Answer 3

Jelly, 11 bytes

“Ɠɼ'ẸẠḌȷżÑ»

Try it online!

Output

{"Llanfairpwllgwyngyllgogerychwyrndrobwllllantysiliogogogoch":0}

Answer 4

Notepad, 7 keystrokes

If you have a Windows computer with the Notepad program, type this:

{"F5":0}

On my Windows 7 computer, at least, this gives you something like:

{"3:42 PM 10/25/2016":0}

Answer 5

Java (JDK 10), 20 bytes

v->"{\"\":"+1/.3+"}"

Try it online!

Output

{"":3.3333333333333335}

Answer 6

JavaScript, 17 15 bytes

Thanks to @Neil for this one. Call with no input.

_=>`{"${_}":0}`

Outputs {"undefined":0}

Old version, 16 bytes

Thanks to @kamoroso94 for -1 on this version

_=>`{"":${9e9}}`

Outputs {"":9000000000}

Answer 7

PHP, 14 13 bytes

{"":<?=M_E?>}

Prints a nice mathsy object that one could almost pretend is useful:

{"":2.718281828459}

Uses the fact that php prints anything outside the tags verbatim to save on some quotation marks, M_E was the shortest long enough constant I could find.

edit: saved one byte thanks to Lynn. Sadly it's no longer a 'nice' mathsy object.

Answer 8

Brainfuck, 50 bytes

+[+<---[>]>+<<+]>>+.>>>--.<+++<[->.<]>>.<+.-.<<++.

Outputs {"999999999999999999999999999999999999999999999999999999999999999999999999999999999":9}. Assumes an interpreter that has 8-bit cells and is unbounded on the left. Try it online!

Answer 9

Pyth - 5 bytes

Prints {"'abcdefghijklmnopqrstuvwxyz'": 10}.

XH`GT

Try it online here.

Answer 10

Jolf, 9 bytes

"{¦q:¦q}"

Outputs: {"{¦q:¦q}":"{¦q:¦q}"}. Try it here!

"{¦q:¦q}"
"{  :  }"  raw string
  ¦q       insert the source code here
     ¦q    and here

Answer 11

Pyth, 7 bytes

.d],`G0

Creates a dictionary containing a single key "'abcdefghijklmnopqrstuvwxyz'" and value 0:

.d         Dictionary from:
  ]         The single-element list containing:
   ,         The two-element list containing:
    `G        The representation of the alphabet (the key)
      0       and 0 (the value)
          Implicitly print the stringification of this.

Answer 12

///, 15 14 characters

/a/{":1234}/aa

(At least the output is 1 2 characters longer than the code.)

Try it online!

Thanks to:

• ETHproductions for reusing the object delimiters as part of key (-1 character)

Sample run:

bash-4.3$ slashes.pl <<< '/a/{":1234}/aa'
{":1234}{":1234}

Just to make it more readable:

bash-4.3$ slashes.pl <<< '/a/{":1234}/aa' | jq ''
{
  ":1234}{": 1234
}

Answer 13

Batch, 16 bytes

Prints {"Windows_NT":0}.

@echo {"%OS%":0}

Answer 14

05AB1E, 9 bytes

Unfortunately, 05AB1E doesn't have a dictionary object so we have to construct our own.

’{"èÖ":7}

Try it online!

Output

{"dictionaries":7}

Answer 15

R, 19 bytes

cat('{"',lh,'":1}')

Becomes a bit longer because the need to escape quotes \". Furthermore, lh is one of the built-in datasets in R and is (to my knowledge) the object with the shortest name that contains the 9 characters needed to fill the length of the key. (edit: turns out pi does the trick as well with the standard option and I was beaten by @JDL who was clever enough to escape using single quotes rather than the extra backslashes)

The description of lh in the R-documentation is:

A regular time series giving the luteinizing hormone in blood samples at 10 mins intervals from a human female, 48 samples.

which is a rather unexpected name of a key, but hey, it works and produces the output:

{" 2.4 2.4 2.4 2.2 2.1 1.5 2.3 2.3 2.5 2 1.9 1.7 2.2 1.8 3.2 3.2 2.7 2.2 2.2 1.9 1.9 1.8 2.7 3 2.3 2 2 2.9 2.9 2.7 2.7 2.3 2.6 2.4 1.8 1.7 1.5 1.4 2.1 3.3 3.5 3.5 3.1 2.6 2.1 3.4 3 2.9 ":1}

The answer can be compared to just padding the key with "random" letters to make the output at least 15 characters (24 bytes):

cat("{\"HeloWorld\":1}")

Answer 16

PowerShell 22 20 14 Bytes

'{"":'+1tb+'}'

Output

{"":1099511627776}

Using the constant defined for 1TB in bytes to reach the character limit and the value of a static integer to make for valid json. Thanks to TimmyD for reducing the characters by 5 by removing some redundancy.

---

Earlier Post 40 Bytes

"{$((1..9|%{'"{0}":{0}'-f$_})-join",")}"

Output

{"1":1,"2":2,"3":3,"4":4,"5":5,"6":6,"7":7,"8":8,"9":9}

Takes a integer array and creates a key-value pair for each. Join with commas and wrap with a set of curly braces.

Answer 17

V, 9 bytes

i{"¹*":0}

Try it online!

Very straightforward. Enters insert mode, enters the following text:

{"*********":0}

The reason this is so short is because ¹ repeats the following character 9 times.

Answer 18

Retina, 11 bytes

 
{"9$*R":1}

Output

{"RRRRRRRRR":1}

Note: the leading newline is significant as nothing is replaced with the resultant output, I've used a non-breaking space to illustrate this!

Try it online!

Answer 19

Dyalog APL, 9 bytes

⎕JSON⎕DMX

Try it online!

In a clean workspace on my PC the result is

{"Category":"","DM":[],"EM":"","EN":0,"ENX":0,"HelpURL":"","InternalLocation":["",0],"Message":"","OSError":[0,0,""],"Vendor":""}

⎕JSON convert to JSON

⎕DMX the (universally available) Diagnostic Message Extended object

Answer 20

Japt -Q, 1 byte

M

Try it online!

The output is {"P":3.141592653589793,"Q":1.618033988749895,"T":6.283185307179586}.

How it works

M is a shorthand for JS's Math object, with one-char aliases to existing functions/constants and some extra functions/constants. The constants shown here are:

• M.P = Math.PI
• M.Q = Golden Ratio = (Math.sqrt(5)+1)/2
• M.T = Math.PI * 2

And the boring part: the -Q flag applies JSON.stringify to the output value. Some of the properties are lost (e.g. Math.E and Math.SQRT2), but we still have the above three values and the result is well over 15 characters.

Answer 21

brainfuck, 83 bytes

--[-->+++++<]>.+[---->+<]>+++.>-[>+<-----]>.........<<.[----->+<]>.>.>--[-->+++<]>.

Outputs {"333333333":3}

There is likely another shorter solution, but I have not yet found it.

Explanation:

--[-->+++++<]>. {
+[---->+<]>+++. "
>-[>+<-----]>.  3
........
<<.             "
[----->+<]>.    :
>.              3
>--[-->+++<]>.  }

Try it online

Answer 22

PHP, 19 bytes

<?='{"'.(9**9).'":1}';

Output: {"387420489":1}

https://eval.in/665889

Thanks to manatwork for the tips!

Answer 23

Perl 5, 16 15 bytes

Uses the unix timestamp of the moment the program was started as the content of a one-element object. It gives valid output if you run it later than 10:46:39 on 3rd of March 1973. But since we can't go back in time that seems legit.

say"{\"$^T\":1}"

Uses the FORMAT_TOP_HANDLE variable $^ which defaults to STDOUT_TOP.

say"{\"$^\":1}";

Run with -E flag at no additional cost.

perl -E 'say"{\"$^\":1}";'

Outputs is 16 bytes long.

{"STDOUT_TOP":1}

Answer 24

Java 7, 36 bytes

String c(){return"{\"a\":"+1e6+"}";}

Java 8, 21 bytes

()->"{\"a\":"+1e6+"}"

Ungolfed & test code:

Try it here.

class M{
  static String c(){
    return "{\"a\":" + 1e6 + "}";
  }

  public static void main(String[] a){
    System.out.println(c());
  }
}

Output (length 15):

{"a":1000000.0}

Answer 25

JavaScript (ES6) + jQuery, 15 bytes

Because jQuery.

_=>`{"${$}":0}`

Outputs {"function (a,b){return new n.fn.init(a,b)}":0} when called. Try it here:

f=_=>`{"${$}":0}`
alert(f())

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

Answer 26

Windows batch, 10 bytes

{"%OS%":5}

The environment variable OS contains the string Windows_NT (On all Windows operating systems since 2000, according to this question on Stack Overflow)

Answer 27

R, 19 bytes

This works in British English locale; it may require +2 bytes in others. (Edit: it probably doesn't --- see comments.)

cat('{"',pi,'":1}')

I was hoping for something clever (perhaps plucking a line of code out of a pre-existing function like q) but couldn't find anything. The result:

{" 3.141593 ":1}

Note that you don't have to escape double quotes in R if you use single quotes to quote the string (and vice-versa). This behaviour is locale-dependent though. I would expect it to work in a US English locale as well though.

This also requires that your default digits option is at least six (which is the factory-fresh default) and that scipen is at least -digits (the factory-fresh default is zero).

Answer 28

HQ9+, 15 bytes

{"Quineland":0}

Outputs itself. I thought an 8-byte answer would be possible, like so:

{":11QQ}

This outputs {":11QQ}{":11QQ}, which is almost valid JSON, but 11QQ is not a valid value.

HQ9+ is not a valid programming language by PPCG standards, but the OP has allowed non-programming languages.

Answer 29

Bash, 18 bytes

echo {\"$PATH\":1}

This works on Mac and Linux, unless your $PATH isn't set.

Answer 30

Ruby, 19 bytes

puts'{"1":'+9**9+?}

Output:

{"1":387420489}