ความท้าทายนี้ตรงไปตรงมา แต่หวังว่าจะมีช่องทางมากมายที่คุณสามารถเข้าใกล้:

คุณต้องพิมพ์ / ส่งคืนวัตถุ JSON ที่ถูกต้องที่มีอักขระอย่างน้อย 15 ตัวโดยไม่นับช่องว่างที่ไม่จำเป็น โปรแกรมของคุณควรทำงานโดยไม่ต้องป้อนข้อมูลใด ๆ

ในความสนใจของความชัดเจนวัตถุ JSON จะเริ่มต้นและสิ้นสุดด้วยเครื่องหมายปีกกาแบบหยิก{}และมีคู่ของคีย์หรือศูนย์: ค่าที่คั่นด้วยเครื่องหมายจุลภาค ข้อมูลจำเพาะ JSON แบบเต็มสามารถพบได้ที่json.orgและผลลัพธ์ของรหัสของคุณจะต้องผ่านตัวตรวจสอบนี้

ดังนั้นสิ่งต่อไปนี้จะไม่ถูกต้อง:

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

อย่างไรก็ตามสิ่งต่อไปนี้จะถูกต้อง:

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

ภาษาที่ไม่ใช่การเขียนโปรแกรมได้รับอนุญาตในการท้าทายนี้ คุณอาจส่งคืนสตริงจากฟังก์ชันหรือพิมพ์ออกมา นี่คือรหัสกอล์ฟดังนั้นตอบด้วยรหัสน้อยที่สุด!

Python 2, 14 ไบต์

print{`str`:1}

ขาออก:

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

backticks รับการแทนค่าสตริงใน Python 2 โดยปกติเอาต์พุตนี้จะสร้างอัญประกาศเดี่ยวซึ่ง Python รับรู้เป็นการกำหนดสตริง แต่ JSON ไม่ได้ แต่ Sp3000 ตั้งข้อสังเกตว่าเมื่อสร้างสตริงประเภทคำอธิบายประเภทนั้นมีเครื่องหมายคำพูดเดี่ยวอยู่แล้วซึ่งบังคับให้เครื่องหมายคำพูดด้านนอกเป็นเครื่องหมายคำพูดคู่

jq, 6 ตัวอักษร

(ตัวเลือกบรรทัดคำสั่งรหัส 3 ตัวอักษร + 3 ตัวอักษร)

env

CW เพราะฉันแน่ใจว่านี่ไม่ใช่คำตอบที่คุณต้องการจะอนุญาต

วิ่งตัวอย่าง:

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

(เห็นได้ชัดว่าการส่งออกสั้นลง)

เยลลี่ 11 ไบต์

“Ɠɼ'ẸẠḌȷżÑ»

ลองออนไลน์!

เอาท์พุต

{"Llanfairpwllgwyngyllgogerychwyrndrobwllllantysiliogogogoch":0}

Notepad, 7 การกดแป้น

หากคุณมีคอมพิวเตอร์ Windows ที่มีโปรแกรม Notepad ให้พิมพ์สิ่งนี้:

{"F5":0}

อย่างน้อยในคอมพิวเตอร์ Windows 7 ของฉันสิ่งนี้ให้สิ่งที่คุณต้องการ:

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

Java (JDK 10) , 20 ไบต์

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

ลองออนไลน์!

เอาท์พุต

{"":3.3333333333333335}

PHP, 14 13 ไบต์

{"":<?=M_E?>}

พิมพ์วัตถุ mathsy ที่ดีที่ใคร ๆ ก็สามารถทำเป็นว่ามีประโยชน์ :

{"":2.718281828459}

ใช้ความจริงที่ว่า php พิมพ์อะไรก็ได้นอกแท็กคำต่อคำเพื่อบันทึกในเครื่องหมายคำพูดบางคำนั่นM_Eเป็นค่าคงที่ที่สั้นที่สุดที่ฉันสามารถหาได้

แก้ไข: บันทึกหนึ่งไบต์ต้องขอขอบคุณ Lynn น่าเศร้าที่มันไม่ใช่วัตถุทางคณิตศาสตร์ที่ 'ดี' อีกต่อไป

JavaScript, 17 15 ไบต์

ขอบคุณ @Neil สำหรับสิ่งนี้ โทรโดยไม่มีอินพุต

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

เอาท์พุท {"undefined":0}

รุ่นเก่า 16 ไบต์

ขอบคุณ @ kamoroso94 สำหรับ -1 ในรุ่นนี้

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

เอาท์พุท {"":9000000000}

Brainfuck, 50 ไบต์

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

{"999999999999999999999999999999999999999999999999999999999999999999999999999999999":9}เอาท์พุท ถือว่าล่ามที่มีเซลล์ 8 บิตและไม่ได้ จำกัด อยู่ทางด้านซ้าย ลองออนไลน์!

Pyth - 5 ไบต์

{"'abcdefghijklmnopqrstuvwxyz'": 10}พิมพ์

