ASCII-table को ASCII-table के रूप में फिर से बनाएँ

26

बार-बार कोड-गोल्फिंग करते समय, मैं जानना चाहता हूं कि एक निश्चित चरित्र का ASCII मान क्या है। जल्दी से सभी मुद्रण योग्य ASCII वर्णों को देखने के लिए मेरे पसंदीदा संसाधनों में से एक ASCIItable.com है । इसकी एक बहुत अच्छी छवि है जो न केवल मुद्रण योग्य ASCII वर्णों और उनके मूल्यों को दिखाती है, बल्कि अप्राप्य और विस्तारित वर्णों और हेक्साडेसिमल, ऑक्टल और HTML में मूल्यों को भी दर्शाती है:

यहाँ छवि विवरण दर्ज करें

आज की चुनौती एक छवि के बजाय उस ASCII तालिका के रूप में उस ASCII तालिका को फिर से बनाना है। चीजों को सरल रखने के लिए, हम नियंत्रण-वर्ण (32 से नीचे के वर्ण) का उपयोग नहीं करेंगे और हम केवल दशमलव मान और वर्ण दिखाएंगे। दूसरे शब्दों में, आपकी चुनौती पूर्ण-प्रोग्राम या एक फ़ंक्शन लिखना है जो निम्नलिखित पाठ को प्रिंट या वापस करता है:

Dec  Chr   | Dec  Chr   | Dec  Chr
----------------------------------
32   Space | 64   @     | 96   `
33   !     | 65   A     | 97   a
34   "     | 66   B     | 98   b
35   #     | 67   C     | 99   c
36   $     | 68   D     | 100  d
37   %     | 69   E     | 101  e
38   &     | 70   F     | 102  f
39   '     | 71   G     | 103  g
40   (     | 72   H     | 104  h
41   )     | 73   I     | 105  i
42   *     | 74   J     | 106  j
43   +     | 75   K     | 107  k
44   ,     | 76   L     | 108  l
45   -     | 77   M     | 109  m
46   .     | 78   N     | 110  n
47   /     | 79   O     | 111  o
48   0     | 80   P     | 112  p
49   1     | 81   Q     | 113  q
50   2     | 82   R     | 114  r
51   3     | 83   S     | 115  s
52   4     | 84   T     | 116  t
53   5     | 85   U     | 117  u
54   6     | 86   V     | 118  v
55   7     | 87   W     | 119  w
56   8     | 88   X     | 120  x
57   9     | 89   Y     | 121  y
58   :     | 90   Z     | 122  z
59   ;     | 91   [     | 123  {
60   <     | 92   \     | 124  |
61   =     | 93   ]     | 125  }
62   >     | 94   ^     | 126  ~
63   ?     | 95   _     | 127  DEL

प्रत्येक पंक्ति पर अनुगामी रिक्त स्थान, और अनुगामी नई रेखा की अनुमति है। चूंकि यह एक कोलमोगोरोव-जटिलता चुनौती है, इसलिए आपका सबमिशन कोई इनपुट नहीं ले सकता है, या किसी बाहरी संसाधन (जैसे फ़ाइल या वेब) तक नहीं पहुंच सकता है, और आपका लक्ष्य इस पाठ को जितना संभव हो उतना आउटपुट करने के लिए कोड को संपीड़ित करना है।

स्टैंडर्ड लूपहोल्स लागू होते हैं, और बाइट्स जीत में सबसे छोटा जवाब होता है। हैप्पी गोल्फिंग!

code-golf  string  ascii-art  kolmogorov-complexity 
— DJMcMayhem
स्रोत
3
मेरे पास सटीक ASCII तालिका की छवि मेरी दीवार पर अटक गई है ... वैसे भी, क्या लाइनों की सूची वापस आ सकती है?
— FlipTack
2
@fliptack बेशक आप कर सकते हैं। मैं ऐसा कुछ पूरी तरह से उचित क्यों नहीं होने दूंगा?
— DJMcMayhem
10
मैं यह नहीं कहूंगा कि यह एक द्वैध है - दूसरे को हेक्स मानों की आवश्यकता होती है, unprintables के नाम, और एक अलग तालिका प्रारूप है। यह ASCII को दिखाई देता है और सभी अनप्रिंटर्स के 3-लेटर कोड नहीं पूछकर गोल्फर कोड की अनुमति देता है।
— FlipTack
@ फैटलटैक में अभी भी स्पेस और DEL है
— simon
2
@gurka हाँ, लेकिन दूसरे का हर एक नियंत्रण चरित्र है।
— FlipTack

जवाबों:

11

पायथन 2, 185 183 175 159 बाइट्स

FlipTack के लिए 8 बाइट्स बचाए गए!

अभी भी पायथन में गोल्फ के लिए काफी नया है।

for a in["Dec  Chr   | "*3,"-"*39]+["".join(["%-5d%-6s| "%(l,('Space',chr(l),'DEL')[(l>32)+(l>126)]) for l in(i,32+i,64+i)])for i in range(32,64)]:print a[:-5]

टेबल बॉडी जेनरेट करने के लिए नेस्टेड लिस्ट कॉम्प्रिहेंशन का उपयोग करता है।

Ungolfed:

lines =   \
  ["Dec  Chr   | "*3, "-"*39] +                    # first two lines
    ["".join(                                        # join 3 parts of each line
      ["%-5d%-6s| " % (l, ('Space',chr(l),'DEL')[(l>32)+(l>126)]) 
        for l in (i,32+i,64+i)]                      # generate 3 parts of a line
      )
      for i in range(32,64)]

for line in lines: print line[:-5]

पुराना प्रयास, 185 183 175 बाइट्स

print("Dec  Chr   | "*3)[:-5]+"\n"+"-"*34
a=lambda x:('Space',chr(x),'DEL')[(x>32)+(x>126)]
for l in range(32,64):print("%-5d%-6s| "*3%(l,a(l),l+32,a(l+32),l+64,a(l+64)))[:-5]

Ungolfed:

print ("Dec  Chr   | "*3)[:-5] + "\n" + "-"*34
def a(x):
    return "Space" if x==32 else "DEL" if x==127 else chr(x)
for line in range(32,64):
    print ("%-5d%-6s| "*3 % (line, a(line), line+32, a(line+32), 
      line+64, a(line+64))) [:-5]
— busukxuan
स्रोत
मैं `के लिए l में एक जगह देखता हूं (i, 32 + i, 64 + i)]), एक बाइट को बचाने के लिए हटाया जा सकता है।
— अधिकतम
5

