මම සංවර්ධකයෙක් වන අතර මගේ වැඩ කටයුතු කිරීමට මට දැනෙන්නේ නැත. XKCD වෙතින් මම දනිමි, මන්දගාමී වීමට හොඳම නිදහසට කරුණ නම් ඔබේ කේතය සම්පාදනය කිරීමයි. මේ නිසා, මට සදාකාලිකවම සම්පාදනය වන කේතයක් අවශ්‍ය යැයි මම සිතමි ! මම කම්මැලි නිසා සහ බොහෝ දේ ටයිප් කිරීමට අවශ්‍ය නැති නිසා, මෙය කළ හැකි කෙටිම කේතය සමඟ කළ යුතුය.

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

පිරිවිතර

• ඔබ සම්පාදකයෙකු ඇති භාෂාවක් භාවිතා කළ යුතුය, පැහැදිලිවම.
• එක් එක් විසඳුම සඳහා භාවිතා කරන ක්රියාත්මක කිරීම සඳහන් කරන්න.
• මෙය කේත ගොල්ෆ් වේ , එබැවින් කෙටිම වලංගු විසඳුම (බයිට් වලින්) ජය ගනී.
• සම්පාදකයාට මතකයෙන් ඉවතට යාමෙන් හෝ ඉඩ ප්‍රමාණයෙන් අවසන් විය හැකිය.

ජැප්ට් , බයිට් 2 යි

