Ce défi est simple, mais j'espère que vous pourrez l'aborder de nombreuses manières:

Vous devez imprimer / retourner un objet JSON valide d'au moins 15 caractères, sans compter les espaces non essentiels. Votre programme devrait fonctionner sans aucune contribution.

Dans un souci de clarté, un objet JSON commence et finit par des accolades {}et ne contient aucune paire clé: valeur séparée par des virgules. La spécification JSON complète peut être trouvée sur json.org , et la sortie de votre code doit réussir ce validateur .

Par conséquent, l'un des éléments suivants ne serait pas valide:

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

Toutefois, les éléments suivants seraient valables:

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

Les langages non programmés sont autorisés pour ce défi. Vous pouvez renvoyer une chaîne d'une fonction ou l'imprimer. Ceci est un code-golf , alors répondez-le avec le moins de code possible!

Python 2, 14 octets

print{`str`:1}

Les sorties:

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

Les backticks obtiennent la représentation de chaîne dans Python 2. En général, cette sortie crée des guillemets simples, ce que Python reconnaît comme délimitant une chaîne, mais pas JSON. Mais Sp3000 observe que lors de la chaîne d'un type, la description du type contient déjà des guillemets simples, ce qui oblige les guillemets extérieurs à être des guillemets doubles.

jq, 6 caractères

(Option de ligne de commande code 3 caractères + 3 caractères.)

env

CW car je suis sûr que ce n'est pas le genre de réponse que vous aviez l'intention de permettre.

Échantillon échantillon:

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

(Sortie évidemment raccourcie.)

Gelée , 11 octets

“Ɠɼ'ẸẠḌȷżÑ»

Essayez-le en ligne!

Sortie

{"Llanfairpwllgwyngyllgogerychwyrndrobwllllantysiliogogogoch":0}

Bloc-notes, 7 frappes

Si vous avez un ordinateur Windows avec le programme Notepad, tapez ceci:

{"F5":0}

Sur mon ordinateur Windows 7, au moins, cela vous donne quelque chose comme:

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

Java (JDK 10) , 20 octets

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

Essayez-le en ligne!

Sortie

{"":3.3333333333333335}

PHP, 14 à 13 octets

{"":<?=M_E?>}

Imprime un bel objet de mathsy dont on pourrait presque dire qu'il est utile :

{"":2.718281828459}

Utilise le fait que php imprime quoi que ce soit en dehors des balises proprement dit pour économiser sur certains guillemets, M_Eétait la constante la plus courte possible assez longue.

edit: enregistré un octet grâce à Lynn. Malheureusement, ce n'est plus un "bel" objet de mathsy.

JavaScript, 17 à 15 octets

Merci à @Neil pour celui-ci. Appel sans entrée.

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

Les sorties {"undefined":0}

Ancienne version, 16 octets

Merci à @ kamoroso94 pour -1 sur cette version

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

Les sorties {"":9000000000}

Brainfuck, 50 octets

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

Sorties {"999999999999999999999999999999999999999999999999999999999999999999999999999999999":9}. Supposons un interpréteur ayant des cellules de 8 bits et non délimité à gauche. Essayez-le en ligne!

Pyth - 5 octets

Impressions {"'abcdefghijklmnopqrstuvwxyz'": 10}.

XH`GT

Essayez-le en ligne ici .

Jolf, 9 octets

"{¦q:¦q}"

Sorties: {"{¦q:¦q}":"{¦q:¦q}"}. Essayez-le ici!

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

Pyth, 7 octets

.d],`G0

Crée un dictionnaire contenant une seule clé "'abcdefghijklmnopqrstuvwxyz'"et une seule valeur 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.

Lot, 16 octets

Impressions {"Windows_NT":0}.

@echo {"%OS%":0}

///, 15 14 caractères

