अपनी खुद की-भाषा कोड चुनें

आइए 16x16 प्रिंट करने योग्य ASCII वर्णों का एक ग्रिड लें (कोड अंक 0x20 से 0x7E)। निम्न दाएं कोने से ऊपर-नीचे दाएं कोने से 30-चुन -15 पथ हैं, जो निम्न उदाहरण की तरह केवल ऑर्थोगोनल चालें बनाते हैं:

##..............
.#..............
.######.........
......##........
.......##.......
........#.......
........#.......
........#.......
........###.....
..........###...
............#...
............####
...............#
...............#
...............#

इस तरह के प्रत्येक पथ में 31 अक्षर होते हैं। ध्यान दें कि उन पात्रों में से प्रत्येक 31 विरोधी विकर्णों में से एक पर है:

0123456789ABCDEF
123456789ABCDEFG
23456789ABCDEFGH
3456789ABCDEFGHI
456789ABCDEFGHIJ
56789ABCDEFGHIJK
6789ABCDEFGHIJKL
789ABCDEFGHIJKLM
89ABCDEFGHIJKLMN
9ABCDEFGHIJKLMNO
ABCDEFGHIJKLMNOP
BCDEFGHIJKLMNOPQ
CDEFGHIJKLMNOPQR
DEFGHIJKLMNOPQRS
EFGHIJKLMNOPQRST
FGHIJKLMNOPQRSTU

^{यह एक उदाहरण ग्रिड नहीं है। यह 31 विरोधी विकर्णों का एक दृश्य है।}

यदि कोई एंटी-विकर्ण दो बार एक ही वर्ण को शामिल करता है, तो हम एक ग्रिड को विकट रूप से अद्वितीय कहेंगे । यदि ग्रिड में यह संपत्ति है, तो किसी भी दो रास्तों में समान स्ट्रिंग नहीं होगी। (स्पष्ट करने के लिए, दृश्य ही मूल रूप से तिरछे अद्वितीय के विपरीत है।)

चुनौती

एक तिरछे अद्वितीय 16x16 ग्रिड को डिज़ाइन करें, जैसे कि संभव के रूप में कई रास्ते वैध कोड हैं जो Jabberwockyसंभव के रूप में कई भाषाओं में STDOUT (वैकल्पिक अनुगामी लाइन ब्रेक के साथ) को प्रिंट करते हैं। प्रत्येक कोड या तो एक पूर्ण कार्यक्रम हो सकता है, या रिटर्न स्टेटमेंट के बिना एक पैरामीटर रहित फ़ंक्शन का शरीर हो सकता है (यह उन भाषाओं को हतोत्साहित करने के लिए नहीं है जिन्हें कुछ बॉयलरप्लेट फ़ंक्शन / क्लास / नेमस्पेस में अपने कोड की आवश्यकता है)।

नोट: सादगी के लिए आप अप्रयुक्त कोशिकाओं के लिए कुछ आरक्षित चरित्र का उपयोग कर सकते हैं जैसे कि Ypnypn ने किया।

प्रत्येक मान्य पथ के लिए, कृपया स्पष्ट रूप से एक प्रोग्रामिंग भाषा बताएं जो इसमें मान्य है।

विजेता उपरोक्त सूची द्वारा कवर की जाने वाली भाषाओं की सबसे बड़ी संख्या है। (वैकल्पिक रूप से, प्रत्येक भाषा के लिए जिसे आप गिनना चाहते हैं, एक रास्ता दिखाएं जो उस भाषा में मान्य है, लेकिन सुनिश्चित करें कि दो भाषाओं के लिए किसी भी पथ की गणना न करें।)

एक टाई की स्थिति में, ग्रिड कोशिकाओं की गणना करें जो किसी भी मान्य पथ द्वारा कवर नहीं की जाती हैं । कम अप्रयुक्त कोशिकाएं जीतती हैं। यदि अभी भी एक टाई है, तो मैं सबसे (शुद्ध) वोटों के साथ उत्तर स्वीकार करूंगा।

मान्यता लिपि

मैं बस जल्दी से एक साथ थोड़ा CJam स्निपेट डाल सकता हूं जिसे आप यह प्रमाणित करने के लिए उपयोग कर सकते हैं कि एक ग्रिड तिरछे अद्वितीय है।

पर जाएं ऑनलाइन CJam दुभाषिया ।
निम्नलिखित कोड पेस्ट करें
```
l:A;
qN/W%A16**33/z{A-__|=}%:*"D""Not d"?"iagonally unique"
```
इनपुट फ़ील्ड में, आपको पहली पंक्ति पर आरक्षित वर्ण डालें (यदि आप किसी आरक्षित वर्ण का मुकदमा नहीं करते हैं, तो अप्रयुक्त वर्ण का उपयोग करें), और फिर लाइन 2 से 17 में आपका ग्रिड। उदाहरण के लिए, Ypnypn के उत्तर के लिए:
```
~
 pr~~~~~~~~~~~~~
 tin~~~~~~~~~~~~
~ypt(~~~~~~~~~~~
~~ef(~~~~~~~~~~~
~~  "J~~~~~~~~~~
~~~~~ab~~~~~~~~~
~~~~~~be~~~~~~~~
~~~~~~~rwo~~~~~~
~~~~~~~~~ck~~~~~
~~~~~~~~~~y~~~~~
~~~~~~~~~~\n~~~~
~~~~~~~~~~~")) ~
~~~~~~~~~~~  ;  
~~~~~~~~~~~~~~~ 
~~~~~~~~~~~~~~~ 
~~~~~~~~~~~~~~~ 
```
Daud।