जावास्क्रिप्ट (ईएस 6), 179 173 बाइट्स

f=n=>n?(n>>6?' | ':`
`)+n+(99<n?'  ':'   ')+(126<n?'DEL':String.fromCharCode(n)+'    '+f(n>95?n-63:n+32)):`${x='Dec  Chr   '}| ${x}| ${x}
${'-'.repeat(34)}
32   Space`+f(64)

console.log(f())
स्निपेट का विस्तार करें

— Arnauld
स्रोत
अच्छा जवाब! आप `${x='Dec Chr '}| ${x}| ${x}पंक्ति 2 के अंत में बदलकर एक और बाइट बचा सकते हैं(x='Dec Chr ')+(' |'+x)*2+`
— ल्यूक
@ L.Serné मुझे ECMAScript के किसी भी संस्करण का पता नहीं है जो *ऑपरेटर के साथ एक स्ट्रिंग को दोहराएगा । या मैं किसी तरह आपके सुझाव को गलत समझ रहा हूं?
— Arnauld
उफ़, मेरी बुर। यही कारण है कि आप एक अजगर समाधान और फिर जावास्क्रिप्ट की कोशिश कर के लिए मिलता है।
— ल्यूक
5

वी , 98, 96 , 94 बाइट्स

i32 | 64 | 9631ñÙl.l.ñÍä«/&   &    
ÎéiD@"
bsDELF 27kdH5lRSpaceÄÒ-Ä3RDec  Chr³ | Î35|D

इसे ऑनलाइन आज़माएं!

सौ के नीचे बस मुश्किल से चीखना। मैं देख रहा हूं कि क्या मैं पायथ को हरा सकता हूं, लेकिन मैं कोई वादा नहीं करूंगा।

यहाँ एक हेक्सडम्प है:

00000000: 6933 3220 7c20 3634 207c 2039 361b 3331  i32 | 64 | 96.31
00000010: f1d9 016c 2e6c 2ef1 cde4 ab2f 2620 2020  ...l.l...../&   
00000020: 1616 2620 2020 200a cee9 6944 4022 0a62  ..&    ...iD@".b
00000030: 7344 454c 1b46 2016 3237 6b64 4835 6c52  sDEL.F .27kdH5lR
00000040: 5370 6163 651b c4d2 2dc4 3352 4465 6320  Space...-.3RDec 
00000050: 2043 6872 b320 7c20 1bce 3335 7c44        Chr. | ..35|D

और यहां बताया गया है कि यह कैसे काम करता है:

i32 | 64 | 96<esc>      " Insert some starting text
31ñ          ñ          " 31 times:
   Ù                    "   Duplicate this line
    <C-a>               "   Increment the first number on this line
         l.             "   Increment the next number
           l.           "   Increment the next number

यहां वह जगह है जहां यह दिलचस्प है। सबसे पहले, मुझे एक विम-ट्रिक समझाएं। इन्सर्ट मोड में, कुछ अक्षर डाले गए हैं (सभी प्रिंट करने योग्य ASCII- वर्ण 0x7f, ऊपर दिए गए अधिकांश अनमैप्ड वर्ण और कुछ अन्य), लेकिन अन्य वर्णों का एक साइड-इफ़ेक्ट है। उदाहरण के लिए, 0x1b( <esc>) सामान्य मोड में भाग जाएगा। 0x01( <C-a>) पिछले सम्मिलित पाठ, आदि को फिर से सम्मिलित करेंगे। कभी-कभी, हम इन अक्षरों को शाब्दिक रूप से सम्मिलित करना चाहते हैं। तो एक शाब्दिक बच चरित्र डालने के लिए, आपको टाइप करना होगा <C-v><esc>। यह उन सभी पात्रों के लिए काम करता है जिनका साइड इफेक्ट है। तो अनिवार्य रूप से, <C-v>स्ट्रिंग शाब्दिक के साथ भाषाओं में एक बैकस्लैश के बराबर है जो आपको एक स्ट्रिंग में कुछ वर्णों से बचने की अनुमति देता है।

<C-v>इन्सर्ट मोड के साथ अन्य उपयोगी ट्रिक यह है कि इसका उपयोग कोड-पॉइंट द्वारा वर्णों को सम्मिलित करने के लिए किया जा सकता है , या तो दशमलव, हेक्साडेसिमल, ऑक्टल या हेक्साडेसिमल यूनिकोड में। चूँकि हमारे पास पहले से ही संख्याएँ हैं जो कुछ ASCII मानों के अनुरूप हैं, हमें केवल <C-v>उन वर्णों से पहले डालने की आवश्यकता है , और संबंधित पाठ को vim-keystrokes के रूप में चलाना होगा। यह एक regex कमांड और "हर लाइन पर" x 'कमांड के साथ प्राप्त किया जा सकता है। सो हम्:

Í                       " Substitute globally:
 ä«                     "   One or more digits
   /                    " With:
    &                   "   The matched number + some spaces
        <C-v><C-v>&     "   A ctrl-v character, then the matched number again
                        "   Since ctrl-v is like a backslash, we need two to enter a literal ctrl-v character
Î                       " On every line:
 éi                     "   Insert an 'i'
   D                    "   Delete this line
    @"                  "   Run it as vim keystrokes

