Esse desafio é direto, mas, esperançosamente, existem muitos caminhos que você pode abordar:

Você precisa imprimir / retornar um objeto JSON válido com pelo menos 15 caracteres, sem contar o espaço em branco não essencial. Seu programa deve funcionar sem nenhuma entrada.

Por questões de clareza, um objeto JSON começa e termina com chaves {}e contém zero ou mais pares chave: valor separados por vírgulas. A especificação JSON completa pode ser encontrada em json.org , e a saída do seu código deve passar neste validador .

Portanto, qualquer um dos seguintes itens não seria 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

No entanto, o seguinte seria válido:

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

Linguagens que não são de programação são permitidas neste desafio. Você pode retornar uma string de uma função ou imprimi-la. Este é um código-golfe , então responda-o com o mínimo de código possível!

Python 2, 14 bytes

print{`str`:1}

Saídas:

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

Os backticks obtêm a representação de string no Python 2. Geralmente, essa saída cria aspas simples, que o Python reconhece como delimitando uma string, mas o JSON não. Mas o Sp3000 observa que, ao especificar um tipo, a descrição do tipo já contém aspas simples, o que força as aspas externas a serem aspas duplas.

jq, 6 caracteres

(Código de 3 caracteres + opção de linha de comando de 3 caracteres.)

env

CW, porque tenho certeza de que esse não é o tipo de resposta que você pretendia permitir.

Exemplo de execução:

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

(Saída obviamente reduzida.)

Gelatina , 11 bytes

“Ɠɼ'ẸẠḌȷżÑ»

Experimente online!

Resultado

{"Llanfairpwllgwyngyllgogerychwyrndrobwllllantysiliogogogoch":0}

Bloco de notas, 7 pressionamentos de teclas

Se você possui um computador Windows com o programa Bloco de Notas, digite:

{"F5":0}

No meu computador com Windows 7, pelo menos, isso oferece algo como:

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

Java (JDK 10) , 20 bytes

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

Experimente online!

Resultado

{"":3.3333333333333335}

PHP, 14 13 bytes

{"":<?=M_E?>}

Imprime um bom objeto matemático que quase se pode fingir que é útil :

{"":2.718281828459}

Usa o fato de que o php imprime qualquer coisa fora das tags literalmente para economizar em algumas aspas, M_Efoi a constante mais curta e longa que eu pude encontrar.

editar: salvou um byte graças a Lynn. Infelizmente, não é mais um objeto matemático "agradável".

JavaScript, 17 15 bytes

Obrigado a @Neil por este. Ligue sem entrada.

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

Saídas {"undefined":0}

Versão antiga, 16 bytes

Obrigado a @ kamoroso94 por -1 nesta versão

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

Saídas {"":9000000000}

Brainfuck, 50 bytes

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

Saídas {"999999999999999999999999999999999999999999999999999999999999999999999999999999999":9}. Pressupõe um intérprete com células de 8 bits e sem limite à esquerda. Experimente online!

Pitão - 5 bytes

Imprime {"'abcdefghijklmnopqrstuvwxyz'": 10}.

XH`GT

Experimente online aqui .

Jolf, 9 bytes

"{¦q:¦q}"

Saídas: {"{¦q:¦q}":"{¦q:¦q}"}. Experimente aqui!

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

Pitão, 7 bytes

.d],`G0

Cria um dicionário que contém uma única chave "'abcdefghijklmnopqrstuvwxyz'"e 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

Imprime {"Windows_NT":0}.

@echo {"%OS%":0}

///, 15 14 caracteres

