प्रत्येक मुद्रण योग्य ASCII वर्ण का उपयोग किए बिना उसे प्रिंट करें

56

एक में प्रोग्रामिंग भाषा अपनी पसंद के 95 कार्यक्रमों, जिनमें से प्रत्येक का एक अलग से एक आउटपुट बारे में 95 प्रिंट योग्य ASCII वर्ण कि चरित्र कार्यक्रम में कहीं भी होने वाली बिना ।

उदाहरण के लिए, यदि आपकी भाषा पायथन थी , तो आपका प्रोग्राम जो चरित्र उत्पन्न करता है, Pहो सकता है

print(chr(80))

क्योंकि PASCII कोड 80 है। यह कार्यक्रम मान्य है क्योंकि Pस्रोत कोड में कभी नहीं दिखाई देता है। हालांकि, इस कार्यक्रम के लिए जो लोअरकेस को आउटपुट करता है p, कुछ ऐसा है

print(chr(112))

यह अमान्य होगा, क्योंकि यह प्रिंट करता है p, pकोड में मौजूद है। एक वैध कार्यक्रम हो सकता है

exec(chr(112)+'rint(chr(112))')

जो प्रिंट pकरता है लेकिन इसमें शामिल नहीं है p।

आपका लक्ष्य अपने प्रत्येक 95 कार्यक्रमों को यथासंभव छोटा बनाना है। आपका स्कोर आपके सभी कार्यक्रमों की चरित्र लंबाई का योग है।

यदि किसी कारण से आप कुछ पात्रों के लिए वैध कार्यक्रम लिखने में असमर्थ हैं, तो आप उन पात्रों को "डिड नॉट प्रोग्राम" या डीएनपी के रूप में चिह्नित कर सकते हैं , और उनके लिए पूरी तरह से प्रोग्राम छोड़ सकते हैं। इस तरह से वाक्य-रचना की सख्त भाषाएं प्रतिस्पर्धा करने में सक्षम होंगी।

जीतने वाला उत्तर वह उत्तर होता है जिसमें सबसे कम DNP वाले उत्तरों के सेट का सबसे कम अंक होता है।

नियम

  • आपके सभी कार्यक्रमों के स्रोत कोड में केवल मुद्रण योग्य ASCII प्लस टैब और नई लाइनें हो सकती हैं, जिनमें से सभी को एक वर्ण के रूप में गिना जाता है। (क्योंकि एक अलग एन्कोडिंग में उन पात्रों को छोड़ना आसान होगा जो मौजूद नहीं हैं!)

    • नोट: यह नियम आवश्यक लगता है, लेकिन विभिन्न एन्कोडिंग वाली कई भाषाएं हैं और मुझे यकीन है कि यह उनके लिए जवाब देखने के लिए अच्छा होगा। इसलिए आप इस नियम को तोड़ सकते हैं , आप जो भी चरित्र चाहते हैं उसका उपयोग कर सकते हैं, लेकिन तब आपका जवाब गैर-प्रतिस्पर्धी हो जाता है , यह जीत नहीं सकता।

  • आपकी भाषा के मानक सम्मेलनों के अनुसार कार्यक्रम वास्तविक, पूर्ण कार्यक्रम होने चाहिए । कार्य और REPL स्निपेट की अनुमति नहीं है।

  • प्रत्येक प्रोग्राम का आउटपुट स्टडआउट या आपकी भाषा के स्वीकृत विकल्प पर जाना चाहिए।

  • प्रोग्राम्स को इनपुट के लिए प्रॉम्प्ट या आवश्यकता नहीं होनी चाहिए। (यदि इनपुट के लिए संकेत देना आपकी भाषा में निहित है, तो यह ठीक है।)

  • कार्यक्रम नियतात्मक होना चाहिए, रन टाइम में परिमित होना चाहिए, और स्वतंत्र होना चाहिए। उदाहरण के लिए अगर किसी को अन्य प्रोग्राम से अलग फ़ोल्डर में चलाया जाता है तो इससे कोई फर्क नहीं पड़ता।

  • एक प्रोग्राम का आउटपुट सटीक प्रिंट करने योग्य एएससीआईआई चरित्र होना चाहिए, जो कि एक ही अनुवर्ती न्यूलाइन से जुड़ा होता है, और कुछ नहीं, कुछ कम नहीं।

अपने जवाब में सभी 95 (आदर्श) कार्यक्रमों के साथ-साथ अपने स्कोर और किसी भी डीएनपी के बारे में जानकारी शामिल करना सुनिश्चित करें। आपको उन सभी कार्यक्रमों को सूचीबद्ध नहीं करना है जो " , ..." जैसे सरल पैटर्न का पालन करते हैं print(chr(80)), लेकिन सुनिश्चित करें कि आप सुनिश्चित हैं कि वे सभी काम करेंगे और आपका स्कोर सही तरीके से जोड़ा गया है।print(chr(81))print(chr(82))

संदर्भ के लिए, यहां 95 प्रिंट करने योग्य ASCII हैं जो आपके कार्यक्रमों को आउटपुट करना चाहिए:

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
code-golf  string  restricted-source  printable-ascii 
— केल्विन के शौक
स्रोत
यदि मेरे एन्कोडिंग में 0x30 कोड हैं, तो 0 के बजाए, 日 कह सकते हैं, तो क्या मैं मान सकता हूं कि प्रिंट करने योग्य एएससीआईआई नियमित 95, माइनस 0, एडिट्स हैं?
— लीकी नून
4
क्या? आपको मुद्रण योग्य ASCII का उपयोग करने की आवश्यकता है। वह सिर्फ एक नियम है।
— केल्विन के शौक
मेरा मानना ​​है कि ऐसे एन्कोडिंग हैं जिनमें 0x30 का सटीक प्रतिनिधित्व नहीं है जैसे कि0
— लीक नून
@LeakyNun EBCDIC
— TuxCrafting
2
@ समय नहीं, स्वतंत्रता नियम का पालन नहीं करता है।
— केल्विन के शौक

जवाबों:

25

पायथन 2, 1075 1065 1043 1040 1039 बाइट्स

प्रत्येक कार्यक्रम में फॉर्म print'\<octal char code>'को छोड़कर, होता है:

  • ' → print"\47"
  • 08→ के माध्यम सेprint~-<N+1>
  • 9 → print-~8
  • \ → print'%c'%92
  • i → exec'pr\151nt"\151"'
  • n → exec'pri\156t"\156"'
  • p → exec'\160rint"\160"'
  • r → exec'p\162int"\162"'
  • t → exec'prin\164"\164"'

संदर्भ और परीक्षण में आसानी के लिए, यहां कार्यक्रमों की पूरी सूची है, न्यूलाइन-अलग।

print'\40'
print'\41'
print'\42'
print'\43'
print'\44'
print'\45'
print'\46'
print"\47"
print'\50'
print'\51'
print'\52'
print'\53'
print'\54'
print'\55'
print'\56'
print'\57'
print~-1
print~-2
print~-3
print~-4
print~-5
print~-6
print~-7
print~-8
print~-9
print-~8
print'\72'
print'\73'
print'\74'
print'\75'
print'\76'
print'\77'
print'\100'
print'\101'
print'\102'
print'\103'
print'\104'
print'\105'
print'\106'
print'\107'
print'\110'
print'\111'
print'\112'
print'\113'
print'\114'
print'\115'
print'\116'
print'\117'
print'\120'
print'\121'
print'\122'
print'\123'
print'\124'
print'\125'
print'\126'
print'\127'
print'\130'
print'\131'
print'\132'
print'\133'
print'%c'%92
print'\135'
print'\136'
print'\137'
print'\140'
print'\141'
print'\142'
print'\143'
print'\144'
print'\145'
print'\146'
print'\147'
print'\150'
exec'pr\151nt"\151"'
print'\152'
print'\153'
print'\154'
print'\155'
exec'pri\156t"\156"'
print'\157'
exec'\160rint"\160"'
print'\161'
exec'p\162int"\162"'
print'\163'
exec'prin\164"\164"'
print'\165'
print'\166'
print'\167'
print'\170'
print'\171'
print'\172'
print'\173'
print'\174'
print'\175'
print'\176'

परीक्षा करना:

$ python printables.py | sed ':a;N;$!ba;s/\n//g'
 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

-1 बाइट्स @ Sp3000 के लिए धन्यवाद!

— तांबा
स्रोत
print~-<N+1>के लिए काम नहीं करता है 1। आपने कहा कि यह काम करता 0है 8।
— हयकम
7
@ मूंगफली यह करता है। कोड <angle brackets>शाब्दिक कोड नहीं है। <N+1>के शाब्दिक मूल्य के साथ स्थानापन्न N+1; इस मामले में, के लिए कार्यक्रम 1होगा print~-2। कार्यक्रमों की पूरी सूची देखें।
— ताम्र
21

सीजेएम, 269 बाइट्स

प्रत्येक कार्यक्रम को '<char - 1>)छोड़कर इस रूप में हैं :

  • अंतरिक्ष => S, 1 बाइट
  • '=> 39c, 3 बाइट्स
  • )=> '*(, 3 बाइट्स
  • 0=> T, 1 बाइट
  • 1=> X, 1 बाइट
  • 2=> Y, 1 बाइट
  • 3=> Z, 1 बाइट
  • 4- 9=> <num-1>), 2 बाइट्स

स्कोर है: 3 * 82 + 1 + 3 + 3 + 4 * 1 + 6 * 2 = 269

— Loovjo
स्रोत
39cके लिए '? इसके अलावा, आप भूल रहे हैं कि एकल अंक बस संख्या हो सकती है
— Sp3000
1
@ Sp3000 वे नहीं कर सकते क्योंकि इसमें वह इनपुट शामिल है जो आप इनपुट में उत्पन्न कर रहे हैं
— ब्लू
लेकिन फिर एक बाइट को बचाने के 1)लिए 2आदि के लिए उपयोग करें
— लुइस मेंडू
क्षमा करें, 1)मेरा मतलब था हाँ
— Sp3000
इसके अलावा, वहाँ हैTXYZ
— Sp3000
12

ASCII ने DOS के लिए X86 मशीन कोड को बाध्य किया, 3104 3101 2913 बाइट्स

खैर ... यह जावा से छोटा है, मुझे लगता है ...

32 अपवादों के लिए लगभग सभी वर्णों के लिए 30 बाइट्स, नीचे देखें।

ज्यादातर समय यह पैटर्न का अनुसरण करता है:

  1. xorअंत तक एक पॉइंटर प्राप्त करने के लिए कुछ करें।
  2. subअंतिम 2 शब्दों से क्योंकि इसके लिए opcode intASCII में नहीं है।
  3. 2 में जाओ AHऔर चरित्र में DL। दोनों xorएड हैं क्योंकि चरित्र ही प्रोग्राम में दिखाई नहीं दे सकता है और 2 एक मुद्रण योग्य ASCII चरित्र नहीं है।
  4. के साथ वर्ण प्रिंट करें int 21h
  5. के साथ बाहर निकलें int 20h

अधिकांश समय, यदि कोई चरित्र अस्वीकृत हो जाता है, तो इसे या तो डेटा को थोड़ा-थोड़ा घुमाकर या किसी भिन्न रजिस्टर पर स्विच करके बदल दिया जा सकता है।

यह थोड़ा और दिलचस्प हो जाता है जब आप अचानक अपने आप को घटाना करने में असमर्थ पाते हैं या धक्का देने में असमर्थ होते हैं या केवल गणना के लिए प्रयोग करने योग्य रजिस्टर करते हैं ...

char  code
      hX'X5B&P[hT!^)7CC)7VX5t#PZ!C!B
!     hX'X5B&P[hS ^)7CC)7VX5r"PZ B A
"     hX'X5B&P[hS!^)7CC)7VX5q#PZ C B
#     hX'X5B&P[hS ^)7CC)7VX5p"PZ B A
$     hX'X5B&P[hS ^)7CC)7VX5w"PZ B A
%     hX'X5B&P[hS ^)7CC)7VX5v"PZ B A
&     hX#X5B"P[hS ^)7CC)7VX5u"PZ B A
'     hX#X5B"P[hS ^)7CC)7VX5t"PZ B A
(     hX'X5B&P[hS ^)7CC)7VX5{"PZ B A
)     hi'X5B&P[h!!X%BBHP^$!P_17C!?C17C!?hiBX5@@PZ2@2A
*     hX'X5B&P[hS ^)7CC)7VX5y"PZ B A
+     hX'X5B&P[hS ^)7CC)7VX5x"PZ B A
,     hX'X5B&P[hT ^)7CC)7VX5x"PZ!B!A
-     hX'X5B&P[hS ^)7CC)7VX5~"PZ B A
.     hX'X5B&P[hS ^)7CC)7VX5}"PZ B A
/     hX'X5B&P[hS ^)7CC)7VX5|"PZ B A
0     hX'X5B&P[hS ^)7CC)7VX5c"PZ B A
1     hX'X5B&P[hS ^)7CC)7VX5b"PZ B A
2     hX'X5B&P[hS ^)7CC)7VX5a"PZ B A
3     hX'X5B&P[hS ^)7CC)7VX5`"PZ B A
4     hX'X5B&P[hS ^)7CC)7VX5g"PZ B A
5     h;'X%[AP[h=S^)7CC)7VX%7"PZ _ ^
6     hX'X5B&P[hS ^)7CC)7VX5e"PZ B A
7     hX'X5B&P[hS _)?CC)?WX5d"PZ B A
8     hX'X5B&P[hS ^)7CC)7VX5k"PZ B A
9     hX'X5B&P[hS ^)7CC)7VX5j"PZ B A
:     hX'X5B&P[hS ^)7CC)7VX5i"PZ B A
;     hX'X5B&P[hS ^)7CC)7VX5h"PZ B A
<     hX'X5B&P[hS ^)7CC)7VX5o"PZ B A
=     hX'X5B&P[hS ^)7CC)7VX5n"PZ B A
>     hX'X5B&P[hS ^)7CC)7VX5m"PZ B A
?     hX'X5B&P[hS ^)7CC)7VX5l"PZ B A