`ÿ

ඔබ සමඟ අමුත්තන් මෙම පරීක්ෂා කළ හැකි මෙහි , නමුත් එය ඔබගේ බ්රව්සරයේ කැටි ඇත ලෙස මම එය නිර්දේශ නැත.

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

නූල් සම්පීඩනය කිරීම සඳහා ජැප්ට් ෂෝකෝ පුස්තකාලය භාවිතා කරයි . පසුපෙළක් සම්පාදකයාට පවසන්නේ ඊළඟ බැක්ටික් හෝ ගොනුවේ අවසානය දක්වා සියල්ල විකේතනය කරන ලෙසයි. සෑම බයිටයක්ම පහත සඳහන් දේ කරයි:

• 00-7F ඒවා නොවෙනස්ව පවතී.
• 80-BFඑක් එක් පොදු සිම්පල් අකුරු දෙකක් යුගල (බවට පත් at, oo, th, ආදිය).
• C0-DFසෑම කෙනෙකුම ඊළඟ බයිට් පරිභෝජනය කරන අතර පොදු අකුරු හතරක නූලක් බවට පරිවර්තනය වේ.
• E0-EFසෑම එකක්ම ඊළඟ බයිට් තුන පරිභෝජනය කර "පොදු" අකුරු අටක නූලක් බවට පරිවර්තනය කරයි ( Wherererඑතැනින් ආරම්භ වී පහළට යන්න).
• F0-F7 විසංයෝජනය බිඳ දමන්න, එය තවමත් සියල්ල බයිට් බයිට් දක්වා ආපසු ලබා දෙයි.
• F8-FFවිසංයෝජනය අසීමිත පුඩුවක් තුළට ඇතුළු වීමට හේතු වේ. ෂෝකෝ පුස්තකාලයේ අභ්‍යන්තර ක්‍රියාකාරකම් ගැන මට එතරම් අවබෝධයක් නැති නිසා (සහ ජාවාස්ක්‍රිප්ට් කේතය සම්පූර්ණයෙන්ම කියවිය නොහැකි බැවින් ) මෙය සිදුවන්නේ මන්දැයි මට විශ්වාස නැත , නමුත් මෙම අවස්ථාවේ දී එය තරමක් පහසුය .

ජැප්ට් සම්පාදකයා සමඟ පටලවා ගැනීමට වෙනත් ක්‍රමයක් ඇතැයි මම විශ්වාස නොකරමි, නමුත් ඔබ කිසි විටෙකත් නොදනී ...

TikZ (pdfTeX 3.14159265-2.6-1.40.17), 85 79 74 24 22 21 බයිට්

බයිට් පොකුරක් wchargin ට ස්තූතියි

එක් බයිට් එකක් ක්‍රිස් එච්ට ස්තූතියි

\input tikz
\tikz\pic

මම ගෙදර වැඩ කරන විට අහම්බෙන් මට මෙය හමු විය. සිදුවන්නේ කුමක්ද යන්න වටහා ගැනීමට පෙර මම එය සම්පාදනය කරන තෙක් බලා සිටියෙමි.

මෙය කොටස් දෙකක් ඇත:

\input tikz

මෙය TikZ පැකේජය පටවයි

හා:

\tikz\pic

මෙය \tikzපරිසරයක් සහ දිනුම් ඇදීමක් ආරම්භ කරයි .

මොනවද වෙන්නේ

Pdflatex සම්පාදකයා සමඟ ගැටළුවක් ඇති \tikz\picඅතර අන්තර්ක්‍රියාකාරී මාදිලියට ඇතුළු වන අතර එමඟින් එය දින නියමයක් නොමැතිව ඇණහිටේ .

සී, බයිට් 18 යි

#include __FILE__

සම්පාදකයින් සාමාන්‍යයෙන් 200 වතාවක් පමණ පුනරාවර්තනය වීමෙන් පසු අත්හරිනු ඇත.

DOM ඉදිකිරීම සම්පාදනය කිරීමේ පියවරක් ලෙස සලකනවාද? එසේ නම් x.htm:

<iframe src=x.htm>

ජාවා, 102 95 89 88 78 බයිට්

class A<T>{}class B<T>extends A<A<?super B<B<T>>>>{A<?super B<A>>a=new B<>();}

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

ගෙවිය යුතු ණය .

මෙහි කුමක් සිදුවේද?

1. A<T>අකුරු 1 ක දෙමව්පියෙකු සිටීම සඳහා එහි ඇත. එය සාමාන්‍යයි. මට භාවිතා කිරීමට හැකියාව Listතිබුනි, නමුත් ආනයන සහ අකුරු 4 ක් පුනරාවර්තනය කිරීම දිගු වේ.
2. B<T> මූලික ජනක ප්‍රකාශයක්.
3. B extends ABසහ අතර ධූරාවලියක් තිබිය Aයුතුය.
4. extends A<A>ස්වයං යොමු කිරීමක් නිර්මාණය කරයි A<T>.
5. A<? super B> ජනක විද්‍යාව සෙවීම අවුලුවයි A<T>
6. B<B<T>>ස්වයං-යොමු කිරීමක් නිර්මාණය කරයි B<T>.
7. A<...> a=new B<>()ඒවා නිර්වචනය කිරීම වෙනුවට ජනක විද්‍යාවේ භාවිතය බල කරයි, සම්පාදනය කිරීමේදී විභේදනය බල කරයි B, පසුව නොවේ.
8. A<?super Bස්වයං-යොමු-නොවන යොමු කිරීමක් නිර්මාණය කරයි, එබැවින් අපට එක් වර්ගයක් සහ තවත් වර්ගයක යොමු දැක්වීමක් ඇත A.
9. B<A>ස්වයං-යොමු-නොවන යොමු කිරීමක් නිර්මාණය කරයි, එබැවින් අපට එක් වර්ගයක් සහ තවත් වර්ගයක යොමු දැක්වීමක් ඇත B.

දැන්, වර්ගයට Aජනකතා වර්ගයක් ඇති Aඅතර B, නමුත් තෝරා ගත යුත්තේ කුමක්ද? ස්වයං ගැන අමතක කරන්න, විසඳීමට උත්සාහ කරමු B. පිං.

හරි, Bgenerics ටයිප් කර Aසහ B, නමුත් ඔහු තෝරා කිරීමට නියමිත? ස්වයං ගැන අමතක කරන්න, විසඳීමට උත්සාහ කරමු A. පොං.

වැනි නීත්යානුකූල අවස්ථා නැති නිසා සහානුයාත වලට මේ වගේ ඇත්තටම මග හැරිය නොහැකිය A<B<A<B<A<B<Object>>>>>>, උදාහරණයක් වශයෙන්, JSON වස්තුව:: List<Map<String,Map<String,List<Map<String,List<String>>>>>>.

සම්පාදන ප්‍රති .ලය

$ javac NoCompile.java


The system is out of resources.
Consult the following stack trace for details.
java.lang.StackOverflowError
        at com.sun.tools.javac.code.Types$UnaryVisitor.visit(Types.java:3260)
        at com.sun.tools.javac.code.Types$23.visitClassType(Types.java:2587)
        at com.sun.tools.javac.code.Types$23.visitClassType(Types.java:2579)
        at com.sun.tools.javac.code.Type$ClassType.accept(Type.java:554)
        at com.sun.tools.javac.code.Types$UnaryVisitor.visit(Types.java:3260)
        at com.sun.tools.javac.code.Types$23.visitClassType(Types.java:2592)
        at com.sun.tools.javac.code.Types$23.visitClassType(Types.java:2579)
        at com.sun.tools.javac.code.Type$ClassType.accept(Type.java:554)

මගේ පද්ධතියේ, පේළි 1024 ක් පෙන්වීමෙන් පසු සිරස් හෝඩුවාව නතර වන අතර ඇත්ත වශයෙන්ම එකම රේඛා 4 256 වතාවක් පුනරාවර්තනය වේ, එමඟින් අසීමිත පුනරාවර්තනයක් සනාථ වේ. ඒ සම්පූර්ණ හෝඩුවාව මම ඔබට ඉතිරි කරමි.

ඉතුරුම්

1. 102 → 95 බයිට්: වෙනුවට interface+ implementsසමඟ class+ extends.
2. බයිට් 95 → 89: ආදේශ Longකර ඇත A(දෙවරක්).
3. බයිට් 89 → 88: භාවිතා කළ දියමන්ති ක්‍රියාකරු ( new B<A>()→ new B<>()).
4. බයිට් 88 → 78: VoteToClose ට ස්තූතිවන්ත වෙමින් විචල්‍ය ප්‍රකාශය පන්ති සාමාජිකයෙකු වෙත ගෙන යන ලදී .

GNU Makefile, බයිට් 8 7

එක් බයිට් එකක් කොන්රාඩ් රුඩොල්ෆ්ට ස්තූතියි

ලෙස සුරකින ලද Makefileසහ ආයාචනා කරන ලද්දේ make:

x:;make

මෙය සොයාගත් පළමු ඉලක්කය මත අසීමිත ගොඩනැගීමේ පුනරාවර්තනයක් ඇති කරයි "x".

ඔබ නැති බව අමුතුවෙන් කිව යුතු නැත ඇත්තටම ඔබේ නිෂ්පාදන සේවාදායකය මත මෙම දෙබලක බෝම්බ ක්රියාත්මක කිරීමට අවශ්ය. :-)

make
make[1]: Entering directory `/path/to/my/dir'
make
make[2]: Entering directory `/path/to/my/dir'
make
make[3]: Entering directory `/path/to/my/dir'
make
make[4]: Entering directory `/path/to/my/dir'
make
make[5]: Entering directory `/path/to/my/dir'
make
make[6]: Entering directory `/path/to/my/dir'
make
make[7]: Entering directory `/path/to/my/dir'
make
...