/a/{":1234}/aa

(Pelo menos a saída tem 1 2 caracteres a mais que o código.)

Experimente online!

Graças a:

• Produções ETH para reutilizar os delimitadores de objeto como parte da chave (caractere -1)

Exemplo de execução:

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

Apenas para torná-lo mais legível:

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

R, 19 bytes

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

Torna-se um pouco mais por causa da necessidade de escapar de aspas \". Além disso, lhé um dos conjuntos de dados internos Re é (que eu saiba) o objeto com o nome mais curto que contém os 9 caracteres necessários para preencher o comprimento da chave. (edit: acontece pique também funciona com a opção padrão e fui derrotado por @JDL, que foi inteligente o suficiente para escapar usando aspas simples, em vez de barras invertidas extras)

A descrição lhna documentação R é:

Uma série temporal regular que fornece o hormônio luteinizante em amostras de sangue em intervalos de 10 minutos de uma fêmea humana, 48 amostras.

que é um nome bastante inesperado de uma chave, mas ei, ele funciona e produz a saída:

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

A resposta pode ser comparada a apenas o preenchimento da tecla com letras "aleatórias" para gerar pelo menos 15 caracteres (24 bytes):

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

PowerShell 22 20 14 bytes

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

Resultado

{"":1099511627776}

Usando a constante definida para 1 TB em bytes para atingir o limite de caracteres e o valor de um número inteiro estático para gerar json válido. Agradecemos a TimmyD por reduzir os caracteres em 5 removendo alguma redundância.

Post anterior 40 bytes

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

Resultado

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

Toma uma matriz inteira e cria um par de valores-chave para cada um. Junte-se com vírgulas e envolva-o com um conjunto de chaves.

05AB1E , 9 bytes

Infelizmente, 05AB1E não possui um objeto de dicionário, portanto, precisamos construir nosso próprio.

’{"èÖ":7}

Experimente online!

Resultado

{"dictionaries":7}

Retina, 11 bytes

 
{"9$*R":1}

Resultado

{"RRRRRRRRR":1}

Nota: a nova linha principal é significativa, pois nada é substituído pela saída resultante; usei um espaço sem interrupções para ilustrar isso!

Experimente online!

V , 9 bytes

i{"¹*":0}

Experimente online!

Muito simples. Entra no modo de inserção e insere o seguinte texto:

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

A razão de ser tão curto é porque ¹repete o seguinte caractere 9 vezes.

JavaScript (ES6) + jQuery, 15 bytes

Porque jQuery.

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

Saídas {"function (a,b){return new n.fn.init(a,b)}":0}quando chamadas. Experimente aqui:

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

Experimente online!

Em um espaço de trabalho limpo no meu PC, o resultado é

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

⎕JSON converter para JSON

⎕DMX o (universalmente disponível) D iagnostic M ENSAGEM E x tendiam objecto

brainfuck, 83 bytes

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

Saídas {"333333333":3}

Provavelmente existe outra solução mais curta, mas ainda não a encontrei.

Explicação:

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

Experimente online

PHP, 19 bytes

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

Resultado: {"387420489":1}

https://eval.in/665889

Obrigado ao manatwork pelas dicas!

Java 7, 36 bytes

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

Java 8, 21 bytes

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

Ungolfed & código de teste:

Experimente aqui.

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

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

Saída (comprimento 15):

{"a":1000000.0}

R, 19 bytes

Isso funciona no código do idioma inglês britânico; pode exigir +2 bytes em outros. (Editar: provavelmente não --- ver comentários.)

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

Eu esperava algo inteligente (talvez arrancando uma linha de código de uma função pré-existente como q), mas não consegui encontrar nada. O resultado:

{" 3.141593 ":1}

Observe que você não precisa escapar aspas duplas em R se usar aspas simples para citar a sequência (e vice-versa). Esse comportamento depende da localidade. Eu esperaria que ele funcionasse em uma localidade em inglês dos EUA também.

Isso também requer que sua digitsopção padrão seja pelo menos seis (que é o padrão original de fábrica) e que scipenseja pelo menos -digits(o padrão original de fábrica é zero).

Ruby, 19 bytes

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

Resultado:

{"1":387420489}

Elemento , 18 bytes

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

Experimente online! Saídas{"a":387420489}

Isso é apenas três bytes menor que a solução ingênua. A primeira metade da saída é codificada (muitos caracteres de escape para viabilizar qualquer outra abordagem), enquanto o valor é calculado 9^9para tornar um número longo o suficiente.

Perl 5, 16 15 bytes

Usa o timestamp unix do momento em que o programa foi iniciado como o conteúdo de um objeto de um elemento. Ele fornece saída válida se você executá-lo depois das 10:46:39 em 3 de março de 1973 . Mas como não podemos voltar no tempo, isso parece legítimo.

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

Usa a variável FORMAT_TOP_HANDLE$^ cujo padrão é STDOUT_TOP.

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

Corra com a -Ebandeira sem nenhum custo adicional.

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

As saídas têm 16 bytes.

{"STDOUT_TOP":1}

Queijo Cheddar, 17 14 bytes

Guardado 3 bytes graças a @ ConorO'Brien

->'{":1234}'*2

Uma função anônima que retorna {":1234}{":1234}, que é um objeto JSON válido:

{
  ":1234}{": 1234
}

Experimente online!

Lote do Windows, 10 bytes

{"%OS%":5}

A variável de ambiente OScontém a sequência Windows_NT(em todos os sistemas operacionais Windows desde 2000, de acordo com esta pergunta no Stack Overflow)

HQ9 +, 15 bytes

{"Quineland":0}

Saída em si. Eu pensei que uma resposta de 8 bytes seria possível, assim:

{":11QQ}

Isso gera {":11QQ}{":11QQ}, que é quase válido JSON, mas 11QQnão é um valor válido.

O HQ9 + não é uma linguagem de programação válida para os padrões PPCG, mas o OP permitiu linguagens que não são de programação.