इस बिंदु पर, बफर इस तरह दिखता है

32         | 64   @     | 96   `    
33   !     | 65   A     | 97   a    
34   "     | 66   B     | 98   b    
35   #     | 67   C     | 99   c    
36   $     | 68   D     | 100   d    
37   %     | 69   E     | 101   e    
38   &     | 70   F     | 102   f    
39   '     | 71   G     | 103   g    
40   (     | 72   H     | 104   h    
41   )     | 73   I     | 105   i    
42   *     | 74   J     | 106   j    
43   +     | 75   K     | 107   k    
44   ,     | 76   L     | 108   l    
45   -     | 77   M     | 109   m    
46   .     | 78   N     | 110   n    
47   /     | 79   O     | 111   o    
48   0     | 80   P     | 112   p    
49   1     | 81   Q     | 113   q    
50   2     | 82   R     | 114   r    
51   3     | 83   S     | 115   s    
52   4     | 84   T     | 116   t    
53   5     | 85   U     | 117   u    
54   6     | 86   V     | 118   v    
55   7     | 87   W     | 119   w    
56   8     | 88   X     | 120   x    
57   9     | 89   Y     | 121   y    
58   :     | 90   Z     | 122   z    
59   ;     | 91   [     | 123   {    
60   <     | 92   \     | 124   |    
61   =     | 93   ]     | 125   }    
62   >     | 94   ^     | 126   ~    
63   ?     | 95   _     | 127

अब हमें बस कुछ सामान्य सफाई की आवश्यकता है, जो इस उत्तर में अधिकांश बाइट्स के लिए जिम्मेदार है

bsDEL<esc>              " Change the literal 0x7f character to "DEL"
          F <C-v>27kd   " Remove a space from the lines that have too many
H5l                     " Move to the first space character
   RSpace<esc>          " And replace it with "Space"
Ä                       " Duplicate this line
 Ò-                     " And replace it with '-'s
   Ä                    " Duplicate this line
    3R                  " And replace it with three copies of the following string:
      Dec  Chr³ | <esc> " 'Dec  Chr   | '

Î35|D                   " Remove all but the first 35 characters of each line
— DJMcMayhem
स्रोत
5

एफ #, 222 बाइट्स

let c,p=String.concat" | ",printfn"%s"
Seq.replicate 3"Dec  Chr  "|>c|>p
p(String.replicate 34"-")
for i=32 to 63 do[for j in[i;i+32;i+64]->sprintf"%-5d%-5s"j (match j with 32->"Space"|127->"DEL"|_->string(char j))]|>c|>p

इसे ऑनलाइन आज़माएं!

— Asik
स्रोत
क्या मैं इसके लिए कृपया अनऑर्गलाइज्ड संस्करण की मांग कर सकता हूं? मैं एफ # सीखने के लिए वास्तव में नया हूं, और मैं ठीक से समझना पसंद करूंगा कि आपने यह कैसे किया!
— सियारन_मस्कारी
1
पहली पंक्ति के उपनाम एकल-वर्ण नामों के लिए दो कार्य करते हैं। अब अगर आप ["ab"; "cd"] |> c |> pइसे "" | वर्ण और उन्हें प्रिंट करता है, जैसे "ab | cd" जो तालिका को प्रिंट करने के लिए मूल विचार है। बाकी काफी सीधा है, जहां भी संभव हो बस व्हाट्सएप से परहेज करें।
— असिक
4

डीसी , 167 बाइट्स

[[Space]nq]sp[[DEL]nq]sq[[ ]n]sc[Dec  Chr]dsen[   | ]dsfnlenlfnlen10P34[[-]n1-d0<a]dsax10P0[[32+dndZ2=c[  ]ndd32=pd127=qP[    ]n]dswx[ | ]nlwx[ | ]nlwx10P95-d32>b]dsbx

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है:

[[Space]nq]sp     # p is a macro that prints "Space" and then quits from the call one level up
[[DEL]nq]sq       # q is a macro that prints "DEL" and then quits from the call one level up
[[ ]n]sc          # c is a macro that prints a space
[Dec  Chr]dsen    # Save the string "Dec  Chr" in register e, and print it.
[   | ]dsfn       # Save the string "   | " in register f, and print it.
len               # Print "Dec  Chr" again.
lfn               # Print "   | " again.
len               # Print "Dec  Chr" again.
10P               # Print a newline.
34                # Push 34 on the stack.

[[-]n1-d0<a]dsa   # a is a macro that repeatedly prints "-" and decrements the top of the stack, while the top of the stack is positive.

x10P              # Execute macro a, followed by a newline. (This prints the line of hyphens.)

0                 # Push 0 on the stack.

[                 # Starting a large macro (which will be stored in register b) for printing the table row by row.

[32+dndZ2=c[  ]ndd32=pd127=qP[    ]n]dsw

                  # w is a macro which:
                        (1) adds 32 to the top of the stack;
                        (2) prints it as a number;
                        (3) uses Z to compute the number of characters the number required to print that number;
                        (4) if it required 2 characters to print the number, calls the macro c to print an extra space
                        (5) prints the string "Space" (for ASCII code 32) or the string "DEL" (for ASCII code 127) or the appropriate character, followed by the right number of spaces

x                 # Execute macro w to print an entry in column 1.
[ | ]n            # Print a column divider.
lwx               # Execute macro w to print an entry in column 2 (ASCII code 32 higher than the previous entry).
[ | ]n            # Print a column divider.
lwx               # Execute macro w to print an entry in column 3 (ASCII code 32 higher than the previous entry).

10P               # Print a newline.
95-               # Subtract 95 to adjust to go to the beginning of the next line.

d32>b             # If the top of stack is <= 32, execute macro b again, effectively looping to print all the rows of the table.

]dsb              # End the definition of the large macro, and store it in register b.

x                 # Execute the macro that's in b (with 0 at the top of the stack initially).
— मिशेल स्पेक्टर
स्रोत
4

पर्ल, 120 बाइट्स

$,="| ";say+("Dec  Chr   ")x3;say"-"x32;say map{sprintf"%-5s%-6s",$_,$_-32?$_-127?chr:DEL:Space}$_,$_+32,$_+64for 32..63

-Eध्वज के साथ चलाएँ :

perl -E '$,="| ";say+("Dec  Chr   ")x3;say"-"x32;say map{sprintf"%-5s%-6s",$_,$_-32?$_-127?chr:DEL:Space}$_,$_+32,$_+64for 32..63'

-2 बाइट्स @ जीबी के लिए धन्यवाद ।

— बापू
स्रोत
अगर मैं थोड़ा पर्ल समझता हूं, तो शायद आप "% -3s" के बजाय "% -5s" का उपयोग करके 2 स्थान काट सकते हैं (संयोग से, यही मैं माणिक में करता हूं)
— GB
3

सी, 179 बाइट्स

i;f(){for(;i++<37;)printf(i<4?"Dec  Chr%s":"-",i<3?"   | ":"\n");printf("\n32   Space | ");for(i=64;i<127;i+=i>95?-63:32)printf("%-5d%-6c%s",i,i,i>95?"\n":"| ");puts("127  DEL");}

इसे ऑनलाइन आज़माएं!

अर्द्ध ungolfed:

i;
f() {
  for(;i++<37;) printf(i<4?"Dec  Chr%s":"-",i<3?"   | ":"\n");

  printf("\n32   Space | ");
  for(i=64;i<127;i+=i>95?-63:32) printf("%-5d%-6c%s",i,i,i>95?"\n":"| ");
  puts("127  DEL");
}
— साइमन
स्रोत
3

रूबी, 124 बाइट्स

 puts [["Dec  Chr   "]*3*"| ",?-*34,(0..31).map{|d|(1..3).map{|x|"%-5s%-6s"%[y=x*32+d,y<33?"Space":y>126?"DEL":y.chr]}*"| "}]
— जीबी
स्रोत
3

वी , 151 150 148 136 135 130 130 129 125 बाइट्स

12 बाइट्स ने @ nmjcman101 की बदौलत <C-v>g<C-a>नंबर के बदले उपयोग के लिए धन्यवाद बचायाline('.')

2 बाइट ने @DJMcMayhem को धन्यवाद दिया ÇÓ/dकि dêअतिरिक्त रिक्त स्थान हटाने और सामान को हटाने के लिए अग्रणी स्थानों के साथ लाइनों को हटाने के लिए और सामान का उपयोग करके

यह उत्तर @ nmjcman101 के V उत्तर (जो उपयोग करता है :set ve=all) के साथ प्रतिस्पर्धा में है । लेकिन अब, मैंने उन A ^[एस को हटाने का एक तरीका खोजा और कुछ बाइट्स को बचाया और हम एक बाइटकाउंट पर हैं 

iSpace 
¬!~Ó./&ò
iDELí^/31   
HlgGo| 63ÙkGld/Sp
$p/`
G$d/@
$p/64
G$d/S
$pÇÓ/d
/d
hdê/32
O34é-O!| !| !Ó!/Dec  Chr