@     hX'X5B&P[h` ^)7CC)7VX5 "PZ-B-A
A     hX'X5B&P[h`!^)7CC)7VX5!#PZ-C-B
B     h['X5A&P[h`"^)7CC)7VX5" PZ-D-C
C     hX'X5B&P_h` ^)5GG)5VX5#"PZ-B-A
D     hX'X5B&P[h` ^)7CC)7VX5$"PZ-B-A
E     hX'X5B&P[h` ^)7CC)7VX5%"PZ-B-A
F     hX'X5B&P[h` ^)7CC)7VX5&"PZ-B-A
G     hX'X5B&P[h` ^)7CC)7VX5'"PZ-B-A
H     hX'X5B&P[h` ^)7CC)7VX5("PZ-B-A
I     hX'X5B&P[h` ^)7CC)7VX5)"PZ-B-A
J     hX'X5B&P[h` ^)7CC)7VX5*"PZ-B-A
K     hX'X5B&P[h` ^)7CC)7VX5+"PZ-B-A
L     hX'X5B&P[h` ^)7CC)7VX5,"PZ-B-A
M     hX'X5B&P[h` ^)7CC)7VX5-"PZ-B-A
N     hX'X5B&P[h` ^)7CC)7VX5."PZ-B-A
O     hX'X5B&P[h` ^)7CC)7VX5/"PZ-B-A
P     hj'X5B&`[[[[[[[[h` ^)7CC)7VX50"`ZZZZZZZZ-B-A
Q     hX'X5B&P[h` ^)7CC)7VX51"PZ-B-A
R     hX'X5B&P[h` ^)7CC)7VX52"PZ-B-A
S     hX'X5B&P[h` ^)7CC)7VX53"PZ-B-A
T     hX'X5B&P[h` ^)7CC)7VX54"PZ-B-A
U     hX'X5B&P[h` ^)7CC)7VX55"PZ-B-A
V     hX'X5B&P[h` _)?CC)?WX56"PZ B A
W     hX'X5B&P[h` ^)7CC)7VX57"PZ-B-A
X     _TYhe'WWWQWWWa5B&P[hSS^)7CC)7CC5_C5 @PZ u t
Y     hX'X5B&P[h` ^)7CC)7VX59"PZ-B-A
Z     _WTYhzBX5 @Phe'WPWQWWWa5B&P[hSS^)7CC)7X u t
[     hX'X5B&P_h` ^)5GG)5VX5;"PZ-B-A
\     hX'X5B&P[h` ^)7CC)7VX5<"PZ-B-A
]     hX'X5B&P[h` ^)7CC)7VX5="PZ-B-A
^     hX'X5B&P[h` _)?CC)?WX5>"PZ-B-A
_     hX'X5B&P[h` ^)7CC)7VX5?"PZ-B-A

`     hX'X5B&P[hS ^)7CC)7VX53"PZ B A
a     hX'X5B&P[hS ^)7CC)7VX52"PZ B A
b     hX'X5B&P[hS ^)7CC)7VX51"PZ B A
c     hX'X5B&P[hS ^)7CC)7VX50"PZ B A
d     hX'X5B&P[hS ^)7CC)7VX57"PZ B A
e     hX'X5B&P[hS ^)7CC)7VX56"PZ B A
f     hX'X5B&P[hS ^)7CC)7VX55"PZ B A
g     hX'X5B&P[hS ^)7CC)7VX54"PZ B A
h     _WWX5b'5B&P[WX5S P^)7CC)7VX5;"PZ B A
i     hX'X5B&P[hS ^)7CC)7VX5:"PZ B A
j     hX'X5B&P[hS ^)7CC)7VX59"PZ B A
k     hX'X5B&P[hS ^)7CC)7VX58"PZ B A
l     hX'X5B&P[hS ^)7CC)7VX5?"PZ B A
m     hX'X5B&P[hS ^)7CC)7VX5>"PZ B A
n     hX'X5B&P[hS ^)7CC)7VX5="PZ B A
o     hX'X5B&P[hS ^)7CC)7VX5<"PZ B A
p     hX'X5B&P[hS ^)7CC)7VX5#"PZ B A
q     hX'X5B&P[hS ^)7CC)7VX5""PZ B A
r     hX'X5B&P[hS ^)7CC)7VX5!"PZ B A
s     hX'X5B&P[hS ^)7CC)7VX5 "PZ B A
t     hX'X5B&P[hS ^)7CC)7VX5'"PZ B A
u     hX'X5B&P[hS ^)7CC)7VX5&"PZ B A
v     hX'X5B&P[hS ^)7CC)7VX5%"PZ B A
w     hX'X5B&P[hS ^)7CC)7VX5$"PZ B A
x     hX'X5B&P[hS ^)7CC)7VX5+"PZ B A
y     hX'X5B&P[hS ^)7CC)7VX5*"PZ B A
z     hX'X5B&P[hS ^)7CC)7VX5)"PZ B A
{     hX'X5B&P[hS ^)7CC)7VX5("PZ B A
|     hX'X5B&P[hS ^)7CC)7VX5/"PZ B A
}     hX'X5B&P[hS ^)7CC)7VX5."PZ B A
~     hX'X5B&P[hS ^)7CC)7VX5-"PZ B A
— माइकल एहरनेरिच
स्रोत
11

Brainfuck, 1770 1710 1703 1686 बाइट्स

डेनिस 17 बाइट्स द्वारा बचाए गए 60 बाइट्स
Sp3000 द्वारा बचाए गए

DNP: 46 ( .)

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

43, 45, 60, 62, 91 और 93 को छोड़कर सभी को बेशर्मी से Esolangs.org से चोरी कर लिया जाता है

— betseg
स्रोत
3
@ .α। संभवत: चूंकि यह ज्यादातर कॉपी किया गया था।
— केल्विन के शौक
8
@ हेलकाहोम्बा मेरा मतलब है, बीएफ कॉन्स्टेंट मूल रूप से सबसे छोटे हैं जो मैं जानता हूं। पहले से ही स्थापित स्थिरांक पर इसे स्वयं करने की कोशिश करना व्यर्थ है।
— पागलखाना
3
--[>-<---]>[<->--]<[->-<]>.आउटपुट के लिए काम करता है +।
— डेनिस
3
@ डेनिस बाद में कोसने लगा:-----[[----<]>>-]<.
— Sp3000
2
इसके अलावा+[+[+>]<<++++]>.
— Sp3000
9

MATL, 305, 302, 300 297 बाइट्स

हर एक कार्यक्रम इस तरह दिखता है:

33c
34c
35c
....

के अलावा

  • अंक। यहां 0-9 के कार्यक्रम हैं:

    O
l
H
I
K
4Q
5Q
6Q
7Q
8Q

  • 'सी'। यह कार्यक्रम है

    'C'k

  • अंतरिक्ष। ये है

    0c

    आज के बाद से मैंने सीखा है, कि MATL वर्ण 0 को अंतरिक्ष के रूप में मानता है। धन्यवाद @LuisMendo!

आप उनमें से किसी को सत्यापित करने के लिए matl.tio का उपयोग कर सकते हैं।

संदर्भ के लिए, उनमें से सभी यहां है:

0c
33c
34c
35c
36c
37c
38c
39c
40c
41c
42c
43c
44c
45c
46c
47c
O
l
H
I
K
4Q
5Q
6Q
7Q
8Q
58c
59c
60c
61c
62c
63c
64c
65c
66c
67c
68c
69c
70c
71c
72c
73c
74c
75c
76c
77c
78c
79c
80c
81c
82c
83c
84c
85c
86c
87c
88c
89c
90c
91c
92c
93c
94c
95c
96c
97c
98c
'C'k
100c
101c
102c
103c
104c
105c
106c
107c
108c
109c
110c
111c
112c
113c
114c
115c
116c
117c
118c
119c
120c
121c
122c
123c
124c
125c
126c
— DJMcMayhem
स्रोत
@LuisMendo मैं अभी भी 297 भरोसा कर रहा हूँ
— DJMcMayhem
@LuisMendo मैं भी 297 गिनता हूं।
— लीक नून
क्षमा करें, मेरी गलती
— लुइस मेंडो
9

जावा 8, 6798 6582 6577 बाइट्स

आह

यह मूल रूप से मेरे पायथन 2 उत्तर का एक बंदरगाह है , लेकिन सभी बॉयलरप्लेट के साथ जो जावा में एक पूर्ण कार्यक्रम लिखने के साथ आता है।

अब बिना किसी डीएनपी के! धन्यवाद, केविन क्रूज़सेन!

अधिकांश कार्यक्रमों में फॉर्म interface A{static void main(String[]a){System.out.print("\<octal char code>");}}को छोड़कर, हैं:

  • अंतरिक्ष → interface\tA{static\tvoid\tmain(String[]a){System.out.print("\40");}}(लेकिन \tकच्चे टैब द्वारा प्रतिस्थापित s के साथ )
  • " → interface A{static void main(String[]a){System.out.print('\42');}}
  • ( → interface A{static void main\u0028String[]a){System.out.print\u0028"\50");}}
  • ) → interface A{static void main(String[]a\u0029{System.out.print("\51"\u0029;}}
  • . → interface A{static void main(String[]a){System\u002Eout\u002Eprint("\56");}}
  • 0 → interface A{static void main(String[]a){System.out.print(1-1);}}
  • 1 → interface A{static void main(String[]a){System.out.print(3-2);}}
  • 2 → interface A{static void main(String[]a){System.out.print(3-1);}}
  • 3 → interface A{static void main(String[]a){System.out.print(4-1);}}
  • 4 → interface A{static void main(String[]a){System.out.print(5-1);}}
  • 5 → interface A{static void main(String[]a){System.out.print(6-1);}}
  • 6 → interface A{static void main(String[]a){System.out.print(7-1);}}
  • 7 → interface A{static void main(String[]a){System.out.print(8-1);}}
  • 8 → interface A{static void main(String[]a){System.out.print(9-1);}}
  • 9 → interface A{static void main(String[]a){System.out.print(8+1);}}
  • ; → interface A{static void main(String[]a){System.out.print("\73")\u003B}}
  • A → interface B{static void main(String[]a){System.out.print("\101");}}
  • S → interface A{static void main(\u0053tring[]a){\u0053ystem.out.print("\123");}}
  • [ → interface A{static void main(String...a){System.out.print("\133");}}
  • \ → interface A{static void main(String[]a){System.out.print((char)92);}}
  • ] → interface A{static void main(String...a){System.out.print("\135");}}
  • a → interf\u0061ce A{st\u0061tic void m\u0061in(String[]b){System.out.print("\141");}}
  • c → interfa\u0063e A{stati\u0063 void main(String[]a){System.out.print("\143");}}
  • d → interface A{static voi\u0064 main(String[]a){System.out.print("\144");}}
  • e → class A{public static void main(String[]a){Syst\u0065m.out.print("\145");}}
  • f → class A{public static void main(String[]a){System.out.print("\146");}}
  • g → interface A{static void main(Strin\u0067[]a){System.out.print("\147");}}// \u0067
  • i → \u0069nterface A{stat\u0069c vo\u0069d ma\u0069n(Str\u0069ng[]a){System.out.pr\u0069nt("\151");}}
  • m → interface A{static void \u006Dain(String[]a){Syste\u006D.out.print("\155");}}
  • n → class A{public static void mai\u006E(Stri\u006Eg[]a){System.out.pri\u006Et("\156");}}
  • o → interface A{static v\u006Fid main(String[]a){System.\u006Fut.print("\157");}}
  • p → interface A{static void main(String[]a){System.out.\u0070rint("\160");}}
  • r → class A{public static void main(St\u0072ing[]a){System.out.p\u0072int("\162");}}
  • s → interface A{\u0073tatic void main(String[]a){Sy\u0073tem.out.print("\163");}}
  • t → class A{public s\u0074a\u0074ic void main(S\u0074ring[]a){Sys\u0074em.ou\u0074.prin\u0074("\164");}}
  • u → interface A{static void main(String[]a){System.console().printf("%c",117);}}
  • v → interface A{static \u0076oid main(String[]a){System.out.print("\166");}}
  • y → interface A{static void main(String[]a){S\u0079stem.out.print("\171");}}
  • { → interface A\u007Bstatic void main(String[]a)\u007BSystem.out.print("\173");}}
  • } → interface A{static void main(String[]a){System.out.print("\175");\u007D\u007D

ओह

जावा संकलक यूनिकोड \u007Bकिसी भी अन्य प्रसंस्करण को करने से पहले की तरह बच जाता है , जिससे कोड लिखना संभव हो जाता है जो यूनिकोड से बचने के लिए पहचानकर्ता और यहां तक ​​कि कीवर्ड का उपयोग करता है। इसलिए, बॉयलरप्लेट में मौजूद चरित्र का उपयोग नहीं करने वाले प्रोग्राम को लिखने के लिए, हम बस इसे यूनिकोड से बचते हैं।

संदर्भ और परीक्षण में आसानी के लिए, कार्यक्रमों की पूरी सूची, नई-अलग-अलग और चार स्थानों द्वारा प्रतिस्थापित कच्चे टैब के साथ:

interface    A{static    void    main(String[]a){System.out.print("\40");}}
interface A{static void main(String[]a){System.out.print("\41");}}
interface A{static void main(String[]a){System.out.print('\42');}}
interface A{static void main(String[]a){System.out.print("\43");}}
interface A{static void main(String[]a){System.out.print("\44");}}
interface A{static void main(String[]a){System.out.print("\45");}}
interface A{static void main(String[]a){System.out.print("\46");}}
interface A{static void main(String[]a){System.out.print("\47");}}
interface A{static void main\u0028String[]a){System.out.print\u0028"\50");}}
interface A{static void main(String[]a\u0029{System.out.print("\51"\u0029;}}
interface A{static void main(String[]a){System.out.print("\52");}}
interface A{static void main(String[]a){System.out.print("\53");}}
interface A{static void main(String[]a){System.out.print("\54");}}
interface A{static void main(String[]a){System.out.print("\55");}}
interface A{static void main(String[]a){System\u002Eout\u002Eprint("\56");}}
interface A{static void main(String[]a){System.out.print("\57");}}
interface A{static void main(String[]a){System.out.print(1-1);}}
interface A{static void main(String[]a){System.out.print(3-2);}}
interface A{static void main(String[]a){System.out.print(3-1);}}
interface A{static void main(String[]a){System.out.print(4-1);}}
interface A{static void main(String[]a){System.out.print(5-1);}}
interface A{static void main(String[]a){System.out.print(6-1);}}
interface A{static void main(String[]a){System.out.print(7-1);}}
interface A{static void main(String[]a){System.out.print(8-1);}}
interface A{static void main(String[]a){System.out.print(9-1);}}
interface A{static void main(String[]a){System.out.print(8+1);}}
interface A{static void main(String[]a){System.out.print("\72");}}
interface A{static void main(String[]a){System.out.print("\73")\u003B}}
interface A{static void main(String[]a){System.out.print("\74");}}
interface A{static void main(String[]a){System.out.print("\75");}}
interface A{static void main(String[]a){System.out.print("\76");}}
interface A{static void main(String[]a){System.out.print("\77");}}
interface A{static void main(String[]a){System.out.print("\100");}}
interface B{static void main(String[]a){System.out.print("\101");}}
interface A{static void main(String[]a){System.out.print("\102");}}
interface A{static void main(String[]a){System.out.print("\103");}}
interface A{static void main(String[]a){System.out.print("\104");}}
interface A{static void main(String[]a){System.out.print("\105");}}
interface A{static void main(String[]a){System.out.print("\106");}}
interface A{static void main(String[]a){System.out.print("\107");}}
interface A{static void main(String[]a){System.out.print("\110");}}
interface A{static void main(String[]a){System.out.print("\111");}}
interface A{static void main(String[]a){System.out.print("\112");}}
interface A{static void main(String[]a){System.out.print("\113");}}
interface A{static void main(String[]a){System.out.print("\114");}}
interface A{static void main(String[]a){System.out.print("\115");}}
interface A{static void main(String[]a){System.out.print("\116");}}
interface A{static void main(String[]a){System.out.print("\117");}}
interface A{static void main(String[]a){System.out.print("\120");}}
interface A{static void main(String[]a){System.out.print("\121");}}
interface A{static void main(String[]a){System.out.print("\122");}}
interface A{static void main(\u0053tring[]a){\u0053ystem.out.print("\123");}}
interface A{static void main(String[]a){System.out.print("\124");}}
interface A{static void main(String[]a){System.out.print("\125");}}
interface A{static void main(String[]a){System.out.print("\126");}}
interface A{static void main(String[]a){System.out.print("\127");}}
interface A{static void main(String[]a){System.out.print("\130");}}
interface A{static void main(String[]a){System.out.print("\131");}}
interface A{static void main(String[]a){System.out.print("\132");}}
interface A{static void main(String...a){System.out.print("\133");}}
interface A{static void main(String[]a){System.out.print((char)92);}}
interface A{static void main(String...a){System.out.print("\135");}}
interface A{static void main(String[]a){System.out.print("\136");}}
interface A{static void main(String[]a){System.out.print("\137");}}
interface A{static void main(String[]a){System.out.print("\140");}}
interf\u0061ce A{st\u0061tic void m\u0061in(String[]b){System.out.print("\141");}}
interface A{static void main(String[]a){System.out.print("\142");}}
interfa\u0063e A{stati\u0063 void main(String[]a){System.out.print("\143");}}
interface A{static voi\u0064 main(String[]a){System.out.print("\144");}}
class A{public static void main(String[]a){Syst\u0065m.out.print("\145");}}
class A{public static void main(String[]a){System.out.print("\146");}}
interface A{static void main(Strin\u0067[]a){System.out.print("\147");}}
interface A{static void main(String[]a){System.out.print("\150");}}
\u0069nterface A{stat\u0069c vo\u0069d ma\u0069n(Str\u0069ng[]a){System.out.pr\u0069nt("\151");}}
interface A{static void main(String[]a){System.out.print("\152");}}
interface A{static void main(String[]a){System.out.print("\153");}}
interface A{static void main(String[]a){System.out.print("\154");}}
interface A{static void \u006Dain(String[]a){Syste\u006D.out.print("\155");}}
class A{public static void mai\u006E(Stri\u006Eg[]a){System.out.print("\156");}}
interface A{static v\u006Fid main(String[]a){System.\u006Fut.print("\157");}}
interface A{static void main(String[]a){System.out.\u0070rint("\160");}}
interface A{static void main(String[]a){System.out.print("\161");}}
class A{public static void main(St\u0072ing[]a){System.out.p\u0072int("\162");}}
interface A{\u0073tatic void main(String[]a){Sy\u0073tem.out.print("\163");}}
class A{public s\u0074a\u0074ic void main(S\u0074ring[]a){Sys\u0074em.ou\u0074.prin\u0074("\164");}}
interface A{static void main(String[]a){System.console().printf("%c",117);}}
interface A{static \u0076oid main(String[]a){System.out.print("\166");}}
interface A{static void main(String[]a){System.out.print("\167");}}
interface A{static void main(String[]a){System.out.print("\170");}}
interface A{static void main(String[]a){S\u0079stem.out.print("\171");}}
interface A{static void main(String[]a){System.out.print("\172");}}
interface A\u007Bstatic void main(String[]a)\u007BSystem.out.print("\173");}}
interface A{static void main(String[]a){System.out.print("\174");}}
interface A{static void main(String[]a){System.out.print("\175");\u007D\u007D
interface A{static void main(String[]a){System.out.print("\176");}}

ध्यान दें कि प्रोग्राम का uउपयोग करने के लिए System.console(), जो अशक्त हो जाएगा (और इस प्रकार कोड को फेंकने का कारण बनता है NullPointerException) यदि आप इसे अपने ओएस के मूल टर्मिनल ( cmdविंडोज पर, और, मुझे लगता है, bashलिनक्स / ओएसएक्स पर) के अलावा किसी और चीज से कहते हैं। ।

परीक्षण करने के लिए, एक नई निर्देशिका बनाएं और printablesउस निर्देशिका में नामित फ़ाइल में उपरोक्त कोड डालें । फिर, निम्नलिखित बैश स्क्रिप्ट चलाएँ:

#!/bin/bash
split -l 1 printables
for i in x*; do
  mkdir z$i
  mv $i z$i/A.java
done
mv zxbh/A.java zxbh/B.java
for i in zx*; do
  javac $i/[AB].java
  if ! java -cp $i A 2> /dev/null; then
    java -cp $i B
  fi
done
rm -r zx*

उपरोक्त स्क्रिप्ट प्रत्येक printablesनिर्देशिका को अपनी स्वयं की निर्देशिका में रखेगी, उन सभी A.javaको नाम देगा (उस फ़ाइल को छोड़कर जो प्रिंट करता है A, जिसे नाम दिया गया है B.java), प्रत्येक फ़ाइल को संकलित करें, उन्हें चलाएं, फिर सबूत हटाएं। मुद्रण योग्य ASCII वर्णों को आपके शेल में प्रदर्शित होने में लगभग दस सेकंड लगने चाहिए।

यदि आप Windows पर हैं, तो इसके बजाय निम्न बैच फ़ाइल चलाएँ:

@echo off
setlocal enabledelayedexpansion
set i=0
for /F "tokens=*" %%L in (printables) do (
  set file=A.java
  if "%i%" == "33" (set file=B.java)
  echo %%L>"%file%"
  javac "%file%"
  java -cp . A
  if not errorlevel 0 (java -cp . B)
  set /A i=%i% + 1
)
del *.java
del *.class

यह बैच फ़ाइल थोड़ा अलग दृष्टिकोण लेती है; लाइनों को पूर्व-विभाजित करने के बजाय, यह फ़ाइल लाइन-बाय-लाइन को संसाधित करता है और प्रत्येक प्रोग्राम को बदले में संकलित करता है। फिर, यह खत्म होने के बाद सबूत मिटा देता है।

केविन क्रूज़सेन के लिए अनगिनत बाइट्स + 1 डीएनपी धन्यवाद!

— तांबा
स्रोत
2
मैं class Bमुद्रण के लिए यादृच्छिक प्यार करता हूँA
— Tas
आपने मुझे इसमें हरा दिया। कल दिन के अंत में मैं यूनिकोड से बचकर जावा के लिए एक उत्तर लिख रहा था। साथ ही आह, +1, अच्छी तरह से लिखित उत्तर और केवल 1 डीएनपी उतना बुरा नहीं है जितना मैंने जावा के लिए पहले से सोचा था। ;)
— केविन क्रूज़सेन
2
Btw, यू के लिए DNP को हटाने की संभावना है यदि आप जावा 8+ का उपयोग करते हैं ( interfaceवर्ग के बजाय ताकि आप निकाल सकें public) और यदि आपके ओएस में कंसोल बनाया गया है, तो आपको उपयोग करने की आवश्यकता नहीं है System.out.print: interface A{static void main(String[]a){System.console().printf("%1",(char)117);}}ग्रहण, IntelliJ और ऑनलाइन संकलक के पास यह कंसोल नहीं है, हालांकि परिणामस्वरूप NullPointerException।
— केविन क्रूज़सेन
@ केविनक्रूजसेन धन्यवाद! मैं अब इस पर काम कर रहा हूं।
— कॉपर
n: बचना भूल गएprint
— हथियार
7

> <> , 443 437 बाइट्स

TIO दुभाषिया लिंक । यहाँ बहुत सारे पैटर्न हैं:

  • [num][num]*o;: दो संख्याओं का गुणन, फिर परिणाम को चार के साथ oऔर एक पड़ाव के रूप में परिणामित करें ;। > <> अंक 15 तक जाते हैं, अर्थात 0123456789abcdef।
    • इसी तरह [num][num]-n;, जो दो संख्याओं के अंतर को लेता है और nइसके बजाय एक संख्या के रूप में आउटपुट देता है ।

  • '-o[invalid char]: > <> टॉरॉयडल है, इसलिए जब निर्देश पॉइंटर एक पंक्ति के अंत तक पहुंचता है तो यह शुरुआत में वापस चला जाता है। इस स्थिति में, यह कोड को दो बार निष्पादित करने का कारण बनता है, अर्थात '-o[char]'-o[char]। पहला '-o[char]'भाग स्टैक में तीन वर्णों को धकेलता है, -गणना करता है और 'o' - [char]फिर oपरिणाम को एक वर्ण के रूप में उत्पन्न करता है। > <> तब त्रुटि तब होती है जब वह पहुंच जाता है [char], या तो किसी अपरिचित आदेश के कारण या खाली स्टैक को पॉप करने से।

    • इसी तरह '-n[invalid char], जो एक संख्या के रूप में आउटपुट करता है।
    • इसी तरह '[num][op]o[invalid char], लागू होता है [op]के साथ [num]पर [char], चार पर बाहर erroring। उदाहरण के लिए, '2+oJआउटपुट L, जो दो से अधिक है J।
    • 'इसके बजाय कोड का "-oHउपयोग कर रहा है "।
    • -इसके बजाय कोड का '%oBउपयोग कर रहा है %।

  • ln;: स्टैक की लंबाई पुश, आउटपुट के रूप में फिर संख्या को रोकने, देना 0। इसी lln;के लिए 1और 'ln;के लिए 3।

  • 4|n+: पुश 4, बंद उछाल |और एक और 4 धक्का, जोड़ने, फिर 8संख्या के रूप में उत्पादन । |फिर से उछाल , और त्रुटि nएक खाली स्टैक पर फिर से निष्पादित करने की कोशिश कर रहा है ।
    • इसी तरह के 3|n*लिए 9।
    • इसी तरह के [num]|o*लिए @Qdy।
  • '1-:00p:o मामले के लिए सबसे दिलचस्प एक ,। oहमारे कोड का उपयोग करने से बचने के लिए, हमें कोडबॉक्स में pजगह बनाने के लिए उपयोग करने की आवश्यकता है o, फिर इसे चलाएं। प्रारंभिक '1-:00p'सेट स्टैक pको शीर्ष पर 1-रखता है , और इसे एक में घटाता है o। :इसे डुप्लिकेट करता है o, और कोडबॉक्स में बदलकर (0, 0) पर 00pएक रखता है । निर्देश सूचक फिर से लपेटता है, दूसरे को आउटपुट करता है । (0, 0) चार को तब प्रोग्राम के अंत में त्रुटियों के समाप्त होने से पहले कुछ और बार बदल दिया जाता है।oo1-:00po

      '-oO
!     '-oN
"     '-oM
#     '-oL
$     '-oK
%     '-oJ
&     '-oI
'     "-oH
(     '-oG
)     '-oF
*     '-oE
+     '-oD
,     '-oC
-     '%oB
.     '-oA
/     '-o@
0     ln;
1     lln;
2     '-o=
3     'ln;
4     '-o;
5     61-n;
6     '-nh
7     '-ng
8     4|n+
9     3|n*
:     '1-o;
;     '6-oA
<     6a*o;
=     '2+o;
>     '3+o;
?     79*o;
@     8|o*
A     '-o.
B     '-o-
C     '-o,
D     '-o+
E     '-o*
F     '-o)
G     '-o(
H     89*o;
I     '1-oJ
J     '-o%
K     '-o$
L     '2+oJ
M     7b*o;
N     '-o!
O     '5+oJ
P     8a*o;
Q     9|o*
R     '8+oJ
S     '9+oJ
T     7c*o;
U     'b+oJ
V     'c+oJ
W     'd+oJ
X     8b*o;
Y     'f+oJ
Z     9a*o;
[     7d*o;
\     'c-oh
]     'b-oh
^     'a-oh
_     '9-oh
`     8c*o;
a     '7-oh
b     7e*o;
c     9b*o;
d     a|o*
e     '3-oh
f     '2-oh
g     '1-oh
h     '2-oj
i     8d*o;
j     '2+oh
k     '3+oh
l     9c*o;
m     '5+oh
n     ab*o;
o     '1-:00p
p     8e*o;
q     '3-ot
r     '2-ot
s     '1-ot
t     '1+os
u     9d*o;
v     '2+ot
w     '3+ot
x     ac*o;
y     b|o*
z     '6+ot
{     '7+ot
|     '8+ot
}     '9+ot
~     9e*o;
— Sp3000
स्रोत
7

डायलाग एपीएल , 527 522 बाइट्स

(गैर-प्रतिस्पर्धात्मक क्योंकि APL वास्तव में केवल ASCII का उपयोग करके नहीं लिखा जा सकता है)

अधिकांश प्रारूप nn⊃⎕AVया nnn⊃⎕AVअपवाद हैं:

⊃''     ⍝ space: extract one char from an empty string
⎕THIS   ⍝ hash: this namespace
⊃1↓⍕÷2  ⍝ period: the first char after stripping one char from 1÷2, i.e. 0.5
⊃⍬      ⍝ zero: extract one number from an empty numeric list
≢#      ⍝ one: tally the root namespace
⍴⍬⍬     ⍝ two: count two empty lists
⎕WX     ⍝ three: default "Window Expose" setting
×⍨2     ⍝ four: 2×2
6-1     ⍝ five: 6-1
!3      ⍝ six: 3!
6+1     ⍝ seven: 6+1
2*3     ⍝ eight: 2³
3*2     ⍝ nine: 3²
⊃⎕a     ⍝ A: first character (Dyalog system names are case insensitive)
2⊃⎕A    ⍝
⋮        ⍝  B-Y: n'th character
25⊃⎕A   ⍝
⊃⌽⎕A    ⍝ Z: last character

यहाँ पूरी सूची है:

⊃''
205⊃⎕AV
216⊃⎕AV
⎕THIS
62⊃⎕AV
13⊃⎕AV
219⊃⎕AV
14⊃⎕AV
186⊃⎕AV
249⊃⎕AV
181⊃⎕AV
170⊃⎕AV
195⊃⎕AV
169⊃⎕AV
⊃1↓⍕÷2
157⊃⎕AV
⊃⍬
≢#
⍴⍬ ⍬
⎕WX
×⍨2
6-1
!3
6+1
2*3
3*2
241⊃⎕AV
194⊃⎕AV
161⊃⎕AV
163⊃⎕AV
165⊃⎕AV
173⊃⎕AV
232⊃⎕AV
⊃⎕a
2⊃⎕A
3⊃⎕A
4⊃⎕A
5⊃⎕A
6⊃⎕A
7⊃⎕A
8⊃⎕A
9⊃⎕A
10⊃⎕A
11⊃⎕A
12⊃⎕A
13⊃⎕A
14⊃⎕A
15⊃⎕A
16⊃⎕A
17⊃⎕A
18⊃⎕A
19⊃⎕A
20⊃⎕A
21⊃⎕A
22⊃⎕A
23⊃⎕A
24⊃⎕A
25⊃⎕A
26⊃⎕A
156⊃⎕AV
159⊃⎕AV
250⊃⎕AV
236⊃⎕AV
17⊃⎕AV
238⊃⎕AV
18⊃⎕AV
19⊃⎕AV
20⊃⎕AV
21⊃⎕AV
22⊃⎕AV
23⊃⎕AV
24⊃⎕AV
25⊃⎕AV
26⊃⎕AV
27⊃⎕AV
28⊃⎕AV
29⊃⎕AV
30⊃⎕AV
31⊃⎕AV
32⊃⎕AV
33⊃⎕AV
34⊃⎕AV
35⊃⎕AV
36⊃⎕AV
37⊃⎕AV
38⊃⎕AV
39⊃⎕AV
40⊃⎕AV
41⊃⎕AV
42⊃⎕AV
43⊃⎕AV
124⊃⎕AV
193⊃⎕AV
126⊃⎕AV
176⊃⎕AV
— एडम
स्रोत
1
यह प्रारूप अन्य उत्तरों के प्रारूप की तुलना में कम उपयोगी है, मेरी राय में
— लीकी नून
@LeakyNun क्या आप उन्हें विधि द्वारा समूहित करना चाहते हैं? काफी कुछ अपवाद हैं।
— 13
2
ये सभी मुद्रण योग्य ASCII नहीं हैं इसलिए तकनीकी रूप से अमान्य हैं। लेकिन मैं एक नोट जोड़ने जा रहा हूं कि गैर-मुद्रण योग्य ASCII को गैर-प्रतिस्पर्धी सबमिशन के लिए अनुमति दी जाती है।
— केल्विन के शौक
@ हेलकाबोम्बा उफ़, मैंने उस आवश्यकता पर ध्यान नहीं दिया।
— 14
⍨मेरी नई पसंदीदा स्माइली है
— Lucas Trzesniewski
6

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

63 अक्षरों के @माध्यम से ~, हमारे पास 10-बाइट समाधान है:

$><<"\xxx"     (3 digit octal code)
$><<92.chr     (special case for \)

सबसे (21) से पात्रों के लिए spaceके माध्यम से ?, हम एक 9-बाइट समाधान है:

puts"\xx"     (2 digit octal code)

ग्यारह विशेष मामले बचे हैं:

$><<34.chr    (10 bytes for ")
p$.           (3 bytes for 0)
p~-2          \
p~-3           \ (4 bytes for 1-8)
...            /
p~-9          /
p 1+8         (5 bytes for 9)

कुल में, स्कोर 10 × 63 + 9 × 21 + 10 + 3 + 8 × 4 + 5 = 869 है।

— लिन
स्रोत
अष्ट भाग के लिए आप 1 बाइट प्रत्येक के ?\xxxबजाय उपयोग कर सकते हैं "\xxx"।
— जॉर्डन
क्यों p 1+8और क्या नहीं p-~8?
— साइओस
@ कोको रूबी की व्याख्या करता है कि बाइनरी -, या कुछ के रूप में। :(
— लिन
@ जोर्डन नोटेड, लेकिन मैं आलसी हूं ... संपादित करने के लिए स्वतंत्र महसूस करता हूं / n_n
— लिन
2
आप इनमें से अधिकांश को putc 65=>A
— histocrat
5

वोल्फ्रामअल्फा , 368 बाइट्स

सामान्य प्रारूप:

u+<character code in hexadecimal>

अपवाद:

Character   Code
+           plus
0           1-1
1           0!
2           1+1
3           1+2
4           2+2
5           2+3
6           3!
7           3+4
8           4+4
9           4+5
u           U+75

यहाँ पूरी सूची है:

u+20
u+21
u+22
u+23
u+24
u+25
u+26
u+27
u+28
u+29
u+2A
plus
u+2C
u+2D
u+2E
u+2F
1-1
0!
1+1
1+2
2+2
2+3
3!
3+4
4+4
4+5
u+3A
u+3B
u+3C
u+3D
u+3E
u+3F
u+40
u+41
u+42
u+43
u+44
u+45
u+46
u+47
u+48
u+49
u+4A
u+4B
u+4C
u+4D
u+4E
u+4F
u+50
u+51
u+52
u+53
u+54
u+55
u+56
u+57
u+58
u+59
u+5A
u+5B
u+5C
u+5D
u+5E
u+5F
u+60
u+61
u+62
u+63
u+64
u+65
u+66
u+67
u+68
u+69
u+6A
u+6B
u+6C
u+6D
u+6E
u+6F
u+70
u+71
u+72
u+73
u+74
U+75
u+76
u+77
u+78
u+79
u+7A
u+7B
u+7C
u+7D
u+7E
— अनास्तासिया-रोमानोवा ova
स्रोत
5

PHP ( 891 680 674 बाइट्स, 2 0 डीएनपी)

संपादित करें: jimmy23013 की बदौलत 203 बाइट बचाईं और 2 डीएनपी को मेगो को धन्यवाद दिया

यह उत्तर PHP की उदार प्रकृति का भारी दुरुपयोग करता है। अधिकांश मामले इनमें से एक रूप लेते हैं (प्रत्येक 7 बाइट्स):

<?=Y^x;
<?=Z&e;
<?=V|Z;

पीएचपी तार करने के लिए ऑपरेटर के दोनों तरफ पत्र धर्मान्तरित, तो इसकी ASCII वर्ण मूल्य के लिए प्रत्येक स्ट्रिंग में कनवर्ट करके उचित बिटवाइज़ कार्रवाई निष्पादित करता है, और अंत में परिणाम धर्मान्तरित वापस एक चरित्र के लिए।

ऊपर के पहले उदाहरण में, Y^xबन जाता है 89^78। इसका परिणाम है 33, जो तब चरित्र के रूप में STDOUT को भेजा जाता है !।

सभी संभावित संयोजनों को पाटने के लिए एक पटकथा लिखी गई थी: परिणाम यहां देखे जा सकते हैं ।

अपवाद:

;है <?=Z^a?>(8 बाइट्स)
|है <?='9'^E;(9 बाइट्स)

<और ?सामान्य रूप से आवश्यक टैग के कारण DNP होगा, लेकिन -rध्वज का उपयोग करके , कोड को उनके बिना निष्पादित किया जा सकता है:

<है echo Z^f;(9 बाइट्स)
?है echo Z^e;(9 बाइट्स)
=है echo Z^g;(9 बाइट्स)

स्कोर:

((* ९ ०) + 9 + ९ + ९ + ९ + ९ = ६ 90४ बाइट्स

— Clamburger
स्रोत
@ jimmy23013 वूप्स, मैंने प्रलेखन को गलत बताया।
— मेगो
आप & | ^सभी मुद्रण योग्य ascii वर्णों को छोड़कर दो अक्षरों के बीच उपयोग कर सकते हैं <?=|;।
— jimmy23013
@ jimmy23013 यह बोनस है। बस जब मैंने सोचा कि मैं PHP के सभी quirks सीखा हूँ!
— क्लैम्बर्गर
1
मानक प्रपत्र समाधानों में से कई को ~XOR, और या OR के बजाय बाइनरी नॉट के साथ बाइट को बचाने के लिए अनुकूलित किया जा सकता है । PHP केवल अक्षरों की तुलना में अधिक मुद्रण योग्य वर्णों को स्थिरांक के रूप में उपयोग कर सकती है।
— फेबियन शेंगलर
1
@fschmengler दुर्भाग्य से, जहाँ तक मैं देख सकता हूँ, कि विस्तारित ASCII (या तेजी से विदेशी यूनिकोड वर्ण) के उपयोग की आवश्यकता होगी, जो मुझे विश्वास है कि इस चुनौती के लिए मान्य नहीं है।
— क्लेम्बर्गर
4

ब्रेकीलॉग , 546 477 बाइट्स

कोड के लिए घातक परिणाम का श्रेय @।

नीचे दी गई सूची में, पहला चरित्र मुद्रित करने के लिए चरित्र है (आसान संदर्भ के लिए)।

  @S
! @Ht
"@P: 2 मी
# @P: 3 मी
$ @P: 4 मी
% @P: 5 मी
& @P: 6 मी
'@ पी: 7 मी
(@P: 8 मीटर
) @ पी: 9 मी
* @ पी: 10 मी
+ @P: 11 मी
, @ एच: 5 मी
- @P: 13 मी
। @P: 14 एम
/ @ पी: 15 मी
0 1-
1 0+
2 1+
3 2+
4 3+
५ ४+
६ ५+
६+
++
९ 9+
: @ पी @ 4bbbbh
; @P: 27m
<@P: 28 मी
= @P: 29 मी
> @P: 30 मी
? @P: 31m
@ "?": "A" ybh
अ @ ज़त @ उ
ब @ च @ उ
C @P: 35 मी
डी @ पी: 36 मी
ई @ पी: 37 मी
एफ @ पी: 38 मी
जी @ पी: 39 मी
एच @ पी: 40 मी
I @P: 41 मी
जे @ पी: 42 मी
के @ पी: 43 मी
एल @ पी: 44 मी
एम @ पी: 45 मी
एन @ पी: 46 मी
ओ @ पी: 47 मी
पी @ ए: 15 मीटर @ यू
क्यू @P: 49 मी
आर @ पी: 50 मी
एस @ पी: 51 मी
टी @ पी: 52 मी
यू @ वीटी @ यू
वी @ पी: 54 मी
डब्ल्यू @ क्यूटी @ यू
X @P: 56 मी
Y @ Wt @ u
Z @ एट @ यू
[@P: ५ ९ मी
\ @P: 60 मी
] @P: 61 मी
^ @ पी: 62 मी
_ @P: 63 मी
`@ पी: 64 मी
एक @ वीएच
b @ च
c @ डभ
d @ ए: 3 मी
e @ वीभ
एफ @ ए: ५ मी
जी @ ए: ६ एम
एच @ ए: @ एम
i @ ए: 8 मी
j @A: 9 मी
k @C: 7 मी
l @ सी: 8 मी
m @ D @ 2ht
n @ ए: १३ मी
ओ @ ह: ४ मी
पी @ ए: १५ मी
q @Z: 9 मी
r @Z: 8 मी
s @Z: 7 मी
t @Z: 6 मी
आप @Vt
v @Z: 4 मी
w @ क्यूटी
x @Z: 2 मी
य @ त
z @At
{@P: 91 मी
| @P: 92m
} @Prbh
~ @Pt

वे सभी विधेय हैं, इसलिए Zआउटपुट प्राप्त करने के लिए तर्क की आवश्यकता है: इसे ऑनलाइन आज़माएं!

व्याख्या

@P क्या यह स्ट्रिंग है:

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

जिसमें प्रत्येक मुद्रण योग्य ASCII शामिल है।

— लीक नन
स्रोत
— घातक
@Fatalize धन्यवाद, अपडेट किया गया।
— लीक नून
4

> <> , 531 बाइट्स

कार्यक्रम दो मुख्य रूप लेते हैं:

##*o;
"chr-1"1+o;

पहला 16 से कम दोनों कारकों वाले चरित्र कोड वाले पात्रों के लिए है, दूसरा अन्य मामलों के लिए है। अधिकांश संख्याएं जिनके लिए मैं दूसरे रूप का उपयोग करता हूं उनके पास कई समान लंबाई के समाधान हैं, लेकिन मैंने पठनीयता के लिए उस एक को चुना।

अपवाद:

" b3*1+o; Would be "!"1+o; normally
0 11-n; n outputs as a number
1 22/n;
2-9 #1+n;
; ":"1+o* Ends in an error

पूरी सूची:

! b3*o;
" b3*1+o;
# 57*o;
$ 66*o;
% "$"1+o;
& "%"1+o;
' d3*o;
( a4*o;
) "("1+o;
* ")"1+o;
+ ","1-o;
, b4*o;
- 95*o;
. "-"1+o;
/ "."1+o;
0 11-n;
1 22/n;
2 11+n;
3 21+n;
4 31+n;
5 41+n;
6 51+n;
7 61+n;
8 71+n;
9 81+n;
: "9"1+o;
; ":"1+o*
< a6*o;
= "<"1+o;
> "="1+o;
? 97*o;
@ 88*o;
A d5*o;
B b6*o;
C "B"1+o;
D "C"1+o;
E "D"1+o;
F a7*o;
G "F"1+o;
H 98*o;
I "H"1+o;
J "D"1+o;
K e5*o;
L "K"1+o;
M b7*o;
N d6*o;
O "D"1+o;
P a8*o;
Q 99*o;
R "Q"1+o;
S "R"1+o;
T c7*o;
U "T"1+o;
V "U"1+o;
W "V"1+o;
X b8*o;
Y "X"1+o;
Z a9*o;
[ c7*o;
\ "["1+o;
] "\"1+o;
^ "]"1+o;
_ "^"1+o;
` c8*o;
a "`"1+o;
b e7*o;
c b9*o;
d aa*o;
e "d"1+o;
f "e"1+o;
g "g"1+o;
h d8*o;
i e7*o;
j "i"1+o;
k "j"1+o;
l c9*o;
m "l"1+o;
n ba*o;
o DNP
p e8*o;
q "p"1+o;
r "q"1+o;
s "r"1+o;
t "s"1+o;
u c9*o;
v "u"1+o;
w "v"1+o;
x ca*o;
y bb*o;
z "y"1+o;
~ e9*o;
— DanTheMan
स्रोत
आपका ;का उपयोग करता है ;। इसके अलावा, मुझे पूरा यकीन है कि इनमें से अधिकांश को गलत तरीके से समझा जा सकता है, और oनिश्चित रूप से संभव है।
— Sp3000
@ Sp3000 जब तक एक दुभाषिया नहीं है जो दोनों को स्वीकार करता है oऔर O, मैं नहीं देखता कि कैसे oसंभव है। और एक त्रुटि में समाप्त कैसे कम होगा?
— 18
oका उपयोग करके किया जा सकता है p। मैं अलग से पोस्ट करने के लिए अलग कर सकता हूं, हालांकि, शायद इसमें बहुत सारे पैटर्न शामिल होंगे।
— 183 बजे Sp3000
@ Sp3000 मैंने ;हालांकि कार्यक्रम तय किया । यह बात बताने के लिए धन्यवाद!
— 18-30 को DanTheMan
4

हेक्सागोनी , 376 373 बाइट्स, 1 डीएनपी

3 बाइट बचाने के लिए FryAmTheEggman को धन्यवाद।

लगभग सभी कार्यक्रमों का एक ही रूप है:

  P0;@
! P1;@
" P2;@
...
| Y2;@
} Y3;@
~ Y4;@

हालांकि कुछ अपवाद हैं:

  • ;उपयोग किए बिना प्रिंट करना असंभव है ;, इसलिए 1 डीएनपी।
  • प्रिंट करने के लिए @, हम @प्रोग्राम को समाप्त करने के लिए उपयोग नहीं कर सकते । इसके बजाय हम S2;:या तो उपयोग करते हैं या S3;%। यह विभाजन-दर-शून्य त्रुटि के साथ समाप्त होता है, लेकिन वह त्रुटि STDOUT पर दिखाई नहीं देती है। तो यह अभी भी चार बाइट्स है।
  • एक झड़प है Uजिसके लिए आवश्यकता होगी U3;@। इसे ठीक करने के कई तरीके हैं, जिनमें लो-केस में स्विच करना, यानी n9;@वेतन वृद्धि या वेतन वृद्धि का उपयोग करना शामिल है, T);@या V(;@। किसी भी मामले में यह अभी भी चार बाइट्स है।
  • मेमोरी किनारों को initialised कर रहे हैं 0, और !एक पूर्णांक मूल्य प्रिंट, इसलिए हम प्राप्त कर सकते हैं 0और 1साथ !@और )!@क्रमश: 3 बाइट्स बचत।

<letter><digit>;@प्रोग्राम कैसे काम करते हैं: फॉर्म के एक प्रोग्राम का हेक्सागोनल लेआउट 1234हमेशा होता है

 1 2
3 4 .
 . .

चूंकि किसी भी प्रोग्राम में कोई कमांड नहीं है जो नियंत्रण को पुनर्निर्देशित करता है, ये केवल रैखिक प्रोग्राम हैं जिन्हें क्रम में निष्पादित किया जाता है।

हर मामले में, कोड की शुरुआत में अक्षर वर्तमान मेमोरी एज को उसके वर्ण कोड में सेट करता है। कार्यक्रम में P1;@, Pमान सेट करता है 80। फिर अंक इस मूल्य को 10 से गुणा करता है और खुद जोड़ता है (यानी अंक को वर्तमान मूल्य से जोड़ा जाता है)। जो 801ऊपर दिए गए उदाहरण में दिया गया है। अंत में, ;इस मूल्य को 256 modul करके और इसे बाइट मान के रूप में उपयोग करके प्रिंट करता है। इस मामले में 801 % 256 = 33और !मुद्रित किया जाता है।

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

व्हॉट्सएप , 1643 बाइट्स, 1 डीएनपी

पात्रों के लिए 17 बाइट्स [33-63] और पात्रों के लिए 18 बाइट्स [64-126]

व्हॉट्सएप में यह सीधे आगे है, क्योंकि प्रिंट करने योग्य वर्ण (अंतरिक्ष को छोड़कर) का वैसे भी कोई अर्थ नहीं है:

[SPACE][SPACE][SPACE][TAB][SPACE][SPACE][SPACE][SPACE][TAB][LF]
[TAB][LF]
[SPACE][SPACE][LF]
[LF]
[LF]

प्रिंट से ऊपर कार्यक्रम एक '!' (100001b)। [TAB][SPACE][SPACE][SPACE][SPACE][TAB]आपको जो भी चरित्र पसंद हो, उसे पहली पंक्ति में बदलें । अंतरिक्ष का उपयोग किए बिना किसी स्थान को प्रिंट करना संभव नहीं है, क्योंकि किसी भी चीज़ की छपाई हमेशा से शुरू होती है[TAB][LF][SPACE]

— रॉल्फ
स्रोत
2
अंतरिक्ष एक मुद्रण योग्य ASCII वर्ण है ("प्रिंट करने योग्य ASCII" 0x20 से 0x7E, समावेशी तक की सीमा को संदर्भित करता है), इसलिए आपको इसे 1 DNP के रूप में शामिल करना होगा जब तक कि आप अपने रिक्त स्थान का उपयोग किए बिना इसे प्रिंट करने का एक तरीका नहीं ढूंढ सकते। इसके अलावा, कृपया कार्यक्रम का स्कोर शामिल करें।
— मार्टिन एंडर
4

रेटिना , 712 बाइट्स, 2 डीएनपी

यह FryAmTheEggman के साथ एक सहयोगात्मक प्रयास था।

समाधान के कई वर्ग हैं। स्थान से अधिकांश वर्णों के लिए ^, हम निम्नलिखित फ़ॉर्म के एक कार्यक्रम का उपयोग करते हैं:


_
T`w`p

दूसरी पंक्ति पर वर्ण श्रेणियों के माध्यम से पुनरावृत्त होता है _0-9A-Za-zजबकि शेष अपरिवर्तित रहता है। यह खाली इनपुट को उस पात्र में बदल देता है और फिर प्रिंट करने योग्य ASCII चरित्र (इसके द्वारा दर्शाए गए p) के साथ बदल देता है । इनमें से प्रत्येक कार्यक्रम 8 बाइट्स लंबा है।

इस सीमा के भीतर, केवल कुछ अपवाद हैं। सबसे महत्वपूर्ण रूप से अंकों को छोटा किया जा सकता है:

  • 0: x( xखाली इनपुट में s की संख्या गिनता है )
  • 1:  (weehoo, खाली प्रोग्राम; खाली इनपुट में खाली मैचों की संख्या गिनता है)

  • 2: अब हम खाली तार गिनने से पहले इनपुट को एक एकल वर्ण में बदल देते हैं:

    
1

  • 3: एक ही बात लेकिन हम इनपुट को दो वर्णों में बदलते हैं:

    
11

  • 4: आप विचार प्राप्त ...

    
111

  • 5 - 9: प्लॉट ट्विस्ट ... हम दूसरी पंक्ति से बचने के लिए चरित्र दोहराव का उपयोग करते हैं:

    
4$*

    ...

    
8$*

अन्य अपवाद यह है कि Tएक DNP है: हमें नहीं लगता कि स्रोत कोड में प्रदर्शित होने के बिना गैर-अंक वर्ण उत्पन्न करना संभव है यदि लिप्यंतरण चरणों का उपयोग नहीं किया जा सकता है।

शेष पात्रों पर। प्रिंट करने के लिए _हम ऊपर के सामान्य समाधान के समान प्रोग्राम का उपयोग करते हैं:


0
T`0`w

तथ्य यह है कि का उपयोग कर wके साथ शुरू होता _।

अगला, `दूसरा DNP है, क्योंकि लिप्यंतरण चरणों के लिए भी आवश्यकता होती है।

तब अधिकांश लोअर-केस अक्षरों को कुछ इस तरह से प्रिंट किया जाता है (जो प्रिंट करता है a):


_
T`w`l

फिर, दूसरी पंक्ति के चरित्र के माध्यम से वेतन वृद्धि _0-9A-O। यहाँ, हम बस के लिए बाहर देखने की जरूरत है lऔर wहै, जो हम निम्नलिखित प्रोग्राम क्रमश साथ मुद्रित कर सकते हैं:


P
T`p`w

6
T`p`l

अंत में, केवल {|}~छोड़ दिया जाता है, जिसमें प्रत्येक को 9 बाइट्स की आवश्यकता होती है। यहां, हम लिप्यंतरण चरण का उपयोग उस चरित्र को बढ़ाने के लिए करते हैं जो उन्हें पहले करता है। जैसे के ~साथ मुद्रित किया जा सकता है:


}
T`_p`p
— मार्टिन एंडर
स्रोत
रेटिना के नए संस्करण के साथ $ L और $ u का उपयोग करते हुए चार बाइट्स के साथ सभी अक्षरों (यहां तक ​​कि T) को प्रिंट करना संभव है ... मैं अभी भी इसका उपयोग किए बिना बैकटिक को प्रिंट करने का एक तरीका नहीं खोज सका, क्या आपको लगता है कि यह संभव है?
— सिंह
@ नहीं, मुझे नहीं लगता। मेरा मतलब है कि एक और बाइनरी ऑपरेटर को प्रतिस्थापन सिंटैक्स में जोड़ना है जो कि सीमा विस्तार होगा, जो समस्या को हल करेगा। मुझे यह पता लगाने की आवश्यकता है कि मैं वास्तव में इसे कैसे लागू करना चाहता हूं। एक अन्य विकल्प कोड बिंदुओं के साथ काम करने के लिए कुछ प्रतिस्थापन वाक्यविन्यास सुविधा होगी।
— मार्टिन एंडर
3

पाइके, 364 362 355 बाइट्स

2*1 + 3*2 + 14*3 + 2*4 + 5 + 73*4

इसके अलावा सभी फॉर्म w<chr(charcode+32)>.C(4 बाइट) में:

  • -> d1 बाइट
  • 0-> Z1 बाइट
  • 1-> ~W2 बाइट्स
  • a-> Gh2 बाइट्स
  • z-> Ge2 बाइट्स
  • पहले 10 लोअरकेस वर्णमाला पत्र (छोड़कर) a ) रूप में G<number>@(3 बाइट्स)
  • k-> GT@3 बाइट्स
  • > -> ~Bh3 बाइट्स
  • ] -> ~Be3 बाइट्स
  • Z -> ~le3 बाइट्स
  • 9 -> ~ue3 बाइट्स
  • w -> G22@ 4 बाइट्स
  • . -> ~B4@ 4 बाइट्स
  • C -> ~K38@ 5 बाइट्स

ऑनलाइन पायके दुभाषिया

— नीला
स्रोत
3

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

सामान्य फ़ॉर्म:

alert`\xhex`

अपवाद:

0 alert(9-9)
...
8 alert(9-1)
9 alert(8+1)
\ alert(atob`XA`)
` alert('\x60')
a \u0061lert`\x61`
e al\u0065rt`\x65`
l a\u006cert`\x6c`
r ale\u0072t`\x72`
t aler\u0074`\x74`
x alert`\u0078`

संपादित करें: @ GOTO0 के लिए 15 बाइट्स सहेजे गए।

— नील
स्रोत
"x" को विशेष हैंडलिंग की भी आवश्यकता है। इसके अलावा, alert(atob`XA`)कुछ बाइट्स को बचाने के लिए "\" का उपयोग करें ।
— गोटो 0
@ GOTO0 ऊघ, मैं विश्वास नहीं कर सकता कि मैं भूल गया था x।
— नील
1
जावास्क्रिप्ट \uस्रोत कोड में भागने की अनुमति देता है ? कूल
— साइयो
@Cyoce: पहचानकर्ताओं में, हाँ, सामान्य तौर पर, नहीं।
— बेर्गी
@Bergi यूनिकोड के पलायन को पहले संसाधित किया जाता है, इसलिए यदि आप चाहें, तो आप यूनिकोड से बचने के संदर्भ में अपना पूरा स्रोत लिख सकते हैं, जबकि हेक्स केवल तार के अंदर काम से बच जाता है।
— नील
3

05AB1E , 417 बाइट्स

!   62D>B
"   63D>B
#   64D>B
$   65D>B
%   66D>B
&   67D>B
'   68D>B
(   69D>B
)   70D>B
*   71D>B
+   72D>B
,   73D>B
-   74D>B
.   75D>B
/   76D>B
0   1<
1   X
2   Y
3   Z
4   3>
5   4>
6   5>
7   6>
8   7>
9   8>
:   77D>B
;   78D>B
<   79D>B
=   80D>B
>   81D1+B
?   82D>B
@   83D>B
A   Th
B   T>h
C   T>>h
D   T3+h
E   T4+h
F   T5+h
G   16D>B
H   17D>B
I   18D>B
J   19D>B
K   20D>B
L   21D>B
M   22D>B
N   23D>B
O   24D>B
P   25D>B
Q   26D>B
R   27D>B
S   28D>B
T   29D>B
U   30D>B
V   31D>B
W   33D>B
X   33D>B
Y   A`\u
Z   A`u
[   84D>B
\   85D>B
]   86D>B
^   87D>B
_   88D>B
`   89D>B
a   A`r
b   A`r\
c   38D>B
d   39D>B
e   40D>B
f   41D>B
g   42D>B
h   43D>B
i   44D>B
j   45D>B
k   46D>B
l   47D>B
m   48D>B
n   49D>B
o   50D>B
p   51D>B
q   52D>B
r   53D>B
s   54D>B
t   55D>B
u   56D>B
v   57D>B
w   58D>B
x   A`\\
y   A`\
z   A`
{   90D>B
|   91D>B
}   92D>B
~   93D>B

व्याख्या

अधिकांश फॉर्म के 5 बाइट्स लंबे होते हैं convert nr to base nr+1:।
>एक अतिरिक्त बाइट की जरूरत है क्योंकि हम उस के लिए वेतन वृद्धि का उपयोग नहीं कर सकते हैं।

a,b,x,y,z,Y,ZAजिसमें से निचली स्थिति में वर्णमाला होती है, निकाला जाता है ।

A,B,C,D,E,F संख्या को हेक्स में परिवर्तित किया जाता है।

0-9 सरल वेतन वृद्धि / वेतन वृद्धि के साथ-साथ पूर्वनिर्धारित चर भी हैं।

— Emigna
स्रोत
3

मारबेलस, 220 बाइट्स

एक चरित्र के लिए जो एक अंक नहीं है, यह चरित्र कोड के केवल दो बड़े अंक हैं। उदाहरण के लिए, निम्न प्रोग्राम आउटपुट A:

41

एक अंक के लिए, जो नहीं है 3, 2Fवर्ण कोड के अपरकेस हेक्स अंकों द्वारा निम्नलिखित कोड में बदलें - 1:

2F
++

के लिए 3:

66
>>

कुल स्कोर: 2 * 85 + 5 * 10 = 220।

दुभाषिया।

मेरा पहला प्रयास बबलगम था और इससे पहले यह पात्रों के लिए काम नहीं करता था ?...

— jimmy23013
स्रोत
3

पर्ल 6: 921 बाइट्स

पायथन समाधान का अनुवाद।

प्रत्येक कार्यक्रम में फॉर्म say "\x<hex escape code>"को छोड़कर, होता है:

  • s → put "\x73"
  • a → put "\x61"

  • y → put "\x79"

  • → "\x20".say

  • " → say chr 34
  • \ → say chr 92
  • x → say chr 120
  • 0 → say 1-1
  • 1 → say 3-2
  • 2, 9→say <n minus one>+1

संदर्भ और परीक्षण में आसानी के लिए, यहां कार्यक्रमों की पूरी सूची है, न्यूलाइन-अलग।

"\x20".say
say "\x21"
say chr 34
say "\x23"
say "\x24"
say "\x25"
say "\x26"
say "\x27"
say "\x28"
say "\x29"
say "\x2A"
say "\x2B"
say "\x2C"
say "\x2D"
say "\x2E"
say "\x2F"
say 1-1
say 3-2
say 1+1
say 2+1
say 3+1
say 4+1
say 5+1
say 6+1
say 7+1
say 8+1
say "\x3A"
say "\x3B"
say "\x3C"
say "\x3D"
say "\x3E"
say "\x3F"
say "\x40"
say "\x41"
say "\x42"
say "\x43"
say "\x44"
say "\x45"
say "\x46"
say "\x47"
say "\x48"
say "\x49"
say "\x4A"
say "\x4B"
say "\x4C"
say "\x4D"
say "\x4E"
say "\x4F"
say "\x50"
say "\x51"
say "\x52"
say "\x53"
say "\x54"
say "\x55"
say "\x56"
say "\x57"
say "\x58"
say "\x59"
say "\x5A"
say "\x5B"
say chr 92
say "\x5D"
say "\x5E"
say "\x5F"
say "\x60"
put "\x61"
say "\x62"
say "\x63"
say "\x64"
say "\x65"
say "\x66"
say "\x67"
say "\x68"
say "\x69"
say "\x6A"
say "\x6B"
say "\x6C"
say "\x6D"
say "\x6E"
say "\x6F"
say "\x70"
say "\x71"
say "\x72"
put "\x73"
say "\x74"
say "\x75"
say "\x76"
say "\x77"
say chr 120
put "\x79"
say "\x7A"
say "\x7B"
say "\x7C"
say "\x7D"
say "\x7E"

यहाँ कोड का उपयोग मैंने उपरोक्त लिस्टिंग का परीक्षण करने के लिए किया था, और स्कोर की गणना की:

#!/usr/bin/env perl6

my $file = 'print_ascii_characters.p6';

my @expected = ' ' .. '~';
my @code     = $file.IO.lines;
my $code     = @code.join: ';';
my @got      = (run 'perl6', '-e', $code, :out).out.lines.map: |*.comb;

given +@expected, +@got, +@code -> ($e, $g, $c) {
    say "WRONG COUNT: Expected $e / output $g / source $c" and exit if not $e == $g == $c;
}

for @expected Z @got -> ($e, $g) {
    say "WRONG OUTPUT: Expected {$e.perl}, got {$g.perl}" and exit if $e ne $g;
}

for @expected Z @code -> ($char, $code) {
    say "COLLISION: {$char.perl} contained in {$code.perl}" if $code.match($char);
}

say "SCORE: ", @code.map(*.chars).sum;
— SMLS
स्रोत
@sch In Perl 5 जो काम करेगा, लेकिन मैंने इसे Perl 6 में करने की कोशिश की, जहाँ sayआवश्यक होने के बाद और ऑक्टल एस्केप सीक्वेंस को लिखा जाता है \o77। एक अलग पर्ल 5 समाधान पोस्ट करने के लिए स्वतंत्र महसूस करें ... :)
— 12
क्षमा करें, मुझे आपके उत्तर में पर्ल 6 भाग याद आ गया।
— sch
3

हास्केल, 1874 1864 1856 1855 1795 1791 1589 बाइट्स, 7 डीएनपी

अधिकांश कार्यक्रम main=putChar '\xx'या main=putChar '\xxx'जहां xx/ xxxछपे की आस्की कोड है। यह सभी 14 वर्णों के लिए काम करता है:

 !"#$%& ()*+,-./0123456789:;< >?@AB DEFGHIJKLMNOPQRSTUVWXYZ[ ]^_` bcdefg  jkl  o q s  vwxyz{|}~
       '                     =     C                        \    a      hi   mn p r tu

हालाँकि, अंकों के लिए 1 7 4 बाइट्स को बचाया जा सकता है (क्रिश्चियन सेवर्स के लिए धन्यवाद!)।

0   main=print$1-1
1   main=print$3-2
2   main=print$1+1
3   main=print$1+2
...

c(कोड 99) तक के 52 कार्यक्रम 18 बाइट लेते हैं, शेष 19 प्रत्येक 19 बाइट लेते हैं।

आंशिक स्कोर: 10*14 + 52*18 + 19*19 = 1437

शेष वर्णों में से 7 के लिए, निम्नलिखित कार्यक्रम काम करते हैं:

    main=putChar$'\32'
'   main=putStr$pred<$>"("
C   main=putStr['\67']
\   main=putChar$pred ']'
h   main=putStr['\104']
p   main=interact(\_->['\112'])
u   main=interact(\_->['\117'])

आंशिक स्कोर: 18 + 22 + 18 + 21 + 19 + 27 + 27 = 152

यह 7 DNPs छोड़ता है: =aimnrt

प्रत्येक हास्केल कार्यक्रम को एक मुख्य ( main=) परिभाषित करने की आवश्यकता होती है , इसलिए यह 5 डीएनपी है। StdOut में प्रिंट करने के लिए putChar, putStrया interactउपयोग किया जा सकता है, उपज tऔर rआगे DNPs के रूप में। (वहाँ भी है print, हालांकि print 'a'प्रिंट 'a'और नहीं a- और भी शामिल है tऔर rवैसे भी।) हास्केल का एक chrफ़ंक्शन भी है जो इसी नंबर को दिए गए चार्ट को वापस करता है, हालांकि इसका उपयोग करने के लिएimport Data.Char लिए आवश्यक है।

कुल स्कोर: 1437 + 152 = 1589 7 डीएनपी

— Laikoni
स्रोत
1
वैकल्पिक नई सुचनाओं के साथ, हम इस तरह से अंक प्राप्त कर सकते हैं: main=print$1-1आदि
— क्रिश्चियन सिवर्स
आपका पी प्रोग्राम पी का उपयोग करता है (लेकिन आसानी से तय किया जा सकता है succ)
— क्रिश्चियन सेवर्स
2

बीबीसी बेसिक, 422 413 बाइट्स

Http://www.bbcbasic.co.uk/bbcwin/bbcwin.html पर नि: शुल्क डाउनलोड करें

9 बाइट्स ने लीक नन को धन्यवाद दिया।

सामान्य फ़ॉर्म 

V.<character code>

32..99 12 विशेष मामलों को छोड़कर: 56x4 = 224 बाइट्स

100..126 : 27x5 = 135 बाइट्स

12 विशेष मामले: 54 बाइट्स

अधिकांश संख्या सामान्य रूप का अनुसरण करती है, लेकिन मैंने उन सभी को यहां शामिल किया जहां समस्या है।

पहला चरित्र मुद्रित होने वाला चरित्र है।

. VDU46       :REM Full form of the command used in general form: send character 46 to VDU)
V P.CHR$86    :REM short for PRINT CHR$(86)
0 V.48       
1 V.49
2 V.50
3 V.51
4 V.52
5 P.1+4
6 V.54
7 V.55
8 V.56
9 V.57
— स्तर नदी सेंट
स्रोत
के V.48लिए उपयोग क्यों नहीं 0?
— लीकी नून
@LeakyNun 9 बाइट्स बचाए, धन्यवाद!
— स्तर नदी सेंट
वाह, क्या आपके पास V.और P.आदेश हमेशा रहे हैं?
— बीटा डेके
@ toα the हां, लेकिन संपादक टाइप करने के बाद उन्हें पूर्ण शब्दों में VDU और PRINT का विस्तार करता है (लेकिन उन्हें BASIC कमांडलाइन पर विस्तार के बिना व्याख्या की जाती है)। सबसे बड़े अक्षरों के बाद .एक कीवर्ड में विस्तार होगा। यह चुनौती नॉनसेबल ASCII का उपयोग करने के बारे में सख्त है, लेकिन यकीनन अन्य चुनौतियों के साथ आप कह सकते हैं कि टोकन कीवर्ड (ascii 127-255) एक बाइट थे। कहा कि मैंने कभी उस तर्क की कोशिश नहीं की है, और आमतौर पर दोनों स्कोर देते हैं।
— लेवल रिवर सेंट
@LevelRiverSt मैं देख रहा हूँ
— बीटा डिके
2

