Este desafío es sencillo, pero con suerte, hay muchas maneras de abordarlo:

Debe imprimir / devolver un objeto JSON válido de al menos 15 caracteres, sin contar espacios en blanco no esenciales. Su programa debería funcionar sin ninguna entrada.

En aras de la claridad, un objeto JSON comienza y termina con llaves {}, y contiene cero o más pares clave: valor separados por comas. La especificación JSON completa se puede encontrar en json.org , y la salida de su código debe pasar este validador .

Por lo tanto, cualquiera de los siguientes no sería válido:

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

Sin embargo, lo siguiente sería válido:

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

Los lenguajes que no son de programación están permitidos en este desafío. Puede devolver una cadena de una función o imprimirla. Este es un código de golf , ¡así que responda con el menor código posible!

Python 2, 14 bytes

print{`str`:1}

Salidas:

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

Los backticks obtienen la representación de cadena en Python 2. Por lo general, estos resultados en el interior crean comillas simples, que Python reconoce como delimitación de una cadena, pero JSON no. Pero Sp3000 observa que cuando se encadena un tipo, la descripción del tipo ya contiene comillas simples, lo que obliga a las comillas externas a ser comillas dobles.

jq, 6 caracteres

(Código de 3 caracteres + opción de línea de comando de 3 caracteres).

env

CW porque estoy seguro de que este no es el tipo de respuesta que pretendías permitir.

Ejecución de muestra:

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"
}

(Salida obviamente acortada)

Jalea , 11 bytes

“Ɠɼ'ẸẠḌȷżÑ»

Pruébalo en línea!

Salida

{"Llanfairpwllgwyngyllgogerychwyrndrobwllllantysiliogogogoch":0}

Bloc de notas, 7 pulsaciones de teclas

Si tiene una computadora con Windows con el programa Bloc de notas, escriba esto:

{"F5":0}

En mi computadora con Windows 7, al menos, esto te da algo como:

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

Java (JDK 10) , 20 bytes

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

Pruébalo en línea!

Salida

{"":3.3333333333333335}

PHP, 14 13 bytes

{"":<?=M_E?>}

Imprime un objeto matemático agradable que casi se podría imaginar que es útil :

{"":2.718281828459}

Usa el hecho de que php imprime cualquier cosa fuera de las etiquetas textualmente para ahorrar entre comillas, M_Efue la constante más corta que pude encontrar.

editar: guardado un byte gracias a Lynn. Lamentablemente ya no es un objeto matemático "agradable".

JavaScript, 17 15 bytes

Gracias a @Neil por este. Llamada sin entrada.

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

Salidas {"undefined":0}

Versión anterior, 16 bytes

Gracias a @ kamoroso94 por -1 en esta versión

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

Salidas {"":9000000000}

Brainfuck, 50 bytes

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

Salidas {"999999999999999999999999999999999999999999999999999999999999999999999999999999999":9}. Asume un intérprete que tiene celdas de 8 bits y no está acotado a la izquierda. Pruébalo en línea!

Pyth - 5 bytes

Impresiones {"'abcdefghijklmnopqrstuvwxyz'": 10}.

XH`GT

Pruébelo en línea aquí .

Jolf, 9 bytes

"{¦q:¦q}"

Salidas: {"{¦q:¦q}":"{¦q:¦q}"}. Pruébalo aquí!

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

Pyth, 7 bytes

.d],`G0

Crea un diccionario que contiene una sola clave "'abcdefghijklmnopqrstuvwxyz'"y valor 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.

Lote, 16 bytes

Impresiones {"Windows_NT":0}.

@echo {"%OS%":0}

///, 15 14 caracteres