इसे ऑनलाइन आज़माएं!

Hexdump:

00000000: 6953 7061 6365 200a 1bac 217e d32e 2f26  iSpace ...!~../&
00000010: f20a 6944 454c 1bed 5e2f 3331 2020 200a  ..iDEL..^/31   .
00000020: 1648 6c67 0147 6f7c 201b 3633 d96b 1647  .Hlg.Go| .63.k.G
00000030: 6c64 2f53 700a 2470 2f60 0a16 4724 642f  ld/Sp.$p/`..G$d/
00000040: 400a 2470 2f36 340a 1647 2464 2f53 0a24  @.$p/64..G$d/S.$
00000050: 70c7 d32f 640a 2f64 0a68 64ea 2f33 320a  p../d./d.hd./32.
00000060: 4f1b 3334 e92d 4f21 7c20 217c 2021 1bd3  O.34.-O!| !| !..
00000070: 212f 4465 6320 2043 6872 2020 20         !/Dec  Chr

स्पष्टीकरण (अपूर्ण और पुराना)

यहां रणनीति यह है कि मैं ASCII कोड पॉइंट जेनरेट करने के लिए लाइन नंबरों का उपयोग कर रहा हूं।

नोट: ^[है 0x1b, ^VहैC-v

पहले हम सभी वर्ण उत्पन्न करते हैं।

iSpace             " insert Space
^[¬!~              " insert every character between ! and ~

वर्तमान बफ़र जैसा दिखता है

Space
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

अब हम इन वर्णों के बीच एक नई पंक्ति सम्मिलित करते हैं

     Ó./&ò         " insert a newline before every character (:s/./&\r/g)
— क्रिक्टी लिथोस
स्रोत
यहां 32 SPACE ... 127 DELआपके कोड के भाग के लिए प्रतिस्थापन में एक बूंद है : इसे ऑनलाइन आज़माएं! यह उस g^A
— साफ़
@ nmjmcman101 हाँ, इसे 7.4 में जोड़ा गया था। इसके विपरीत, लेकिन आधिकारिक तौर पर 8. में जोड़ा गया। आदर्श कमांड का उपयोग करने के लिए और भी बेहतर होगा इसे ऑनलाइन आज़माएं!
— डीजेएमकेम
किसी भी तरह से, एक बार जब आप प्राप्त कर लेते हैं कि आप एक कर सकते हैं :set ve=allऔर फिर कर्सर उन स्थानों पर चला जाएगा जहां कोई पाठ नहीं है, तो आपको पाइप को आसान डालने और उन जगहों पर कॉपी / पेस्ट करने दें, जहां आपको A <esc>हर जगह छिड़काव करने की आवश्यकता है
— nmjcman101
@ nmjcman101 Re g^Aधन्यवाद, इसने मुझे 12 बाइट्स बचाए :)
— Kritii Lithos
@DJMcMayhem किसी कारण के लिए, मानदंड का उपयोग करके और फिर संख्याओं में वृद्धि से काम नहीं होता है
— Kritii Lithos
3

वी , 130 120 99 बाइट्स

उप 100 क्लब। मुझे अब यकीन नहीं है कि :se ve=allऐसा करने का सबसे अच्छा तरीका है। यह एक अतिरिक्त है ... सिर्फ लिखने के लिए 11 बाइट्स |! लेकिन मेरे पास यही है।

मैं लगभग :se ve=allकुछ के साथ बचने के लिए @KritiiLuthos जवाब के साथ प्रतियोगिता में यह पोस्ट कर रहा हूँ A <esc>। मुझे यकीन नहीं है कि या तो विधि अभी तक बेहतर है, इसलिए उम्मीद है कि यह दोनों पक्षों पर कुछ गोल्फ को प्रेरित कर सकता है और देख सकता है कि कौन सी विधि केक लेती है।

मैं भी उम्मीद कर रहा हूं कि दोनों हमारे पैंट को लात मारने के लिए @DJMcMayhem

iSpace
¬!~Ó./&ò
iDELí^/31   
Hlg:se ve=all
12|êr|2ñ031j$x)PñHd)ÄÒ-Ä3RDec  Chr³ | /d
hdêÎ35|D

इसे ऑनलाइन आज़माएं!

जिज्ञासु के लिए हेक्सडम्प (यदि मेरी रुचि है तो मैं इसे विम-स्टाइल हिडन कैरेक्टर ब्लॉक में बदल दूंगा)

00000000: 6953 7061 6365 0a1b ac21 7ed3 2e2f 26f2  iSpace...!~../&.
00000010: 0a69 4445 4c1b ed5e 2f33 3120 2020 0a16  .iDEL..^/31   ..
00000020: 486c 6701 3a73 6520 7665 3d61 6c6c 0a31  Hlg.:se ve=all.1
00000030: 327c 16ea 727c 32f1 3016 3331 6a24 7829  2|..r|2.0.31j$x)
00000040: 50f1 4864 29c4 d22d c433 5244 6563 2020  P.Hd)..-.3RDec  
00000050: 4368 72b3 207c 201b 2f64 0a68 64ea ce33  Chr. | ./d.hd..3
00000060: 357c 44                                  5|D
— nmjcman101
स्रोत
1
वैश्विक कमान को काफी लेकिन छोटा किया जा सकता है। एक के लिए, ddनिहित है यदि आप बस करते हैं d। आप ऐसा भी कर सकते हैं <M-s>जो हमेशा \sरेगेक्स के बराबर हो । तो आप इसे छोटा कर सकते हैं ç^ó*/d:। लेकिन अगर आप उलटे के लिए वैश्विक कमांड को स्विच करते हैं तो आप गैर-व्हाट्सएप चरित्र से मेल नहीं खा :g!रहे हर लाइन को खोज सकते हैं । जो के बराबर हैÇÓ/d:g!/\S/normal dd
— DJMcMayhem
3

AWK , 200 बाइट्स

BEGIN{b="-----------";a="Dec  Chr   ";print a"|",a"|",a"\n-"b b b;for(a=31;a++<63;){printf"%-5d%-6s| %-5d%-6c| %-5d%-5s\n",a,a<33?"Space":sprintf("%c",a),a+32,a+32,a+64,a<63?sprintf("%c",a+64):"DEL"}}

प्रारूपित:

BEGIN {
  b="-----------"
  a="Dec  Chr   "
  print a"|",a"|",a"\n-"b b b
  for(a=31;a++<63;) {
    printf "%-5d%-6s| %-5d%-6c| %-5d%-5s\n",
      a,    a<33 ? "Space" : sprintf("%c", a),
      a+32, a+32,
      a+64, a<63 ? sprintf("%c", a+64) : "DEL"
  }
}

इसे ऑनलाइन आज़माएं!

— स्टीव
स्रोत
2

C 188 बाइट्स

f(){i=31;printf("Dec Chr | Dec Chr | Dec Chr");printf("\n--------------------------");for(;i<63;i++)printf("\n%d%4c  | %d%4c  | %d%4c",(i+1),(i+1),(i+33),(i+33),(i+65),(i+65));puts("DEL");

आम तौर पर इस तरह दिखता है:

f()
{
    int  i=31;
    printf("Dec Chr | Dec Chr | Dec Chr");
    printf("\n--------------------------"); 
    for(;i<63;i++)  
      printf("\n%d%4c  | %d%4c  | %d%4c", (i+1),(i+1),(i+33),(i+33),  (i+65),(i+65));
    puts("DEL");
}
— हाबिल टॉम
स्रोत
2

सी (249 बाइट्स)

स्पष्टता के लिए नई कड़ियाँ जोड़ी गईं।

#define L(s,e)for(i=s;i<e;++i)
#define P printf
main(i){L(0,3)P("Dec  Chr  %s",i<2?" | ":"\n");
L(0,34)P("-");P("\n");L(32,64){P("%-5d", i);
i==32?P("Space"):P("%-5c",i);
P(" | %-5d%-5c | %-5d ",i+32,i+32,i+64);
i==63?P("DEL"):P("%-5c",i+64);P("\n");}}
— musarithmia
स्रोत
आप निश्चित रूप से कुछ बाइट्स बना Pसकते हैं printf(, जैसा कि यहाँ दिखाया गया है: repl.it/JBRD
— Zacharý
और अपनी चौथी पंक्ति पर स्थान हटाकर।
— ज़ाचरी
2

जावा, 434 422 321 बाइट्स

class A{public static void main(String[]a){
    int k=1,r,s=32;
    for(;k<4;k++)
        o("Dec   Chr  ",k);
    for(;k<37;k++)                                                                              
        o("-",k==36?3:4);
    for(k=r=s;!(k==64&&r==-63);r=k>95?-63:s,k+=r)
        o(k+"   "+((k>99)?"":" ")+(k==s?"Space":k==127?"DEL  ":((char)k+"    ")),k/s);
    }
    static void o(String s,int j){
        System.out.print(s+(j==4?"":j==3?"\n":"|"));
    }
}

जावा शायद इसके लिए सबसे अच्छी भाषा नहीं है क्योंकि कक्षाओं और मुख्य विधि का ओवरहेड है ...

आप स्थैतिक घोषणा का उपयोग करके मुख्य विधि को समाप्त कर सकते हैं, बाइट की गिनती को और कम कर सकते हैं:

class A{
    static{...}

लेकिन इसके परिणामस्वरूप त्रुटि होती है (अन्यथा सफलतापूर्वक चलने के बाद):

Exception in thread "main" java.lang.NoSuchMethodException: A.main([Ljava.lang.String;)
    at java.lang.Class.getMethod(Class.java:1786)
    ...

बाइट काउंट int में newlines या इंडेंटेशन शामिल है।

— xirt
स्रोत
मुझे नहीं लगता कि आपको एक स्थान की आवश्यकता है void main(){, और न ही बीच while(s.length()<5)और s+=" "। (जब तक कि आप अपनी बाइट गिनती में नहीं गिने जाते)। और अगर आप को बदल कर कुछ बाइट्स बचा सकते हैं d="Dec",c="Chr"करने के लिए d=p("Dec"),c=p("Chr")और अपने कॉल बदलते बनाने p(d)और p(c)करने के लिए dऔर c।
— ज़ाचरी
434 सभी अनावश्यक व्हाट्सएप को हटा रहा था। आपका सुझाव इसे 425 तक लाता है। धन्यवाद!
— एक्सर्ट
434 के बारे में एक नोट जोड़ना चाहते हो सकता है w / ओ जवाब में
— व्हाट्सएप व्हाट्सएप
किया हुआ। नोट: कार्यक्रम में काफी के बाद से (और कम हो) तो ऊपर टिप्पणी नहीं रह गया है हो सकता है प्रासंगिक बदल गया है
— xirt
2

टीईसी , 233 बाइट्स

lassign {"Dec  Chr" "   | " 31} h S i
set H $h$S$h$S$h\n[string repe - 34]
proc p x {format %-5d%c $x $x}
time {set H "$H
[p [incr i]]  $S[p [expr $i+32]]  $S[p [expr $i+64]]"} 32
puts [regsub {\ {8}} [regsub \177 $H DEL] "   Space"]

इसे ऑनलाइन आज़माएं!

— sergiol
स्रोत
मैं इस भाग गया और मैं 32 (उदाहरण के लिए '' के बजाय Space), और 33!(कोई अंतरिक्ष के बीच 33 और !)।
— NoOneIsHere
@SeeOneRhino: आप स्पष्ट रूप से कोड पर ध्यान नहीं दे रहे हैं। मैंने यहां पेस्ट करने के बाद लिंक के कोड को संशोधित किया, इसे और अधिक करने के प्रयास में, लेकिन मैं अभी तक सफल नहीं हुआ। मैं अभी पृष्ठ पर गया और अपनी असफल कोशिश के बारे में टिप्पणी की और यहाँ से कोड को फिर से लिखा; यदि आप अभी वहाँ जाते हैं, तो आपको कोड बिल्कुल समान दिखाई देगा और आप इसे सही चीजों को प्रिंट करते देखेंगे!
— सर्गिओल
मुझे खेद है, मैंने लिंक को आपका संपादन नहीं देखा। मैंने मान लिया कि कोड वही था जो आपने यहाँ पोस्ट किया था।
— NoOneIsHere
कोई बात नहीं, यह मेरी गलती थी
— सर्गिओल
@SeeOneRhino: मैंने इसे हासिल किया! मैं अपने आप को outgolfed!
— सर्गियोल
2

आर , 235 228 221 212 बाइट्स

y=apply(rbind(rep("Dec  Chr  ",3),1,matrix(sapply(1:96,function(i)paste(i+31,rep(" ",i<69),"if"(i<2,"Space","if"(i>95,"DEL",intToUtf8(c(i+31,rep(32,4))))))),nrow=32)),1,paste,collapse=" | ")
y[2]=strrep("-",34)
y

इसे ऑनलाइन आज़माएं!

मैं वास्तव में 200 बाइट्स से कम प्राप्त करने के लिए बहुत कोशिश की लेकिन इन pasteऔर collapseमुझे मार रहे हैं। लाइनों की एक सूची देता है।

— Jayce
स्रोत
1

जावास्क्रिप्ट (ईएस 6), 258 बाइट्स

a="Dec  Chr   | ".repeat(2)+"Dec  Chr\n"+"-".repeat(34);for(b=32;64>b;b++)a+="\n"+b+"   "+(32==b?"Space  ":String.fromCharCode(b)+"      ")+"| "+(b+32)+"   "+String.fromCharCode(b+32)+"     | "+(b+64)+(35<b?"  ":"   ")+(63==b?"DEL":String.fromCharCode(b+64))

console.log(a)
— जूलियन लचनीट
स्रोत
1

पॉवरशेल , 159 बाइट्स

,'Dec  Chr'*3-join'   | '
'-'*34
32..63|%{($_,($_+32),($_+64)|%{"$_".PadRight(5)+"$(([char]$_,('Space','DEL')[$_-ne32])[$_-in32,127])".padRight(5)})-join' | '}

इसे ऑनलाइन आज़माएं!

पहली दो लाइनें सिर्फ शाब्दिक तार पैदा कर रही हैं और उन्हें पाइपलाइन पर छोड़ रही हैं। पहले ,एक एरे बनाने के लिए अल्पविराम ऑपरेटर का उपयोग करता है , और फिर -joinहेडर बनाने के लिए एक साथ उस एरे को बनाता है। दूसरा सिर्फ एक सीधा स्ट्रिंग गुणन है।

तीसरी लाइन के ऊपर लूप 32..63और प्रत्येक यात्रा तीन मानों भेजता है $_, ($_+32)और ($_+64)एक आंतरिक लूप में। आंतरिक लूप PadRightमान पर करता है ( 5वर्णों के लिए उपयुक्त रिक्त स्थान जोड़ता है )। इसके बाद +एक नेस्टेड छद्म-टर्नरी के परिणाम के साथ स्ट्रिंग को समतल किया जाता है ( )[ ]। छद्म-टर्नरी या तो charउस संख्या के प्रतिनिधित्व का चयन करता है , या अन्यथा Spaceया DELयदि यह उचित मूल्य है। फिर, हम PadRightउपयुक्त पात्र हैं।

उन तीन तार (उदाहरण के लिए, 32 Space, 64 @, 96 `) कोष्ठक में समाहित कर रहे हैं और -joinएक भी स्ट्रिंग में स्तंभ मार्कर के साथ एड। उन 32 तारों में से प्रत्येक को फिर पाइप लाइन पर छोड़ दिया जाता है। निष्पादन के अंत में, एक निहित Write-Outputपाइप लाइन पर तत्वों के बीच एक नई रेखा सम्मिलित करता है, इसलिए हमें वह मुफ्त में मिलता है।