විකල්ප අනුවාදය, බයිට් 5 ක්

කොන්රාඩ් රුඩොල්ෆ් විසින් යෝජනා කරන ලද්දේ:

x:;$_

$_යනු පෙර විධානයෙහි අවසාන තර්කය වෙත යොමු කිරීමකි. වඩාත් නිශ්චිතවම, එය ක්‍රියාත්මක කරනු ලබන්නේ විධානය ක්‍රියාත්මක කිරීමේ නිරපේක්ෂ මාවත ලෙස makeය.

මෙය අව්‍යාජ Bash පරිසරයක හොඳින් ක්‍රියාත්මක විය යුතු නමුත් වින්ඩෝස් + MinGW මත නොවේ.

සී ++, 60 58

template<class T>class a{a<T*>operator->();};a<int>i=i->b;

මෙය පුනරාවර්තන ලෙස class aවිවිධ අච්චු පරාමිතීන් සහිත අවස්ථා නිර්මාණය කරයි . operator->පුද්ගලිකත්වය පිළිබඳ වැරදි ටොන් ගණනක් සහිත පුනරාවර්තන මට්ටම් 900 කට පසු ජීසීසී 7.0 නතර වන නමුත් නිදසුනක් ලෙස අයිසීසී 17 සහ මයික්‍රොසොෆ්ට් (ආර්) සී / සී ++ කම්පයිලර් ප්‍රශස්තිකරණය 19 ක් ගොඩ්බෝල්ට් සඳහා කාලයයි .

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