मिंकोलंग 0.15 , 604 बाइट्स

अधिकांश पात्रों के लिए, "<char-1>"1+O.एक वैध कार्यक्रम होगा, शायद सबसे छोटा। हालांकि, इस तथ्य के कारण कि पात्रों को स्टैक पर कोड बिंदुओं के रूप में संग्रहीत किया जाता है, इसका मतलब है कि उनमें से कई को पांच बाइट्स या उससे कम में गुणा और जोड़कर उत्पादित किया जा सकता है। इसके अलावा, कृपया ध्यान दें कि l, $1, $2, $3, $4, $5, $6, $lकर रहे हैं 10, 11, 12, 13, 14, 15, 16, 100क्रमशः।

प्रारूप: <character>: <program>

 : 48*O.
!: $13*O.
": 66*2-O.
#: 57*O.
$: 66*O.
%: 66*1+O.
&: 4l*2-O.
': 3$3*O.
(: 4l*O.
): 4l*1+O.
*: ")"1+O.
+: "*"1+O.
,: $14*O.
-: 59*O.
.: "-"1+d$10pO-
/: "."1+O.
0: 68*O.
1: 77*O.
2: 5l*O.
3: 5l*1+O.
4: lZIO.
5: lZdIO.
6: 239**O.
7: 5$1*O.
8: 4$4*O.
9: 6l*3-O.
:: 6l*2-O.
;: 6l*1-O.
<: 6l*O.
=: 6l*1+O.
>: 6l*2+O.
?: 79*O.
@: 88*O.
A: 5$3*O.
B: 6$1*O.
C: 7l*3-O.
D: 7l*2-O.
E: 7l*1-O.
F: 7l*O.
G: 7l*1+O.
H: 89*O.
I: 89*1+O.
J: 89*2+O.
K: 355**O.
L: 89*4+O.
M: 7$1*O.
N: 6$3*O.
O: "N"1+d90pN.
P: 8l*O.
Q: 99*O.
R: 8l*2+O.
S: 8l*3+O.
T: 347**O.
U: 8l*5+O.
V: 8l*6+O.
W: 8l*7+O.
X: 8$1*O.
Y: 8l*9+O.
Z: 9l*O.
[: $l9-O.
\: $l8-O.
]: $l7-O.
^: $l6-O.
_: $l5-O.
`: 8$2*O.
a: $l3-O.
b: $l2-O.
c: 9$1*O.
d: $lO.
e: $l1+O.
f: $l2+O.
g: $l3+O.
h: $l4+O.
i: $l5+O.
j: $l6+O.
k: $l7+O.
l: $l8+O.
m: $l9+O.
n: l$1*O.
o: $l$1+O.
p: $l$2+O.
q: $l$3+O.
r: $l$4+O.
s: $l$5+O.
t: $l$6+O.
u: "t"1+O.
v: "u"1+O.
w: 7dl+*O.
x: 358**O.
y: $1d*O.
z: 53;3-O.
{: 53;2-O.
|: 53;1-O.
}: 53;O.
~: 53;1+O.

विशेष उल्लेख:

.: "-"1+d$10pO-

(यह कोशिश करो।) मिंकोलंग में कोड बॉक्स में पात्रों को संशोधित करने की क्षमता है, इसलिए यह कार्यक्रम क्या करता है कि यह इसके -साथ अंत में बदल देता है ., जो कार्यक्रम को रोकने के लिए आवश्यक है। "N"1+d90pN.के लिए Oएक ही तरह से काम करता है।

4: lZIO.

(इसे आज़माएं।) lZ अपरकेस और लोअरकेस अल्फाबेट्स को स्टैक पर ले जाता है, और स्टैक Iकी लंबाई को धक्का देता है, जो कि 52 है, ठीक "4" का कोड बिंदु। सबसे अच्छी बात यह है कि मैं शुरू में इसके समाधान पर विचार कर रहा था 4$3*O., जो 52 प्राप्त करने के लिए 4 और 13 को गुणा करता है, लेकिन ऐसा नहीं हो सकता क्योंकि इसमें 4 था, इसलिए मैंने वैसे भी एक गोल्फ समाधान खोजना शुरू कर दिया!

y: $1d*O.

(यह कोशिश करो।) d स्टैक के शीर्ष को डुप्लिकेट करता है, इसलिए कोड का यह टुकड़ा क्या करता है कि यह धक्का देता है 11, इसे दोहराता है, और फिर गुणा करता है। इसे लिखने का एक वैकल्पिक तरीका होता $12;O., जिसमें एक ही बाइट काउंट होता।

}: 53;O.

(इसे आज़माएं।) ; प्रतिपादक है, इसलिए 125 प्राप्त करने के लिए यह 5 ^ 3 है।

— एलेंडिया स्ट्राटन
स्रोत
2

ग्रूवी, 1019 बाइट्स

मेरे पास एक अलग ग्रूवी सॉल्यूशन लिखा था (नीचे देखें), लेकिन मैंने इसे सबमिट करने के बाद कैरेक्टर एस्क्यू में थोड़ा और खुदाई की, जिससे प्रोग्राम को और छोटा करने का एक रास्ता मिल गया, और पता चला कि ग्रूवी का ऑक्टल कैरेक्टर बच गया है: का पता नहीं था। यह महत्वपूर्ण रूप से कोड को सरल करता है, इस बिंदु पर कि यह दुर्भाग्य से लगभग सभी विचित्र वर्कआर्ड्स की आवश्यकता को हटा देता है, जिनके साथ मैं आया था।

यह कॉपर के पायथन 2 समाधान के लगभग समान है , इस बिंदु पर जहां यह मूल रूप से ऐसा लगता है जैसे मैंने उनके काम को कम कर दिया है। ओह।

प्रत्येक कार्यक्रम में फॉर्म print'\<octal value>'को छोड़कर, होता है:

  • p, r, i, n, t→'print''\<octal value>' (लेकिन "प्रिंट" का मिलान पत्र के साथ भी ऑक्टल मान के साथ बदल दिया)
  • 0- 9→print~-<next int>

यहाँ चरित्र द्वारा कार्यक्रमों की पूरी सूची है।

    print'\40'
!   print'\41'
"   print'\42'
#   print'\43'
$   print'\44'
%   print'\45'
&   print'\46'
'   print'\47'
(   print'\50'
)   print'\51'
*   print'\52'
+   print'\53'
,   print'\54'
-   print'\55'
.   print'\56'
/   print'\57'
0   print~-1
1   print~-2
2   print~-3
3   print~-4
4   print~-5
5   print~-6
6   print~-7
7   print~-8
8   print~-9
9   print~-10
:   print'\72'
;   print'\73'
<   print'\74'
=   print'\75'
>   print'\76'
?   print'\77'
@   print'\100'
A   print'\101'
B   print'\102'
C   print'\103'
D   print'\104'
E   print'\105'
F   print'\106'
G   print'\107'
H   print'\110'
I   print'\111'
J   print'\112'
K   print'\113'
L   print'\114'
M   print'\115'
N   print'\116'
O   print'\117'
P   print'\120'
Q   print'\121'
R   print'\122'
S   print'\123'
T   print'\124'
U   print'\125'
V   print'\126'
W   print'\127'
X   print'\130'
Y   print'\131'
Z   print'\132'
[   print'\133'
\   print'\134'
]   print'\135'
^   print'\136'
_   print'\137'
`   print'\140'
a   print'\141'
b   print'\142'
c   print'\143'
d   print'\144'
e   print'\145'
f   print'\146'
g   print'\147'
h   print'\150'
i   'pr\151nt''\151'
j   print'\152'
k   print'\153'
l   print'\154'
m   print'\155'
n   'pri\156t''\156'
o   print'\157'
p   '\160rint''\160'
q   print'\161'
r   'p\162int''\162'
s   print'\163'
t   'prin\164''\164'
u   print'\165'
v   print'\166'
w   print'\167'
x   print'\170'
y   print'\171'
z   print'\172'
{   print'\173'
|   print'\174'
}   print'\175'
~   print'\176'