— AdmBorkBork
स्रोत
1

पर्ल, 165 155 बाइट्स

$s='Dec  Chr   ';$_=join"\n",("$s| $s| $s","-"x34,map{join"| ",map{sprintf'%1$-5d%1$-6c',$_}($_,$_+32,$_+64)}32..63);s/ {8}/   Space/;s/\x7f.*/DEL\n/;print
— NWK
स्रोत
1

पायथन 2, 1564 218 बाइट्स

मेरा पहला गोल्फ, स्पष्ट गलतियों के लिए खेद है

print("Dec  Chr   | "*3)[:-2]+"\n"+"-"*34+"\n32   Space | 64   @     | 96   `"
for n in range(33,63):print"| ".join([str(n+x).ljust(5)+chr(n+x).ljust(6)for x in [0,32,64]])
print"63   ?     | 95   _     | 127  DEL"

इसे ऑनलाइन आज़माएं!

आप समझ रहे हैं कि पहला संस्करण बेस 64 एनकोडेड स्ट्रिंग था।

— sagiksp
स्रोत
@ फेलटैक ने इसे एक वास्तविक समाधान में बदल दिया
— sagiksp
बिना लाइसेंस के व्हाट्सएप पर ljust(6) for।
— यति
एक और पर x in [। और IIRC वर्गाकार कोष्ठकों joinको हटाया जा सकता है।
— यति
1

05AB1E , 82 76 बाइट्स

žQSDÇƵQ¸«.Bs𔇲”:"DEL"¸«.B)øvyð2×ý})3äøvy… | ©ý}®”†…  Chr  ÿ”3ר¨'-34×.Á.Á»