සංස්කරණය කරන්න: බොලොව් විසින් බයිට් 2 ක් සුරකින ලදි - ස්තූතියි

පර්ල් , බයිට් 15 13

BEGIN{{redo}}

එය මාර්ගගතව උත්සාහ කරන්න!

දැන් බයිට් 2 ක් ඉතිරි කර ඇත: a සයිඩ් මට පර්ල් හි ලූපයක් කිරීමට දැඩි ක්‍රමයක් මතක් කළේය.

මෙය ඉතා සරල ය: එය අනන්ත පුඩුවක් සහිත විග්‍රහ කොක්කක් ස්ථාපනය කරන අතර කේතය විග්‍රහ කිරීමට අසීමිත කාලයක් ගත වේ. . යතුරු පදයක්.) එය අන්තර්ජාලය හරහා උත්සාහ කරන්න! ඉහත සබැඳිය මඟින් -cවිකල්පය ලබා දෙයි (නිරවද්‍යතාව සඳහා වාක්‍ය ඛණ්ඩය සත්‍යාපනය කිරීම සඳහා කේතය සම්පාදනය කිරීම, නමුත් එය ක්‍රියාත්මක නොකිරීම), අසීමිත ලූපය සම්පාදනය කරන වේලාවේදී සිදුවන බව සනාථ කිරීම.

ස්ක්‍රිප්ටින් භාෂාවක "කාලය සම්පාදනය කිරීම" ගැන ඔබ කල්පනා කරන්නේ නම්: පර්ල් ඇත්ත වශයෙන්ම බයිට් කේතයට සම්පාදනය කර පසුව බයිට් කේතය ධාවනය කරයි, නමුත් මෙය ක්‍රමලේඛනය කිරීමේදී කලාතුරකින් අදාළ වන විස්තරයකි. මෙම -MO=(මෙම bytecode ජනනය කළ හැකි පෙර අනන්ත පුඩුවක් සිදු ලෙස, නමුත් නොවේ මෙම වැඩසටහන සමග) විධාන විකල්පය පවුලේ එය ධාවනය වඩා වෙනත් bytecode දේවල් කරන්න කිරීම සඳහා භාවිතා කල හැක.

සී ++, 37 යි 30 යි බයිට් 29 යි

int f(auto p){f(&p);},a=f(0);

එය අනාගත ස්වයංක්‍රීය ශ්‍රිත පරාමිතිය භාවිතා කරයි. එය C ++ 17 වෙත යෝජනා කරන ලදි, නමුත් එය එය සෑදූ බව මම නොසිතමි. gccකෙසේ වෙතත් එය දිගුවක් ලෙස සහය දක්වයි.

මූලික වශයෙන්

void foo(auto p);

සමාන වේ

template <class T>
void foo(T p);

කේතය fවිවිධ අච්චු තර්ක සමඟ පුනරාවර්තනය වීමට උත්සාහ කරයි . gccසමඟ අසමත් වේ

මාරාන්තික දෝෂය: අච්චු ස්ථාපනය කිරීමේ ගැඹුර උපරිම 900 ඉක්මවයි (උපරිමය වැඩි කිරීමට -ftemplate-deep = භාවිතා කරන්න)

සමඟ -ftemplate-depth=10000 මම කෙළ එය විය - godbolt මත "මරුට සකසන කාලය ඉක්මවා".

ගොඩ්බෝල්ට් මත එය පරීක්ෂා කරන්න

ක්වෙන්ටින් විසින් බයිට් 1 ක් සුරකින ලදි. ඔබට ස්තුතියි.

පොදු ලිස්ප්, බයිට් 8 යි

#.(loop)

සම්පාදකයා පෝරමයක් කියවීමට උත්සාහ කරන අතර කියවීමේ වේලාවේදී කේතය තක්සේරු කරන සහ එහි ප්‍රති result ලය සම්පාදනය කිරීමේ ආකෘතිය ලෙස භාවිතා කරන තියුණු-ඩොට් රීඩර් මැක්‍රෝව හමුවනු ඇත. මෙන්න, ක්‍රියාත්මක කරන කේතය අනන්ත පුඩුවක්.