मुझे पता है अगर आपको लगता है कि यह एक बग है।

— मार्टिन एंडर
स्रोत

'Twas brillig, और slithey toves Wabe में चक्र और gimble किया था ... (हाँ, मुझे लगता है कि याद है);)

— दरवाज़े

यह केल्विन के शौक के सवालों में से एक की तरह लगता है, जो एक शानदार उपलब्धि है। मुझे अभी तक समझ नहीं आया है कि यह कैसे किया जाता है।

— सोहम चौधरी

जवाबों:

३० ३३ ३५ भाषाएँ

आरक्षित वर्ण: ~

 println!~~~~~~~
 puts    (1,~~~~
    echo   '~~~~
"cWprintfn"Ja~~~
Eork~~~;'Jabbe~~
\ui)K00~~~~~br~~
]tteL~0~~~~~ew~~
]<~ln(0~~~~~ro~~
`<~~~ 0~~~~~wc~~
m"~~~ "~~~~~ok~~
rJ~~~'J~~~~~cy~~
j"<< "a~~~~~k'..
^~~~~~bberwoy");
f~~~~~~~~~~c'  ;
t~~~~~~~~~~ky"  
XX"););  5f+');

भाषाएँ:

01. Rust        | println! (  "Jabberwocky") ;  |
02. Groovy      | println     "Jabberwocky"     |
03. E           | println  (  "Jabberwocky")    |
04. Swift       | println  (  "Jabberwocky") ;  |
05. Julia       | println  (  "Jabberwocky");;  |
06. Processing  | println  (  "Jabberwocky")  ; |
07. Falcon      | printl   (  "Jabberwocky")    |
08. ALGOL 68    | print    (  "Jabberwocky")    |
09. Vala        | print    (  "Jabberwocky") ;  |
10. Pawn        | print    (  "Jabberwocky");;  |
11. Batsh       | print    (  "Jabberwocky")  ; |
12. freeBASIC   | print       "Jabberwocky"     |
13. Rebol       | print       "Jabberwocky"  ;  |
14. Red         | print       "Jabberwocky"   ; |
15. AWK         | print       'Jabberwocky'     |
16. Perl        | print       'Jabberwocky'  ;  |
17. bc          | print       'Jabberwocky'   ; |
18. Euphoria    |  puts    (1,"Jabberwocky")    |
19. C           |  puts    (  "Jabberwocky") ;  |
20. Tcl         |  puts       "Jabberwocky"     |
21. Ruby        |  puts       'Jabberwocky'     |
22. Zsh         |      echo   "Jabberwocky"     |
23. Bash        |      echo   "Jabberwocky"  ;  |
24. tcsh        |      echo   "Jabberwocky"   ; |
25. PHP         |      echo   'Jabberwocky'     |
26. Fish        |      echo   'Jabberwocky'  ;  |
27. Dash        |      echo   'Jabberwocky'   ; |
28. F#          |      printfn"Jabberwocky"   ; |
29. C++         |    cout<<"J"<< "abberwocky" ; |
30. D           |     Writeln(  'Jabberwocky'); |
31. Pascal      |     WriteLn(  'Jabberwocky'); |
32. Delphi      |     Writeln(  "Jabberwocky"); |
33. GolfScript  |      print;'Jabberwocky'..;;  |
34. CJam        |   "E\]]`mrj^ftXX"););  5f+'); |
35. Pyth        |      pk)K00000"Jabberwocky"   |

(Py23 और CJam user23013 को धन्यवाद)

— अनुकूलक
स्रोत

दरअसल, हैस्केल कोड स्ट्रिंग को उद्धरण चिह्नों के साथ प्रिंट करता है। उनके बिना इसे मुद्रित करने के लिए आपको आवश्यकता होगी putStr[ln]...। इसके अलावा, haskell नहीं है ;;। मेरा मानना है कि आपने इसे Ocaml के साथ मिलाया है।

— गर्वित हैकेलर

यहां तक कि Ocaml कि नहीं है। (यदि मैं डालूं तो ऑनलाइन दुभाषिया त्रुटि देता है ;;)। वैसे भी, हास्केल को किसी और चीज़ से बदल दिया गया।

— ऑप्टिमाइज़र

Pyth को जोड़ना आसान होगा - | p b"Jabberwocky" |उदाहरण के लिए

— isaacg

@isaacg धन्यवाद! मैं पायथ को भी देखने जा रहा था। यह मेरा समय बचाता है :)

— ऑप्टिमाइज़र

@ लिसाक BTW, ऐसा रास्ता कहाँ है?

