Questa sfida è semplice, ma speriamo che ci siano molte strade che puoi affrontare:

È necessario stampare / restituire un oggetto JSON valido di almeno 15 caratteri, senza contare gli spazi bianchi non essenziali. Il tuo programma dovrebbe funzionare senza alcun input.

Per motivi di chiarezza, un oggetto JSON inizia e termina con parentesi graffe {}e contiene zero o più chiavi: coppie di valori separate da virgole. La specifica JSON completa è disponibile su json.org e l'output del codice deve superare questo validatore .

Pertanto, nessuna delle seguenti condizioni non sarebbe valida:

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

Tuttavia, sarebbe valido quanto segue :

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

Linguaggi non di programmazione sono ammessi su questa sfida. È possibile restituire una stringa da una funzione o stamparla. Questo è un codice-golf , quindi rispondi con il minor codice possibile!

Python 2, 14 byte

print{`str`:1}

Uscite:

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

I backtick ottengono la rappresentazione della stringa in Python 2. Di solito, questo output all'interno crea virgolette singole, che Python riconosce come delimitazione di una stringa, ma JSON no. Ma Sp3000 osserva che quando si restringe un tipo, la descrizione del tipo contiene già virgolette singole, il che impone alle virgolette esterne di essere virgolette doppie.

jq, 6 caratteri

(Codice di 3 caratteri + opzione della riga di comando di 3 caratteri.)

env

CW perché sono sicuro che questo non è il tipo di risposta che intendevi consentire.

Esecuzione di esempio:

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

(Uscita ovviamente abbreviata.)

Gelatina , 11 byte

“Ɠɼ'ẸẠḌȷżÑ»

Provalo online!

Produzione

{"Llanfairpwllgwyngyllgogerychwyrndrobwllllantysiliogogogoch":0}

Blocco note, 7 battute

Se hai un computer Windows con il programma Blocco note, digita questo:

{"F5":0}

Sul mio computer Windows 7, almeno, questo ti dà qualcosa di simile:

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

Java (JDK 10) , 20 byte

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

Provalo online!

Produzione

{"":3.3333333333333335}

PHP, 14 13 byte

{"":<?=M_E?>}

Stampa un simpatico oggetto matematico che si potrebbe quasi fingere sia utile :

{"":2.718281828459}

Usa il fatto che php stampa qualcosa al di fuori dei tag alla lettera per salvare alcune virgolette, è M_Estata la costante più breve che potessi trovare.

modifica: salvato un byte grazie a Lynn. Purtroppo non è più un "simpatico" oggetto matematico.

JavaScript, 17 15 byte

Grazie a @Neil per questo. Chiama senza input.

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

Uscite {"undefined":0}

Vecchia versione, 16 byte

Grazie a @ kamoroso94 per -1 in questa versione

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

Uscite {"":9000000000}

Brainfuck, 50 byte

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

Uscite {"999999999999999999999999999999999999999999999999999999999999999999999999999999999":9}. Presuppone un interprete che ha celle a 8 bit e non ha limiti a sinistra. Provalo online!

Pyth - 5 byte

Stampe {"'abcdefghijklmnopqrstuvwxyz'": 10}.

XH`GT

Provalo online qui .

Jolf, 9 byte

"{¦q:¦q}"

Uscite: {"{¦q:¦q}":"{¦q:¦q}"}. Provalo qui!

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

Pyth, 7 byte

.d],`G0

Crea un dizionario contenente una sola chiave "'abcdefghijklmnopqrstuvwxyz'"e valore 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.

Lotto, 16 byte

Stampe {"Windows_NT":0}.

@echo {"%OS%":0}

///, 15 14 caratteri