इसे ऑनलाइन आज़माएं!

अभी भी गोल्फ, यह एक बहुत सुधार किया जा सकता है।

žQSDÇƵQ¸«.Bs𔇲”:"DEL"¸«.B)ø पाठ समतुल्य के साथ गद्देदार संख्याएँ:

[['32 ', 'Space'], ['33 ', '!    '], ['34 ', '"    '], ['35 ', '#    '], ['36 ', '$    '], ['37 ', '%    '], ['38 ', '&    '], ['39 ', "'    "], ['40 ', '(    '], ['41 ', ')    '], ['42 ', '*    '], ['43 ', '+    '], ['44 ', ',    '], ['45 ', '-    '], ['46 ', '.    '], ['47 ', '/    '], ['48 ', '0    '], ['49 ', '1    '], ['50 ', '2    '], ['51 ', '3    '], ['52 ', '4    '], ['53 ', '5    '], ['54 ', '6    '], ['55 ', '7    '], ['56 ', '8    '], ['57 ', '9    '], ['58 ', ':    '], ['59 ', ';    '], ['60 ', '<    '], ['61 ', '=    '], ['62 ', '>    '], ['63 ', '?    '], ['64 ', '@    '], ['65 ', 'A    '], ['66 ', 'B    '], ['67 ', 'C    '], ['68 ', 'D    '], ['69 ', 'E    '], ['70 ', 'F    '], ['71 ', 'G    '], ['72 ', 'H    '], ['73 ', 'I    '], ['74 ', 'J    '], ['75 ', 'K    '], ['76 ', 'L    '], ['77 ', 'M    '], ['78 ', 'N    '], ['79 ', 'O    '], ['80 ', 'P    '], ['81 ', 'Q    '], ['82 ', 'R    '], ['83 ', 'S    '], ['84 ', 'T    '], ['85 ', 'U    '], ['86 ', 'V    '], ['87 ', 'W    '], ['88 ', 'X    '], ['89 ', 'Y    '], ['90 ', 'Z    '], ['91 ', '[    '], ['92 ', '\\    '], ['93 ', ']    '], ['94 ', '^    '], ['95 ', '_    '], ['96 ', '`    '], ['97 ', 'a    '], ['98 ', 'b    '], ['99 ', 'c    '], ['100', 'd    '], ['101', 'e    '], ['102', 'f    '], ['103', 'g    '], ['104', 'h    '], ['105', 'i    '], ['106', 'j    '], ['107', 'k    '], ['108', 'l    '], ['109', 'm    '], ['110', 'n    '], ['111', 'o    '], ['112', 'p    '], ['113', 'q    '], ['114', 'r    '], ['115', 's    '], ['116', 't    '], ['117', 'u    '], ['118', 'v    '], ['119', 'w    '], ['120', 'x    '], ['121', 'y    '], ['122', 'z    '], ['123', '{    '], ['124', '|    '], ['125', '}    '], ['126', '~    '], ['127', 'DEL  ']]