ටෙක්ස්, බයිට් 9 යි

\def~{~}~

ටෙක්ස් ක්‍රියා කරන්නේ මැක්‍රෝස් පුළුල් කිරීමෙනි. බොහෝ විට, ටෙක්ස් හි මැක්‍රෝස් ( පාලන අනුක්‍රම ලෙසද හැඳින්වේ ) ස්වරූපයෙන් පවතින \nameනමුත් ඇතැම් අක්ෂර සාර්ව ලෙස අර්ථ දැක්විය හැකිය, මේවා ක්‍රියාකාරී අක්ෂර ලෙස හැඳින්වේ . අක්ෂර ~සාමාන්‍ය ටෙක්ස් හි පෙරනිමියෙන් සක්‍රිය වන අතර වැඩිදුර ප්‍රකාශ කිරීමකින් තොරව සාර්ව නාමයක් ලෙස භාවිතා කළ හැකිය. මෙම \def~{~}ඉහත නිර්වචනය තුළ ~එය පුළුල් වන පරිදි ~. එනම්, ටෙක්ස් හමු වූ සෑම විටම ~එය ප්‍රතිස්ථාපනය කර ප්‍රතිස්ථාපනය ~නැවත පරීක්ෂා කරයි, එයින් අදහස් කරන්නේ එය සම්පූර්ණයෙන්ම නව සිදුවීමකට මුහුණ දී එය ~ප්‍රතිස්ථාපනය කරන ~බවයි. මෙය අනන්ත පුඩුවක් අර්ථ දක්වයි. එවිට අවශ්‍ය වන්නේ ලූපය ආරම්භ කිරීම පමණයි ~.

සංස්කරණයට එකතු කරන ලදි

මෙය නිසි ලෙස සම්පාදනය කිරීම සඳහා , ආයාචනා කරන්න:

pdftex -ini "&pdftex \def~{~}~"

මෙම -iniධජය බවයි pdftexයුතු සම්පාදනය නව ආකෘතිය ගොනු. මෙය පෙර සැකසූ නිර්වචන සමූහයක් වන අතර එය ලේඛනයක් සැකසීම වේගවත් කිරීම සඳහා ටෙක්ස් පසුව ආයාචනා කළ විට පැටවිය හැකිය (LaTeX2e මේ සඳහා උදාහරණයකි). මම හිතන්නේ &pdftexඑකතු කිරීම් බයිට් කිහිපයක් එකතු කර මුළු එකතුව 17 දක්වා ගෙන යයි.

හැස්කෙල්, 25 + 17 = බයිට් 42 යි

a= $(let a='a':a in[|a|])

අසීමිත අගයක් නිර්වචනය කරන සහ සම්පාදනය කරන වේලාවේදී එම අගය ගණනය කිරීමට උත්සාහ කරන සරල හස්කල් රූප සටහනක්.

ghc -XTemplateHaskell <file.hs>(සම්පාදකයාට පරාමිතිය සඳහා +17) සමඟ ආයාචනා කරන්න

gradle, බයිට් 10 9

for(;;){}

ඉහත කේතය සමඟ a build.gradle ගොනුවක . ග්‍රේඩ්ල් එහි මූලික භාෂාව ලෙස ග්‍රෝවි භාවිතා කරයි, එබැවින් අපි මෙහි ඇත්ත වශයෙන්ම කතා කරන්නේ කුරිරුකම ගැන ය, නමුත් ප්‍රශ්නය වන්නේ ගොඩනංවන කාලය පිළිබඳ ප්‍රශ්නය වන බැවින් මම සිතුවේ ශ්‍රේණිය වඩාත් යෝග්‍ය වනු ඇති බවයි.

ඉහත කේතය සමඟ ඕනෑම ශ්‍රේණියේ බිල්ඩ් විධාන ක්‍රියාත්මක කිරීමෙන් ලක්ෂ්‍ය-හිසකෙස්-ලොක්කාට අනුකූල ගොඩනැගීමේ තත්ව රේඛාව මුද්‍රණය කරයි:

$ gradle tasks
> Configuring > 0/1 projects > root project

