ඔබේ කාර්යය (පමණක් මුද්රණය කළ හැකි බසක් සහ / හෝ ටැබ් සහ හිස් පේලි ගැන භාවිතා කරමින්) (මෙම මුද්රිත ASCII අවකාශය හරියටම චරිත අතරින් මුද්රණය කරන වැඩසටහන නිර්මාණය කිරීම වේ 0x20කිරීමට 0x7e) ඒ නැහැ කෙසේ වෙතත්, ඕනෑම සඳහා (ඔබගේ වැඩසටහනේ මූල කේතය පෙනී ඔබට අවශ්‍ය වාර ගණනක්).

ඕනෑම භාෂාවකින් මෙය කිරීමට ඇති කෙටිම කේතය ජය ගනී.

ගොල්ෆ් ස්ක්‍රිප්ට්, අක්ෂර 15 12

{`),32>^.}.~

ජෑන් ඩ්වොරක්ගේ පිළිතුර පදනම් කරගෙන විකෘති කිහිපයක් සහ පීටර් ටේලර්ගේ ශෛලිය අනුව .

පොලිග්ලොට්, 95

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

• පර්ල්
• පර්ල් 6
• ඕනෑම * NX-වැනි shell ( tclsh, bash, sh, ksh, ආදී)
• අවුල් (GNU / POSIX)
• බ්‍රේන්ෆක් , බ්‍රයන් සහ චක් , වෙනත් ව්‍යුත්පන්නයන්
• රූබි
• කෝෆ්ස්ක්‍රිප්ට්
• ගොල්ෆ් පිටපත
• පයිතන්
• ආර්
• ජූලියා
• වයිට්ස්පේස්
• rk
• Gaot ++
• bc
• jq
• සතුට
• Tcl
• 99 යි
• V (FMota)
• ඇක් !!
• සී - main()අවශ්‍ය නොවේ නම්. යූරොන්ට ස්තූතියි
• බොහෝ විට.

කිසිවක් නොකරයි.

PHP 5.2, 4

<?<<

NYUIOMK()'DEAQRWVX[Z]\^@CBGFJqwv{z}|~`bgfkj203547698;=>!#"%$&+*-.phpකොතැනක හෝ ඇති ගොනුවක් ලෙස සුරකින්න /home. short_open_tagවිය යුතු Onඔබේ php.ini.

ප්‍රතිදානය:

PHP Parse error:  syntax error, unexpected T_SL in /home/wherever/NYUIOMK()'DEAQRWVX[Z]\^@CBGFJqwv{z}|~`bgfkj203547698;=>!#"%$&+*-.php on line 1

ජාවාස්ක්‍රිප්ට් - 88

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

"bcdfghijkmnpquvxyz" මුද්‍රණය කරයි

වයිට්ස්පේස්, අක්ෂර 61 57

එය කෙටිම නොවේ නමුත් එය බොහෝ විට සරලම තර්කනය ඇත (එය ඇත්තෙන්ම පුඩුවක් පමණි).

මෙන්න එය සම්පුර්ණයෙන්ම අදහස් දක්වා ඇත, එහිදී S අවකාශය, T යනු පටිත්ත, L යනු රේඛීය සංග්‍රහය:

SSSTSSSSSL     # push 0x20
LSSSL          # label S
SSSTL          # push 1
TSSS           # add
SLS            # duplicate top of stack
SLS            # duplicate again
TLSS           # output ASCII character
SSSTTTTTTSL    # push 0x7E
TSST           # subtract (result - 0x7E)
LTTSL          # branch to label S if top of stack is negative
LLL            # end

ඉහත කරුණු නිවැරදි කිරීම සඳහා @res ට ස්තූතියි (ශාඛා උපදෙස් සඳහා අමතර අනුපිටපතක් අවශ්‍ය වේ) සහ කුඩා සංඛ්‍යාවක් තොගයට තල්ලු කිරීම සඳහා.

සී, අක්ෂර 83 74 69

main(z) {for(;++z<96;"\33iE!vk?}GkRP8z"[z/7]&1<<z%7&&putchar(z+32));}

මම එය අක්ෂර 80 ට වඩා අඩු කිරීමට උත්සාහ කළෙමි, නමුත් මට එය ඇද ගැනීමට නොහැකි විය. මෙය පළ කිරීමෙන් මිනිත්තු දහයකට පසුව මම (හෝ වෙනත් අයෙකු) අක්ෂර 79 ක විසඳුමක් සොයාගනු ඇතැයි යන උපකල්පනය මත මා සතුව ඇති දේ පළ කිරීමට මම අවසානයේ තීරණය කළෙමි. හරි, එය විනාඩි දහයක් නොවේ, නමුත් එය ප්‍රතිපත්තිමය වශයෙන් ක්‍රියාත්මක විය.

මට ඇත්ත වශයෙන්ම අවශ්‍ය වූයේ ප්‍රභව කේතයේ අනවශ්‍ය ඉඩක් නොතිබිය යුතු අනුවාදයක් පළ කිරීමට ය, නමුත් එය අමුතු ආකර්ශනීය කක්ෂයකට ගොඩ බැස්සේ විසඳුම් අතලොස්සක් අතරට ය. ඔවුන්ගෙන් එක් අයෙකු ස්ථාවර විසඳුමකට තල්ලු කිරීමට මිනිත්තු ගණනක උත්සාහයෙන් පසුව, මම එය අත්හැර අවකාශය එකතු කළෙමි.

ගොල්ෆ් පිටපත, 26 අක්ෂර 24 යි

"126,32>''+".~\-'.~\-"'-

පරාස පරම්පරාවේ ස්ක්‍රිප්ටයක් ගෙන, එය අනුපිටපත් කර, ක්‍රියාත්මක කර, එහි ප්‍රති result ලයෙන් එය ආදේශ කර, පසුව ප්‍රති result ල අඩු කිරීමේ කේතය සහ අනෙක් උපුටා දැක්වීමේ අක්‍ෂරය ආදේශ කරයි.

මාළු - 80

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

මාළු දෝෂ ඇති විට එය මුද්‍රණය කරන්නේ "යමක් මාළු සුවඳක් දැනේ ...". Z නරක උපදෙස් බැවින් එය වහාම වැරදී යයි

මම දන්නවා එය කිසිදු තරඟයක් ජය නොගන්නා බව. මට අවශ්‍ය වූයේ එය සාමාන්‍යයෙන් භාවිතා නොකරන භාෂාවකින්, පයින් ගැසීම සඳහා පමණි.

ජාවා - 209 195 152 140 අක්ෂර

class a{public static void main(String[]a){for(char c=0;;c++)System.out.print("publicas{tvodmn(Srg[])h=0;w+ye.\"\\xO<?:}".indexOf(c)<0?c:"");}}

රේඛා බිඳීම් සහ ටැබ් සමඟ

class a{
    public static void main(String[]a) {
        for(char c=0;;c++)
            System.out.print("publicas{tvodmn(Srg[])h=0;w+ye.\"\\xO<?:} ".indexOf(c)<0?c:"");
    }
}

ඔබ ක්‍රියාත්මක කරන්නේ නම් පරිස්සම් වන්න: වැඩසටහන අවසන් නොවේ. හාහා

පැහැදිලි කිරීම

1. for(char c=0;;c++): A charලෙස සැලකිය හැකි බැවින්, හැකි සෑම අගයක්ම වැඩි කර ගැනීම සඳහා intමම එය මෙහි මගේ වාසියට යොදා ගනිමි c. අක්ෂර සුරැකීම සඳහා මම ලූපයේ අවසන් වන තත්වය (අර්ධ සළකුණු දෙක අතරට යන එක) අතහැර දමමි. :)
2. "publicas{tvodmn(Srg[])h=0;w+ye.\"\\xO<?:} ".indexOf(c)<0?c:"": කනගාටුවට කරුණක් නම්, ඉතා අලංකාර ප්‍රවේශයක් නොව, එම කාර්යය ඉටු කිරීමයි. ප්‍රභව කේතයේ ඇති සෑම අක්‍ෂරයක්ම Stringවචනාර්ථයෙන් ලැයිස්තුගත කරන්න, ඉන්පසු char cඑය තුළ ධාරාව සිදුවන්නේ දැයි පරීක්ෂා කරන්න indexOf(). නම් indexOf()ඇමතුමක් ප්රතිලාභ -1, එය නොපවතියි, එම නිසා අප එය මුද්රණය කළ යුතුය. එහි ඉතිරි කොටස අක්ෂර සහ අවකාශය සුරැකීමට ත්‍රිමාණ ක්‍රියාකරු භාවිතා කරයි.