/a/{":1234}/aa

(Almeno l'output è 1 2 caratteri più lungo del codice.)

Provalo online!

Grazie a:

• ETHproductions per riutilizzare i delimitatori di oggetti come parte della chiave (-1 carattere)

Esecuzione di esempio:

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

Solo per renderlo più leggibile:

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

R, 19 byte

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

Diventa un po 'più lungo perché è necessario sfuggire alle virgolette \". Inoltre, lhè uno dei set di dati integrati Red è (per quanto ne sappia) l'oggetto con il nome più breve che contiene i 9 caratteri necessari per riempire la lunghezza della chiave. (modifica: si scopre che pifa anche il trucco con l'opzione standard e sono stato battuto da @JDL che è stato abbastanza intelligente da scappare usando virgolette singole anziché le barre rovesciate extra)

La descrizione lhnella documentazione R è:

Una serie storica che fornisce l'ormone luteinizzante in campioni di sangue a intervalli di 10 minuti da una femmina umana, 48 campioni.

che è un nome piuttosto inaspettato di una chiave, ma ehi, funziona e produce l'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}

La risposta può essere paragonata al solo riempimento della chiave con lettere "casuali" per rendere l'output di almeno 15 caratteri (24 byte):

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

PowerShell 22 20 14 byte

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

Produzione

{"":1099511627776}

Utilizzo della costante definita per 1 TB in byte per raggiungere il limite di caratteri e il valore di un numero intero statico per creare json valido. Grazie a TimmyD per aver ridotto i personaggi di 5 rimuovendo la ridondanza.

Posta precedente 40 byte

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

Produzione

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

Accetta un array intero e crea una coppia chiave-valore per ciascuno. Unisciti alle virgole e avvolgi con una serie di parentesi graffe.

05AB1E , 9 byte

Sfortunatamente, 05AB1E non ha un oggetto dizionario, quindi dobbiamo costruirne uno nostro.

’{"èÖ":7}

Provalo online!

Produzione

{"dictionaries":7}

Retina, 11 byte

 
{"9$*R":1}

Produzione

{"RRRRRRRRR":1}

Nota: la nuova riga principale è significativa in quanto nulla viene sostituito con l'output risultante, ho usato uno spazio non-break per illustrare questo!

Provalo online!

V , 9 byte

i{"¹*":0}

Provalo online!

Molto semplice. Entra in modalità inserimento, inserisce il seguente testo:

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

Il motivo per cui è così breve è perché ¹ripete il seguente carattere 9 volte.

JavaScript (ES6) + jQuery, 15 byte

Perché jQuery.

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

Emette {"function (a,b){return new n.fn.init(a,b)}":0}quando chiamato. Provalo qui:

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

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

Dyalog APL , 9 byte

⎕JSON⎕DMX

Provalo online!

Il risultato è in un'area di lavoro pulita sul mio PC

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

⎕JSON convertire in JSON

⎕DMX il (universalmente disponibili) D iagnostic M essage E X tendeva oggetto

Brainfuck, 83 byte

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

Uscite {"333333333":3}

C'è probabilmente un'altra soluzione più breve, ma non l'ho ancora trovata.

Spiegazione:

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

Provalo online

PHP, 19 byte

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

Produzione: {"387420489":1}

https://eval.in/665889

Grazie a manatwork per i suggerimenti!

Java 7, 36 byte

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

Java 8, 21 byte

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

Codice non testato e test:

Provalo qui.

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

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

Uscita (lunghezza 15):

{"a":1000000.0}

R, 19 byte

Funziona in inglese britannico locale; potrebbe richiedere +2 byte negli altri. (Modifica: probabilmente non --- vede i commenti.)

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

Speravo in qualcosa di intelligente (forse strappando una riga di codice da una funzione preesistente come q) ma non sono riuscito a trovare nulla. Il risultato:

{" 3.141593 ":1}

Nota che non devi sfuggire alle doppie virgolette in R se usi virgolette singole per citare la stringa (e viceversa). Questo comportamento dipende dalle impostazioni locali. Mi sarei aspettato che funzionasse anche in un locale inglese americano.

Ciò richiede anche che l' digitsopzione predefinita sia almeno sei (che è l'impostazione predefinita di fabbrica) e che scipensia almeno -digits(l'impostazione predefinita di fabbrica è zero).

Rubino, 19 byte

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

Produzione:

{"1":387420489}

Elemento , 18 byte

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

Provalo online! Uscite{"a":387420489}

Questo è solo tre byte più corto della soluzione ingenua. La prima metà dell'output è codificata (troppi caratteri di escape per rendere possibile qualsiasi altro approccio), mentre il valore viene calcolato in modo 9^9da rendere un numero abbastanza lungo.

Perl 5, 16 15 byte

Utilizza il timestamp unix del momento in cui il programma è stato avviato come contenuto di un oggetto a un elemento. Fornisce un output valido se lo esegui dopo le 10:46:39 il 3 marzo 1973 . Ma dal momento che non possiamo tornare indietro nel tempo questo sembra legittimo.

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

Utilizza la variabile FORMAT_TOP_HANDLE$^ che è impostata automaticamenteSTDOUT_TOP .

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

Esegui con -Ebandiera senza costi aggiuntivi.

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

Le uscite sono lunghe 16 byte.

{"STDOUT_TOP":1}

Cheddar, 17 14 byte

Salvato 3 byte grazie a @ ConorO'Brien

->'{":1234}'*2

Una funzione anonima che restituisce {":1234}{":1234}, che è un oggetto JSON valido:

{
  ":1234}{": 1234
}

Provalo online!

Lotto di Windows, 10 byte

{"%OS%":5}

La variabile d'ambiente OScontiene la stringa Windows_NT(su tutti i sistemi operativi Windows dal 2000, secondo questa domanda su StackTranslate.it)

HQ9 +, 15 byte

{"Quineland":0}

Produce se stesso. Ho pensato che sarebbe stata possibile una risposta di 8 byte, in questo modo:

{":11QQ}

Ciò genera {":11QQ}{":11QQ}, che è quasi valido JSON, ma 11QQnon è un valore valido.

HQ9 + non è un linguaggio di programmazione valido secondo gli standard PPCG, ma l'OP ha consentito linguaggi non di programmazione.