ඔබ වැඩි කිරීමක් අරමුණු කරන්නේ නම්, මේ සඳහා නිදොස් කිරීමේ -dධජය එක් කරන්න :

$ gradle -d tasks
14:56:25.522 [INFO] [org.gradle.internal.nativeintegration.services.NativeServices] Initialized native services in: .gradle/native
14:56:25.757 [DEBUG] [org.gradle.launcher.daemon.client.DaemonClient] Executing build 84908c0d-f28d-4c57-be61-40eaf0025e16.1 in daemon client {pid=27884}
14:56:25.761 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Adding IP addresses for network interface tun0
14:56:25.762 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Is this a loopback interface? false
14:56:25.762 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Is this a multicast interface? false
14:56:25.764 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Adding remote address /x:x:x:x:x:x:%tun0
14:56:25.764 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Adding remote address /x.x.x.x
14:56:25.764 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Adding IP addresses for network interface eth1
14:56:25.764 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Is this a loopback interface? false
14:56:25.764 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Is this a multicast interface? true
14:56:25.764 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Adding remote address /x:x:x:x:x:x:%eth1
14:56:25.764 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Adding remote address /x.x.x.x
14:56:25.764 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Adding remote multicast interface eth1
14:56:25.764 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Adding IP addresses for network interface lo
<snip>
14:57:07.055 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Releasing lock on daemon addresses registry.
14:57:07.056 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Waiting to acquire shared lock on daemon addresses registry.
14:57:07.056 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Lock acquired.
14:57:07.056 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Releasing lock on daemon addresses registry.
> Configuring > 0/1 projects > root project

ඒවා සිත් ඇදගන්නා සුළු ලෙස බැලීමට අමතරව නව කට්ටලයක් සමඟ යාවත්කාලීන කරයි:

15:07:57.054 [DEBUG] [org.gradle.launcher.daemon.server.Daemon] DaemonExpirationPeriodicCheck running
15:07:57.054 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Waiting to acquire shared lock on daemon addresses registry.
15:07:57.054 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Lock acquired.
15:07:57.055 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Releasing lock on daemon addresses registry.
15:07:57.055 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Waiting to acquire shared lock on daemon addresses registry.
15:07:57.055 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Lock acquired.
15:07:57.055 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Releasing lock on daemon addresses registry.

සෑම තත්පර 10 කට වරක් තත්ව රේඛා, වැදගත් තාක්‍ෂණික ... දේවල් කිරීම කාර්යබහුල බව පෙනේ.

SWI-Prolog, බයිට් 34 යි

term_expansion(_,_):-repeat,1=0.

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

term_expansion/2 ප්‍රභව කේතයේ සමහර පද වෙනත් පද බවට පරිවර්තනය කිරීම සඳහා කේතය සම්පාදනය කිරීමට පෙර සම්පාදකයා විසින් ස්වයංක්‍රීයව කැඳවනු ලබන දෙයකි.

මෙන්න, අපි මේ සඳහා නව රීතියක් හඳුන්වා දෙන්නෙමු term_expansion/2: repeat,1=0..

repeat/0 යනු සැමවිටම සාර්ථක වන පුරෝකථනයක් වන අතර අසීමිත තේරීම් ලකුණු සංඛ්‍යාවක් සපයයි.

1=0සැමවිටම එක්සත් වන එක්සත් 1වීමට උත්සාහ කරයි . මෙය සම්පාදකයා පසුපසට යාමට හේතු වේ (එය සැමවිටම තේරීම් ලක්ෂ්‍යයක් සපයන බැවින්) නැවත උත්සාහ කරන්න .0falserepeat1=0

GNU Make, 44

.PHONY:x
$(MAKEFILE_LIST):x;sleep 1;touch $@

මට මේ සඳහා ණය ලබා ගත නොහැක. එය ව්‍යුත්පන්න වී ඇත්තේ රොබට් මෙක්ලන්බර්ග්ගේ GNU Make: Manage Project with GNU Make: The Power of GNU Make for Anything .

