ඔබේ භාෂාව භාවිතයට නුසුදුසු කරන්න


196

ඔබේ භාෂාවෙන් යම් කේතයක් ලිවීමට උත්සාහ කර එය අපගේ තෘප්තියට පත් නොකරන්න ක්‍රමලේඛන භාෂාවක් වීමේ නිර්ණායක සපුරාලන්නේ නැත.

ක්‍රමලේඛන භාෂාවක් වීම පිළිබඳ භාෂාවක් අපගේ නිර්ණායක (මෙම අභියෝගය සඳහා සරල කළ අනුවාදය) තෘප්තිමත් කරන්නේ නම්:

  • යම් ආකාරයකින් ධනාත්මක නිඛිලවල ටුපල් නියෝජනය කරන පරිශීලක ආදානය එයට කියවිය හැකිය.
  • එය ආදානය මත පදනම්ව අවම වශයෙන් වෙනස් ප්‍රති results ල දෙකක්වත් ලබා දිය හැකිය.
  • එයට ධනාත්මක නිඛිල දෙකක් ගෙන ඒවා එකතු කළ හැකිය (ප්‍රති result ලය ප්‍රතිදානයට බලපායි).
  • එයට ධන නිඛිලයක් ගෙන එය ප්‍රාථමිකයක්ද යන්න තීරණය කළ හැකිය (ප්‍රති result ලය ප්‍රතිදානයට බලපායි).
  • මෙම අභියෝගයේ අරමුණ සඳහා, සාමාන්‍ය අභියෝගයක් සඳහා අවසර දී ඇති ප්‍රතිදාන ක්‍රමයක් නොවන ඕනෑම ආකාරයක ප්‍රතිදානයක් නොසලකා හරිනු ලැබේ. එබැවින් වැඩසටහනට සංගීත භාණ්ඩයක් වාදනය කළ හැකිද, නැතහොත් HTTP හරහා පළ කිරීම ආදිය වැදගත් නොවේ.
  • යාවත්කාලීන කිරීම: ඔබට අවසර දී ඇති නිමැවුම් ක්‍රම එකක් හෝ කිහිපයක් තෝරා ගත හැකි අතර අනෙක් සියල්ල නොසලකා හරින්න. නමුත් ඔබ පහත දැක්වෙන නිර්ණායකයන්හි සෑම තැනකම එකම අර්ථ දැක්වීම භාවිතා කළ යුතුය. ඔබේ වැඩසටහනට ප්‍රතිදාන ක්‍රම එකකට වඩා අක්‍රිය කළ හැකි නම් - එය වැඩි දියුණු කිරීම වටී.

නිමැවුම් කිරීමට නොහැකි වීම හෝ සියලු ලූප ඉදිකිරීම් අක්‍රීය කිරීම වැනි උදාහරණ මඟින් ප්‍රාථමික පරීක්‍ෂණයක් කිරීමට නොහැකි වන අතර පරිශීලකයාට ඒවා නැවත සක්‍රීය කළ නොහැකි බවට වග බලා ගන්න.

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

නමුත් ඇතුළත් කළ කේතය නිර්ණායකයන් සපුරාලන භාෂාවක් වැනි ආකාරයකින් ක්‍රියාත්මක කළ යුතුය :

  • ඇතුළත් කළ කේතය ව්‍යාකරණමය වශයෙන් යම් දෙයකට සමාන විය යුතුය (එය පහත දැක්වෙන නිර්ණායකයන්හි කේත වාරණයක් යැයි කියන්න ) සාමාන්‍යයෙන් නිර්ණායක සපුරාලන, සින්ටැක්ස් හයිලයිටරයක් ​​ලිවීමට කැමති අයගේ දෘෂ්ටි කෝණයෙන්. එබැවින් එය නූලක්, අදහස් දැක්වීමක් යනාදියෙහි තිබිය නොහැක.
  • ඇතුළත් කළ කේතය ඇත්ත වශයෙන්ම ක්‍රියාත්මක කළ යුතුය, යම් ආකාරයකින් එය නිර්ණායක සපුරාලිය යුතුය. එබැවින් එය භාවිතයට නොගත් ශ්‍රිතයක විය නොහැකsizeof සී හි විය නොහැක, ඔබට කේතයේ ක්‍රියාකාරී නොවන කොටසක් පමණක් ක්‍රියාත්මක කළ නොහැකි අතර ඔබට එය අසීමිත ලූපයකට පසුව තැබිය නොහැක.
  • මේ ආකාරයෙන් ජනනය කළ හැකි ව්‍යාකරණ නිවැරදි වැඩසටහන් ගණන ඔබට සීමා කළ නොහැක. ඔබ භාවිතා කරන භාෂාවේ දිග සීමාවක් වැනි දෙයක් දැනටමත් තිබේ නම්, මෙම සීමාව ඉවත් කළද එය නිර්ණායක සපුරාලිය යුතු නොවේ.
  • ඔබට ආදාන / ප්‍රතිදානයේ අන්තර්ගතය වෙනස් කිරීමට හෝ "භාවිතා කිරීමට" නොහැක, නමුත් ඔබට ඒවාට ප්‍රවේශ වීම වළක්වා ගත හැකිය.
  • මෙම නිර්ණායක සාමාන්‍යයෙන් අදාළ වන්නේ පැහැදිලි I / O නොමැතිව භාෂාවන්ට පමණි:
    • කේත වාරණයකට සාමාන්‍යයෙන් ඔබ භාවිතා කරන භාෂාවෙන් සෘජුවම / පැහැදිලිව පරිශීලක ආදානය ලබා ගත නොහැකි නම්, ඔබේ කේතය පරිශීලක ආදානය (අත්තනෝමතික දිග පිළිබඳ තොරතුරු අඩංගු) ඇතුළු කළ කේතයට හරවා යැවිය යුතුය.
    • කේත වාරණයකට සාමාන්‍යයෙන් ඔබ භාවිතා කරන භාෂාවෙන් දේවල් සෘජුව / පැහැදිලිව ප්‍රතිදානය කිරීමට නොහැකි නම්, ඔබේ කේතය ඇතුළු කළ කේතයේ ආපසු ලබා දුන් අගය මුද්‍රණය කළ යුතුය.
    • ඔබ ආපසු ලබා දුන් අගය මුද්‍රණය කර එය භාවිතා කරන භාෂාවෙන් ටයිප් කර තිබේ නම්, ආපසු ලබා දුන් වර්ගයට ප්‍රායෝගිකව හැකි අගයන් 2 ක් තිබිය යුතුය. උදාහරණයක් ලෙස, ඔබට වර්ගය struct {}හෝ struct {private:int x;}C ++ භාවිතා කළ නොහැක .

මෙය ජනප්‍රියත්වය-තරගයයි. වැඩිම ඡන්දය දුන් වලංගු පිළිතුර (එබැවින් කිසිවෙකු දෝෂයක් හඳුනාගෙන නැත හෝ සියලු දෝෂ නිවැරදි කර ඇත) ජය ගනී.

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

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

ප්‍රමුඛ පුවරුව