vyð2×ý})3äøvy… | ©ý} तालिका में एक साथ शामिल होते हैं:

['32   Space | 64   @     | 96   `    ', '33   !     | 65   A     | 97   a    ', '34   "     | 66   B     | 98   b    ', '35   #     | 67   C     | 99   c    ', '36   $     | 68   D     | 100  d    ', '37   %     | 69   E     | 101  e    ', '38   &     | 70   F     | 102  f    ', "39   '     | 71   G     | 103  g    ", '40   (     | 72   H     | 104  h    ', '41   )     | 73   I     | 105  i    ', '42   *     | 74   J     | 106  j    ', '43   +     | 75   K     | 107  k    ', '44   ,     | 76   L     | 108  l    ', '45   -     | 77   M     | 109  m    ', '46   .     | 78   N     | 110  n    ', '47   /     | 79   O     | 111  o    ', '48   0     | 80   P     | 112  p    ', '49   1     | 81   Q     | 113  q    ', '50   2     | 82   R     | 114  r    ', '51   3     | 83   S     | 115  s    ', '52   4     | 84   T     | 116  t    ', '53   5     | 85   U     | 117  u    ', '54   6     | 86   V     | 118  v    ', '55   7     | 87   W     | 119  w    ', '56   8     | 88   X     | 120  x    ', '57   9     | 89   Y     | 121  y    ', '58   :     | 90   Z     | 122  z    ', '59   ;     | 91   [     | 123  {    ', '60   <     | 92   \\     | 124  |    ', '61   =     | 93   ]     | 125  }    ', '62   >     | 94   ^     | 126  ~    ', '63   ?     | 95   _     | 127  DEL  ']