මෙම Makefile ක්‍රියාත්මක කරන විට, makefile යල්පැන ඇති බව පෙනේ (.PHONY ඉලක්කය යල්පැන ඇති නිසා, එය ස්පර්ශ විධානය ක්‍රියාත්මක කරයි, එය makefile හි කාලරාමුව යාවත්කාලීන කරයි. ඉන්පසු ගොනුව නැවත කියවා සොයා ගන්න makefile යල්පැන ඇත .... හොඳයි ඔබට අදහස ලැබෙනවා.

මම මෙය අනෙකාට වඩා කැමති වන්නේ එය පුනරාවර්තනය භාවිතා නොකරන නිසාය. මගේ වීඑම් එකේ, අනෙක් පිළිතුරු පිළිතුර දිගින් දිගටම ව්‍යාජ ක්‍රියාවලීන් වන අතර 7,000 ක් පමණ ගැඹුරු තැනක වීඑම් ප්‍රතිචාර නොදක්වන ලෙස නතර වේ. කෙසේ වෙතත්, මෙම පිළිතුර සමඟ පද්ධති සම්පත් ආහාරයට නොගෙන දින නියමයක් නොමැතිව ඉදිරියට යා හැකිය. මෙම ගොඩනැගීම සමඟ ඔබට සැබවින්ම ඉවත් වීමට හැකි වනු ඇත. පද්ධති පරිහානියකින් තොරව මම පුනරාවර්තන 1,000,000 ඉක්මවා ඇත.

සටහන මට එක් කිරීමට සිදු වූ sleep 1නිසා මේක්ෆයිල් කාලරාමුව සෑම විටම යාවත්කාලීන වේ. ඔබට sleep 0.01එය නැවත නැවත නැවත වේගවත් කිරීමට අවශ්‍ය නම් මෙය වෙනස් කළ හැකිය .

ග්නූ ෆෝර්ත්, බයිට් 15 යි

ගොල්ෆ්

: : [do] [loop]

වචනය නැවත අර්ථ දැක්වීම (නැවත සම්පාදනය කිරීම) :සහ ක්ෂණික අනන්ත පුඩුවක් ඉල්ලා සිටී[do] [loop] නව අර්ථ දැක්වීම තුළ (සම්පාදනය කරන අවස්ථාවේදීම).

වචන වර්ගයක් සම්පාදනය නොකෙරේ. පෙළ අර්ථ නිරූපකයා අර්ථ නිරූපණය කරන්නේද නැතහොත් සම්පාදනය කරන්නේද යන්න නොසලකා මෙම ඊනියා ක්ෂණික වචන ක්‍රියාත්මක වේ (දැන් ක්‍රියාත්මක වේ).

එය මාර්ගගතව උත්සාහ කරන්න!

ක්ලෝජුර්, බයිට් 21 යි

(defmacro a[]`(a))(a)

නැවත නැවත ඇමතුම් විමෝචනය කරන සාර්වයක් නිර්වචනය කිරීමෙන් සම්පාදකයා බැඳ තබයි.

මගේ දුරකථනයේ, මෙය REPL උපාංගය එල්ලීමට හා ප්‍රමාද වීමට හේතු වේ. මගේ ලැප්ටොප් පරිගණකයේ, මෙය StackOverflow සමඟ සම්පූර්ණයෙන්ම අසමත් වේ.

අවාසනාවට StackOverflow ක්ෂණිකව සිදු වේ, නමුත් එය තවමත් නීතිරීති අනුව වලංගු වේ.

හැස්කෙල් _{^{(ජීඑච්සී, අච්චු හෝ අභිරුචි නැවත ලිවීමේ නීති නොමැතිව )}} , 138

{-#LANGUAGE FlexibleContexts,UndecidableInstances#-}
data A x=A
class C y where y::y
instance C(A(A x))=>C(A x)where y=A
main|A<-y=pure()

න්‍යායාත්මකව, මෙය C ++ ප්‍රවේශය කරන ආකාරයටම අනන්ත පුඩුවක් තුළට ඇතුළු වේ : බහුමාමක ක්‍රමය yවෙන කවරදාටත් වඩා සංකෝචිත වර්ග සඳහා ක්ෂණිකව සකසා ඇත. ප්රායෝගිකව, පෙරනිමි වෙන් කළ තොගයේ ප්රමාණය සැබවින්ම ඉක්මණින් පිටාර ගැලේ:

$ ghc-7.10 wtmpf-file14146.hs 
[1 of 1] Compiling Main             ( wtmpf-file14146.hs, wtmpf-file14146.o )

wtmpf-file14146.hs:5:9:
    Context reduction stack overflow; size = 101
    Use -fcontext-stack=N to increase stack size to N
      C (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A t0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
    In a stmt of a pattern guard for
                   an equation for ‘main’:
      A <- y
    In an equation for ‘main’: main | A <- y = pure ()

ලූක් පාමර්ට ගෞරවය .

MSBuild, බයිට් 130 යි

<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
    <Target Name="X">
        <Exec Command="msbuild"/>
    </Target>
</Project>

මෙය .projදිගුවක් සහිත ගොනුවක් ලෙස සුරකින්න msbuild, විධාන විමසුමේ සිට ධාවනය කරන්න . MSBuild සිය එකම ඉලක්කය ක්‍රියාත්මක කරනු ඇති අතර එය වෙනත් msbuildක්‍රියාවලියක් බිහි කරයි.

සී, බයිට් 31 යි

main[-1llu]={1};

ඩිජිටල් කම්පනයෙන් දේවානුභාවයෙන් . සමඟ සම්පාදනය කරන්න-mcmodel=mediumධජය .

මෙය සම්පාදනය කිරීමේ වාසනාව, ඔබට යෝටාබයිට් 1.8 ක RAM සහ තැටි ඉඩක් අවශ්‍ය වේ.

ගණිතය 33 බයිට්

Compile[{},Evaluate@While[True,]]

කේතය සම්පාදනය කිරීමට පෙර තර්කය සංකේතාත්මකව ඇගයීමට උත්සාහ කරනු ඇති අතර තර්කයම අනන්ත පුඩුවක් වේ. අතර ශ්‍රිතය වැදගත් නොවන බැවින් ශුන්‍ය දෙවන තර්කයක් ඇත.

මලකඩ, බයිට් 18 යි

include!(file!());

ක්ලැසික් ස්වයං ඇතුළත් කිරීම. රස්ට්ක් කරදරකාරී ලෙස බුද්ධිමත් වන අතර, පෙරනිමියෙන් පුනරාවර්තන 128 කට පසුව ඇප ලැබෙනු ඇත, එය ගැඹුර පළමුවෙන් පුළුල් කරයි, එබැවින් on ාතීය වර්ධනයද ක්‍රියා නොකරයි. C සහ C ++ විසඳුම් සඳහා ද එය අදාළ වේ.

බූ, බයිට් 25 යි

macro l:
 x=0 while 1>0
l

මෙය සාර්ව අර්ථ දක්වයි, එය සම්පාදනය කරන වේලාවේදී ක්‍රියාත්මක වන අතර එය අසීමිත පුඩුවක් ක්‍රියාත්මක කරයි, පසුව සාර්ව ආයාචනය කරයි.

හස්කල් (ghc), 32 + 2 = බයිට් 34 යි

{-#RULES""main=main#-}
main=main

සමඟ දුවන්න ghc -O <file>. එකම දෙයට නැවත ලිවීමේ ප්‍රධාන කාර්යය සඳහා නැවත ලිවීමේ රීතියක් ක්‍රියාත්මක කරයි. එකම අවාසනාවන්ත ලක්ෂණය නම් මෙය හඳුනා ගැනීමට සහ පුනරාවර්තන 100 කට පසුව නැවැත්වීමට ghc දක්ෂ වීමයි. මෙම හැසිරීම අක්‍රීය කිරීමට පහසු ක්‍රමයක් ගැන මම නොදනිමි.

PHP, බයිට් 19 යි

<?include __FILE__;

සාධකය , 29 16

<< [ t ] loop >>

අතර කොටස << >>විග්‍රහ කරන වේලාවේදී ක්‍රියාත්මක වේ.

කුමක් සඳහාද [ t ] loop, මම ඔබට අනුමාන කිරීමට ඉඩ දෙමි ...

ඔබට එය සවන්දෙන්නන්ට තැබිය හැකිය, නැතහොත් අනුරූප බොයිලේරු දේවල් සමඟ ඕනෑම වචන මාලාවකට හෝ ස්ක්‍රිප්ට් ගොනුවකට එය එක් කරන්න.