var QUESTION_ID=61115/*,OVERRIDE_USER=8478*/;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,/*getComments()*/(more_answers?getAnswers():process())}})}/*function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}*/function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),score:s.score,language:a[1],lang:jQuery('<div>').html(a[1]).text(),link:s.share_link})}),e.sort(function(e,s){var r=e.score,a=s.score;return a-r});var s={},r=1,a=null,n=1;e.forEach(function(e){e.score!=a&&(n=r),a=e.score,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",e.n=n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.score).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text())/*,s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}*/});var t=e/*[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o])*/;t.sort(function(e,s){return (e.lang.toUpperCase()>s.lang.toUpperCase())-(e.lang.toUpperCase()<s.lang.toUpperCase())||(e.lang>s.lang)-(e.lang<s.lang)});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{PLACE}}",o.n).replace("{{LANGUAGE}}",o.language).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.score).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<(?:h\d|(?!.*<h\d>)p)>\s*((?:[^,;(\s]| +[^-,;(\s])+)(?=(?: *(?:[,;(]| -).*?)?\s*<\/(h\d|p)>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
body{text-align:left!important}#answer-list,#language-list{padding:10px;float:left}table{width:250px}table thead{font-weight:700}table td{padding:5px}
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="https://cdn.sstatic.net/Sites/codegolf/all.css?v=7509797c03ea"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Score</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Sorted by Language</h2> <table class="language-list"> <thead> <tr><td></td><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{PLACE}}</td><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>


කේතය ක්‍රියාත්මක කිරීමට පෙර එය වෙනස් කිරීමට මට අවසර තිබේද? එසේම, ලබා දී ඇති කේතය ධාවනය කරන අතරතුර මට වෙනත් කේත ධාවනය කළ හැකිද?
නිල්

21
මෙය මා සිතන තරම් විශාල පොලිස් නිලධාරීන් සහ කොල්ලකරුවන්ට අභියෝගයක් විය හැකිය.
ඩෑන්ක්මේම්ස්

6
Ank ඩෑන්ක්මේම්ස් එකඟ විය. එය පවතින විට, එය බොහෝ අපැහැදිලි වන අතර, බොහෝ පිළිතුරු ක්‍රියාමාර්ගයක් සොයා ගැනීමෙන් අවලංගු වේ. මෙම පරිශ්‍රය සමඟ සීඑන්ආර් රසවත් වනු ඇත.
මෙගෝ

3
එබැවින් පැහැදිලිව පෙනෙන අයි.ඕ. සහිත භාෂාවලින් ස්ටැඩින් හි අන්තර්ගතය කියවීම සහ ඉවතලීම වැනි නීරස දේවල් කිරීමට අවසර ඇති බව පෙනේ. එය සම්පූර්ණයෙන්ම අසාධාරණ ක්‍රීඩා පිටියක් සැකසෙන අතර සමහර භාෂාවන් විසින් ඇතුළත් කළ කේතය සඳහා IO පරිස්සමින් හැසිරවිය යුතු අතර වෙනත් භාෂා මඟින් එය කුණු කූඩයට දැමීමටත් ඇතුළු කළ කේතයට IO ප්‍රතික්ෂේප කිරීමටත් ඉඩ සලසයි.
පීටර් ටේලර්

2
ආරම්භ කිරීමට දැනටමත් භාවිතා කළ නොහැකි භාෂාවක් භාවිතා කිරීමට අපට අවසර තිබේද? (උදාහරණයක් ලෙස JavaScript)
12Me21

Answers:


321

ජාවාස්ක්‍රිප්ට් ෂෙල්

මෙය භාෂාව සම්පූර්ණයෙන්ම භාවිතයට ගත නොහැකි වනු ඇත.

clear(this);

ජාවාස්ක්‍රිප්ට් තමාවම විනාශ කර ගැනීමට මෙතරම් හොඳ කාර්යයක් කරන්නේ කෙසේද?


මෙය ඉතා සරල ය, clearශ්‍රිතය වස්තුවක් සම්පූර්ණයෙන්ම හිස් කරයි. ඉදිකිරීම්කරුවන් සහ කාර්යයන් ඇතුළුව සියල්ලthis ඉවත් කරන ගෝලීය වස්තුව යන්නෙන් අදහස් කෙරේ .


මෙය සෑම දෙයක්ම නිෂ්කාශනය කරන නිසා , ඕනෑම දෙයක් කිරීම , වචනානුසාරයෙන් අර්ථ දැක්වීම පවා දෝෂයක් ඇති කරයි, එමඟින් භාෂාව සම්පූර්ණයෙන්ම නිෂ් less ල වනු ඇත: * REPL පරිසරය අවශ්‍ය නොවේ . භාවිතා කරයිඋදාහරණ භාවිතය SpiderMonkey එන්ජින් විධාන (බ්රවුසරය නැත), මුල් JS එන්ජිම.


5
එම clearශ්‍රිතය ස්පයිඩර්මන්කි-ෂෙල්-විශේෂිත එකතු කිරීමක් ලෙස පෙනේ, සාමාන්‍ය ජාවාස්ක්‍රිප්ට් දෙයක් නොවේ. එය නිසැකවම ගෝලීය වස්තුවෙහි ES5 පිරිවිතර § ක්‍රියාකාරී ගුණාංගවල නොපෙන්වයි . මම මෙය උත්සාහ nodeකර "ReferenceError: clear යන්න අර්ථ දක්වා නැත". ක්‍රෝම් සහ ෆයර්ෆොක්ස් හි කොන්සෝලය තුළ, clearකුමන තර්ක සම්මත වුවද, ශ්‍රිතය කොන්සෝලය හිස් කරයි. නැතහොත් ඔබ භාවිතා කළ මෙවලම 5.1 ට වඩා පැරණි ECMAScript අනුවාදයකට අනුකූලද?
ඇන්කෝ

2
ඒ වෙනුවට ඔබට “ජාවාස්ක්‍රිප්ට් විනාශ කිරීමට තරම් හොඳ කාර්යයක් තිබීම සතුටක් නොවේද?” යන ප්‍රකාශය සංශෝධනය කළ හැකිද? ජාවාස්ක්‍රිප්ට් සතුව එම ශ්‍රිතය නොමැත, ස්පයිඩර්මන්කි ක්‍රියාත්මක කිරීම පමණක් සිදු කරයි.
ඇන්කෝ

1
N ඇන්කෝ ස්පයිඩර්මන්කි යනු ජාවාස්ක්‍රිප්ට් වුවද එය ෆයර්ෆොක්ස් සමඟ එකතු වේ (ස්පයිඩර්මන්කි යනු ෆයර්ෆොක්ස් හි ජේඑස් එන්ජිමයි). මම වේලාව ඇති විට පසුව node.js යනාදිය සඳහා අනුවාදයක් ලියමි
ඩවුන්ගෝට්

7
මම හිතන්නේ ඔබ ජාවාස්ක්‍රිප්ට් (භාෂාව) ස්පයිඩර් මොන්කි ( භාෂාවේ බොහෝ ක්‍රියාත්මක කිරීම් වලින් එකක් ) සමඟ පටලවා ගෙන ඇත. අතිශයින්ම උපමාව: මානව හිමිකම් ප්‍රකාශනයේ සම්පූර්ණ පිටපත මුද්‍රණය කිරීම සඳහා නිර්වචනය නොකළ හැසිරීමේ සියලු ආයාචනා වල ප්‍රති C ලයක් ලෙස සී හි පිස්සු ක්‍රියාත්මක කිරීමක් මට ලිවිය හැකි අතර , බොහෝ විට මගේ සී ඉදිරිපත් කිරීම “ගොල්ෆ් යූඩීඑච්ආර්” යැයි තර්ක කිරීමට මට නොහැකි වනු ඇත. “එය ශුන්‍ය දර්ශකයක් අවලංගු කිරීම වලංගු C විසඳුමකි. :)
ඇන්කෝ

8
N ඇන්කෝ අඩවි රීතියක් අනුව, භාෂාවක් අර්ථ දැක්වෙන්නේ එය ක්‍රියාත්මක කිරීමෙනි. ප්‍රශ්නයට පෙර ප්‍රකාශයට පත් කරන ලද අවම වශයෙන් එක් ක්‍රියාත්මක කිරීමක දී පිළිතුරක් අඛණ්ඩව ක්‍රියාත්මක වන්නේ නම් එය පිළිගත හැකිය. මෙතැනින් සහ මෙතැනින් බලන්න . (එබැවින් කේතය වලංගු වේ. නමුත් මම එම නිශ්චිත වචන ගැන අදහස් දක්වන්නේ නැත.)
jimmy23013

173

චිත්තවේගීය

;#33!

මම දන්නවා මෙය කේත ගොල්ෆ් නොවන බව, නමුත් කාර්යය සඳහා නිවැරදි මෙවලම, ඔබ දන්නවා ...

පරිශීලක කේතය පසුව ඇතුළත් කළ හැකිය !.

Emmental යනු පරිවර්තකයා නැවත ලිවීම මත පදනම් වූ සිත්ගන්නාසුලු esolang වේ . සෑම සංකේතයක්ම (ගොඩනඟන ලද ඒවා ඇතුළුව) අත්තනෝමතික Emmental වැඩසටහනක් ලෙස නැවත අර්ථ දැක්විය හැකිය. භාෂාව මෙම අංගය මත රඳා පවතින අතර එය කිසිදු ලූප සැකැස්මක් සපයන්නේ නැත. ඒ වෙනුවට, ඔබ ඔවුන්ගේම අර්ථ දැක්වීම්වල දැක්වෙන පුනරාවර්තන විධාන අර්ථ දක්වයි.

මෙම ප්‍රතිනිර්මාණය සිදුවන්නේ !, එය අකුරෙන් අක්‍ෂරයක් කියවන අතර, එය හමු වන තුරු තොගයේ සිට නූලක් කියවයි ;. චරිතය නැවත අර්ථ දැක්වෙන්නේ එම නූලෙන් නිරූපණය වන වැඩසටහනයි.

මාධ්යයන්, අපි නව අරුතක් විසින් Emmental ගේ ප්රහාරක විශේෂාංග අක්රීය කල හැක ! හිස් වැඩසටහනක් ලෙස. අනෙක් සියලුම එමල් කේතය තවමත් හොඳින් ක්‍රියාත්මක වන අතර ක්‍රමලේඛන භාෂාවක බොහෝ නිර්ණායක තවමත් සපුරා ඇති නමුත් තවත් සංකේත නැවත අර්ථ දැක්විය නොහැක. මෙම අංගය නොමැතිව (එම නිසා, ලූප් කිරීමට නොහැකිව), එමන්ටල්ට තවදුරටත් අංකයක් ප්‍රමුඛද යන්න පරීක්ෂා කළ නොහැක.


50
භාෂාවේ තනි නිර්වචන අංගය අක්‍රීය කිරීම: පිරිසිදු බුද්ධිය. මෙය නිසැකවම කාර්යය සඳහා නිවැරදි මෙවලම වේ. +1
ETH නිෂ්පාදන

97

PHP

මතක සීමාව 1 දක්වා සකස් කිරීමෙන් කෙනෙකුට PHP සම්පූර්ණයෙන්ම විනාශ කළ හැකිය.

එය සම්පූර්ණයෙන්ම මිය යනු ඇත.

මේක උත්සාහ කරන්න:

<?php
    ini_set('memory_limit',1);

    //code here

මේ සඳහා ප්‍රමාණවත් මතකයක් නොමැති බැවින් මෙය කිසිදු දෝෂයක් පවා නොතැබිය යුතුය.

විධානය ගැන ඔබට වැඩිදුර කියවිය හැකියmemory_limit


පෙර එක අවලංගු නම්, කෙනෙකුට ප්‍රතිදාන බෆර භාවිතා කළ හැකිය:

<?php
    ob_start();

    //code here

    ob_clear();

මෙය ඕනෑම ප්‍රතිදානයක් සම්පූර්ණයෙන්ම ඉවත් කරයි. ප්‍රතිදාන බෆරය තවමත් විවෘතව පවතින බැවින්, කේතයෙන් පසුව අහම්බෙන් ඉතිරි වූ තවත් දේවල් ද නොපෙන්වයි.


භාවිතා @fschmengler ගේ අදහස:

<?php
    define('OB_START_LEVEL', ob_get_level());
    ob_start(function(){return'';}, -1, PHP_OUTPUT_HANDLER_CLEANABLE);
    //or, for PHP <5.3:
    //ob_start(create_function('','return"";'), -1, PHP_OUTPUT_HANDLER_CLEANABLE);

    //code here

    while(ob_get_level() > OB_START_LEVEL) ob_clear();

සම්පීඩනය කළ යුතු ප්‍රතිදානය අල්ලා ගැනීමට භාවිතා කරන ස්වයංක්‍රීයව ආරම්භ කරන ලද ප්‍රතිදාන බෆරය මකාදැමීමේ ගැටළුව මෙය වළක්වනු ඇත.

ප්‍රතිදාන බෆරය මකාදැමීම හෝ පිම්බීම (බ්‍රව්සරයට යවනු ලැබේ) මෙය වළක්වයි. එය නැවත දැනුම් දීම සඳහා, ප්‍රතිදාන හසුරුවන්නෙකු එක් කරනු ලැබේ, එය සෑම විටම හිස් නූලක් ලබා දෙයි.
ධාවනය ob_end_flush(); echo "Hello, world!";කිරීමෙන් කිසිවක් නිපදවන්නේ නැත, නමුත් ප්‍රතිදානය සරල ලෙස යවනු ඇත ob_start();.

මෙම ගැටළුව හෙළි කිරීම ගැන ucLucasTrzesniewski ට ස්තූතියි !


1
ඔබට දැඩි මට්ටමේ නිමැවුම් බෆරින් තිබිය හැකි බැවින්, දෙවැන්න ක්‍රියා නොකරයි. බොහෝ විට, while(ob_get_level()) ob_end_flush();අහම්බෙන් විවෘතව තබා ඇති සියලුම නිමැවුම් බෆරයන් ගලවා ගැනීමට රාමු වල භාවිතා වේ.
ෆේබියන් ෂ්මෙන්ග්ලර්

sfschmengler එය ස්වයංක්‍රීයව විවෘත කරන ලද ප්‍රතිදාන බෆර සමඟ ගැටලු ඇති කරයි, සාමාන්‍යයෙන් gzip භාවිතයෙන් ප්‍රතිදානය සම්පීඩනය කිරීමට භාවිතා කරයි. එමඟින් අරමුණ පරාජය වනු ඇත.
ඉස්මයිල් මිගෙල්

මෙය මඟ හැරිය හැක:ob_end_flush(); echo "Hello, world!";
ලූකස් ට්‍රෙස්නියෙව්ස්කි

8
PHP ඡන්ද සටහනේ ඉහළින්ම සිටීම ගැන මා පුදුම නොවන්නේ ඇයි :)
MonkeyZeus

48
This shouldn't even throw any error, since there isn't enough memory for that.LOL'ed at :)
ETHproductions

91

x86 යන්ත්‍ර කේතය තාත්වික ප්‍රකාරයේදී (=> ඕනෑම ඩොස් වැඩසටහනක් පාහේ)

00000000  6a 00 07 b9 00 04 30 c0  31 ff f3 aa              |j.....0.1...|
0000000c

එනම්

push 0
pop es
mov cx,400h
xor al,al
xor di,di
rep stosb

ඔබගේ බාධා කිරීම් මේසයට ඔබත් සම්බන්ධ නොවූ බව මම විශ්වාස කරමි.


75
සර්, මම ඔබට චක්‍ර කිහිපයක් සඳහා බාධා කළහොත් මට අවසන් විය හැකිය ....
දීප්තිමත්

6
ඉතින් මගේ ඇතුළත් කළ කේතයේ පළමු උපදෙස් නම් cli, පසුව මම බාධා වගුව සවි කර, සමහර ප්‍රාථමිකයන් ගණනය කිරීමට යන්නේ නම් කුමක් කළ යුතුද?
නේට් එල්ඩ්‍රෙජ්

3
AteNateEldredge: මීලඟ පියවර වන්නේ ඉතිරි කේතය 3 නාද කිරීම සඳහා සිරගත කිරීමයි. මම එකට වැඩ උදාහරණයක් දමා කළමනාකරණය නම් (තවත් හැකියාවක් මුළු ලිපිනය අවකාශය හා NOP-ඉවත් සියලු පරිලෝකනය කිරීමට වනු ඇත බලන්නම් cli(සහ inpසහ outpඉතා හොඳ පියවරක් සඳහා), නමුත් එම අවසර ලබාදී ඇතැයි නම් මම දන්නේ නැහැ නීති රීති අනුව
මැටියෝ ඉතාලියා

2
අවම වශයෙන් එය පවතින විට, මෙය වැඩසටහනක් සෘජුවම තිර බෆරයට ලිවීම නවත්වන්නේ නැත (එය ඩොස් යටතේ සුලභ විය).
ජෙරී කොෆින්

1
AteNateEldredge: මේ පිළිබඳ නීති සැබවින්ම පැහැදිලි නැත, ඔබ බොහෝ පිළිතුරු දෙස බැලුවහොත් ඇත්ත වශයෙන්ම සුළු වෙනස් උපදෙස් මත යම් ආකාරයක ධාවන කාල දෝෂයක් ජනනය කරන පරිසරයේ වෙනස් කිරීම් වලින් සමන්විත වේ (JS clear(this);, PHP හි මතක සීමාව, පුනරාවර්තනය පයිතන් හි සීමාව, පයිතන්හි වැලිපිල්ල සහිත පරිසරය සහ තවත් බොහෝ දේ), මම මෙය ගැටලුවක් ලෙස නොදකිමි.
මැටියෝ ඉතාලියා

71

ජාවා

import java.io.*;
import java.lang.reflect.*;
public class Test2 {
    public static void main(String[] args) throws Exception {
        args = new String[0];
        System.setOut(new PrintStream(new ByteArrayOutputStream()));
        System.setErr(new PrintStream(new ByteArrayOutputStream()));
        System.setIn(new ByteArrayInputStream(new byte[0]));

        Field modifiersField = Field.class.getDeclaredField("modifiers");
        modifiersField.setAccessible(true);

        Class<?> fdClass = java.io.FileDescriptor.class;
        Field outField = fdClass.getDeclaredField("out");
        outField.setAccessible(true);
        modifiersField.setInt(outField, outField.getModifiers() & ~Modifier.FINAL);
        outField.set(null, new FileDescriptor());
        Field errField = fdClass.getDeclaredField("err");
        errField.setAccessible(true);
        modifiersField.setInt(errField, errField.getModifiers() & ~Modifier.FINAL);
        errField.set(null, new FileDescriptor());
        Field inField = fdClass.getDeclaredField("in");
        inField.setAccessible(true);
        modifiersField.setInt(inField, inField.getModifiers() & ~Modifier.FINAL);
        inField.set(null, new FileDescriptor());

        System.setSecurityManager(new SecurityManager(){
            private boolean exitAllowed = false;
            public void checkPermission(java.security.Permission perm) {
                String name = perm.getName();
                if(name.equals("setIO")
                        || name.equals("setSecurityManager")
                        || name.equals("writeFileDescriptor")
                        || name.equals("readFileDescriptor")
                        || name.equals("suppressAccessChecks")
                        || (perm instanceof FilePermission
                            && name.startsWith("/proc/self/fd/"))){
                    throw new SecurityException("Nope");
                }
                if(name.startsWith("exitVM") && !exitAllowed){
                    exitAllowed = true;
                    System.exit(0);
                }
            }
            public void checkExec(String cmd){
                throw new SecurityException("nope");
            }
        });

        // program here
    }
}

සංස්කරණය කරන්න: ප්‍රති-ප්‍රති-මිනුම් මෙම යෝධයා බවට පත් කරයි :(

Stdin සහ stdout ශුන්‍ය ධාරා වෙත හරවා යවන අතර ආග්ස් හිස් අරාවකින් ප්‍රතිස්ථාපනය කරයි. සම්මත IO සැබවින්ම සැඟවී ඇති බව තහවුරු කර ගැනීම සඳහා අතිවිශාල පරාවර්තන හක්ක භාවිතා කරයි. අවසාන වශයෙන්, එය සම්මත IO ප්‍රතිනිර්මාණය කළ නොහැකි බවට වග බලා ගැනීම සඳහා ආරක්ෂක කළමනාකරුවෙකු සකසයි. එමඟින් වැඩසටහන් වලට පිටවීමේ කේතය සැකසිය නොහැකි බව සහතික කරයි.




10
+1 පුද්ගලිකව මම / proc ක්‍රියාකාරීත්වය ලෙස සලකන්නේ නැත ලිනක්ස් භාවිතා නොකරන නිසාත්, මගේ යුනික්ස් මෙහෙයුම් පද්ධතියට මගේ වින්ඩෝස් මෙහෙයුම් පද්ධතියට / ප්‍රොක් ගොනු පද්ධතියක් නොමැති නිසාත් සැබෑ ගනුදෙනු කඩනයන් ලෙස මම නොසලකමි.
ජෙරී ජෙරමියා

68
මේ දක්වා ඇති මෙම අභියෝගයේ සාරාංශය: 1. ජාවාස්ක්‍රිප්ට්, අක්ෂර 12 යි. 2. චිත්තවේගීය, අක්ෂර 6 යි. 3. x86, බයිට් 12 යි. 4. පයිතන්, අක්ෂර 42 යි. 5. ජාවා, අක්ෂර 2264 ! මා පුදුම නොවන්නේ ඇයි?
හැරීම නතර විය

34
aceceasedtoturncounterclockwis එයට හේතුව ජාවා වඩා ආරක්ෂිත බැවින් එය බිඳ දැමීම දුෂ්කර ය: D
පියරේ ආර්ලෝඩ්

64

ලුවා

_ENV=""

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


1
කරන්නේ _ENV=5වැඩ? එසේ නම්, එය එක් අක්ෂරයක් කෙටි වේ.
user253751

7
ඉමිබිස් ඇත්ත, නමුත් මෙය ජනප්‍රිය තරඟයක් මිස කේත දිග තරඟයක් නොවේ. PS - Lua පිළිතුර මත ඔබව ගෙදරට විශ්වාස කරන්න.
Pharap

ලුවා සඳහා +1. $ _G = නිල් more වැඩි වශයෙන් හෝ අඩුවෙන්ම එසේ නොවේද?
ඩොඩි

Od ඩොඩි නෝප්, _G යනු _ENV හි පිටපතක් පමණක් වන බැවින් ඔබට විචල්‍යයන් සහ ඒ හා සමාන දෑ සොයා බැලීමට භාවිතා කළ හැකිය - එය ඇත්ත වශයෙන්ම පරිසරය නොවේ. කෙසේ වෙතත්, ඔබට _G = නිල් කළ හැකි අතර පසුව පරිසරය _G ලෙස සැකසිය හැකිය, එය එකම බලපෑමක් ඇති කරයි.
නිකෝ ඒ

සම්පූර්ණයෙන්ම සත්‍ය නොවේ. දේශීය විචල්‍යයේ කොතැනක හෝ ඔබට උපස්ථයක් තිබේ නම්, ඔබට එය ප්‍රතිස්ථාපනය කළ හැකිය. ඔබට තවමත් දේශීය විචල්‍යයන් නිර්වචනය කළ හැකි අතර නූල් ආශ්‍රිත ශ්‍රිත පවා අමතන්න!
val පවසන්නේ නැවත

48

ෂේක්ස්පියර් ක්‍රමලේඛන භාෂාව

Have Fun Mr Parser.

Romeo, a young man of Verona.
Juliet, a young lady of Verona.
Hamlet, another character which causes the crash.

Act I
Scene I The crash.

[Enter Romeo]
[Enter Juliet]
[Exit Hamlet]

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

PS මෙම භාෂාව ක්‍රියාත්මක වන්නේ කෙසේදැයි ඔබට අදහසක් නැත්නම් ගූගල් කරන්න. ඒක නියමයි.


1
ඉතින්, එය විග්‍රහ කිරීමේ දෝෂයක්ද නැතහොත් ධාවන කාල දෝෂයක්ද?
ෆේබියන් ෂ්මන්ග්ලර්

4
sfschmengler එය මූලික වශයෙන් අර්ථකථනය කරන ලද භාෂාවන් සඳහා එකම දෙයකි.
nwp

13
අන්තිම පේළියට පසුව මම කේතයක් එකතු කළහොත් එය ඇත්ත වශයෙන්ම ක්‍රියාත්මක වේද?
Sp3000

@ Sp3000 එය නිසැකවම උත්සාහ කරනු ඇත ...... එය සාමාන්‍යයෙන් කිසිවක් සිදු නොවූ බවක් පෙනේ ... විග්‍රහකය බිඳ වැටෙන තුරු. :)
3.14ed_Piper

45

ස්මාල්ටෝක්

මෙය සුදුසුකම් ලබන්නේදැයි මට විශ්වාස නැත:

Smalltalk := Nil.

මෙය වස්තු එන්ජිම එල්ලා මුළු ධාවන කාල පරිසරය මකා දමයි. මෙය නිවැරදි කිරීමට ඇති එකම ක්‍රමය නම් ක්‍රියාවලිය බලහත්කාරයෙන් අවසන් කර උපස්ථයෙන් නැවත ආරම්භ කිරීමයි.

නොදන්නා අය සඳහා, [දෘශ්‍ය කෘති] ස්මාල්ටෝක් ක්‍රියා කරන ආකාරය තරමක් අමුතුයි. එය කුඩා මෙහෙයුම් පද්ධතියක් වැනි ය. ඔබ ස්මාල්ටෝක් ආරම්භ කරන විට, ඔබ "මතක රූපයක්" RAM වෙත පටවන අතර එය නතර වූ ස්ථානයේ සිට එය දිගටම ක්‍රියාත්මක කරයි. සමස්ත ස්මාල්ටෝක් IDE ස්මාල්ටෝක් හි ලියා ඇති අතර එය ගතිකව වෙනස් කළ හැකිය.

විශේෂයෙන්, Smalltalk සියලු ගෝලීය විචල්‍යයන් අඩංගු ශබ්දකෝෂයකි. වඩාත් විශේෂයෙන්, ඔබ නව පංතියක් ප්‍රකාශයට පත් කරන සෑම අවස්ථාවකම, එම නම සහිත ගෝලීය විචල්‍යයක් නිර්මාණය වන අතර, එය Classඔබගේ නව පන්තිය සඳහා වන වස්තුව වෙත යොමු කරයි . එබැවින් සැකසුමSmalltalk කිරීමටNil (මූලික වශයෙන් ශූන්ය) සමස්ත පද්ධතිය සියලු පන්ති දමයි. GUI සිදුවීම් හසුරුවන්නන් පවා අශෝභන වේ.

මෙම විචල්‍යය පවා ලිවිය හැක්කේ මන්දැයි මා දන්නේ නැත. බොහෝ විට එය ගෝලීය විචල්‍යයක් වන අතර එම නිසා එය ඇතුලත ප්‍රවේශයක් ලෙස පවතී. (ඔබේ හිසට තවම රිදෙනවාද? සෑම වස්තුවකටම පන්තියක් ඇති බවත්, පන්ති වස්තු බවත්, එබැවින් සෑම පන්තියකටම පන්තියක් ඇති බවත් මා සඳහන් කළාද? පන්තිය...)

ඔබ බොහෝ විට විසින් මීට සමාන ප්රතිඵලයක් සාක්ෂාත් කර ගැනීමට සෝදිසි වෙනුවට ශබ්ද කෝෂය ශූන්ය ඒ වෙනුවට. ඇත්ත වශයෙන්ම, පද්ධතියේ සියලුම පන්ති මකා දැමීමට ඔබට කේත කළ හැකි දේවල් ගණනාවක් ඇති අතර ඔබට කිසිවක් කිරීමට නොහැකි වේ. නමුත් නියම ස්මාල්ටෝක් සම්පාදකයා ද පංතියක් බැවින් ... භාෂාව බිඳෙන ඕනෑම දෙයක් සමස්ත IDE එක ම බිඳ දමයි, එබැවින් ...


එය එල්ලී ඇත්නම් එය වලංගු නොවේ, නමුත් ඊළඟ විධානය නොවේ. නමුත් මට කුතුහලයක් තිබේ: පංතියක් වීම සහ සාමාන්‍ය වස්තුවක් වීම යන අගයන් දෙකම තිබිය හැකි පන්තියක් එයට තිබේද? එම අගයන් දෙකම තිබිය හැකි පන්තියක් සහ මෙම නව පන්තිය? ඒ වගේම පන්තියක්ද?
jimmy23013

ස්මාල්ටෝක් පන්තියක් ජාවාස්ක්‍රිප්ට් මූලාකෘතියකට සමාන ය. පද්ධති පංති අනවසරයෙන් හැක් කිරීමෙන් ඔබට ස්මාල්ටෝක් බහු උරුම භාෂාවක් බවට පත් කළ හැකිය. එසේම, ක්‍රම ඇමතුම් වස්තූන් වේ, කේත බ්ලොක් යනු වස්තූන්ය ... ඔබට නිර්වචනය නොකළ ක්‍රම ඇමතුම් වලට බාධා කර ඒවා දේවල් කිරීමට පෙළඹවිය හැකිය ... එය ඉතා ගතික භාෂාවකි. සෑම දෙයක්ම වස්තුවකි! IDE ඇතුළුව ...
ගණිතමය

1
ෆාරෝ nilවෙනුවට භාවිතා කිරීමට Nilසිදුවිය.
mgarciaisaia

5
තවත් එකක් නම් true become: false, නමුත් මම හිතන්නේ මෙය භාෂාවේ නවතම අනුවාද වල ක්‍රියා නොකරයි. ඔබට ස්මාල්ටෝක් / වී 286 මේ ආකාරයෙන් මරා දැමිය හැකිය.

16
“සෑම වස්තුවකටම පන්තියක් ඇති බවත්, පන්ති වස්තු බවත්, එබැවින් සෑම පන්තියකටම පන්තියක් ඇති බවත් මා සඳහන් කළාද? පංතියක පන්තිය මෙටාක්ලාස් ලෙස හැඳින්වේ, නමුත් මෙටාක්ලාස් යනු වස්තුවකි, එබැවින් පන්තියක් ඇත ... ”පයිතෝනිස්ටා ලෙස, මගේ හිසට කිසිසේත් හානියක් නැත. ඊට පටහැනිව, ස්මාල්ටෝක් සමඟ මට නිවසේදීම දැනෙනු ඇතැයි මම සිතමි.
බ්ලැක් ලයිට් බැබළෙන

41

හස්කල්

මෙහි හැකියාවන් කිහිපයක් තිබේ.

කම්මැලි අදහස # 1: අර්ථ දක්වන්න main කිසිවක් කිරීමට කරන්න. දැන් ඔබ ලියන වෙනත් කේත කුමක් වුවත්, එය කිසි විටෙකත් ක්‍රියාත්මක කළ නොහැක. (ඔබ එය REPL වෙතින් අතින් ක්‍රියාත්මක නොකරන්නේ නම්)

කම්මැලි අදහස # 2: පොදු අපනයන නොමැති මොඩියුලයක් නිර්වචනය කරන්න. දැන් ඔබගේ ලිවීමේ වෙනත් කේතය කුමක් වුවත්, එය කිසි විටෙකත් ක්‍රියාත්මක කළ නොහැක.

සිත්ගන්නා අදහස: සියලුම ආනයන අක්‍රීය කරන්න.

module Fubar where
import Prelude ()
foo = foo
-- More code here.

දැන් ඔබට කාර්යයන් අර්ථ දැක්විය හැකිය වේ දෘශ්යමාන සහ හැකි ධාවනය කළ ... නමුත් ඔවුන් කිසිම දෙයක් කරන්න බැහැ. සියලුම සම්මත හැස්කල් වර්ග සහ කාර්යයන් දැන් සැඟවී ඇත. (අ කාරණා කිහිපයක් හැර ඇත්තටම ගැඹුරින් දැඩි යාන්ත්රණයක් පැවතීමත් භාෂාව බවට.)

විශේෂයෙන්, ඔබට කිසිම ආකාරයක I / O සිදු කළ නොහැක. ඔබට යන්ත්‍ර නිරවද්‍ය ගණිතයද කළ නොහැක. (සිට Int,Double ආදිය දැන් නිර්වචනය නොකළ ඇත.)

ඔබට තවමත් සැබෑ ගණනය කිරීම් සිදුකරන ලැම්බඩා-කැල්කියුලස් ශ්‍රිත ලිවිය හැකිය . ඔබට කිසිම දත්තයක් තුළට හෝ පිටතට ගෙන යා නොහැක. නමුත් ඔබට ඇත්ත වශයෙන්ම වෙනත් මොඩියුලයක් ලිවිය හැකිය, එය Fubarඉහත මොඩියුලය අමතා ඒ වෙනුවෙන් I / O කරයි (එමඟින් කේතය ක්‍රියාත්මක වන බවත් දේවල් කරන බවත් ඔප්පු කරයි).

සමහර සියුම්කම්:

  • foo = fooකිසිවෙකු අතිරේක ආනයන එකතු කිරීම වැළැක්වීම සඳහා ව්‍යාජ ප්‍රකාශය අවශ්‍ය වේ. (ආනයන නොපෙන්වයි ප්‍රකාශ කිරීමෙන් පසු .)

  • මෙම තත්වයෙන් මිදීමට ඔබට හැකි විවිධ සම්මත නොවන හස්කල් භාෂා දිගු තිබේ. නමුත් භාෂා දිගු කිරීම ගොනුවේ ඉහළින් ඇති සම්පාදක ප්‍රාග්මා සමඟ ක්‍රියාත්මක කළ යුතුය . (නැතහොත් සම්පාදකයා වෙත විධාන රේඛා මාරුවකින්. මට එය වළක්වා ගත නොහැක!)


-0.1 භාවිතා කරන්න foobar, ඔබ භාවිතා කළ අක්ෂර වින්‍යාසය තුළ සමහර ... බලාපොරොත්තු නොවූ අර්ථයන් ඇත.
wizzwizz4

@ wizzwizz4 මට හොඳටම විශ්වාසයි "ෆූබාර්" යනු වාරණයන් මග හැරීම සඳහා "ෆුබාර්" පමණක් බව. ක්‍රමලේඛන උදාහරණ වලදී මම එය වළක්වා ගැනීමට නැඹුරු වන්නේ එබැවිනි.
jpmc26

4
pm jpmc26 ඇත්ත වශයෙන්ම එය දිගු හා කීර්තිමත් ඉතිහාසයක් ඇති අතර, එම්අයිටී ආදර්ශ දුම්රිය කණ්ඩායමක් හරහා ගොස්, ලේඛනගත කිරීමට පෙර ක්‍රමලේඛන පොතක ජනප්‍රිය වී පසුව ජනප්‍රිය සංස්කෘතියට ගෙන එනු ලැබේ. මට විශ්වාසයි එය අහම්බයක්.
wizzwizz4

පරිශීලක කේතය ඇත්ත වශයෙන්ම ක්‍රියාත්මක නොවන නිසා "කම්මැලි අදහස්" දෙකම අවලංගුය. (“සිත්ගන්නා අදහස” වලංගු බව පෙනේ, නමුත්)
pppery

41

PostScript

ඔව්, PostScript යනු ක්‍රමලේඛන භාෂාවකි. එපමණක් නොව, එය ක්‍රමලේඛන භාෂාවක් වන අතර එය සියලු භාෂා ව්‍යුහයන් පද්ධති අර්ථ දක්වන ලද කාර්යයන් වන අතර එය නැවත අර්ථ දැක්විය හැකිය ...

1000 dict /Magic def
systemdict {pop Magic exch {} put} forall
Magic begin

ඉංග්රීසි භාෂාවෙන්:

  • මූලද්රව්ය 1,000 කින් යුත් ශබ්ද කෝෂයක් සාදා එය නම් කරන්න Magic.
  • තුළ ඇති සෑම යතුරක් සඳහාම systemdict, Magicහිස් අර්ථ දැක්වීමක් සහිතව එකම යතුර එක් කරන්න (" {}").
  • Magicශබ්ද කෝෂයේ මුදුනට තල්ලු කරන්න .

මේ මොහොතේ සිට සෑම පෝස්ට් ස්ක්‍රිප්ට් භාෂා විධානයක්ම කිසිවක් කිරීමට නිර්වචනය කර ඇත. AFAIK, ඒ කළ නොහැකි ය මෙම තත්වයෙන් ගැලවීමට .

(තාක්ෂණික වශයෙන්, ඔබ පැරණි නිර්වචන "විනාශ" නොකරයි, ඔබ ඒවා සෙවනැල්ල කරයි. ඔබට තවමත් ක්‍රියාත්මක කළ හැකි නම් end, එය සිදුවනු ඇතMagic සියලු විධාන එක්සත් ජාතීන්ගේ-රධරෝය සහ ඔබ ඔබේ ජීවිතය නැවත ලබා දීම, එම ශබ්ද කෝෂය අඩුක්කුව ලකුණු. එහෙත් සිටend එයම සෙවනැලි වී ඇත ... එය දැන් කිසිවක් නොකරනු ඇත.)

සියලුම විධානයන් තවමත් ක්‍රියාත්මක වන බව සලකන්න ... එය දැන් කිසිවක් කර නැතැයි අර්ථ දක්වා ඇත. ඔබට කිසිදු ආකාරයක දෝෂයක් නොලැබෙනු ඇත, එය කිසිවක් සිදු නොවනු ඇත. (හොඳයි, මම හිතන්නේ තොග පිටාර ගැලීම අවසානයේ සිදුවනු ඇත ...)


මෙය ඇත්තෙන්ම විහිලු සහගතයි ... එසේම බියජනකයි ...
ග්‍රිෆොන්

36

ලිනක්ස් / x86 (-64) යටතේ ක්‍රියාත්මක වන ඕනෑම වැඩසටහනක්

මෙම වැඩසටහන C හි ලියා ඇත, නමුත් එය ලිනක්ස් / x86 (-32 හෝ -64) යටතේ ක්‍රියාත්මක වන ඕනෑම වැඩසටහනක් ක්‍රියාත්මක කිරීම කඩාකප්පල් කළ හැකිය. ඔබ එය කඩාකප්පල් කිරීමට අවශ්‍ය වැඩසටහනේ විධාන රේඛා ආයාචනයට සූදානම් කරයි.

ඉලක්කගත වැඩසටහන කිසිදු ප්‍රතිදානයක් ඇතිවීම වැළැක්වීම සඳහා එය නිදොස් කිරීමේ API භාවිතා කරයි. නිශ්චිතවම, ක්‍රියාවලියෙන් පිටත ලෝකයට යමක් සන්නිවේදනය කළ හැකි සියලුම පද්ධති ඇමතුම් (වඩාත් පැහැදිලිවම write, ඇත්ත වශයෙන්ම, නමුත් openගොනුවක් නිර්මාණය කිරීමේදී, සොකට් ඒපීඅයි හි වැඩි කොටසක් killවෙනත් ක්‍රියාවලියකට යොදන විට, ...) අසාර්ථක වනු ඇත ඒවා ක්‍රියාත්මක නොවූවාක් මෙන්. _exitඅවසර ඇත, නමුත් පිටවීමේ කේතය ශුන්‍යයකින් නැවත ලියනු ලැබේ.

මෙම පිළිතුරේ පෙර සංස්කරණය මෙන් නොව, බොහෝ වැඩසටහන් මෙම කොන්දේසි යටතේ සම්පූර්ණ කිරීමට ආසන්නව ක්‍රියාත්මක විය හැකිය; එය ඔවුන්ගේ සියලු වැඩ අපතේ යාම පමණි. නිදසුනක් ලෙස, ඔබ එසේ කරන්නේ නම් ./no-syscalls /bin/ls(GNU coreutils උපකල්පනය කර ls) එය සම්පූර්ණ නාමාවලියම කියවා එය ආකෘතිකරණය කරයි, එවිට writeප්‍රතිදානය නිපදවීම සඳහා වන සියලුම ඇමතුම් අසාර්ථක වේ. (සියලු X11 සේවාදායකයින් වැනි ද්විපාර්ශ්වික සන්නිවේදන නාලිකාවක් විවෘත කිරීමට අවශ්‍ය ඕනෑම දෙයක් එම අවස්ථාවේදී අසාර්ථක වනු ඇත. මම ඉඩ දීම ගැන සිතුවෙමි socketනමුත් නොවෙමි send, නමුත් එය අඩුපාඩු විවෘත කිරීමට ඉඩ ඇති බවක් පෙනෙන්නට තිබුණි.)

හැසිරීම වෙනස් කිරීමට විධාන රේඛා විකල්ප කිහිපයක් තිබේ;

-a  log allowed system calls
-d  log denied system calls
-e  deny everything, not just output
-S  permit writes to stderr

ගතිකව සම්බන්ධිත වැඩසටහන් -eප්‍රකාරයේදී ගතික සම්බන්ධකයෙන් ඉවත් නොවනු ඇත . -Sපැහැදිලිවම ප්‍රතිපත්තියේ විශාල සිදුරක් විවෘත කරයි, නමුත් වැඩ කරන කිසිවක් ගැන විලාප නඟන වැඩසටහන් නැරඹීම විනෝදජනක විය හැකිය, උදා

$ ./no-syscalls -daeS /bin/ls
syscall 59...
syscall 59 = 0
syscall 12 (denied) = -38
syscall 21 (denied) = -38
syscall 9 (denied) = -38
syscall 20...
/bin/ls: error while loading shared libraries: cannot create cache for search path: Cannot allocate memory
syscall 20 = 107
syscall 231...
Program exited, status = 0

ඔබ සමඟ ලොග් ප්‍රතිදානය කියවිය යුතුය /usr/include/asm*/unistd.h වෙනත් කවුළුවක විවෘතව , මන්ද මෙය දැනටමත් සෑහෙන තරම් දිගුය.

කනගාටුවට කරුණක් නම්, මෙම භාවිතා කරන නිදොස් කිරීමේ අතුරුමුහුණත් යුනික්ස් ක්‍රියාත්මක කිරීම් හරහා පමණක් දුර්වල ලෙස අනුකූල වන අතර ඒවා සහජයෙන්ම CPU විශේෂිත වේ. එය අනෙක් CPU සැකසුම් සඳහා එය වරායට සාපේක්ෂ වශයෙන් සරලව (හුදෙක් සුදුසු අර්ථ දැක්වීම් එකතු වනු ඇත SYSCALL_*_REG), සහ එය බොහෝ දුරට හැකි වරායට එය ඕනෑම යුනික්ස් යුතු බව ptrace, එහෙත් ඔබ මෙන්ම සුදු ලැයිස්තුවේ පුළුල් ලෙස syscall විෂමතාවන් සමඟ කටයුතු සමග muck කිරීමට අවශ්ය විය හැකි ඇතුළත ptrace.

#define _GNU_SOURCE 1
#include <stddef.h>
#include <sys/types.h>
#include <sys/mman.h>
#include <sys/ptrace.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <sys/user.h>
#include <sys/wait.h>
#include <errno.h>
#include <fcntl.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#if defined __linux__
# define SYS_unimplemented -1L
# if defined __i386__
#  define SYSCALL_NUMBER_REG regs.orig_eax
#  define SYSCALL_ARG1_REG   regs.ebx
#  define SYSCALL_ARG2_REG   regs.ecx
#  define SYSCALL_ARG3_REG   regs.edx
#  define SYSCALL_ARG4_REG   regs.esi
#  define SYSCALL_RESULT_REG regs.eax
# elif defined __x86_64__
#  define SYSCALL_NUMBER_REG regs.orig_rax
#  define SYSCALL_ARG1_REG   regs.rdi
#  define SYSCALL_ARG2_REG   regs.rsi
#  define SYSCALL_ARG3_REG   regs.rdx
#  define SYSCALL_ARG4_REG   regs.r10
#  define SYSCALL_RESULT_REG regs.rax
# else
#  error "Need to know system call convention for this CPU"
# endif
#else
# error "Need to know system call convention for this OS"
#endif

static long
xptrace(int request, pid_t pid, void *addr, void *data)
{
  errno = 0;
  long rv = ptrace(request, pid, addr, data);
  if (rv == -1 && errno) {
    perror("ptrace");
    if (pid != 0) kill(pid, SIGKILL);
    exit(1);
  }
  return rv;
}
#define GET_REG_(pid, x) \
  xptrace(PTRACE_PEEKUSER, pid, (void*)offsetof(struct user, x), 0)
#define GET_REG(pid, x) GET_REG_(pid, SYSCALL_##x##_REG)
#define SET_REG_(pid, x, v) \
  xptrace(PTRACE_POKEUSER, pid, (void*)offsetof(struct user, x), (void*)v)
#define SET_REG(pid, x, v) SET_REG_(pid, SYSCALL_##x##_REG, v)

/* This function defines the system-call policy.  */
static int
deny_syscall(pid_t pid, int scnum, int deny_all, int allow_stderr)
{
  switch (scnum) {
  /* These syscalls are unconditionally allowed (when not in -e mode);
     they perform input, or change only process-local state. */
#ifdef SYS_access
  case SYS_access:
#endif
#ifdef SYS_alarm
  case SYS_alarm:
#endif
#ifdef SYS_arch_prctl
  case SYS_arch_prctl:
#endif
#ifdef SYS_brk
  case SYS_brk:
#endif
#ifdef SYS_capget
  case SYS_capget:
#endif
#ifdef SYS_clock_getres
  case SYS_clock_getres:
#endif
#ifdef SYS_clock_gettime
  case SYS_clock_gettime:
#endif
#ifdef SYS_clock_nanosleep
  case SYS_clock_nanosleep:
#endif
#ifdef SYS_close
  case SYS_close:
#endif
#ifdef SYS_dup
  case SYS_dup:
#endif
#ifdef SYS_dup2
  case SYS_dup2:
#endif
#ifdef SYS_dup3
  case SYS_dup3:
#endif
#ifdef SYS_epoll_create
  case SYS_epoll_create:
#endif
#ifdef SYS_epoll_create1
  case SYS_epoll_create1:
#endif
#ifdef SYS_epoll_ctl
  case SYS_epoll_ctl:
#endif
#ifdef SYS_epoll_ctl_old
  case SYS_epoll_ctl_old:
#endif
#ifdef SYS_epoll_pwait
  case SYS_epoll_pwait:
#endif
#ifdef SYS_epoll_wait
  case SYS_epoll_wait:
#endif
#ifdef SYS_epoll_wait_old
  case SYS_epoll_wait_old:
#endif
#ifdef SYS_eventfd
  case SYS_eventfd:
#endif
#ifdef SYS_eventfd2
  case SYS_eventfd2:
#endif
#ifdef SYS_faccessat
  case SYS_faccessat:
#endif
#ifdef SYS_fadvise64
  case SYS_fadvise64:
#endif
#ifdef SYS_fadvise64_64
  case SYS_fadvise64_64:
#endif
#ifdef SYS_fanotify_init
  case SYS_fanotify_init:
#endif
#ifdef SYS_fanotify_mark
  case SYS_fanotify_mark:
#endif
#ifdef SYS_fgetxattr
  case SYS_fgetxattr:
#endif
#ifdef SYS_flistxattr
  case SYS_flistxattr:
#endif
#ifdef SYS_fstat
  case SYS_fstat:
#endif
#ifdef SYS_fstat64
  case SYS_fstat64:
#endif
#ifdef SYS_fstatat64
  case SYS_fstatat64:
#endif
#ifdef SYS_fstatfs
  case SYS_fstatfs:
#endif
#ifdef SYS_fstatfs64
  case SYS_fstatfs64:
#endif
#ifdef SYS_ftime
  case SYS_ftime:
#endif
#ifdef SYS_futex
  case SYS_futex:
#endif
#ifdef SYS_getcpu
  case SYS_getcpu:
#endif
#ifdef SYS_getcwd
  case SYS_getcwd:
#endif
#ifdef SYS_getdents
  case SYS_getdents:
#endif
#ifdef SYS_getdents64
  case SYS_getdents64:
#endif
#ifdef SYS_getegid
  case SYS_getegid:
#endif
#ifdef SYS_getegid32
  case SYS_getegid32:
#endif
#ifdef SYS_geteuid
  case SYS_geteuid:
#endif
#ifdef SYS_geteuid32
  case SYS_geteuid32:
#endif
#ifdef SYS_getgid
  case SYS_getgid:
#endif
#ifdef SYS_getgid32
  case SYS_getgid32:
#endif
#ifdef SYS_getgroups
  case SYS_getgroups:
#endif
#ifdef SYS_getgroups32
  case SYS_getgroups32:
#endif
#ifdef SYS_getitimer
  case SYS_getitimer:
#endif
#ifdef SYS_get_kernel_syms
  case SYS_get_kernel_syms:
#endif
#ifdef SYS_get_mempolicy
  case SYS_get_mempolicy:
#endif
#ifdef SYS_getpeername
  case SYS_getpeername:
#endif
#ifdef SYS_getpgid
  case SYS_getpgid:
#endif
#ifdef SYS_getpgrp
  case SYS_getpgrp:
#endif
#ifdef SYS_getpid
  case SYS_getpid:
#endif
#ifdef SYS_getpmsg
  case SYS_getpmsg:
#endif
#ifdef SYS_getppid
  case SYS_getppid:
#endif
#ifdef SYS_getpriority
  case SYS_getpriority:
#endif
#ifdef SYS_getrandom
  case SYS_getrandom:
#endif
#ifdef SYS_getresgid
  case SYS_getresgid:
#endif
#ifdef SYS_getresgid32
  case SYS_getresgid32:
#endif
#ifdef SYS_getresuid
  case SYS_getresuid:
#endif
#ifdef SYS_getresuid32
  case SYS_getresuid32:
#endif
#ifdef SYS_getrlimit
  case SYS_getrlimit:
#endif
#ifdef SYS_get_robust_list
  case SYS_get_robust_list:
#endif
#ifdef SYS_getrusage
  case SYS_getrusage:
#endif
#ifdef SYS_getsid
  case SYS_getsid:
#endif
#ifdef SYS_getsockname
  case SYS_getsockname:
#endif
#ifdef SYS_getsockopt
  case SYS_getsockopt:
#endif
#ifdef SYS_get_thread_area
  case SYS_get_thread_area:
#endif
#ifdef SYS_gettid
  case SYS_gettid:
#endif
#ifdef SYS_gettimeofday
  case SYS_gettimeofday:
#endif
#ifdef SYS_getuid
  case SYS_getuid:
#endif
#ifdef SYS_getuid32
  case SYS_getuid32:
#endif
#ifdef SYS_getxattr
  case SYS_getxattr:
#endif
#ifdef SYS_inotify_add_watch
  case SYS_inotify_add_watch:
#endif
#ifdef SYS_inotify_init
  case SYS_inotify_init:
#endif
#ifdef SYS_inotify_init1
  case SYS_inotify_init1:
#endif
#ifdef SYS_inotify_rm_watch
  case SYS_inotify_rm_watch:
#endif
#ifdef SYS_ioprio_get
  case SYS_ioprio_get:
#endif
#ifdef SYS_kcmp
  case SYS_kcmp:
#endif
#ifdef SYS_lgetxattr
  case SYS_lgetxattr:
#endif
#ifdef SYS_listxattr
  case SYS_listxattr:
#endif
#ifdef SYS_llistxattr
  case SYS_llistxattr:
#endif
#ifdef SYS_lookup_dcookie
  case SYS_lookup_dcookie:
#endif
#ifdef SYS_lseek
  case SYS_lseek:
#endif
#ifdef SYS_lstat
  case SYS_lstat:
#endif
#ifdef SYS_lstat64
  case SYS_lstat64:
#endif
#ifdef SYS_madvise
  case SYS_madvise:
#endif
#ifdef SYS_mbind
  case SYS_mbind:
#endif
#ifdef SYS_mincore
  case SYS_mincore:
#endif
#ifdef SYS_mlock
  case SYS_mlock:
#endif
#ifdef SYS_mlockall
  case SYS_mlockall:
#endif
#ifdef SYS_mprotect
  case SYS_mprotect:
#endif
#ifdef SYS_mremap
  case SYS_mremap:
#endif
#ifdef SYS_munlock
  case SYS_munlock:
#endif
#ifdef SYS_munlockall
  case SYS_munlockall:
#endif
#ifdef SYS_munmap
  case SYS_munmap:
#endif
#ifdef SYS_name_to_handle_at
  case SYS_name_to_handle_at:
#endif
#ifdef SYS_nanosleep
  case SYS_nanosleep:
#endif
#ifdef SYS_newfstatat
  case SYS_newfstatat:
#endif
#ifdef SYS_nice
  case SYS_nice:
#endif
#ifdef SYS_oldfstat
  case SYS_oldfstat:
#endif
#ifdef SYS_oldlstat
  case SYS_oldlstat:
#endif
#ifdef SYS_oldolduname
  case SYS_oldolduname:
#endif
#ifdef SYS_oldstat
  case SYS_oldstat:
#endif
#ifdef SYS_olduname
  case SYS_olduname:
#endif
#ifdef SYS_pause
  case SYS_pause:
#endif
#ifdef SYS_perf_event_open
  case SYS_perf_event_open:
#endif
#ifdef SYS_personality
  case SYS_personality:
#endif
#ifdef SYS_pivot_root
  case SYS_pivot_root:
#endif
#ifdef SYS_poll
  case SYS_poll:
#endif
#ifdef SYS_ppoll
  case SYS_ppoll:
#endif
#ifdef SYS_prctl
  case SYS_prctl:
#endif
#ifdef SYS_pread64
  case SYS_pread64:
#endif
#ifdef SYS_preadv
  case SYS_preadv:
#endif
#ifdef SYS_prlimit64
  case SYS_prlimit64:
#endif
#ifdef SYS_pselect6
  case SYS_pselect6:
#endif
#ifdef SYS_query_module
  case SYS_query_module:
#endif
#ifdef SYS_read
  case SYS_read:
#endif
#ifdef SYS_readahead
  case SYS_readahead:
#endif
#ifdef SYS_readdir
  case SYS_readdir:
#endif
#ifdef SYS_readlink
  case SYS_readlink:
#endif
#ifdef SYS_readlinkat
  case SYS_readlinkat:
#endif
#ifdef SYS_readv
  case SYS_readv:
#endif
#ifdef SYS_recvfrom
  case SYS_recvfrom:
#endif
#ifdef SYS_recvmmsg
  case SYS_recvmmsg:
#endif
#ifdef SYS_recvmsg
  case SYS_recvmsg:
#endif
#ifdef SYS_remap_file_pages
  case SYS_remap_file_pages:
#endif
#ifdef SYS_request_key
  case SYS_request_key:
#endif
#ifdef SYS_restart_syscall
  case SYS_restart_syscall:
#endif
#ifdef SYS_rt_sigaction
  case SYS_rt_sigaction:
#endif
#ifdef SYS_rt_sigpending
  case SYS_rt_sigpending:
#endif
#ifdef SYS_rt_sigprocmask
  case SYS_rt_sigprocmask:
#endif
#ifdef SYS_rt_sigreturn
  case SYS_rt_sigreturn:
#endif
#ifdef SYS_rt_sigsuspend
  case SYS_rt_sigsuspend:
#endif
#ifdef SYS_rt_sigtimedwait
  case SYS_rt_sigtimedwait:
#endif
#ifdef SYS_sched_getaffinity
  case SYS_sched_getaffinity:
#endif
#ifdef SYS_sched_getattr
  case SYS_sched_getattr:
#endif
#ifdef SYS_sched_getparam
  case SYS_sched_getparam:
#endif
#ifdef SYS_sched_get_priority_max
  case SYS_sched_get_priority_max:
#endif
#ifdef SYS_sched_get_priority_min
  case SYS_sched_get_priority_min:
#endif
#ifdef SYS_sched_getscheduler
  case SYS_sched_getscheduler:
#endif
#ifdef SYS_sched_rr_get_interval
  case SYS_sched_rr_get_interval:
#endif
#ifdef SYS_sched_setaffinity
  case SYS_sched_setaffinity:
#endif
#ifdef SYS_sched_setattr
  case SYS_sched_setattr:
#endif
#ifdef SYS_sched_setparam
  case SYS_sched_setparam:
#endif
#ifdef SYS_sched_setscheduler
  case SYS_sched_setscheduler:
#endif
#ifdef SYS_sched_yield
  case SYS_sched_yield:
#endif
#ifdef SYS_select
  case SYS_select:
#endif
#ifdef SYS_setfsgid
  case SYS_setfsgid:
#endif
#ifdef SYS_setfsgid32
  case SYS_setfsgid32:
#endif
#ifdef SYS_setfsuid
  case SYS_setfsuid:
#endif
#ifdef SYS_setfsuid32
  case SYS_setfsuid32:
#endif
#ifdef SYS_setgid
  case SYS_setgid:
#endif
#ifdef SYS_setgid32
  case SYS_setgid32:
#endif
#ifdef SYS_setgroups
  case SYS_setgroups:
#endif
#ifdef SYS_setgroups32
  case SYS_setgroups32:
#endif
#ifdef SYS_setitimer
  case SYS_setitimer:
#endif
#ifdef SYS_setns
  case SYS_setns:
#endif
#ifdef SYS_setpgid
  case SYS_setpgid:
#endif
#ifdef SYS_setpriority
  case SYS_setpriority:
#endif
#ifdef SYS_setregid
  case SYS_setregid:
#endif
#ifdef SYS_setregid32
  case SYS_setregid32:
#endif
#ifdef SYS_setresgid
  case SYS_setresgid:
#endif
#ifdef SYS_setresgid32
  case SYS_setresgid32:
#endif
#ifdef SYS_setresuid
  case SYS_setresuid:
#endif
#ifdef SYS_setresuid32
  case SYS_setresuid32:
#endif
#ifdef SYS_setreuid
  case SYS_setreuid:
#endif
#ifdef SYS_setreuid32
  case SYS_setreuid32:
#endif
#ifdef SYS_setrlimit
  case SYS_setrlimit:
#endif
#ifdef SYS_set_robust_list
  case SYS_set_robust_list:
#endif
#ifdef SYS_setsid
  case SYS_setsid:
#endif
#ifdef SYS_set_thread_area
  case SYS_set_thread_area:
#endif
#ifdef SYS_set_tid_address
  case SYS_set_tid_address:
#endif
#ifdef SYS_setuid
  case SYS_setuid:
#endif
#ifdef SYS_setuid32
  case SYS_setuid32:
#endif
#ifdef SYS_sigaction
  case SYS_sigaction:
#endif
#ifdef SYS_sigaltstack
  case SYS_sigaltstack:
#endif
#ifdef SYS_signal
  case SYS_signal:
#endif
#ifdef SYS_signalfd
  case SYS_signalfd:
#endif
#ifdef SYS_signalfd4
  case SYS_signalfd4:
#endif
#ifdef SYS_sigpending
  case SYS_sigpending:
#endif
#ifdef SYS_sigprocmask
  case SYS_sigprocmask:
#endif
#ifdef SYS_sigreturn
  case SYS_sigreturn:
#endif
#ifdef SYS_sigsuspend
  case SYS_sigsuspend:
#endif
#ifdef SYS_socketpair
  case SYS_socketpair:
#endif
#ifdef SYS_stat
  case SYS_stat:
#endif
#ifdef SYS_stat64
  case SYS_stat64:
#endif
#ifdef SYS_statfs
  case SYS_statfs:
#endif
#ifdef SYS_statfs64
  case SYS_statfs64:
#endif
#ifdef SYS_sysfs
  case SYS_sysfs:
#endif
#ifdef SYS_sysinfo
  case SYS_sysinfo:
#endif
#ifdef SYS_time
  case SYS_time:
#endif
#ifdef SYS_timer_create
  case SYS_timer_create:
#endif
#ifdef SYS_timer_delete
  case SYS_timer_delete:
#endif
#ifdef SYS_timerfd_create
  case SYS_timerfd_create:
#endif
#ifdef SYS_timerfd_gettime
  case SYS_timerfd_gettime:
#endif
#ifdef SYS_timerfd_settime
  case SYS_timerfd_settime:
#endif
#ifdef SYS_timer_getoverrun
  case SYS_timer_getoverrun:
#endif
#ifdef SYS_timer_gettime
  case SYS_timer_gettime:
#endif
#ifdef SYS_timer_settime
  case SYS_timer_settime:
#endif
#ifdef SYS_times
  case SYS_times:
#endif
#ifdef SYS_ugetrlimit
  case SYS_ugetrlimit:
#endif
#ifdef SYS_ulimit
  case SYS_ulimit:
#endif
#ifdef SYS_umask
  case SYS_umask:
#endif
#ifdef SYS_uname
  case SYS_uname:
#endif
#ifdef SYS_unshare
  case SYS_unshare:
#endif
#ifdef SYS_uselib
  case SYS_uselib:
#endif
#ifdef SYS_ustat
  case SYS_ustat:
#endif
#ifdef SYS_wait4
  case SYS_wait4:
#endif
#ifdef SYS_waitid
  case SYS_waitid:
#endif
#ifdef SYS_waitpid
  case SYS_waitpid:
#endif
    return deny_all;

#ifdef SYS_exit
  case SYS_exit:
#endif
#ifdef SYS_exit_group
  case SYS_exit_group:
#endif
    /* Special case: exiting is allowed, even in -e mode,
       but the exit status is forced to 0. */
    SET_REG(pid, ARG1, 0);
    return 0;

#ifdef SYS_fcntl
  case SYS_fcntl:
#endif
#ifdef SYS_fcntl64
  case SYS_fcntl64:
#endif
    /* Special case: fcntl is allowed, but only for the *FD and *FL
       operations.  This is a compromise between not allowing it at
       all, which would break some interpreters, and trying to go
       through the dozens of extended ops and figure out which ones
       can affect global state.  */
    {
      int cmd = GET_REG(pid, ARG2);
      if (cmd == F_DUPFD || cmd == F_DUPFD_CLOEXEC ||
          cmd == F_GETFD || cmd == F_SETFD || cmd == F_SETFL || cmd == F_GETFL)
        return deny_all;
    }
    return 1;

#ifdef SYS_kill
  case SYS_kill:
#endif
#ifdef SYS_rt_sigqueueinfo
  case SYS_rt_sigqueueinfo:
#endif
#ifdef SYS_rt_tgsigqueueinfo
  case SYS_rt_tgsigqueueinfo:
#endif
#ifdef SYS_tkill
  case SYS_tkill:
#endif
#ifdef SYS_tgkill
  case SYS_tgkill:
#endif
    /* Special case: kill is allowed if and only if directed to the calling
       process. */
    {
      pid_t kpid = GET_REG(pid, ARG1);
      if (kpid == pid)
        return deny_all;
    }
    return 1;

#ifdef SYS_mmap
  case SYS_mmap:
#endif
#ifdef SYS_mmap2
  case SYS_mmap2:
#endif
    /* Special case: mmap is allowed if it is private or read-only.  */
    {
      int prot  = GET_REG(pid, ARG3);
      int flags = GET_REG(pid, ARG4);
      if ((flags & (MAP_SHARED|MAP_PRIVATE)) == MAP_PRIVATE)
        return deny_all;
      if (!(prot & PROT_WRITE))
        return deny_all;
    }
    return 1;

    /* Special case: open() variants are allowed only if read-only and
       not creating. */
#ifdef SYS_open
  case SYS_open:
#endif
#ifdef SYS_openat
  case SYS_openat:
#endif
#ifdef SYS_open_by_handle_at
  case SYS_open_by_handle_at:
#endif
    {
      int flags = ((scnum == SYS_open)
                   ? GET_REG(pid, ARG2)
                   : GET_REG(pid, ARG3));
      if (!(flags & O_CREAT) && ((flags & O_ACCMODE) == O_RDONLY))
        return deny_all;
    }
    return 1;

#ifdef SYS_write
  case SYS_write:
#endif
#ifdef SYS_write64
  case SYS_write64:
#endif
#ifdef SYS_writev
  case SYS_writev:
#endif
#ifdef SYS_pwrite
  case SYS_pwrite:
#endif
#ifdef SYS_pwrite64
  case SYS_pwrite64:
#endif
#ifdef SYS_pwritev
  case SYS_pwritev:
#endif
    /* Special case: optionally, the program is allowed to write to
       stderr.  This opens a gaping hole in the policy, but it can be
       quite entertaining to watch programs moan about how nothing works. */
    if (allow_stderr) {
      int fd = GET_REG(pid, ARG1);
      if (fd == 2)
        return 0;
    }
    return 1;

  default:
    /* All other system calls are unconditionally denied. */
    return 1;
  }
}

static void
usage(char *progname)
{
  fprintf(stderr, "usage: %s [-adeS] program args...\n", progname);
  fputs("\t-a  log allowed system calls\n"
        "\t-d  log denied system calls\n"
        "\t-e  deny everything, not just output\n"
        "\t-S  permit writes to stderr\n", stderr);
  exit(2);
}

int
main(int argc, char **argv)
{
  pid_t pid;
  int   status;
  int   opt;
  long  last_syscall = SYS_unimplemented;
  int   last_allowed = 0;
  int   after_execve = 0;
  int   trace_active = 0;
  int   allow_stderr = 0;
  int   deny_all     = 0;
  int   log_allowed  = 0;
  int   log_denied   = 0;

  while ((opt = getopt(argc, argv, "+adeS")) != -1) {
    switch (opt) {
    case 'a': log_allowed  = 1; break;
    case 'd': log_denied   = 1; break;
    case 'e': deny_all     = 1; break;
    case 'S': allow_stderr = 1; break;
    default:
      usage(argv[0]);
    }
  }
  if (optind == argc) {
    usage(argv[0]);
  }

  setvbuf(stdout, 0, _IOLBF, 0);
  setvbuf(stderr, 0, _IOLBF, 0);

  pid = fork();
  if (pid == -1) {
    perror("fork");
    exit(1);

  } else if (pid == 0) {
    raise(SIGSTOP); /* synch with parent */
    execvp(argv[optind], argv+optind);
    perror("execvp");
    exit(1);
  }

  /* If we get here, we are the parent. */
  for (;;) {
    pid_t rv = waitpid(pid, &status, WUNTRACED);
    if (rv != pid) {
      perror("waitpid");
      kill(pid, SIGKILL);
      exit(1);
    }
    if (!WIFSTOPPED(status)) {
      if (WIFEXITED(status))
        printf("Program exited, status = %d\n", WEXITSTATUS(status));
      else if (WIFSIGNALED(status))
        printf("Program killed by signal %d\n", WTERMSIG(status));
      else {
        printf("Un-decodable status %04x\n", status);
        kill(pid, SIGKILL); /* just in case */
      }
      exit(0);
    }
    if (WSTOPSIG(status) == SIGSTOP && !trace_active) {
      /* This is the raise(SIGSTOP) on the child side of the fork. */
      trace_active = 1;
      xptrace(PTRACE_SEIZE, pid, 0, (void*)PTRACE_O_TRACESYSGOOD);
      xptrace(PTRACE_SYSCALL, pid, 0, 0);
    }
    else if (WSTOPSIG(status) == (SIGTRAP|0x80)) {
      if (last_syscall == SYS_unimplemented) {
        last_syscall = GET_REG(pid, NUMBER);
        /* The child process is allowed to execute normally until an
           execve() succeeds.  */
        if (after_execve && deny_syscall(pid, last_syscall,
                                         deny_all, allow_stderr)) {
          last_allowed = 0;
          SET_REG(pid, NUMBER, SYS_unimplemented);
        } else {
          last_allowed = 1;
          if (log_allowed) {
            /* Log this now, we may not get another chance. */
            printf("syscall %ld...\n", last_syscall);
          }
        }
      } else {
        if (last_allowed ? log_allowed : log_denied) {
          long scret = GET_REG(pid, RESULT);
          printf("syscall %ld%s = %ld\n",
                 last_syscall, last_allowed ? "" : " (denied)", scret);
        }
        if (last_allowed && (last_syscall == SYS_execve ||
                             last_syscall == SYS_execveat)) {
          long scret = GET_REG(pid, RESULT);
          if (scret == 0)
            after_execve = 1;
        }
        last_syscall = SYS_unimplemented;
      }
      xptrace(PTRACE_SYSCALL, pid, 0, 0);
    }
    else if (WSTOPSIG(status) == SIGTRAP) {
      /* Swallow all SIGTRAPs, they are probably spurious debug events. */
      xptrace(PTRACE_SYSCALL, pid, 0, 0);
    } else {
      /* Allow all normal signals to proceed unmolested. */
      if (log_allowed) {
        printf("process received signal %d\n", WSTOPSIG(status));
      }
      xptrace(PTRACE_SYSCALL, pid, 0, (void*)(uintptr_t)WSTOPSIG(status));
    }
  }
}

1
“ඉලක්කයට එහි විධාන රේඛා තර්ක කියවිය හැකිය, පිරිසිදු ගණනය කිරීම් කළ හැකි අතර බිටු 8 ක පිටවීමේ තත්වයක් ඇති කළ හැකි නමුත් මතකය වෙන් කිරීමට හෝ I / O කිරීමට නොහැකි වනු ඇත” - මම නොකියමි, ඔබ තවමත් නිර්ණායක හතර සපුරාලයි . විධාන රේඛා තර්ක වලින් පූර්ණ සංඛ්‍යා අර්ථ දැක්විය හැකිය; සරල නිමැවුම් සඳහා පිටවීමේ තත්වය උත්තේජනය කළ හැකිය; එකතු කිරීමට බාධාවක් නැත; ප්‍රාථමික පරීක්‍ෂණයක් සඳහා ඔබට අවශ්‍ය වන්නේ පිරිසිදු ගණනය කිරීම් කිරීමට ඇති හැකියාව, ටිකක් ඉඩ ප්‍රමාණයක් සහ ලූපයක් පමණි.
බ්ලැක් ලයිට් බැබළෙන

1
La බ්ලැක්ලයිට්ෂයිනින් සාමාන්‍ය හැසිරීමට සාපේක්ෂව මෙතරම් විශාල සීමාවක් මෙය ඉටු කරන බව මම සිතමි. ඔබ පවසන පරිදි, ඔබට තවමත් ප්‍රාථමික පරීක්ෂකයෙකු ලිවිය හැකිය, නමුත් -DNO_EXITමාදිලිය යනු ඔබට දැනෙන අය සඳහා ය. එම ප්‍රකාරයේදී අර්ථවත් ප්‍රතිදානයක් කළ නොහැක.
zwol

1
L බ්ලැක්ලයිට්ෂයිනිං මම ඒ ගැන තව ටිකක් කල්පනා කළ අතර මම මුල සිටම වැඩසටහන නැවත ලිව්වෙමි. එය දැන් කරන දෙය වඩා දක්ෂ වන අතර (මම විශ්වාස කරමි) අභියෝගය වඩාත් දැඩි ලෙස කියවීම පවා සපුරාලමි.
zwol

2
Os ජෝෂුවා එය දක්ෂයි, මෙම ප්‍රවේශය භාවිතා කිරීම වැළැක්වීම දුෂ්කර වනු ඇත (වැඩසටහන හුදෙක් එහි මතකය වෙනස් කරන බැවින්) නමුත් එය දැනට "අවසර ලත් නිමැවුම් ක්‍රම" ලැයිස්තුවේ නොමැත.
zwol

7
EsesesTG ඔබට හුරු පුරුදු ද strace?
zwol

31

ටෙක්ස්

\catcode`\\=10

මෙය සැබවින්ම ක්‍රියාත්මක වනු ඇතැයි මට විශ්වාස නැත, නමුත් න්‍යායිකව මෙය බිඳ දැමිය යුතුය \ ගැලවීමේ චරිතයක් ලෙස එය නිවැරදි කිරීමට ඔබට හැකියාවක් නැත. සාමාන්‍යයෙන් ටෙක්ස්ට ලිපිගොනු කියවීමට හා ලිවීමට හැකිය, දැන් එයට තර්කනය මත රඳා පවතින කිසිවක් ලිවිය නොහැක. මේ අනුව OP විසින් අර්ථ දක්වා ඇති පරිදි භාෂාව දැන් බිඳී ඇත.

සංස්කරණය කරන්න: අදහස් දැක්වීම් වලින් ලබාගත් වෙනත් kill ාතන විධානයන් (දෙකම කේත-ක්‍රියාත්මක කළ යුතු රීතිය උල්ලං may නය කළ හැකි වුවද):

  • \def\fi{}\iffalsesmpl විසින් වසා දැමිය නොහැකි නම් ශාඛාවක් නිර්මාණය කරයි
  • \catcode13=9%iwillnotexist විසින් idonotexist විසින් කිසිදා නිම නොවන අදහසක් නිර්මාණය කරයි

3
වඩා හොඳ අනුවාදය: \def\fi{}\iffalse. මට මෙම වෙබ් අඩවියෙන් අවම වශයෙන් 10 ක් වත් උපයා ගත යුතු බැවින් මට පිළිතුරු පළ කළ නොහැක, නමුත් මෙය තවදුරටත් ප්‍රතිදානයට ඉඩ නොදේ.
user530873

1
msmpl ඔබට තවමත් \fiඑහි මුල් අරුත නැවත අර්ථ දැක්විය හැකිය , නේද? මේ අනුව භාෂාව කිසිදු අලුත්වැඩියාවකින් ඔබ්බට ගොස් නැත.
සීෆලෝපොඩ්

1
Ep සෙෆලෝපොඩ් \fiයනු ටෙක්ස් ප්‍රාථමිකයකි. මේ අවස්ථාවේදී ඔබට කිසිවක් නැවත අර්ථ දැක්විය නොහැක \iffalse.
user530873

1
msmpl හ්ම්, මට පෙනේ. හරිම දක්ෂයි.
සීෆලෝපොඩ්

1
+1. මම ටෙක්ස්බුක් එකෙන් ඉගැන්වීමට පටන් ගත් \catcode13=9%අතර භාෂාව මුළුමනින්ම බිඳ දමනු ඇති බව මට වැටහුණු විට ( %අදහස් දැක්වීමෙන් පසුව සියල්ල සහ නව රේඛා (ASCII char 13) නොසලකා හරිනු ලැබේ, එබැවින් අදහස් අනන්තය දක්වා විහිදේ) මට එය මෙහි පළ කිරීමට අවශ්‍ය විය. නමුත් ඔබට දැනටමත් මෙහි තරමක් දිගු විධානයක් ඇත.
Iwillnotexist Idonotexist

30

සීරීමට

සීරීම් රූපය බිඳ දමන්න
මෙම when [timer v] > (0)කේතය ඔබට පවා කේතය ආරම්භ කිරීමට පෙර ඔබ විසින් කර්තෘ ඉන්නේ නම් වන වන අතර, initialised වූ වහාම ක්රියාත්මක වනු ඇත. මෙම when I receive (join[][])දෝෂයක් කාලය කිසිවක් සෑම දමනු කරනු ඇත කේතය ක්රියාත්මක pausing ඔබ ෆ්ලෑෂ් වල සංවර්ධක අනුවාදය ඇති නම්, විකාශනය වේ. මෙම breakකාර්යය ක්ලෝන නිර්මාණය, සහ විකාශන දෝෂයක් පුපුරවා හරිනු ඇත. සෑම ක්ලෝනයක්ම තත්පර දෙකක් පවතිනු ඇති අතර පසුව එය මකා දමනු ඇත. සෑම ක්ලෝනයක්ම ප්‍රතිචාර දක්වනු ඇත when [timer v] > (0), breakසබ්ට්‍රවුටින් ධාවනය කර ටයිමරය නැවත සකස් කිරීම, එමඟින් ටයිමර් කේතය නැවත ක්‍රියාත්මක වීමට හේතු වේ. එසේම, සෑම ක්ලෝනයක්ම සෑම විකාශන දෝෂයක් සඳහාම ප්‍රතිචාර දක්වනු ඇත, එයින් අදහස් වන්නේ ඇගයීමකට අනුව දෝෂ breakගණන වර්ග කොටසේ සංඛ්‍යාව බවයි. breakශ්‍රිතය ඇති බව සඳහන් කිරීමට මට අමතක වූවාද?run without screen refreshපරීක්‍ෂා කර, සංස්කාරකය කැටි කිරීම, විහිළු කිරීම සහ ප්‍රමාද වීම මෙන්ම මතකය උදුරා ගැනීම සහ වෙන් කිරීම සිදු කරයි. සහ CPU උපරිම කිරීම.

මෙම ධාවනය සමඟ ඕනෑම තැනක එකතු කරන ඕනෑම කේතයකට ක්ලෝන (300 ක්ලෝන සීමාව ඉක්මවා ඇත) නිර්මාණය කිරීමට නොහැකි වන අතර එය ක්‍රියාත්මක වන පරිගණකය උණුසුම් කිරීම හා බිඳ වැටීම සිදු වේ. තව දුරටත් ග්‍රහණය කර ගැනීමට නොහැකි වන තෙක් මතකය ග්‍රහණය කර ගනිමින් විචල්‍යයන් වැරදි ලෙස හැසිරේ.

තවද, when [timer v] > (0)වාරණය අවුලුවාලීමට තරම් ප්‍රමාදයකින් පසුව , එය තවමත් ක්‍රියාත්මක breakවේ.

when I receiveටික කලකට පෙර මා සොයාගත් දෝෂය ගැන මට මතක් කිරීම සහ ඒ සඳහා මට අදහස ලබා දීම ගැන owtowerofnix ට ස්තූතියි run without screen refresh. ඔබ මෙය කැමති නම්, මෙහි මුල් පිටපත: https://codegolf.stackexchange.com/a/61357/43394


+1 පරමාණුක (තිර නැවුම්බව නොමැතිව ධාවනය) බ්ලොක් එකක් ධාවනය කිරීමද විනෝදජනක විය හැකිය stop this script: පී
ෆ්ලෝරි

එම “ when I receiveදෝෂය” ක්‍රියාත්මක වන්නේ කෙසේද?
Scimonster

C සිමොන්ස්ටර් when I receiveතොප්පි බ්ලොක් නිර්මාණය කර ඇත්තේ පතන ලැයිස්තුවෙන් ආදානය ලබා ගැනීම සඳහා පමණි. මෙම join[][]වාරණ බව දත්ත වර්ගය නැවතwhen I recieve වාරණ පිළිගැනීමට නිර්මාණය කර නැත. යමක් විකාශනය වන සෑම අවස්ථාවකම, තොප්පි කොටස් සියල්ලම පරීක්ෂා කර, බ්ලොක් එකේ ප්‍රතිලාභ අගය තක්සේරු කරමින් incorrect typeදෝෂයක් ඇති කරයි.
wizzwizz4

මට පේනවා. ඔබට JSON ගොනුව හැක් කිරීමට සිදු වුවද ඇත්ත වශයෙන්ම එහි joinඅවහිරය ලබා ගත හැකිය.
Scimonster

1
මෙම - එය නොසලකා හරියි වැරදි බව සැණෙළිය වෙළුමක් මත රඳා තියෙන්නේ @ppperry කරන්නේ පවතී. එහි අන්තයට ගත් විට, ධනාත්මක <3 සඳහා කෘති nපැවසීමට " ප්‍රමාණවත් තරම් කුඩා " භාවිතා කළ හැකිය , නමුත් මෙය ඇල්ගොරිතම මත පදනම් වූ බැවින් හොඳ ඇල්ගොරිතමයකට එම තර්කය ඉවතට හරවා ගැනීමට තරම් විශාල කළ හැකිය. වේගවත් හෝ මන්දගාමී යන්ත්‍රයක් එය වඩාත් භාවිතයට ගත හැකිදැයි මට විශ්වාස නැත. කෙසේ වෙතත්, මෙම විසඳුම වටා වැඩ කළ හැකි බව මම එකඟ වෙමි. එය පොලිස් සහ මංකොල්ලකරුවන් නොවේ , කෙසේ හෝ හොඳින් සිදු වේ.(n-1)nn
wizzwizz4

29

PHP

එය සැබවින්ම ක්‍රියාත්මක වන බව මම විශ්වාස කරමි, නමුත් සියලු නිමැවුම් වසා දැමීම STDOUTසහ STDERRමර්දනය කිරීම. ඒවා නැවත විවෘත නොවන බවට වග බලා ගැනීම සඳහා /dev/null, 0, 1 සහ 2 යන ගොනු විස්තර නැවත පැවරීම සඳහා අපි තුන් වරක් විවෘත කරමු :

<?php
fclose(STDIN);
fclose(STDOUT);
fclose(STDERR);
fopen('/dev/null','r');
fopen('/dev/null','w');
fopen('/dev/null','w');

// insert program here

ඒ පිළිබඳ වැඩි විස්තර: /programming/937627/how-to-redirect-stdout-to-a-file-in-php


ලිපිගොනු වලට ලිවීම සහ වැඩසටහනේ පිටවීමේ කේතය භාවිතා කිරීම ඇතුළුව වෙනත් වලංගු ප්‍රතිදාන ආකෘති තිබේ. පිරිවිතරයේ අදාළ බුලට් පොයින්ට් එකේ ඇති සබැඳිය බලන්න.
මාටින් එන්ඩර්

1
හරියටම අවසර දී ඇති හා නොකළ දේ මට පැහැදිලිව පෙනෙන්නට නැත. උදාහරණයක් ලෙස විකී ටැගය තුළ මට ලිපිගොනු සහ පිටවීමේ කේත ගැන කිසිවක් හමු නොවීය. නමුත් ඔවුන්ට අවසර දී ඇත්නම්, මෙය වලංගු ඉදිරිපත් කිරීමක් බවට පත් කළ හැකි යැයි මම නොසිතමි.
ෆේබියන් ෂ්මෙන්ග්ලර්

එක් ප්‍රතිදාන පෝරමයක් පමණක් අක්‍රීය කිරීමට ඉඩ දීම සඳහා ප්‍රශ්නය සංස්කරණය කරන ලදි.
jimmy23013

21
@ ජිමී 23013 කුමක්ද? එය ප්‍රශ්නයේ කාරණය මුළුමනින්ම පරාජය කරයි.
හොබ්ස්

6
im jimmy23013 එක් නිමැවුම් පෝරමයක් පමණක් අක්‍රීය කිරීම වලංගු නම්, උදාහරණයක් ලෙස වැඩසටහනේ පිටවීමේ කේතය යටපත් කිරීම (මාටින් යෝජනා කළ පරිදි) පිටවීමේ කේතයක් නොමැතිව භාෂාව සම්පූර්ණයෙන්ම භාවිතා කළ හැකි වුවද මා කළ යුත්තේ එයද?
ජෙරී ජෙරමියා

29

ගණිතය / වුල්ෆ්රාම් භාෂාව

ගණිතය යනු අර්ථකථනය කරන ලද භාෂාවක් වන අතර විධාන නම් යනු ක්‍රමලේඛකයාට හැසිරවිය හැකි සංකේත වේ. ඔබට ගොඩනංවන ලද ක්‍රියාකරුවන් මකා දැමිය නොහැක, නමුත් ඔබට ඒවා අධික ලෙස පැටවීමට හෝ ඒවායේ ක්‍රියාකාරිත්වය වෙනස් කිරීමට හැකිය. පහත දැක්වෙන්නේ "සමඟ" විධානය සීරීමට ය, එය අභ්‍යන්තරව පවා විචල්‍යයන්ට පැවරීම සඳහා අවශ්‍ය වේ. මෙම වෙනස කර්නලය පැවරුම සම්පුර්ණ වන තෙක් තක්සේරු නොකළ තර්ක රඳවා තබා ගැනීම වළක්වන අතර එමඟින් භාෂාව තරමක් මිය යයි.

ClearAttributes["With", HoldAll]

මෙම විධානය අන්තර්ක්‍රියාකාරී සැසියක හෝ කේත කාණ්ඩයක් තුළ ක්‍රියාත්මක වන්නේ නම්, ගණිතයට එකතු කිරීමට පවා නොහැකි වනු ඇත 1+1(එහි ප්‍රති error ලයක් ලෙස ඇති වූ දෝෂ පණිවිඩය පිටුවක් පමණ දිගු බැවින් මම එය මෙහි ඇතුළත් නොකරමි).


25

සීරීමට

මෙන්න ඔබගේ බ්‍රව්සරය බිඳ වැටෙන ඉතා සරල උදාහරණයක් (සහ, න්‍යායිකව, ඔබේ පරිගණකය):

ක්ෂණික බිඳ වැටීම

මම තත්පර 20 ක් පමණ මෙම ධාවන පථයෙන් ඉවත්ව ගිය අතර පසුව සීරීමට 2.65 GB මතකයක් අහිමි විය. මොහොතකට පසුව සහ 5 GB අතුරුදහන් විය.

මෙය ක්‍රියාත්මක කිරීමට පෙර ඔබට ඇඩෝබි ෆ්ලෑෂ් හෝ ඔබේ වෙබ් බ්‍රව්සරයෙන් ඉවත් වීමට බල කිරීමට ක්‍රමයක් ඇති බව මම තරයේ යෝජනා කරමි!


මට ඇත්ත වශයෙන්මclear(this) ජේඑස් වැනි සිසිල් පිළිතුරක් දීමට අවශ්‍ය වූ නමුත් කනගාටුවට කරුණක් නම් ස්ක්‍රැච්ට ඒ සඳහා ක්‍රමයක් නොමැත. සීරීමට භාවිතා කළ නොහැකි වෙනත් ක්‍රමයක් ඔබ සොයා ගන්නේ නම් මෙම ලිපිය යාවත්කාලීන කිරීමට (හෝ ඔබේම දෑ සාදා ගන්න) නිදහස් වන්න!


2
ඔබ පරිශීලක කේතය එකතු කරන්නේ කොතැනින්ද, එය සත්‍ය වශයෙන්ම ක්‍රියාත්මක වේද?
jimmy23013

පරිශීලක කේතය? ව්‍යාපෘතියේ ඕනෑම තැනක, මෙම ස්නිපටය ඇතුළත් කර ඇති තාක් කල්. ආරම්භක ධාවනයෙන් තත්පර 0.3 කට වරක් එය ක්‍රියාත්මක වන අතර පසුව සෑම තත්පර 0.3 කට වරක්ම (එය නිරන්තරයෙන් අවසානයක් නොමැතිව ස්ක්‍රිප්ට් එකක් නැවත ධාවනය කිරීම හැර, සීරීම් ඉතා මන්දගාමී වේ). වඩා හොඳ, බලවත් කඩාවැටීමකින් මම මෙම ලිපිය යාවත්කාලීන කළහොත් කමක් නැද්ද?
ෆ්ලෝරි

5
කවුරුහරි සීරීම් භාවිතා කරනවා ... d: -D ඔව් !!!
wizzwizz4

owtowerofnix මාර්ගය වන විට, මම මෙය වැඩි දියුණු කර / රැඩිකල් ලෙස වෙනස් කර / ප්‍රතිනිර්මාණය කර ඇත්තෙමි : codegolf.stackexchange.com/a/61490/43394 මයික්‍රෝෆෝනය ක්‍රියාත්මක වීම මත පතල රඳා නොපවතී.
wizzwizz4

1
@ wizzwizz4 ඔව් ඔයාගේ එක මට වඩා හොඳයි. කරුණාකර ඔහුගේ ඡන්දය දෙන්න
ෆ්ලෝරි

24

ඩොස් කණ්ඩායම (වින්ඩෝස් 95 ට පෙර මම විශ්වාස කරමි)

CTTY

කිසිදු තර්කයක් නොමැතිව නිකුත් කර ඇති මෙය විධාන රේඛාව පර්යන්තයෙන් විසන්ධි කරයි. ආදානය කියවීමට හෝ ප්‍රතිදානය උත්පාදනය කිරීමට තවදුරටත් උත්සාහ කිරීම කිසිවක් නොකරයි.

CTTY නිවැරදිව භාවිතා කරන්නේ කෙසේදැයි දැන ගැනීමට ඔබට අවශ්‍ය නම්:

MODE COM1,8600,8,N,1
CTTY COM1

තරමක් බලවත් කණ්ඩායම් ගොනුවකට මොඩමයට පිළිතුරු දිය හැකි අතර CTTY වෙත ඇමතූ ඕනෑම දෙයක් සම්බන්ධ කළ හැකිය.


22

පොදු ලිප්

(set-macro-character #\( (lambda (x y) ()))

ආරම්භක වරහන් ඔබට අවශ්‍ය නොවනු ඇතැයි මම සිතමි.

මෙය පා er ක මැක්‍රෝවක් වන අතර, සෑම අවස්ථාවක්ම (ඇමතුමකින් ප්‍රතිස්ථාපනය කරන ලෙස ලිස්ප් රීඩර්ට පවසයි (lambda (x y) ()). උදාහරණයක් ලෙස, එය කියවීමක් (foo)ලෙස විචල්‍යයක් ලෙස foo)අර්ථකථනය fooකර අසමසම වරහන් දෝෂයක් විසි කරයි 0.


2
කරුණාකර )බිඳෙන දෙයක් ලෙස අර්ථකථනය කරන්න! ඒ ආකාරයෙන් අඩු දෝෂ ඇති වේ.
wizzwizz4

7
මම මෙයට කැමතියි. "ලිස්ප් රඳා පවතින්නේ කුමක් ද? එක් තනි චරිතයක් ද? යමක් සිදුවුවහොත් එය ලැජ්ජාවකි ... එයට සිදුවී ඇත ..." එය ටෙක්ස් හි `\` නැවත අර්ථ දැක්වීම හා සමාන තර්කනයකි.
felixphew

21

Thue

::=

අවසානයේ නව රේඛාවක් සමඟ

මෙම භාෂාව රීසෙට්ස් නිර්වචනය කිරීම මත රඳා පවතින අතර එය රීට්සෙට් ::=හි අවසානය දක්වයි. නීති රීති නිර්වචනය නොකර කිසිවක් කළ නොහැකි ය, එබැවින් ඔබ පසුව තැබූ දේ නොසලකා ::=කිසිවක් සිදුවිය නොහැක.

විකල්ප පිළිතුර

A::=
B::=
C::=
D::=
E::=
F::=
G::=
H::=

(සහ යුනිකෝඩ් හි ඇති සෑම අක්ෂරයක් සඳහාම අක්ෂරයට පෙර Aසහ මුද්‍රණය කළ නොහැකි අක්ෂර ඇතුළුව ). මේ සඳහා විධාන රේඛා විකල්පය අවශ්‍ය වේ -r.


යම් දෙයක් නිර්ණායකයන් (රීට්සෙට් වැනි) තෘප්තිමත් කරන ආකාරයටම එය ව්‍යාකරණමය වශයෙන් සමාන නොවන බව මම අනුමාන කරමි.
jimmy23013

16

මැට්ලබ්

කේත පහත සඳහන් කෑල්ලක් පරිසරය සම්පූර්ණයෙන්ම මෙවිට කරයි 1 :

builtin = @(varargin)false; clear = @(varargin)false;
%// Insert code after this point

මෙය අභිබවා යයි builtinclear නව නිර්නාමික ශ්‍රිත හසුරුවලින් ශ්‍රිතය සහ ශ්‍රිතයfalse ඔබ උත්සාහ කරන සෑම අවස්ථාවකම නැවත පැමිණේ . මෙම builtinබිල්ට් MATLAB කිරීමට කටයුතු කරන බව එම (වගේ දේවල් ලෙස එම නම කියා ඔබ MATLAB ලියන්න ඕනෑම අභිරුචි කාර්යයන් පවතී නම්, එම කාර්යය වගකීම sum, max, min, ආදිය), ඔබ වුවමනාවන් කාර්යයන් වෙනුවට පරිද්දෙන් තේරුම නිශ්චිතවම මේ කතා කිරීමට හැකි . ඒ හා සමානව,clear දැනට ප්‍රකාශයට පත් කර ඇති සියලුම විචල්‍යයන් ඉවත් කිරීමට ඔබට හැකියාව ලබා දෙන අතර එවිට ඔබට නැවත ආරම්භ කළ හැකිය. මෙම හැකියාවන් ඉවත් කිරීමෙන්, ඔබ වැඩසටහන නැවත ආරම්භ නොකරන්නේ නම් ඔබට MATLAB භාවිතා කළ හැකි ක්‍රමයක් නොමැත.

MATLAB R2015a හි, මට පහත පණිවිඩය ද ලැබේ:

රූප විස්තරය මෙහි ඇතුළත් කරන්න

වැඩපොළ යනු දැනට පරිසරය තුළ ප්‍රකාශයට පත් කර ඇති විචල්‍යයන් වන අතර එමඟින් ඔබට ඒවා පසුව භාවිතා කළ හැකිය. මෙය වැඩපොළ ස්ථීර ලෙස අක්‍රීය කරයි, එබැවින් ඔබ උත්සාහ කර නිර්මාණය කරන ඕනෑම විචල්‍යයන් සුරැකෙන්නේ නැත. එබැවින් MATLAB හි කේත රේඛා ක්‍රියාත්මක කිරීමේදී කිසිදු ප්‍රගතියක් ලබා ගත නොහැක.

1: ණය පරිශීලකයාට යයි අදහස මුලින්ම සොයාගත් Dev-iL වේ.


2
R2014b හි ඔබට feval('clear')එය නිවැරදි කිරීමට කළ හැකිය. හෝ : s=str2func('clear'); s().
ස්ටීවි ග්‍රිෆින්

13

///

/\///

/// හි ඇති එකම මෙහෙයුම වන්නේ නැවත නැවත නූල් ආදේශ කිරීම ය: /pattern/replacement/ .

මෙම කේතය සෑම දෙයක්ම ඉවත් කරයි / , එමගින් ඔබට නැවත නැවත ආදේශන භාවිතා කළ නොහැක, එබැවින් මූලික වශයෙන් ඔබ පසුව ලියන සෑම දෙයක්ම මුද්‍රණය වේ (ය හැර /).

ඔබට තවමත් \s භාවිතා කළ හැකිය , නමුත් එය ඔබට බොහෝ සෙයින් උපකාරී නොවේ.


සෑම දෙයක්ම මකා දැමිය හැකි බවට සහතික වන /// කේත කැබැල්ලක් ලිවිය හැකිදැයි මම නිතරම කල්පනා කර ඇත්තෙමි. එය කළ නොහැකි බව පෙනේ, නමුත් එය කළ නොහැකි බවට සාක්ෂියක් ගැන මම සිතුවේ නැත.
ටැනර් ස්වේට්

12

Befunge-96

'~h

මෙම අනුක්‍රමයෙන් පසුව ඕනෑම තැනක පරිශීලකයාගේ කේතය අනුගමනය කළ හැකිය, මේවා ප්‍රභවයේ පළමු අක්ෂර තුන වන තාක් කල්.

මෙම 'විධානය (එක්-වෙඩි string මාතය) වල ASCII අගය තල්ලු ~අඩුක්කුව (එනම් 126) මතට, සහ hවිධානය ලෙස හැඳින්වෙන සකසයි සාකල්ය ඩෙල්ටා එම අගය සමග. Befunge-96 ගැන හුරු නැති අයට, හොලිස්ටික් ඩෙල්ටා යනු පරිවර්තකයා හමු වන සෑම විධාන වටිනාකමට එකතු කරන ඕෆ්සෙට් ය.

ඩෙල්ටාව 126 ලෙස සැකසූ පසු, ජනනය කළ හැකි එකම වලංගු විධානය වේ ~ (අක්ෂර ආදානය), ප්‍රභවයේ ශුන්‍ය බයිට් එකක් හරහා ය. ශුන්‍ය බයිට් එකක් හැර වෙනත් ඕනෑම දෙයක් 126 ට වඩා වැඩි අගයකට පරිවර්තනය වන අතර එම අගයන් කිසිවක් වලංගු Befunge විධානයන් නොවේ.

මෙය ක්‍රමලේඛන භාෂාවක් ලෙස සුදුසුකම් ලැබීමට නුසුදුසු යැයි පැවසීම ආරක්ෂිත යැයි මම සිතමි.


11

බූ

macro harmless:
    Context.Parameters.Pipeline.Clear()

ඊට පස්සේ, ව්යාපෘතියේ වෙනත් තැනක,

harmless

හානිකර නොවන ශබ්ද නාමයක් සහිත සරල සාර්ව, නමුත් පුදුමාකාර කලකිරවන බලපෑමක්. බූ සම්පාදකයා බහු-පියවර නල මාර්ගයක් භාවිතා කරන අතර එය ප්‍රභවය AST බවට විග්‍රහ කිරීමෙන් ආරම්භ වන අතර කේත උත්පාදනය සමඟ අවසන් වේ. (සාමාන්‍යයෙන් එය විවිධ යෙදුම් සඳහා නැවත සකස් කළ හැකිය.) ඒ අතර සෑම පියවරක්ම AST හි විවිධ මෙහෙයුම් සිදු කරයි.

පාර්ට්වේ හරහා යනු සාර්ව ප්‍රසාරණ අවධිය වන අතර එහිදී සම්පාදකයාගේ සන්දර්භය තුළ මැක්‍රෝස් ක්‍රියාත්මක වේ. නල මාර්ගය නැවත සකස් කළ හැකි බව අවසාන ඡේදයේ ඇති බිට් මතකද? සාර්ව ප්‍රසාරණය අතරතුර, ඔබ නල මාර්ගය පිරිසිදු කරන සාර්වයක් ඉල්ලා සිටියහොත්, පරිශීලකයාට කිසිදු දෝෂයක් නොපෙන්වයි, නමුත් සාර්ව ප්‍රසාරණයෙන් පසු (කේත උත්පාදනය ඇතුළුව) සියලු පියවර තවදුරටත් එහි නොමැත. එබැවින් ඔබ සාර්ථක සම්පාදනයක් මෙන් පෙනෙන දෙයකින් අවසන් වේ - දෝෂ පණිවිඩ කිසිවක් ප්‍රදර්ශනය නොකෙරේ - නමුත් කිසියම් හේතුවක් නිසා ද්විමය නිෂ්පාදනයක් නොමැත! ඔබ සාර්ව හා ආයාචනය හොඳින් සඟවා ගන්නේ නම්, හොඳම දෝශ නිරාකරණ පවා බිත්තියට තල්ලු කිරීමට සහතිකයි.


පරිශීලක කේතය කිසි විටෙකත් ක්‍රියාත්මක නොවන බැවින් මෙම පිළිතුර අවලංගුය.
pppery

@ppperry: එය එසේ බව සහතිකයි: සාර්ව පරිශීලක කේතයේ කොටසක් ලෙස ලිවිය හැකි අතර එය සම්පාදකයා තුළ ක්‍රියාත්මක වේ .
මේසන් රෝද

ඔබ චරිත සමූහයක් චරිතයක් සඳහා එවැනි සාර්ව නිර්වචනය කිරීමට සිදුවන අවශ්ය ටයිප් කිරීමට නිර්ණායක ගැලපෙන හූව කරවන වැඩසටහන් සෑම වැඩසටහනක් හෝ කට්ටලයක් .
pppery

@ppperry: ඔව්, සාර්ව (කේතයේ ඕනෑම තැනක) ආයාචනා කිරීම සම්පාදකයා බිඳී යාමට හේතු වන අතර නිර්ණායක සපුරාලයි. ඔබ ඊට වඩා ගැඹුරු යමක් පැවසීමට උත්සාහ කරන්නේ නම්, ඔබට තව ටිකක් පැහැදිලි විය යුතුය, මන්ද ගැටලුව කුමක්දැයි මා නොදකිමි.
මේසන් රෝද

2
leslebetman: ඔබ සතුව REPL හෝ මැක්‍රෝස් ඇති විට පරිශීලක කේතය සම්පාදනය කරන වේලාවේදී, දෙක අතර වෙනස ඉතා බොඳ වේ.
මේසන් වීලර්

10

එන්ජීඑන් / ඒපීඑල්

එන්ජීඑන් / ඒපීඑල් විසින් ප්‍රාථමිකයන් නැවත අර්ථ දැක්වීමට ඉඩ දෙයි, එබැවින් ( ) සියළුම ප්‍රාථමික කාර්යයන් නැවත අර්ථ දැක්වීම ("හරහා යන්න": දෙකම ⊢3සහ 2⊢3ලබා දෙයි 3) භාෂාව සම්පූර්ණයෙන්ම නිෂ් less ල කරයි:

⍪←-←+←?←⍵←∊←⍴←~←↑←↓←⍳←○←*←⌈←⌊←⍕←⊂←⊃←∩←∪←⊥←⊤←|←<←≤←=←≥←>←≠←∨←∧←×←÷←⍒←⍋←⌽←⍉←⊖←⍟←⍱←⍲←!←⌹←⊣←⍎←⊢

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


1
-1 දැනට, නමුත් මෙය යහපත් යැයි පෙනේ! සමහර විට ඔබ සියලු ප්‍රාථමිකයන් නැවත අර්ථ දැක්වුවහොත් …
බ්ලැක් ලයිට් බැබළෙන

L බ්ලැක්ලයිට්ෂයිනින් ඔබ යන්න.
ඇඩම්

8

රූබි (අක්ෂර 29)

class Object;def send;end;end

රූබී තුළ ක්‍රමයක් කැඳවන සෑම අවස්ථාවකම අභ්‍යන්තරව 'යැවීම' භාවිතා වන අතර, සියලු වස්තු වස්තු පන්තියෙන් උරුම වන හෙයින්. මෙය ක්‍රියාත්මක වන ඕනෑම ක්‍රමයක් නතර කළ යුතුය.

විනෝදජනක සත්‍යය: මෙය න්‍යායිකව පරිපූර්ණ ය. නමුත් යම් හේතුවක් නිසා රූබි භාෂාව විහිළුවට ලක් නොකරන බව පෙනේ. මෙම කේතය ක්‍රියාත්මක කර විවෘත රූබි පරිසරයක් භාවිතා කළ හැක්කේ මන්දැයි මට අදහසක් නැත.


ඇත්තටම මෙය ක්‍රියාත්මක වන්නේ ප්‍රයි රූබි කවචයේ ය.
ෆීලික්ස් සපරෙලි

ඔබ අදහස් කරන්නේ එය "මෙය බිඳ දමයි" හෝ "එය තවමත් මෙයින් පසුව ක්‍රියාත්මක වේ" ලෙස ක්‍රියා කරනවාද? මම සඳහන් කළේ දෙවැන්න සරල පරණ ඉර්බ් හි ඇති බවයි
ඒ.ජේ.ෆාරඩේ

1
මම කිව්වේ ඒක ප්‍රයිව කඩනවා. එය IRB බිඳ නොදමන අතර .rb ලිපිගොනු වල ධාවනය බිඳෙන්නේ නැත, නමුත් එය Pry බිඳ දමයි.
ෆීලික්ස් සපරෙලි

සිත්ගන්නා සුළුය. යැවීමේ ක්‍රමයට යම් ආරක්ෂාවක් ඇති බව මම අනුමාන කරමි.
AJFaraday

8

Tcl

foreach x [info commands] {if {$x!="rename"&&$x!="if"} {rename $x ""}}

මෙය ifසහ හැර අනෙකුත් සියලුම වචන භාෂාවෙන් ඉවත් කරයි rename.

ඉහත කේතය ඕනෑම නව කේතයක් දෝෂ සහිත වීමට හේතු වේ. එබැවින් නව ඇතුළත් කළ කේතය ඇත්ත වශයෙන්ම "ක්‍රියාත්මක" වන්නේ නම් එය විවාදාත්මක ය. පහත දැක්වෙන්නේ නව කේතයක් ක්‍රියාත්මක කරන නමුත් කිසිවක් නොකරන්නේ එය සියලු මූල පද (හැර ) ifසහ procක්‍රියාකාරී නොවන ලෙස වෙනස් කරන බැවිනි :

foreach x [info commands] {if {$x!="if"&&$x!="proc"} {
    proc $x args {}
}}

මූලපද මකා දැමීම වෙනුවට මෙම කේතය ඒවා කිසිවක් නොකරන ශ්‍රිතයක් මගින් ප්‍රතිස්ථාපනය කරයි.

(සටහන: මම මෙහි "වචන" ඉතා ලිහිල් ලෙස භාවිතා කරන්නේ Tcl ට මූල පද නොමැති නිසා, කාර්යයන් පමණි)


1
නැවත නම් කිරීමෙන් ifසහ ලූපයෙන් renameපසුව ඔබට එය වඩා හොඳ කළ හැකි යැයි මම සිතමි . දෙවන අනුවාදයේ දී, ඔබ ද procව්යතිරේකයක් කළ යුතුය .
jimmy23013

im jimmy23013 හ්ම් .. තාක්‍ෂණිකව ඔබ නිවැරදි විය යුතු නමුත් එම කේත ස්නිපටය procකලින් ලැයිස්තුවේ දිස් වූවත් tcl හි වර්තමාන අනුවාදය සමඟ ක්‍රියා කරයි puts. තාක්ෂණික වශයෙන් කේතය ද නොමැතිව ක්‍රියා කළ යුතු renameනමුත් බිල්ට් විධාන වෙනත් ආකාරයකින් ආරක්ෂා වන බව පෙනේ. සිදුවන්නේ කුමක්දැයි නිශ්චිතවම කිව නොහැකි නමුත් කේතය පරීක්ෂා කර ප්‍රචාරණය කළ පරිදි ක්‍රියා කරයි.
නිදිමත

im ජිමී 23013: හරි. ඇමතුමකින් තොරව කේතය දැන් ක්‍රියාත්මක වේ rename. එය මගේ පැත්තෙන් මොළයක් විය - මට බැහැර කිරීමට අමතක විය proc.
නිදිමත

ඔබට ප්‍රතිදානය උත්පාදනය කිරීමට අවශ්‍ය නම් තනිවම කළ ifහැකි වීම නිෂ් less ල බැවින් මම නැවත නම් නොකිරීමට තීරණය කළෙමි if.
නිදිමත

ඇත්ත වශයෙන්ම ඔබට ඒවා නැවත නම් කිරීමට අවශ්‍ය නැත. නමුත් මෙය කේත ගොල්ෆ් නොවේ. මම හිතුවේ ඒවා නැවත නම් කිරීම මෙම පිළිතුර වඩා හොඳ පෙනුමක් ලබා දෙයි (හෝ නොවිය හැක).
jimmy23013

7

හූන්

=<  ~
(your code)

හූන් අමුතුයි. එය සින්ටැක්ස් වල පමණක් නොව අර්ථකථන වලද වෙනත් ක්‍රමලේඛන භාෂාවන්ට වඩා බෙහෙවින් වෙනස් ය. ෂඩාස්රාකාරය වැනි භාෂාවන් මෙන් නොව එය හිතාමතාම ව්‍යාකූල එකක් බවට පත් කර නැත.

හූන් නොක් වෙත සම්පාදනය කරයි , අවම සංයෝජක පාදක වීඑම්. නොක් මෝඩය: පිරිවිතර බයිට් 340 ක් දක්වා gzip කළ හැකිය. එකම ගණිත මෙහෙයුම වැඩි කිරීම වේ. සෑම දෙයක්ම නාම පදයකි: පරමාණුවක් (බිග්නම්) හෝ සෛලයක් (නාම පද යුගලයක්), සම්පූර්ණ මතක ආකෘතියම වෙනස් කළ නොහැකි ඇසික්ලික් ද්විමය ගසක සකසා ඇත. එකම ප්‍රතිදානය ඔබේ ප්‍රකාශනය අඩු කරන නාම පදයයි.

අමුතු සම්පාදන ඉලක්කය නිසා, හූන් ද අමුතු ය: එය සම්පූර්ණයෙන්ම පිරිසිදු ය. "සන්දර්භය" මත තක්සේරු කරනු ලබන නොක් ප්‍රකාශනයකට හූන් සම්පාදනය කරයි. සමස්ත කර්නලය සහ stdlib, සියලු විචල්‍යයන් සමඟ, සන්දර්භය මඟින් වැඩසටහනට ව්‍යංගයෙන් ලබා දෙනු ලැබේ.

හූන් භාවිතයට නුසුදුසු බවට පත් කිරීම සඳහා අපි භාවිතා කරන්නේ =<, එය "b හි සන්දර්භය තුළ ඇගයීම" යන්නයි. අපි සෑම විටම ඇගයීමට ලක් කරමු ~, එය ශුන්‍ය වේ. කුමක් කළත් b, එය අඩු කරන අගය වෙනස් කළ නොහැකි අතර, අතුරු ආබාධයක් නොමැති බැවින් එයට ආදානය හෝ ප්‍රතිදානය කළ නොහැක.

පැති සටහන: ඔබට ඇත්ත වශයෙන්ම හූන් (සංශුද්ධතාවය!) වෙතින් ආදානය ඉල්ලා සිටිය නොහැකි බැවින්, නීතිරීති අනුව එය ඇත්ත වශයෙන්ම ක්‍රමලේඛන භාෂාවක් නොවේ. ආදානය යනු ශ්‍රිත තර්ක හරහා ය, ප්‍රතිදාන ප්‍රතිලාභ අගයන් හරහා (හෝ~& , එය මුද්‍රණ නිදොස් කිරීමේ අංගයක් වන අතර එය වැඩසටහනට විනිවිද පෙනෙන).

වැඩසටහනක් උර්බිට් හි ආදානය ලබා ගැනීම සඳහා, ඔබ ඇත්ත වශයෙන්ම ආදාන පිළිගන්නා ශ්‍රිතයක් ආපසු ලබා දෙන වැඩසටහනක් ලියන අතර, කවචය ඔබ වෙනුවෙන් ඉල්ලන අතර ඇමතුමට ආපසු යයි.


3
නියත වශයෙන්ම අපගේ ප්‍රමිතීන්ට අනුව ක්‍රමලේඛන භාෂාවක් වුවද
බළලා

7

කුලී රථ, බයිට් 2354.

මෙම කුඩා වැඩසටහන ටවුන්ස්බර්ග් හරහා විශාල ජොයිරයිඩ් රථයකින් කුලී රථය ධාවනය කරයි. මෙයින් පසු ඔබ ධාවනය කරන ඕනෑම කේතයක් ඉක්මනින් දෝෂ සහිත error: out of gasවේ. මගීන් නොමැති බැවින් මුදල් එකතු කර නොමැති බැවින් ඔබට ගෑස් මධ්‍යස්ථානයකට ළඟා විය හැකි යැයි මම නොසිතමි.

Go to Trunkers: west, 1st right, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st right, 1st left, 3rd left, 2nd left, 3rd left, 2nd right, 1st right, 2nd right, 1st right, 1st left, 1st left, 1st left, 1st right.

6

බ්‍රව්සරයේ ජාවාස්ක්‍රිප්ට්

හොඳයි, අවම වශයෙන් IE11 හි.

window.addEventListener("error", function(){});
document = document.write = alert = prompt = confirm = console = void(
    (function (window) {
        try {
            //Code goes here
        } catch (e) {}
    })({})
);

ලේඛනයට ලිවීම, ගෝලීය විචල්‍යයට ලිවීම සහ ශ්‍රිතයෙන් ආපසු යාම අක්‍රීය කරයි.

මට ප්‍රතිදාන ක්‍රමයක් මග හැරී ඇත්නම් අදහස් දක්වන්න!


ව්‍යතිරේකයන් තවමත් කොන්සෝලය තුළ පෙන්වනු ඇත. ඔබට ඒවා හැසිරවිය හැකියwindow.addEventListener('error',function(){});
ඉස්මයිල් මිගෙල්

S ඉස්මයිල් මිගෙල් දැන් මට සියලු ගෞරවය ලබා ගත නොහැක! d ;-D
wizzwizz4

4
මෙය බැරෑරුම් ලෙස ක්‍රියාත්මක වේද? එය කිසිසේත්ම තේරුමක් නැති දෙයක්: documentඇතුළත් කළ කේතයේ පිටත විෂය පථයෙන් තවමත් ප්‍රවේශ විය යුතු අතර, ඇතුළු කළ කේතය ක්‍රියාත්මක කිරීමෙන් පසු එය ප්‍රතිස්ථාපනය නොකළ යුතුය .
පීටර් ටේලර්

Et පීටර් ටේලර් :-( ඔබේ තර්කනය මගේ න්‍යාය බිඳ දැමීය.
wizzwizz4


5

ගොල්ෆ් ස්ක්‍රිප්ට්

"#{def eval(s) end}":+:%:/:,:*:do:while:until

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

සියලු ලූප ක්‍රියාකරවන්නන් ප්‍රතිස්ථාපනය කිරීමට අවශ්‍ය හේතුව, අහිංසක අය පවා ,, ප්‍රාථමික පරීක්ෂාවට අසීමිත ලූප අවශ්‍ය නොවේ. උදා: ක් අතර, පහත දැක්වෙන භාවිතා ,එහි ආකාර තුනක් (දී range, filter, lenprimality පරීක්ෂණ කරන්න):

~.,2>{1$\%!},,\;

ප්‍රතිස්ථාපනය කිරීමට +හේතුව, ජිමී 23013, ලූප සැකැස්මක් ලබා ගැනීම සඳහා ක්විං භාවිතා කිරීම යෝජනා කිරීමයි. ඔහු විසින් සපයන ලද නිශ්චිත ක්‍රියාවට නැංවීම ක්‍රියාත්මක නොවන්නේ ක්ලෝබර් කිරීම මගින් fooමම (සම්මත) පරිවර්තකයාගේ නූල් විග්‍රහ කිරීමේ ක්‍රමයටද සම්බන්ධ කර ඇති නිසාය, නමුත් එය නූල් වෙනුවට බ්ලොක් භාවිතා කර නැවත සකස් කළ හැකි යැයි මම බලාපොරොත්තු වෙමි, එබැවින් මම එය ආරක්ෂිතව වාදනය කරමි.


ප්‍රාථමික පරීක්ෂණය තවමත් කළ හැකිය : ~.1>2\'3$3$\'@2$-@@2$0>!.+.+.+.+.+.+>.~\'.~;;!!@&@)\@3$3$>.+.+.+.+.+.+.+>.~'.~;\;\;. evalනූල් සහ සංඛ්‍යා නොමැතිව කෙලින්ම නියම කළ නොහැක, නමුත් වැනි ක්‍රියාමාර්ග n[n!!.+.+.+.+.+.+]+තිබේ.
jimmy23013

සබැඳි පරීක්ෂකයාගේ දෝෂයක් ඇති බව පෙනේ; මම පසුව එය නිවසේදී උත්සාහ කරමි. අදහස මූලිකවම ලූපයක් ලබා ගැනීම සඳහා ක්වයින් තාක්ෂණයක් භාවිතා කිරීමද?
පීටර් ටේලර්

ඔව්. එය "#{def eval(s) end}"කෙලින්ම ක්‍රියාත්මක නොවන අතර තවත් සංකීර්ණ ක්‍රියාමාර්ගයක් අවශ්‍ය වේ, එය තවමත් ක්‍රියාත්මක කිරීමට මට කරදරයක් වී නොමැත.
jimmy23013

අවහිර නොකරන්නේ ඇයි ~? ඒවා .+.+... ආදේශ කළ හැකිය 1000 0 if.
ජිමී 23013

1
ඇයි හැම දෙයක්ම අවහිර නොකරන්නේ ...?
ලින්
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.