®”†… Chr ÿ”3ר¨'-34×.Á.Á» तालिका के शीर्ष लेख भाग का ध्यान रखता है:

Dec  Chr   | Dec  Chr   | Dec  Chr   
----------------------------------
32   Space | 64   @     | 96   `    
33   !     | 65   A     | 97   a    
34   "     | 66   B     | 98   b    
35   #     | 67   C     | 99   c    
36   $     | 68   D     | 100  d    
37   %     | 69   E     | 101  e    
38   &     | 70   F     | 102  f    
39   '     | 71   G     | 103  g    
40   (     | 72   H     | 104  h    
41   )     | 73   I     | 105  i    
42   *     | 74   J     | 106  j    
43   +     | 75   K     | 107  k    
44   ,     | 76   L     | 108  l    
45   -     | 77   M     | 109  m    
46   .     | 78   N     | 110  n    
47   /     | 79   O     | 111  o    
48   0     | 80   P     | 112  p    
49   1     | 81   Q     | 113  q    
50   2     | 82   R     | 114  r    
51   3     | 83   S     | 115  s    
52   4     | 84   T     | 116  t    
53   5     | 85   U     | 117  u    
54   6     | 86   V     | 118  v    
55   7     | 87   W     | 119  w    
56   8     | 88   X     | 120  x    
57   9     | 89   Y     | 121  y    
58   :     | 90   Z     | 122  z    
59   ;     | 91   [     | 123  {    
60   <     | 92   \     | 124  |    
61   =     | 93   ]     | 125  }    
62   >     | 94   ^     | 126  ~    
63   ?     | 95   _     | 127  DEL
— जादू ऑक्टोपस Urn
स्रोत
1

PHP, 163 149 147 बाइट्स

<?=($p=str_pad)(D,31,"ec Chr   | D"),$p("
",32,"-");whhile($i<96)printf("%s%-4d%-6s",$i%3?"| ":"
",$o=$i%3*32+32+$i/3,$i++?$i<96?chr($o):DEL:Space);

टूट - फूट

                        # print header
<?=($p=str_pad)(D,31,"ec Chr   | D"),$p("\n",32,"-");
while($i<96)            # loop $i from 0 to 96
    printf("%s%-4d%-6s",    # print formatted:
                            # string, 4 space decimal leftbound, 6 space string leftbound
        $i%3?"| ":"\n",                 # linebreak for 1st column, pipe+space else
        $o=$i%3*32+32+$i/3,             # ($i mapped to) ASCII value
        $i++?$i<96?chr($o):DEL:Space    # character
    );

उपयोग %-Nबाइट के लायक है जो राइटबाउंड नंबर और चरित्र को बचाएगा।

— टाइटस
स्रोत
एक ही बाइट की गिनती के साथ मेरी राय में बेहतर दिखता है इसे ऑनलाइन आज़माएं!
— जोर्ग हल्सरमन
0

टी-एसक्यूएल, 242 बाइट्स

DECLARE @ INT=32PRINT'Dec  Chr   | Dec  Chr   | Dec  Chr
'+REPLICATE('-',34)L:PRINT CONCAT(@,'   ',IIF(@=32,'Space | ',CHAR(@)+'     | '),@+32,'   ',CHAR(@+32),'     | ',@+64,SPACE(5-LEN(@+64)),IIF(@=63,'DEL',CHAR(@+64)))SET @+=1IF @<64GOTO L

प्रारूपित:

DECLARE @ INT=32
PRINT'Dec  Chr   | Dec  Chr   | Dec  Chr
' + REPLICATE('-',34)
L:
    PRINT CONCAT(@,'   ',IIF(@=32,'Space | ',CHAR(@)+'     | ')
                ,@+32,'   ',CHAR(@+32),'     | ',
                 @+64,SPACE(5-LEN(@+64)),IIF(@=63,'DEL',CHAR(@+64)))
    SET @+=1
IF @<64 GOTO L

कुछ बदलावों की कोशिश की, जिसमें अन्य चर के साथ विभिन्न सामान्य तारों को बदलना शामिल है, लेकिन यह सबसे छोटा संस्करण था जो मुझे मिला।

— BradC
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.