/a/{":1234}/aa

(Au moins, la sortie contient 1 à 2 caractères de plus que le code.)

Essayez-le en ligne!

Grâce à:

• ETHproductions pour la réutilisation des délimiteurs d'objets dans la clé (-1 caractère)

Échantillon échantillon:

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

Juste pour le rendre plus lisible:

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

R, 19 octets

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

Devient un peu plus long car il faut échapper aux guillemets \". En outre, il lhs’agit de l’un des jeux de données intégrés de Rl’objet dont le nom le plus court contient, à ma connaissance, les 9 caractères nécessaires pour remplir la longueur de la clé. (edit: en fin de compte, piça fonctionne aussi avec l'option standard et j'ai été battu par @JDL qui était assez malin pour échapper en utilisant des guillemets simples plutôt que des barres obliques inverses supplémentaires)

La description de lhdans la documentation R est la suivante:

Série chronologique régulière donnant l'hormone lutéinisante dans des échantillons de sang prélevés toutes les 10 minutes chez une femme, 48 échantillons.

ce qui est un nom assez inattendu de clé, mais bon, ça marche et produit le résultat:

{" 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 réponse peut être comparée à la simple insertion de lettres "aléatoires" dans la touche pour obtenir au moins 15 caractères (24 octets):

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

PowerShell 22 20 14 octets

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

Sortie

{"":1099511627776}

Utilisez la constante définie pour 1 To en octets pour atteindre la limite de caractères et la valeur d'un entier statique pour obtenir un json valide. Merci à TimmyD d'avoir réduit le nombre de caractères de 5 en supprimant certaines redondances.

Message précédent 40 octets

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

Sortie

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

Prend un tableau d'entiers et crée une paire clé-valeur pour chacun. Rejoignez avec des virgules et enveloppez-les avec un ensemble d'accolades.

05AB1E , 9 octets

Malheureusement, 05AB1E n’ayant pas d’objet dictionnaire, nous devons donc construire le nôtre.

’{"èÖ":7}

Essayez-le en ligne!

Sortie

{"dictionaries":7}

Rétine, 11 octets

 
{"9$*R":1}

Sortie

{"RRRRRRRRR":1}

Remarque: la nouvelle ligne principale est importante car rien n’est remplacé par la sortie résultante, j’ai utilisé un espace insécable pour illustrer cela!

Essayez-le en ligne!

V , 9 octets

i{"¹*":0}

Essayez-le en ligne!

Très simple. Passe en mode insertion, entre le texte suivant:

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

Ceci est si court parce que ¹répète le caractère suivant 9 fois.

JavaScript (ES6) + jQuery, 15 octets

Parce que jQuery.

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

Sorties {"function (a,b){return new n.fn.init(a,b)}":0}à l'appel. Essayez-le ici:

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

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

Dyalog APL , 9 octets

⎕JSON⎕DMX

Essayez-le en ligne!

Dans un espace de travail propre sur mon PC, le résultat est

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

⎕JSON convertir en JSON

⎕DMX l' objet de traitement (disponible universellement) D iagnostic M x

brainfuck, 83 octets

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

Les sorties {"333333333":3}

Il existe probablement une autre solution plus courte, mais je ne l’ai pas encore trouvée.

Explication:

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

Essayez-le en ligne

PHP, 19 octets

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

Sortie: {"387420489":1}

https://eval.in/665889

Merci à manatwork pour les conseils!

Java 7, 36 octets

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

Java 8, 21 octets

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

Ungolfed & code de test:

Essayez ici.

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

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

Sortie (longueur 15):

{"a":1000000.0}

R, 19 octets

Cela fonctionne en anglais britannique local; cela peut nécessiter +2 octets chez les autres. (Edit: ce n'est probablement pas --- voir les commentaires.)

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

J'espérais quelque chose d'intelligent (peut-être extraire une ligne de code d'une fonction préexistante, par exemple q), mais je n'ai rien trouvé. Le résultat:

{" 3.141593 ":1}

Notez qu'il n'est pas nécessaire d'échapper aux guillemets doubles dans R si vous utilisez des guillemets simples pour citer la chaîne (et inversement). Ce comportement dépend cependant de la localisation. Je m'attendrais cependant à ce que cela fonctionne dans une langue anglaise anglaise.

Cela nécessite également que votre digitsoption par défaut soit au moins six (ce qui correspond à la valeur par défaut d'origine) et scipenau moins -digits(la valeur d'usine par défaut est zéro).

Ruby, 19 octets

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

Sortie:

{"1":387420489}

Elément , 18 octets

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

Essayez-le en ligne! Les sorties{"a":387420489}

Ce n'est que trois octets plus court que la solution naïve. La première moitié de la sortie est codée en dur (trop de caractères d'échappement pour rendre une autre approche possible), tandis que la valeur est calculée 9^9pour créer un nombre suffisamment long.

Perl 5, 16 15 octets

Utilise l'horodatage unix du moment où le programme a été lancé en tant que contenu d'un objet à un élément. Il donne une sortie valide si vous le lancez après le 3 mars 1973 à 10:46:39 . Mais puisque nous ne pouvons pas remonter dans le temps, cela semble légitime.

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

Utilise la variable FORMAT_TOP_HANDLE$^ dont la valeur par défaut est STDOUT_TOP.

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

Courez avec un -Edrapeau sans frais supplémentaires.

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

Les sorties ont une longueur de 16 octets.

{"STDOUT_TOP":1}

Cheddar, 17 à 14 octets

3 octets sauvés grâce à @ ConorO'Brien

->'{":1234}'*2

Une fonction anonyme qui retourne {":1234}{":1234}un objet JSON valide:

{
  ":1234}{": 1234
}

Essayez-le en ligne!

Lot Windows, 10 octets

{"%OS%":5}

La variable d'environnement OScontient la chaîne Windows_NT(sur tous les systèmes d'exploitation Windows depuis 2000, conformément à cette question sur le dépassement de capacité).

HQ9 +, 15 octets

{"Quineland":0}

Se produit lui-même. Je pensais qu'une réponse sur 8 octets serait possible, comme ceci:

{":11QQ}

Cette sortie {":11QQ}{":11QQ}, qui est un JSON presque valide, mais 11QQn'est pas une valeur valide.

HQ9 + n'est pas un langage de programmation valide selon les normes PPCG, mais l'OP a autorisé les langages autres que de programmation.