/a/{":1234}/aa

(Al menos el resultado es 1 2 caracteres más largo que el código).

Pruébalo en línea!

Gracias a:

• ETHproductions para reutilizar los delimitadores de objetos como parte de la clave (-1 carácter)

Ejecución de muestra:

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

Solo para hacerlo más legible:

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

R, 19 bytes

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

Se vuelve un poco más largo porque la necesidad de escapar de las citas \". Además, lhes uno de los conjuntos de datos integrados Ry es (que yo sepa) el objeto con el nombre más corto que contiene los 9 caracteres necesarios para completar la longitud de la clave. (editar: resulta pique también funciona con la opción estándar y @JDL me derrotó, que era lo suficientemente inteligente como para escapar usando comillas simples en lugar de las barras invertidas adicionales)

La descripción de lhen la documentación R es:

Una serie de tiempo regular que proporciona la hormona luteinizante en muestras de sangre a intervalos de 10 minutos de una hembra humana, 48 muestras.

que es un nombre bastante inesperado de una clave, pero bueno, funciona y produce la salida:

{" 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}

La respuesta se puede comparar con solo rellenar la tecla con letras "aleatorias" para que la salida tenga al menos 15 caracteres (24 bytes):

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

PowerShell 22 20 14 Bytes

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

Salida

{"":1099511627776}

Usando la constante definida para 1TB en bytes para alcanzar el límite de caracteres y el valor de un entero estático para hacer json válido. Gracias a TimmyD por reducir los caracteres en 5 al eliminar algo de redundancia.

Publicación anterior 40 bytes

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

Salida

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

Toma una matriz de enteros y crea un par clave-valor para cada uno. Únete con comas y envuélvete con un conjunto de llaves.

05AB1E , 9 bytes

Desafortunadamente, 05AB1E no tiene un objeto de diccionario, así que tenemos que construir el nuestro.

’{"èÖ":7}

Pruébalo en línea!

Salida

{"dictionaries":7}

Retina, 11 bytes

 
{"9$*R":1}

Salida

{"RRRRRRRRR":1}

Nota: la nueva línea principal es importante ya que nada se reemplaza con la salida resultante, ¡he usado un espacio continuo para ilustrar esto!

Pruébalo en línea!

V , 9 bytes

i{"¹*":0}

Pruébalo en línea!

Muy sencillo Entra en modo insertar, ingresa el siguiente texto:

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

La razón por la que esto es tan breve es porque ¹repite el siguiente carácter 9 veces.

JavaScript (ES6) + jQuery, 15 bytes

Porque jQuery.

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

Salidas {"function (a,b){return new n.fn.init(a,b)}":0}cuando se llama. Pruébalo aquí:

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

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

Dyalog APL , 9 bytes

⎕JSON⎕DMX

Pruébalo en línea!

En un espacio de trabajo limpio en mi PC, el resultado es

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

⎕JSON convertir a JSON

⎕DMX el (universalmente disponible) D iagnostic M ensaje E x tendía objeto

brainfuck, 83 bytes

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

Salidas {"333333333":3}

Es probable que haya otra solución más corta, pero aún no la he encontrado.

Explicación:

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

Pruébalo en línea

PHP, 19 bytes

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

Salida: {"387420489":1}

https://eval.in/665889

Gracias a manatwork por los consejos!

Java 7, 36 bytes

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

Java 8, 21 bytes

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

Ungolfed y código de prueba:

Pruébalo aquí.

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

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

Salida (longitud 15):

{"a":1000000.0}

R, 19 bytes

Esto funciona en inglés británico local; Puede requerir +2 bytes en otros. (Editar: probablemente no --- ver comentarios).

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

Esperaba algo inteligente (tal vez extraer una línea de código de una función preexistente como q), pero no pude encontrar nada. El resultado:

{" 3.141593 ":1}

Tenga en cuenta que no tiene que escapar de las comillas dobles en R si usa comillas simples para citar la cadena (y viceversa). Sin embargo, este comportamiento depende de la configuración regional. Sin embargo, también esperaría que funcione en un idioma inglés de EE. UU.

Esto también requiere que su digitsopción predeterminada sea ​​al menos seis (que es el valor predeterminado de fábrica) y que scipenes al menos -digits(el valor predeterminado de fábrica es cero).

Ruby, 19 bytes

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

Salida:

{"1":387420489}

Elemento , 18 bytes

\{\"a\"\:`9 9^`\}`

Pruébalo en línea! Salidas{"a":387420489}

Esto es solo tres bytes más corto que la solución ingenua. La primera mitad de la salida está codificada (demasiados caracteres de escape para que cualquier otro enfoque sea factible), mientras que el valor se calcula 9^9para hacer un número lo suficientemente largo.

Perl 5, 16 15 bytes

Utiliza la marca de tiempo de Unix del momento en que se inició el programa como contenido de un objeto de un elemento. Proporciona un resultado válido si lo ejecuta después de las 10:46:39 del 3 de marzo de 1973 . Pero como no podemos retroceder en el tiempo, eso parece legítimo.

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

Utiliza la variable FORMAT_TOP_HANDLE$^ que está predeterminada STDOUT_TOP.

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

Corre con -Ebandera sin costo adicional.

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

Las salidas tienen 16 bytes de longitud.

{"STDOUT_TOP":1}

Cheddar, 17 14 bytes

Guardado 3 bytes gracias a @ ConorO'Brien

->'{":1234}'*2

Una función anónima que devuelve {":1234}{":1234}, que es un objeto JSON válido:

{
  ":1234}{": 1234
}

Pruébalo en línea!

Lote de Windows, 10 bytes

{"%OS%":5}

La variable de entorno OScontiene la cadena Windows_NT(en todos los sistemas operativos Windows desde 2000, de acuerdo con esta pregunta sobre desbordamiento de pila)

HQ9 +, 15 bytes

{"Quineland":0}

Salidas en sí. Pensé que una respuesta de 8 bytes sería posible, así:

{":11QQ}

Esto genera {":11QQ}{":11QQ}, que es JSON casi válido, pero 11QQno es un valor válido.

HQ9 + no es un lenguaje de programación válido según los estándares PPCG, pero el OP ha permitido lenguajes que no son de programación.