පර්ල්, අක්ෂර 49 යි

say grep/[^+-246\[-^aceghmprsy]/,map chr,041..126

මෙය සිත්ගන්නාසුලු අභියෝගයකි - එය එක්තරා ආකාරයක ප්‍රති-ක්වයින් වර්ගයක් වන අතර, එහි ඇති අක්ෂර පරාසය වැඩි කිරීමෙන් වැඩසටහන කිහිප වතාවක් කෙටි කිරීමට මට හැකි විය .

රූබි, 81 78 68 66 62 57

(?!..?~).map{|a|$><<a if/[()ifmap{}|?!.~\/\\\[\]$><]/!~a}

සරලවම පරීක්ෂා කරයි. අනුපිටපත් අතින් අතින් ඉවත් කරන ලදි.

අක්ෂර 4 ක් ඉතිරි කිරීම ගැන ජොෂ්ට ස්තූතියි, සහ අක්ෂර 5 ක් ඉතිරි කිරීම සඳහා මිනිටෙක්!

බෙෆන්ජ් (48)

<|::-1,+*88:<+3*87
6<@.**85
9>"()~&"/%$ |!#';=?}

ප්‍රතිදානයන්: {zyxwvutsrqponmlkjihgfedcba` _ ^] [ZYXWVUTSRQPONMLKJIHGFEDCBA240

එතරම් බැරෑරුම් නොවේ, නමුත් මට එය අත්හැර දැමීමට සිදු විය:

JSFuck (138152)

(සම්පාදිත මූලාශ්‍රය මෙහි)

මුල් ප්‍රභවය:

for(x=0x7e;x>0x19;x--){
    console.log(String.fromCharCode(x).replace(/[\[\]!\+\(\)]/ig, ''))
}

() + [] හැර සියලුම අක්ෂර මුද්‍රණය කරයි !

ඔබේ කාර්යය වන්නේ වැඩසටහනක් තැනීමයි (මුද්‍රණය කළ හැකි ASCII අක්ෂර සහ / හෝ ටැබ් සහ නව රේඛා පමණක් භාවිතා කිරීම)

ගෝෂ්, ඔබ ඒපීඑල් සඳහා එය අමාරු කළා (එය හිතාමතාමද?)
එබැවින් මම සියලු නීති නොසලකා හැරීමට තීරණය කරමි !!!

ඒපීඑල් (ඩයලොග්), 3 10

⎕AV

පරමාණුක දෛශිකය මුද්‍රණය කරයි (සියලුම මුද්‍රණය කළ හැකි ASCII අක්ෂර ඇතුළත් වේ)

"නැති" කොටස මට සම්පූර්ණයෙන්ම අමතක වී ඇති බව හැරෙනවා ...
නමුත් එය පහසු විසඳුමක්

⎕AV~'AV'''

~'AV'''යන්නෙන් අදහස් කරන්නේ ( ~) A, V සහ තනි උපුටා දැක්වීම් (ද්විත්ව තනි උපුටා දැක්වීම් ලෙස පැන යාම)

ASCII නොවන මුද්‍රණය සම්බන්ධයෙන්, මම සියලු නීති නොසලකා හරිමි.

ගොල්ෆ් ස්ක්‍රිප්ට් (අක්ෂර 18 16)

"),@`^^32>#.~".~

අතිරේක රේඛාවක් සමඟ සබැඳි නිරූපණය නිරවද්‍යතාව පරීක්‍ෂා කරන අතර වැරදි අක්ෂර ගණන ප්‍රතිදානය කරයි.

(මට විවිධ සමාන විකල්ප තිබේ. @`^එය ප්‍රතිස්ථාපනය කළ හැකිය \\`; ප්‍රතිස්ථාපනය #කළ හැකිය . `හෝ ]නිවැරදි සංයෝජනය හොවාර්ඩ්ගේ උපක්‍රමය සමඟ ඔහුගේ ලකුණු 15 ට සමාන කළ හැකිය. {),\`^32>].~}.~නමුත් එම උපක්‍රමයේ ගෞරවය හොවාර්ඩ් ලැබිය යුතුය).

බ්‍රේන්ෆක්, 173

+++++[->++++++<]>>>++[------<+>]<++++>>----[----<+>]>-[-------<+>]>-[---<+>]<------->>-[---<+>]<+++++++++>>--[-----<+>]<+++++>>+[---------<++>]+++++++++++++[<[.+<]>[>]<-]\=,

සෑහෙන කාලයක්, මට පසුව නැවත උත්සාහ කළ හැකිය.

ජේ ( 52 40)

සංස්කරණය කරන්න: ඩූ, අමතකයි e.

'''(-@.e#[)~95{32}a'(-.@e.#[)~95{.32}.a.

පැරණි අනුවාදය:

(>@(*/@('(>@*/''&~:).#]32{95}a'&~:)&.>)#])95{.32}.a.

වෙනත් ප්‍රභේදයක් (එකම දිග නමුත් අඩු ප්‍රතිදානය):

([#~*/"1@('([#~*/"1@''&:0)95{.32}a'&~:"0))95{.32}.a.

පයිතන් 3 - 68 යි 61

x=r"print(*set(map(chr,range(32,127)))-set(x+'=\"'))"
exec(x)

... වැඩිදියුණු කිරීම් සඳහා @ වුල්ෆ්රාම් එච් වෙත ස්තූතියි.

පවර්ෂෙල්: 96

සුරැකිය යුතු අතර පිටපතක් ලෙස ධාවනය කළ යුතුය.

diff([char[]](gc $MyInvocation.InvocationName))([char[]](32..126))-Pa|?{$_.SideIndicator-eq'=>'}

diffසඳහා සාදන ලද අන්වර්ථයකි Compare-Object.

gcසඳහා සාදන ලද අන්වර්ථයකි Get-Content.

$MyInvocation.InvocationName ස්ක්‍රිප්ට් ක්‍රියාත්මක කිරීමට සම්පූර්ණ මාර්ගය ලබා ගනී.

32..126යනු දශමයට සමාන 0x20..0x7eවන අතර ඒ නිසා අප සොයන දශම ASCII කේත සමූහයක් නිර්මාණය කරයි.

[char[]]ඊළඟ වස්තුවේ අන්තර්ගතය ගෙන ඒවා අරාවකට දමා ඒවා බිඳ දමා ASCII අක්ෂර බවට පරිවර්තනය කරයි. ඉතින්, අපට දැන් ASCII අක්ෂර දෙකක් තිබේ - එකක් මෙම පිටපතෙන් ඇද ගන්නා ලද අතර අනෙක අභියෝග නිර්ණායක මගින් අර්ථ දක්වා ඇත.

-PaCompare-Object"Passthru" ආකෘතියට සකසයි , එබැවින් යෙදවුම් අතර වෙනස් වන අයිතම පමණක් කොන්සෝලයෙහි ප්‍රතිදානය වේ - වස්තුවේ දත්ත තුළ ආදානය තවමත් ගබඩා කර ඇති නමුත් දර්ශණය නොකෙරෙන අයිතමයන්ගේ දර්ශක.

|?{$_.SideIndicator-eq'=>'}පයිප්පයේ Compare-Objectප්‍රතිදානය Where-Object, එය දෙවන ආදානයට පමණක් සීමා වූ අයිතම වලට පමණක් පෙරහන් කරයි.

PHP - 92

<? //A"$%&'()*+[,.]0123456789:=-@ABCDEFGHIJKLMNOPQRSTUVWYZ\^_`abcdefghijklmopqrstuvwxyz{|}~#

ප්‍රතිදානය:

කිසිවක් නැත

OP භාවිතා නොකරන සියලුම අක්ෂර මුද්‍රණය කරන ලෙස ඉල්ලා සිටී, හොඳයි, මම ඒවා සියල්ලම භාවිතා කරමි

ජාවාස්ක්‍රිප්ට්, 92

(function f(){for(i=32;126>i++;)!~(""+f).indexOf(c=String.fromCharCode(i))&&console.log(c)})()

ජාවා - අක්ෂර 126

අවම:

class hjq{public static void main(String...w){for(char z='"'|0;++z!='a';)if("'()+.0;=OS".indexOf(z)==~0)System.out.print(z);}}

අඩු නොකළ:

class hjq {
    public static void main(String... w) { 
        for (char z = '"'|0; ++z != 'a';) {
            if ("'()+.0;=OS".indexOf(z) == ~0) {
                System.out.print(z);
            }
        }
    }
}

මෙය සිත්ගන්නාසුලු ගැටළුවක් වන බැවින් තනි ටෝකන ඒවායේ දිගු ස්වරූපයෙන් ප්‍රයෝජන ගත හැකි බැවින් එය අක්ෂර නැවත භාවිතා කරයි. උදාහරණයක් ලෙස, සාමාන්‍යයෙන් String[]කෙටි වනු ඇත, නමුත් String...කොන්දේසි සහිත නූලෙහි වර්ග වරහන් සඳහා අවශ්‍යතාවය ඉවත් කරයි.

උපක්‍රමය නම් පරාසයේ ආරම්භයේ සහ අවසානයේ අක්ෂර උත්සාහ කර භාවිතා කිරීමයි, එවිට ඔබේ ලූප ආරම්භය සහ අවසානය වෙනස් කිරීමෙන් ඔබට ඒවා ප්‍රතිදානයෙන් බැහැර කළ හැකිය.

ජාවා සඳහා, බැහැර කළ යුතු ප්‍රධාන චරිතයක් වන්නේ ", එය නූල් තුළ තිබීම එයින් ගැලවීම අවශ්‍ය වන අතර, එය \ඔබේ වැඩසටහනට එකතු කරන අතර, එය නූලට යා යුතු අතර එය එකතු කරයි \\. "ඔබගේ කොන්දේසි සහිත නූලෙන් ඉවත් කිරීමෙන් ඔබ අක්ෂර 4 ක් ඉවත් කරයි. මෙම වග බලා ගන්න ඔබ භාවිතා කරමින් අත්පත් කර ගත හැකි හා !හා ඔබේ පුඩුවක් ආරම්භ #.

සියලු සිම්පල් අකුරු පමණක්, පරාසයක් අවසන් අසල පෙනී {, |, }හා ~ඔවුන් පසුව එන. ජාවා හි වාචිකතාව නිසා, කුඩා අකුරු බොහොමයක් බොයිලර් තහඩුව සඳහා පමණක් භාවිතා කරයි. ඒ හා සමානව, {සහ }ජාවා වැඩසටහනක් සඳහා ඉතා සුළු වේ, මන්ද බොයිලර් පුවරුවට ඒවා අවශ්‍ය වේ.

|ඔබට තත්වයක් හෝ කොන්දේසියක් තිබේ නම් භාවිතා කළ හැකිය, නමුත් |බිට්වේස් ක්‍රියාකරුවෙකු ලෙස භාවිතා කරනවාට වඩා කෙටි වැඩසටහනකට මඟ පෙන්වන ක්‍රමයකින් ප්‍රයෝජන ගැනීමට මට ක්‍රමයක් සොයාගත නොහැකි විය . මේ |0නිසා මට ටිකක් අපිරිසිදු බවක් දැනේ, මන්ද එය චරිතය ලබා ගැනීමට ඇති එකම කොටසයි.

~0අස්වැන්න -1, එය පහසු බැවින් එය අප විසින් පරීක්ෂා කළ යුතුය indexOf. මෙය !=ලූප කොන්දේසි සහිත භාවිතය සමඟ සංයෝජනය කිරීමෙන් <අක්‍ෂරය මුළුමනින්ම ඉවත් කරයි , එයින් අදහස් කරන්නේ එය කොන්දේසි සහිත නූල තුළට යාමට අවශ්‍ය නොවන බවයි.

sh (47)

tr</dev/urandom -cd \[:print:]|tr -d "`cat $0`"

ස්වයං-යොමු කිරීමේ ප්රවේශය භාවිතා කරයි. උපකල්පන /dev/urandomඅවසානයේ සෑම අෂ්ටකයක්ම අවම වශයෙන් එක් වරක්වත් ප්‍රතිදානය කරනු ඇත. අවසන් නොවේ.

manඑය ස්ථාපනය කර ඇතැයි අපි උපකල්පනය කරන්නේ නම්, අපට ඒ වෙනුවට ascii(7)මෑන්පේජ් භාවිතා කළ හැකිය (මේ අනුව අවසන් කිරීමේ වැඩසටහනක් ඇත) ( අක්ෂර 44 , ස්තූතියි enfennec).

man ascii|tr -cd \[:print:]|tr -d "`cat $0`"

බිට්ෂිෆ්ට් , බයිට් 1038

BitShift පමණක් සහය වන භාෂාව වන්නේ 0සහ 1කාරක රීති ලෙස. අනෙක් සියලුම අක්ෂර මුද්‍රණය කිරීම පහසු වනු ඇතැයි මම සිතුවෙමි, නමුත් එය සැබවින්ම ලූපයට සහාය නොදක්වන බැවින් එය තවමත් බයිට් 1038 ක දැවැන්ත අගයක් ගනී.
කෙසේ වෙතත්, මම විශ්වාස කරන්නේ මෙයට වඩා කුඩා කිසිවක් යා නොහැකි බවයි ..

101001100101011011010100110111010100100101011001101111010100100101011001000101011011010100101100110110101001001010110010001010110110101000001101010010010101100100010101101101010000010000011001010110110101000010000101011011010100110111010100100101011111100101011011010100110111010100100101011001101111010100100101011001000101011011010100000000011010100100101011001000101011011010100110010000101011011010100110111010100100101011001101001101010010010101100100010101101101010011001000010101101101010011011101010010010101111011111110010101101101010011011101010010010101100101100101011011010100010001010110110101001000010101101101010011011101010010010101110111110010101101101010011011101010010010101111111100101011011010100110111010100100101011111011110101001001010110010001010110110101001000100000101011011010100110111010100100101011111010011010100100101011001000101011011010100100000101011011010100110111010100100101011001101111010100100101011001000101011011010100010000010101101101010011011101010010010101101001101101010010010101101001101010

මුද්රණ

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

එය මෙහි උත්සාහ කරන්න

නිසැකවම මෙහි දීර් est තම විසඳුම, නමුත් ලිනෝ හි කේතීකරණය සැමවිටම විනෝදජනක ය:

L.in.oleum -655 යි අක්ෂර 523

"libraries"/arch/cpu/base;/hmi/conout;/data/bytes;/data/string/t2s;/data/heap;/data/heap/connect/mgrab;"stockfile"a;"directors"displaystatus=engage;"injection"c=524;b<-bytes.bytesizeconvert:c;b<-heap.alloc:b;a<-heap.alloc:c;[filecommand]=readfile;[filename]=stockfile;[fileposition]=0;[fileblocksize]=c;[fileblockpointer]=b;arch.fileread;[string.psource]=b;[string.ptarget]=a;string.t2s;b<-heap.alloc:7fh;c=32;d=b;"f"[d_32]=c;+c;+d;?c<7fh>f;"w"d=[a];+a;?d=0>y;?d<32>w;?d>7eh>w;e=b;e+d;[e]=33;^w;"y"b+32;"v"conout.say:b;bye;

අදහස් දැක්වීමක් නැත, ද්විමය ලෙස සම්පාදනය කරන ලද මූලාශ්‍රය කියවන්න. ලෙස සුරකින්න a.txtහෝ එය සම්පාදනය නොකරනු ඇත!

බ්‍රේන්ෆක්, 133 123 114 110 බයිට්

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

කලින් විසඳුමක් සමඟ මඳක් වැඩි අවධානයක් යොමු කිරීම (පහත දැක්වෙන දේ කුඩා බව මට වැටහෙන්නට පෙර - මේ සියල්ල මම විශාල ප්‍රශස්තිකරණයකට පෙර සිදු විය). මෙය ක්‍රියාත්මක වන්නේ ඇස්කි අංක 4 ක් ගබඩා කර ඒවා උපක්‍රමශීලී ලූපයකින් මුද්‍රණය කර පසුව නැතිවූ අක්ෂර පසුව ලබා දෙන්න (එනම් අවලංගු ඇස්කි අංක අතර ඇති).

මුල් ඉදිරිපත් කිරීම

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

එය පහත සඳහන් දේ කරයි:

• 11. 13, 28, 33 අඩංගු ලේඛණ 4 ක් සාදන්න
• මුද්‍රණය ආරම්භ කිරීම සඳහා 31 අගය සමඟ 5 වන කොටස සාදන්න
• Ascii 32-42 (11) මුද්‍රණය කරන්න
• Ascii 44 මුද්‍රණය කරන්න
• Ascii 47-59 (13) මුද්‍රණය කරන්න
• Ascii 61 මුද්‍රණය කරන්න
• Ascii 63-90 (28) මුද්‍රණය කරන්න
• Ascii 92 මුද්‍රණය කරන්න
• Ascii 94-126 (33) මුද්‍රණය කරන්න

හස්කල් (70)

import Data.List
main=putStrLn$[' '..'~']\\" \\\"$'.=DLS[]aimnoprstu~"

නීරස අනුපිටපත්-අක්ෂර-වැඩසටහන-තුළ-නූල්, විශ්ව-සැකසුම් විසඳුමෙන් අඩු කරන්න. කෝඩ්ගොල්ෆ් ජයග්‍රාහකයෙකුට වඩා, එහි දිග ගැන පුදුම සහගත ලෙස පැහැදිලි වුවද.

(දැන් filter/ notWith. වෙනුවට ලැයිස්තු අඩු කිරීම සමඟ )

ජේ - 21

(u:32+i.97)-.1!:1<":5

5වත්මන් නාමාවලියෙහි ඇති ගොනුවකට මෙය ලියන්න . ඉන්පසු ස්ක්‍රිප්ට් එක ක්‍රියාත්මක කරන්න0!:1<'5'

හෝ 25 ගොනු උපක්‍රම නොමැතිව:

(-.~".)'(":u:32+i.0-~95)'

Clojure (142, 106, 103)

(defn -main[](let[c"(fn[l](pr(reduce disj(set(map char(range 32 126)))l)));-\\\"o"]((load-string c)c)))

ආකෘතිකරණය:

(defn -main []
  (let [c "(fn[l](pr(reduce disj(set(map char(range 32 126)))l)));-\\\"o"]
    ((load-string c) c)))

මෙය සිදු කරයි යැයි සිතන්න, සමහර වෙනස් කිරීම් අවශ්‍ය විය හැකිය. ප්‍රතිදානය:

#{@ ` ! A B b # C $ D % E & F ' G H I * J + K k , L M . N / O 0 P Q q R S 4 T 5 U V v 7 W w 8 X x 9 Y y : Z z { < | = } > ^ ? _}

තක්සේරු කළ හැකි ක්ලෝජර් කේතයක් වන නූල ක්‍රියාත්මක වේ. නූල් වලින් පිටත භාවිතා කරන අක්ෂර ලබා ගැනීම සඳහා නූල් අවසානයේ අදහස් කිහිපයක් ඇත (ප්‍රධාන ක්‍රමය, ආදිය)

පයිතන් 2, 69

for x in range(38):print chr(x+59)#!"$%&'*,-./012467bdjklmqsuvwyz{|}~

අඛණ්ඩ අක්ෂර මාලාවේ දීර් est තම (මට සොයාගත හැකි) අනුක්‍රමය මම මුද්‍රණය කර අනෙක් ඒවා කේතයෙන් පසුව අදහස් දැක්වීමක් ලෙස එක් කරමි.