XH`GT

ลองมันออนไลน์ได้ที่นี่

Jolf, 9 ไบต์

"{¦q:¦q}"

เอาท์พุท: {"{¦q:¦q}":"{¦q:¦q}"}. ลองที่นี่!

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

Pyth, 7 ไบต์

.d],`G0

สร้างพจนานุกรมที่มีคีย์"'abcdefghijklmnopqrstuvwxyz'"และค่าเดียว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.

รุ่นที่ 16 ไบต์

{"Windows_NT":0}พิมพ์

@echo {"%OS%":0}

///, 15 14 ตัวอักษร

/a/{":1234}/aa

(อย่างน้อยผลลัพธ์คือ1 2 ตัวอักษรยาวเกินรหัส)

ลองออนไลน์!

ขอบคุณที่:

• ETHProductionsสำหรับการนำตัวคั่นวัตถุมาใช้ใหม่เป็นส่วนหนึ่งของคีย์ (อักขระ -1 ตัว)

วิ่งตัวอย่าง:

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

เพียงเพื่อให้อ่านง่ายขึ้น:

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

R, 19 ไบต์

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

\"กลายเป็นอีกนิดเพราะความจำเป็นที่จะหลบหนีคำพูด นอกจากนี้ยังlhเป็นหนึ่งในชุดข้อมูลในตัวRและเป็น (กับความรู้ของฉัน) วัตถุที่มีชื่อสั้นที่สุดที่มี 9 ตัวอักษรที่จำเป็นในการเติมความยาวของคีย์ (แก้ไข: เปิดออกpiเป็นเคล็ดลับเช่นเดียวกับตัวเลือกมาตรฐานและฉันถูก @JDL ซึ่งฉลาดพอที่จะหลบหนีโดยใช้เครื่องหมายคำพูดเดียวแทนที่จะเป็นเครื่องหมายแบ็กสแลชเสริม)

คำอธิบายของlhในเอกสาร R- คือ:

อนุกรมเวลาปกติให้ฮอร์โมน luteinizing ในตัวอย่างเลือดในช่วงเวลา 10 นาทีจากหญิงมนุษย์ 48 ตัวอย่าง

ซึ่งเป็นชื่อที่ค่อนข้างคาดไม่ถึงของคีย์ แต่เดี๋ยวก่อนมันทำงานและผลิตผลลัพธ์:

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

คำตอบสามารถเปรียบเทียบกับการเติมคีย์ด้วยตัวอักษร "สุ่ม" เพื่อให้เอาต์พุตอย่างน้อย 15 อักขระ (24 ไบต์):

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

PowerShell 22 20 14 ไบต์

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

เอาท์พุต

{"":1099511627776}

การใช้ค่าคงที่ที่กำหนดไว้สำหรับ 1TB ในไบต์เพื่อให้ถึงขีด จำกัด ของอักขระและค่าของจำนวนเต็มคงที่เพื่อสร้างสำหรับ json ที่ถูกต้อง ขอบคุณ TimmyD สำหรับการลดตัวอักษร 5 โดยการลบความซ้ำซ้อน

โพสต์ก่อนหน้านี้ 40 ไบต์

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

เอาท์พุต

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

รับอาร์เรย์จำนวนเต็มและสร้างคู่คีย์ - ค่าสำหรับแต่ละรายการ เข้าร่วมกับจุลภาคและห่อด้วยชุดเครื่องมือจัดฟันแบบหยิก

05AB1E , 9 ไบต์

น่าเสียดายที่ 05AB1E ไม่มีวัตถุพจนานุกรมดังนั้นเราต้องสร้างของเราเอง

’{"èÖ":7}

ลองออนไลน์!

เอาท์พุต

{"dictionaries":7}

เรติน่า 11 ไบต์

 
{"9$*R":1}

เอาท์พุต

{"RRRRRRRRR":1}

หมายเหตุ: newline ชั้นนำมีความสำคัญเนื่องจากไม่มีสิ่งใดถูกแทนที่ด้วยผลลัพธ์ผลลัพธ์ฉันใช้พื้นที่ที่ไม่ทำลายเพื่ออธิบายสิ่งนี้!

ลองออนไลน์!

V , 9 ไบต์

i{"¹*":0}

ลองออนไลน์!

ตรงไปตรงมามาก เข้าสู่โหมดแทรกแล้วป้อนข้อความต่อไปนี้:

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

เหตุผลนี้สั้นมากเพราะ¹ทำซ้ำอักขระต่อไปนี้ 9 ครั้ง

JavaScript (ES6) + jQuery, 15 ไบต์

เพราะ jQuery

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

เอาต์พุต{"function (a,b){return new n.fn.init(a,b)}":0}เมื่อถูกเรียก ลองที่นี่:

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

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

Dyalog APL ขนาด 9 ไบต์

⎕JSON⎕DMX

ลองออนไลน์!

ในพื้นที่ทำงานที่สะอาดบนพีซีของฉันผลลัพธ์คือ

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

⎕JSON แปลงเป็น JSON

⎕DMX (ใช้ได้ในระดับสากล) D iagnostic M essage E x tended object

brainfuck, 83 ไบต์

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

เอาท์พุท {"333333333":3}

อาจเป็นอีกวิธีที่สั้นกว่า แต่ฉันยังไม่พบ

คำอธิบาย:

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

ลองออนไลน์

PHP, 19 ไบต์

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

เอาท์พุท: {"387420489":1}

https://eval.in/665889

ขอบคุณmanatworkสำหรับคำแนะนำ!

Java 7, 36 ไบต์

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

Java 8, 21 ไบต์

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

Ungolfed & รหัสการทดสอบ:

ลองที่นี่

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

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

เอาท์พุท (ความยาว 15):

{"a":1000000.0}

R, 19 ไบต์

ใช้งานได้ในภาษาอังกฤษแบบอังกฤษ มันอาจต้อง +2 ไบต์ในคนอื่น ๆ (แก้ไข: อาจไม่เห็นความคิดเห็น)

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

ฉันหวังว่าจะมีบางสิ่งที่ฉลาด (อาจจะดึงรหัสออกมาจากฟังก์ชั่นที่มีอยู่แล้วq) แต่หาอะไรไม่เจอ ผลลัพธ์:

{" 3.141593 ":1}

โปรดทราบว่าคุณไม่จำเป็นต้องหลีกเลี่ยงอัญประกาศคู่ใน R หากคุณใช้เครื่องหมายคำพูดเดี่ยวเพื่ออ้างอิงสตริง (และในทางกลับกัน) พฤติกรรมนี้ขึ้นอยู่กับสถานที่ ฉันคาดหวังว่ามันจะทำงานในสถานที่ภาษาอังกฤษแบบสหรัฐอเมริกาเช่นกัน

สิ่งนี้ต้องการdigitsตัวเลือกเริ่มต้นของคุณอย่างน้อยหกตัว (ซึ่งเป็นค่าเริ่มต้นจากโรงงาน) และscipenเป็นอย่างน้อย-digits(ค่าเริ่มต้นจากโรงงานคือศูนย์)

ทับทิมขนาด 19 ไบต์

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

เอาท์พุท:

{"1":387420489}

องค์ประกอบ , 18 ไบต์

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

ลองออนไลน์! เอาท์พุท{"a":387420489}

นี่เป็นเพียงสามไบต์ที่สั้นกว่าโซลูชันไร้เดียงสา ครึ่งแรกของการส่งออกเป็นรหัสยาก (ตัวละครการหลบหนีมากเกินไปที่จะทำให้วิธีการใด ๆ ที่เป็นไปได้) ในขณะที่ค่าที่คำนวณได้9^9จะทำให้จำนวนยาวพอ

Perl 5, 16 15 ไบต์

ใช้การประทับเวลา unix ของช่วงเวลาที่โปรแกรมเริ่มต้นเป็นเนื้อหาของวัตถุองค์ประกอบเดียว มันจะช่วยให้การส่งออกที่ถูกต้องถ้าคุณใช้มันช้ากว่า 10:46:39 ใน 3 มีนาคม 1973 แต่เนื่องจากเราไม่สามารถย้อนเวลากลับไปในลักษณะที่ถูกต้องได้

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

ใช้ตัวแปร FORMAT_TOP_HANDLE$^STDOUT_TOPที่เริ่มต้นที่

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

ทำงานด้วย -Eตั้งค่าสถานะโดยไม่มีค่าใช้จ่ายเพิ่มเติม

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

เอาต์พุตมีความยาว 16 ไบต์

{"STDOUT_TOP":1}

Cheddar, 17 14 ไบต์

บันทึกแล้ว 3 ไบต์ขอบคุณ @ ConorO'Brien

->'{":1234}'*2

ฟังก์ชั่นไม่ระบุชื่อที่ส่งคืน{":1234}{":1234}ซึ่งเป็นวัตถุ JSON ที่ถูกต้อง:

{
  ":1234}{": 1234
}

ลองออนไลน์!

แบตช์ Windows 10 ไบต์

{"%OS%":5}

ตัวแปรสภาพแวดล้อมOSมีสตริงWindows_NT(ในทุกระบบปฏิบัติการ Windows ตั้งแต่ปี 2000 ตามคำถามนี้ใน Stack Overflow)

HQ9 +, 15 ไบต์

{"Quineland":0}

เอาท์พุตเอง ฉันคิดว่าคำตอบ 8 ไบต์จะเป็นไปได้เช่น:

{":11QQ}

ผลลัพธ์นี้{":11QQ}{":11QQ}ซึ่งเกือบจะ JSON ที่ถูกต้อง แต่11QQไม่ใช่ค่าที่ถูกต้อง

HQ9 + ไม่ใช่ภาษาโปรแกรมที่ถูกต้องตามมาตรฐาน PPCG แต่ OP อนุญาตภาษาที่ไม่ใช่ภาษาโปรแกรม