ग्रूवी, 1130 बाइट्स

मेरा पिछला कार्यक्रम, इससे पहले कि मुझे पता चला कि ऑक्टेल बच गया है। बहुत अधिक दिलचस्प, आईएमओ।

प्रत्येक कार्यक्रम में फॉर्म print(--'<next char>')को छोड़कर, होता है:

  • -, [, ~→print(++'<previous char>')
  • & → print(--"'")
  • p, r, i, n→System.out<<--'<next char>'
  • t → 'prin\u0074'(--'u')
  • ( → print'\u0028'
  • ) → print'\u0029'
  • 0- 9→print~-<next int>

यहाँ प्रत्येक चरित्र के लिए कार्यक्रमों की पूरी सूची दी गई है:

    print(--'!')
!   print(--'"')
"   print(--'#')
#   print(--'$')
$   print(--'%')
%   print(--'&')
&   print(--"'")
'   print(--'(')
(   print'\u0028'
)   print'\u0029'
*   print(--'+')
+   print(--',')
,   print(--'-')
-   print(++',')
.   print(--'/')
/   print(--'0')
0   print~-1
1   print~-2
2   print~-3
3   print~-4
4   print~-5
5   print~-6
6   print~-7
7   print~-8
8   print~-9
9   print~-10
:   print(--';')
;   print(--'<')
<   print(--'=')
=   print(--'>')
>   print(--'?')
?   print(--'@')
@   print(--'A')
A   print(--'B')
B   print(--'C')
C   print(--'D')
D   print(--'E')
E   print(--'F')
F   print(--'G')
G   print(--'H')
H   print(--'I')
I   print(--'J')
J   print(--'K')
K   print(--'L')
L   print(--'M')
M   print(--'N')
N   print(--'O')
O   print(--'P')
P   print(--'Q')
Q   print(--'R')
R   print(--'S')
S   print(--'T')
T   print(--'U')
U   print(--'V')
V   print(--'W')
W   print(--'X')
X   print(--'Y')
Y   print(--'Z')
Z   print(--'[')
[   print(++'Z')
\   print(--']')
]   print(--'^')
^   print(--'_')
_   print(--'`')
`   print(--'a')
a   print(--'b')
b   print(--'c')
c   print(--'d')
d   print(--'e')
e   print(--'f')
f   print(--'g')
g   print(--'h')
h   print(--'i')
i   System.out<<--'j'
j   print(--'k')
k   print(--'l')
l   print(--'m')
m   print(--'n')
n   System.out<<--'o'
o   print(--'p')
p   System.out<<--'q'
q   print(--'r')
r   System.out<<--'s'
s   print(--'t')
t   'prin\u0074'(--'u')
u   print(--'v')
v   print(--'w')
w   print(--'x')
x   print(--'y')
y   print(--'z')
z   print(--'{')
{   print(--'|')
|   print(--'}')
}   print(--'~')
~   print(++'}')
— एम। जस्टिन
स्रोत
2

दरअसल , 383 382 381 बाइट्स

1 बाइट मीगो की बदौलत।

आसान संदर्भ के लिए, पहला कॉलम वर्ण कोड है, दूसरा कॉलम वर्ण है, और तीसरा कॉलम कोड है।

के लिए कोड 0एक एकल स्थान है।

032   :32c
033 ! HN
034 " 9Fc
035 # :35c
036 $ :36c
037 % :37c
038 & :38c
039 ' :39c
040 ( :40c
041 ) 9R$N
042 * :42c
043 + :43c
044 , :44c
045 - :45c
046 . :46c
047 / :47c
048 0  
049 1 0Y
050 2 0P
051 3 1P
052 4 3u
053 5 2P
054 6 3!
055 7 3P
056 8 6F
057 9 NF
058 : 9P;+c
059 ; :59c
060 < :60c
061 = :61c
062 > :62c
063 ? :63c
064 @ :64c
065 A :65c
066 B :66c
067 C :67c
068 D :68c
069 E :69c
070 F :70c
071 G :71c
072 H :72c
073 I :73c
074 J :74c
075 K :75c
076 L :76c
077 M :77c
078 N :78c
079 O :79c
080 P :80c
081 Q :81c
082 R :82c
083 S :83c
084 T :84c
085 U :85c
086 V :86c
087 W :87c
088 X :88c
089 Y :89c
090 Z :90c
091 [ k$F
092 \ :92c
093 ] k$N
094 ^ :94c
095 _ :95c
096 ` :96c
097 a :97c
098 b :98c
099 c :12#"%x"%
100 d :100c
101 e :101c
102 f :102c
103 g :103c
104 h :104c
105 i :105c
106 j :106c
107 k :107c
108 l :108c
109 m :109c
110 n :110c
111 o :111c
112 p :112c
113 q 9PPc
114 r 9R$F
115 s :115c
116 t :116c
117 u :117c
118 v :118c
119 w 5!Dc
120 x 5!c
121 y 5!uc
122 z :122c
123 { :123c
124 | :124c
125 } :125c
126 ~ :126c

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

गोल्फ सुझावों का स्वागत है।

— लीक नन
स्रोत
:5 में:9P2*c
— Mego
@ मेगो धन्यवाद, जोड़ा गया।
— लीक नून
2

फूरियर, 306 बाइट्स, 1 डीएनपी

बहुत सारे कार्यक्रम सभी पैटर्न का अनुसरण करते हैं naजहां n प्रत्येक वर्ण का वर्ण कोड है। उदाहरण के लिए:

!       33a
"       34a
#       35a
$       36a
%       37a
&       38a
'       39a

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

तो मैं सिर्फ अपवादों को सूचीबद्ध करूंगा:

0 (शून्य)

चूंकि संचायक शून्य पर पूर्व निर्धारित है, हम इसे एकल वर्ण का उपयोग करके प्रदर्शित कर सकते हैं:

o

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

1

शून्य के समान, यह 1 प्राप्त करने के लिए संचायक को बढ़ाता है।

^o

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

5

5 के लिए ASCII कोड 53 है, इसलिए मुझे इसके आसपास काम करना था:

6vo

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

ए

aचरित्र आउटपुट फ़ंक्शन होने के कारण , चरित्र का निर्माण करने का कोई अन्य तरीका नहीं है, इसलिए यह मेरा एकमात्र DID NOT PROGRAM है ।

सारे कार्यक्रम यहाँ देखें

— बीटा डिके
स्रोत
2

मतलाब, 1238 1224 बाइट्स, 2 डीएनपी

मुख्य पैटर्न है:

disp([<char code> ''])

अंकों के लिए यह थोड़ा छोटा है:

disp(<sum or difference of two other digits>)

पात्रों के लिए []'यह है:

" " -- disp([0,''])
"[" -- disp(char(91))
"]" -- disp(char(93))
"'" -- disp(char(39))

वर्ण dsसे dispका उपयोग कर प्रदर्शित किए जाते हैं fprintf( धन्यवाद @Stewie ग्रिफिन ); ipहालाँकि वहां भी हैं, इसलिए मैं स्ट्रिंग को स्थानांतरित कर रहा हूं और उपयोग कर रहा हूं eval:

d -- fprintf([100 ''])
i -- eval(['ejtq)(j(*'-1 ''])
s -- fprintf([115 ''])
p -- eval(['ejtq)(q(*'-1 ''])

दोनों पात्रों ()के लिए हालांकि जरूरी हैं dispया eval, तो वे DNP हैं।

पूरी सूची के संदर्भ के लिए:

    char    char code   code                        length
            32          disp([0 ''])                12
    !       33          disp([33 ''])               13
    "       34          disp([34 ''])               13
    #       35          disp([35 ''])               13
    $       36          disp([36 ''])               13
    %       37          disp([37 ''])               13
    &       38          disp([38 ''])               13
    '       39          disp(char(39))              14
    (       40          DNP
    )       41          DNP 
    *       42          disp([42 ''])               13
    +       43          disp([43 ''])               13
    ,       44          disp([44 ''])               13
    -       45          disp([45 ''])               13
    .       46          disp([46 ''])               13
    /       47          disp([47 ''])               13
    0       48          disp(1-1)                   9
    1       49          disp(3-2)                   9
    2       50          disp(5-3)                   9
    3       51          disp(7-4)                   9
    4       52          disp(9-5)                   9
    5       53          disp(2+3)                   9
    6       54          disp(3+3)                   9
    7       55          disp(4+3)                   9
    8       56          disp(5+3)                   9
    9       57          disp(6+3)                   9
    :       58          disp([58 ''])               13
    ;       59          disp([59 ''])               13
    <       60          disp([60 ''])               13
    =       61          disp([61 ''])               13
    >       62          disp([62 ''])               13
    ?       63          disp([63 ''])               13
    @       64          disp([64 ''])               13
    A       65          disp([65 ''])               13
    B       66          disp([66 ''])               13
    C       67          disp([67 ''])               13
    D       68          disp([68 ''])               13
    E       69          disp([69 ''])               13
    F       70          disp([70 ''])               13
    G       71          disp([71 ''])               13
    H       72          disp([72 ''])               13
    I       73          disp([73 ''])               13
    J       74          disp([74 ''])               13
    K       75          disp([75 ''])               13
    L       76          disp([76 ''])               13
    M       77          disp([77 ''])               13
    N       78          disp([78 ''])               13
    O       79          disp([79 ''])               13
    P       80          disp([80 ''])               13
    Q       81          disp([81 ''])               13
    R       82          disp([82 ''])               13
    S       83          disp([83 ''])               13
    T       84          disp([84 ''])               13
    U       85          disp([85 ''])               13
    V       86          disp([86 ''])               13
    W       87          disp([87 ''])               13
    X       88          disp([88 ''])               13
    Y       89          disp([89 ''])               13
    Z       90          disp([90 ''])               13
    [       91          disp(char(91))              14
    \       92          disp([92 ''])               13
    ]       93          disp(char(93))              14
    ^       94          disp([94 ''])               13
    _       95          disp([95 ''])               13
    `       96          disp([96 ''])               13
    a       97          disp([97 ''])               13
    b       98          disp([98 ''])               13
    c       99          disp([99 ''])               13
    d       100         fprintf([100 ''])           17
    e       101         disp([101 ''])              14
    f       102         disp([102 ''])              14
    g       103         disp([103 ''])              14
    h       104         disp([104 ''])              14
    i       105         eval(['ejtq)(j(*'-1 ''])    24
    j       106         disp([106 ''])              14
    k       107         disp([107 ''])              14
    l       108         disp([108 ''])              14
    m       109         disp([109 ''])              14
    n       110         disp([110 ''])              14
    o       111         disp([111 ''])              14
    p       112         eval(['ejtq)(q(*'-1 ''])    24
    q       113         disp([113 ''])              14
    r       114         disp([114 ''])              14
    s       115         fprintf([115,''])           17
    t       116         disp([116 ''])              14
    u       117         disp([117 ''])              14
    v       118         disp([118 ''])              14
    w       119         disp([119 ''])              14
    x       120         disp([120 ''])              14
    y       121         disp([121 ''])              14
    z       122         disp([122 ''])              14
    {       123         disp([123 ''])              14
    |       124         disp([124 ''])              14
    }       125         disp([125 ''])              14
    ~       126         disp([126 ''])              14
— pajonk
स्रोत
क्या कुछ [100 105 115 112](चार-कोड) के लिए काम करता है disp?
— लीकी नून
आप का क्या तात्पर्य है? disp([100 105 115 112])एक स्ट्रिंग का उत्पादन नहीं होगा, eval([100 105 115 112])न ही।
— पजाकोंग
आप fprintfडी ans s: के लिए उपयोग कर सकते हैं fprintf([115,''])। 2x7 बाइट्स बचाता है)) इसे विजयी सबमिशन नहीं बनाया जाएगा, लेकिन हे: 14 बाइट्स 14 बाइट्स हैं,,
— स्टिव ग्रिफिन
इसके अलावा: disp([0 ''])एक स्थान शामिल है। disp([0,''])ऐसा नहीं करता।
— स्टिव ग्रिफिन
@StewieGriffin धन्यवाद, मैं एक स्थान से चूक गया। इसके अलावा, इस चाल के लिए धन्यवाद fprintf।
— पजाँक
2

जेली (गैर-प्रतिस्पर्धी), 406 बाइट्स

32Ọ
33Ọ
34Ọ
35Ọ
36Ọ
37Ọ
38Ọ
39Ọ
40Ọ
41Ọ
42Ọ
43Ọ
44Ọ
45Ọ
46Ọ
47Ọ
48Ọ
49Ọ
50Ọ
51Ọ
52Ọ
49+4Ọ
54Ọ
55Ọ
56Ọ
57Ọ
58Ọ
59Ọ
60Ọ
61Ọ
62Ọ
63Ọ
64Ọ
65Ọ
66Ọ
67Ọ
68Ọ
69Ọ
70Ọ
71Ọ
72Ọ
73Ọ
74Ọ
75Ọ
76Ọ
77Ọ
78Ọ
79Ọ
80Ọ
81Ọ
82Ọ
83Ọ
84Ọ
85Ọ
86Ọ
87Ọ
88Ọ
89Ọ
90Ọ
91Ọ
92Ọ
93Ọ
94Ọ
95Ọ
96Ọ
97Ọ
98Ọ
99Ọ
³Ọ
101Ọ
102Ọ
103Ọ
104Ọ
105Ọ
106Ọ
107Ọ
108Ọ
109Ọ
110Ọ
111Ọ
112Ọ
113Ọ
114Ọ
115Ọ
116Ọ
117Ọ
118Ọ
119Ọ
120Ọ
121Ọ
122Ọ
123Ọ
124Ọ
125Ọ
126Ọ

यह सभी वर्णों को 32 - 126 से प्रिंट करता है। बाइट की गणना https://mothereff.in/byte-counter के साथ की जाती है ।

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

— सोरेन
स्रोत
1
मुझे नहीं लगता कि यह एक मान्य उत्तर है। सबसे पहले, आपको एक इनपुट लेने की अनुमति नहीं है, और दूसरा, यह एक प्रोग्राम है, न कि 95 प्रोग्राम। चुनौती का कहना हैIn a programming language of your choice, write 95 programs, each of which outputs a different one of the 95 printable ASCII characters without that character occurring anywhere in the program.
— DJMcMayhem
@DJMcMayhem ठीक है, मैं इसे बदल दूंगा
— सोरेन
डीजे सही है। यह स्पष्ट रूप से अमान्य है।
— केल्विन के शौक
@HelkaHomba मेरी बाइट सभी कार्यक्रमों की कुल गिनती है?
— सोरेन
1
इसे ठीक करने के लिए धन्यवाद, और साइट पर आपका स्वागत है! मुझे उम्मीद है कि आप इसका आनंद लेंगे। इसके अलावा, जैसा कि आप जानते हैं, जेली एक कस्टम कोड पेज का उपयोग करता है , इसलिए इस मामले में यह वास्तव में 406 वर्ण है, भले ही यह UTF-8 में 503 होगा।
— DJMcMayhem
2

बेफुज -93, 530 बाइट्स

चरित्र का उत्पादन करने का सबसे आसान तरीका, वास्तव में उस चरित्र का उपयोग किए बिना, ASCII मूल्य की गणना करना और ,इसे प्रस्तुत करने के लिए (वर्ण आउटपुट) कमांड का उपयोग करना है। उदाहरण के लिए, 49*,@डॉलर चरित्र (ASCII 36, 4 * 9) को आउटपुट करता है। यह शायद ही सबसे इष्टतम है, हालांकि, चूंकि अधिकांश मान गणना करने के लिए 3 से अधिक बाइट लेते हैं।

3 बाइट्स में एक संख्या उत्पन्न करने का दूसरा तरीका इस तथ्य का लाभ उठाना है कि gप्लेफील्ड की पहली सेल में (प्राप्त) कमांड जी का ASCII मान उत्पन्न करेगा (एक खाली स्टैक को शून्य के साथ आबादी वाला माना जाता है, इसलिए प्लेफील्ड का मान 0,0 पर पढ़ रहा है)। इस प्रकार g1+,@आपको एच मिलता है , और g1-,@आपको एफ मिलता है । यह स्पष्ट रूप से ऑफ़सेट्स की एक श्रृंखला के लिए काम करता है, और इसके अलावा संचालन भी संभव है +और -संभव है। इसलिए उदाहरण के लिए g3/,@आपको एक डबल उद्धरण मिलता है।

इसका एक रूपांतर, gएक अन्य आदेश के साथ पूर्ववर्ती है जो स्टैक पर सभी शून्य को छोड़ देता है। तो आप अभी भी 0,0 पर playfield से एक मूल्य पढ़ रहे हैं, लेकिन पढ़ा जा रहा चरित्र अब अलग है। यह एक और बाइट खर्च करता है, लेकिन आपको कई और मूल्यों तक पहुंच देता है। उदाहरण के लिए, 0g1-,@आपको आगे की स्लैश :g1+,@मिलती है और आपको अर्धविराम मिल जाता है। अन्य व्यवहार्य उपसर्गों शामिल *, +, -, >, \और _। और फिर से ध्यान दें कि अन्य ऑपरेशन संभव हैं: >g2*,@आपको एक ऊर्ध्वाधर बार मिलता है।

एक और भिन्नता एक के gसाथ पूर्ववर्ती है 1, इसलिए अब आप 0,0 से नहीं पढ़ रहे हैं, लेकिन रिक्त सेल से 0,1 पर। Befunge में, रिक्त कोशिकाओं को डिफ़ॉल्ट रूप से रिक्त स्थान के साथ प्रारंभ किया 1g,@जाता है , इसलिए आपको एक स्थान मिलता है, और1g1+,@ आपको एक विस्मयादिबोधक चिह्न मिलता है।

अंकों के वर्णों के लिए, अधिक संदिग्ध चाल है जिसका हम उपयोग कर सकते हैं। उन्हें वर्णों के रूप में आउटपुट करने की कोशिश करने के बजाय, हम उन्हें संख्याओं के रूप में आउटपुट करते हैं (एक छोटी संख्या इसके एएससीआईआई समकक्ष के मुकाबले उत्पन्न करना आसान है)। उदाहरण के लिए, 11+.@आप देता है 2 , और विशेष रूप से ध्यान दें विशेष मामलों: .@के लिए 0 , और !.@के लिए 1 । इसका संदिग्ध हिस्सा यह है कि Befunge में एक संख्यात्मक आउटपुट में संख्या के बाद एक स्थान शामिल होता है, इसलिए यह शुद्ध वर्ण आउटपुट नहीं है।

एक और संदिग्ध चाल जिसका हम उपयोग कर सकते हैं, वह है gतकनीक की भिन्नता । उपसर्ग के लिए खुद को Befunge कमांड पर सीमित करने के बजाय, हम किसी भी वर्ण का तकनीकी रूप से उपयोग कर सकते हैं जो कि Befunge कमांड नहीं है। ज्यादातर व्याख्याताओं पर एक गैर-मान्यता प्राप्त आदेश की अनदेखी की gजाएगी , इसलिए पूर्ववर्ती चरित्र के एएससीआईआई मूल्य को पढ़ना समाप्त हो जाएगा। यह हमें अधिकांश अन्य ASCII मान उत्पन्न करने में सक्षम बनाता है जो अन्यथा 3 बाइट्स में परिकलित नहीं किए जा सकते। एक उदाहरण के रूप में: Qg1+,@आपको आर ।

अंत में, तीन विशेष मामले हैं। एक जी 5 बाइट्स से कम में उत्पन्न नहीं किया जा सकता है, इसलिए हमें इसका सहारा लेना होगा "f"1+,@। एक कॉमा सबसे अधिक जटिल है, जिसे प्लेफील्ड के गतिशील संशोधन की आवश्यकता है 0g4-:80p @:। हम चरित्र से बचने के लिए एक समान तकनीक का उपयोग कर सकते हैं, लेकिन %टर्मिनेटर के रूप में (मोडुलो) कमांड का उपयोग करने के लिए एक अधिक कुशल हैक है 88*,%। जब% पहुंच जाता है तो स्टैक पर कुछ भी नहीं होता है, इसलिए मोडुलो गणना शून्य से एक विभाजन उत्पन्न करती है, और संदर्भ दुभाषिया पर यह कार्यक्रम समाप्त कर देगा।

नीचे कार्यक्रमों की पूरी सूची है, प्रति पंक्ति एक।

1g,@
1g1+,@
g3/,@
57*,@
49*,@
1g5+,@
1g6+,@
1g7+,@
58*,@
1g9+,@
0g6-,@
0g5-,@
0g4-:80p @
59*,@
0g2-,@
0g1-,@
.@
!.@
11+.@
21+.@
31+.@
41+.@
51+.@
61+.@
71+.@
81+.@
>g4-,@
:g1+,@
:g2+,@
:g3+,@
:g4+,@
79*,@
88*,%
>g3+,@
>g4+,@
>g5+,@
>g6+,@
>g7+,@
>g8+,@
>g9+,@
89*,@
Hg1+,@
Ig1+,@
Jg1+,@
Kg1+,@
Lg1+,@
Mg1+,@
Ng1+,@
Og1+,@
99*,@
Qg1+,@
\g9-,@
\g8-,@
\g7-,@
\g6-,@
\g5-,@
\g4-,@
\g3-,@
\g2-,@
\g1-,@
_g3-,@
\g1+,@
g9-,@
g8-,@
g7-,@
g6-,@
g5-,@
g4-,@
g3-,@
g2-,@
g1-,@
"f"1+,@
g1+,@
g2+,@
g3+,@
g4+,@
g5+,@
g6+,@
g7+,@
g8+,@
g9+,@
tg3-,@
tg2-,@
tg1-,@
:g2*,@
tg1+,@
tg2+,@
tg3+,@
tg4+,@
tg5+,@
tg6+,@
tg7+,@
>g2*,@
tg9+,@
*g3*,@
— जेम्स होल्डरनेस
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.