— ऑप्टिमाइज़र

17 भाषाओं

यहाँ .आरक्षित चरित्र के साथ ग्रिड है :

 prin...........
 utstln!........
       (1,......
<?echo    ".....
.........'Jab...
............b...
............e...
............r...
............w...
............o...
............c...
............k...
............y"..
............' ).
.............  ;
..............

और यहाँ भाषाएँ और उनके मार्ग हैं (ऊर्ध्वाधर पट्टियों को अनदेखा करें):

01. Rust        | println!(   "Jabberwocky" ) ; |
02. Swift       | println (   "Jabberwocky" ) ; |
03. Scala       | println (   "Jabberwocky" )   |
04. Falcon      | printl  (   "Jabberwocky" )   |
05. Vala        | print   (   "Jabberwocky" ) ; |
06. Lua         | print   (   'Jabberwocky' ) ; |
07. ALGOL 68    | print   (   "Jabberwocky" )   |
08. Dart        | print   (   'Jabberwocky' )   |
09. Rebol       | print       "Jabberwocky"   ; |
10. Perl        | print       'Jabberwocky'   ; |
11. AWK         | print       "Jabberwocky"     |
12. Euphoria    | puts    (1, "Jabberwocky" )   |
13. C           | puts    (   "Jabberwocky" ) ; |
14. Tcl         | puts        "Jabberwocky"     |
15. Ruby        | puts        'Jabberwocky'     |
16. Bash        |     echo    "Jabberwocky"     |
17. PHP         |     echo    "Jabberwocky"   ; |

मैं उन सभी का परीक्षण करने में सक्षम नहीं था, इसलिए मुझे बताएं कि क्या कुछ काम नहीं करता है।

— gRC
स्रोत

मुझे लगता है कि आप एक से अधिक भाषाओं के लिए एक ही पथ का उपयोग नहीं कर सकते हैं और इसे अपने स्कोर में जोड़ सकते हैं।

— ऑप्टिमाइज़र

@Optimizer मुझे नहीं लगता कि दो बार इस्तेमाल किए गए कोई भी रास्ते हैं। बेशक, मतभेद बहुत छोटे हैं।

— grc

उह, तुम डरपोक आदमी! : P

— ऑप्टिमाइज़र

PHP के लिए, बॉयलरप्लेट को हटाने के बाद, `इको“ फोब्बर ”` (हर बार 1 से अधिक जगह) ठीक प्रिंट करता है। बिना किसी सफेद जगह के। इसे यहाँ आज़माएँ

— ऑप्टिमाइज़र

कोड से बॉयलरप्लेट को हटाने के लिए इसका ठीक है, जो <?यहां है

— ऑप्टिमाइज़र

18 भाषाओं और अधिक

आरक्षित वर्ण ~:।

         "~~~~~~
12345678 "~~~~~~
12345678 "~~~~~~
12345678 "~~~~~~
1234567: ea~~~~~
1234567: c;~~~~~
1234567: hL~~~~~
1234567: o'~~~~~
1234567:  Jab~~~
1234567:?""""~~~
~~~~~~~~~Jabberw
~~~~~~~~~~~~~~~o
~~~~~~~~~~~~~~~c
~~~~~~~~~~~~~~~k
~~~~~~~~~~~~~~~y
~~~~~~~~~~~~~~~"

भाषाएँ:

CJam                             |             ea;L'J"abberwocky"|
GolfScript                       |              cho "Jabberwocky"|
Bc                               |                  "Jabberwocky"|
Bash                             |         """"echo J"abberwocky"|
Zsh                              |           ""echo J"abberwocky"|
Fish                             |             echo J"abberwocky"|
Tcsh                             |         """"echo Ja"bberwocky"|
Dash                             |           ""echo Ja"bberwocky"|
Ksh                              |             echo Ja"bberwocky"|
Mksh                             |         """"echo Jab"berwocky"|
Yash                             |           ""echo Jab"berwocky"|
Sash                             |             echo Jab"berwocky"|
Posh                             |         """"echo "Jabberwocky"|
Csh                              |           ""echo "Jabberwocky"|
PHP                              |             echo "Jabberwocky"|

तथा...

FreeBasic                        |                 ?"Jabberwocky"|
QBasic                           | 12345678        ?"Jabberwocky"|
QB64                             | 123456788       ?"Jabberwocky"|

कई और बेसिक बोलियाँ होनी चाहिए जो काम करती हैं। लेकिन मेरे पास अभी तक उन सभी का परीक्षण करने का समय नहीं है।

— jimmy23013
स्रोत

याद रखें कि आप 1 से अधिक भाषा के लिए एक ही पथ का उपयोग नहीं कर सकते हैं। इसलिए सभी बुनियादी बोली में फिट नहीं होगा।

— ऑप्टिमाइज़र

@ ऑप्टिमाइज़र कम से कम उन बोलियों की जिनके पास लाइन नंबर हैं और ओवरफ्लो की जांच नहीं करते हैं (और जिनके पास ?है print) को काम करना चाहिए ... बस एक अलग लाइन नंबर चुनें।

— jimmy23013