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


171

මෙම අභියෝගයේදී, ක්‍රමයෙන් වයස්ගත වීමට ඉඩ ඇති ක්‍රමලේඛන භාෂාවලින් තරමක් සරල කේතීකරණ කාර්යයන් තුනක් සම්පූර්ණ කිරීමට පරිශීලකයින් පියවර ගනු ඇත.

පළමු පිළිතුර 2015 වර්ෂයේ සාදන ලද ක්‍රමලේඛන භාෂාවක් භාවිතා කළ යුතුය. 2015 භාෂාවෙන් අවම වශයෙන් එක් පිළිතුරක් ලැබුණු පසු, පිළිතුරු 2014 දී සාදන ලද ක්‍රමලේඛන භාෂාවන් භාවිතා කළ හැකිය. ඒ හා සමානව, 2013 සිට භාෂා භාවිතා කරන පිළිතුරු සඳහා අවසර නැත. අවම වශයෙන් 2014 පිළිතුරක් ලැබෙන තුරු.

පොදුවේ ගත් කල, Y + 1 වර්ෂයේ සිට භාෂාවක් භාවිතා කරමින් පිළිතුරක් ඉදිරිපත් කරන තුරු Y වර්ෂයේ සිට ක්‍රමලේඛන භාෂාවක් භාවිතා කිරීමට අවසර නැත. එකම ව්යතිරේකය Y = 2015 වේ.

ඔබේ භාෂා වර්ෂය සොයා ගැනීම

මෙම ප්‍රශ්නයට පිළිතුරු සැපයීම සඳහා, ඔබේ ක්‍රමලේඛන භාෂාව "සාදන ලද" වර්ෂය ඔබ දැන සිටිය යුතුය. ඇත්ත වශයෙන්ම මෙය ආත්මීය යෙදුමකි; සමහර භාෂාවන් වසර ගණනාවක් පුරා සංවර්ධනය කරන ලද අතර බොහෝ භාෂා සෑම වසරකම යාවත්කාලීන වෙමින් පවතී. භාෂාවක් “සාදන ලද” වර්ෂය සාමාන්‍ය ජනතාව තුළ එම භාෂාව ක්‍රියාත්මක කිරීමේ පළමු වසර වේවා.

උදාහරණයක් ලෙස, පයිතන් 1991 දී නිපදවන ලද නමුත් එහි සංවර්ධනය 1989 සිට ක්‍රියාත්මක වෙමින් පැවතුනද 1.0 අනුවාදය 1994 වන තෙක් නිකුත් නොවීය.

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

ක්‍රමලේඛන භාෂාවක විවිධ අනුවාදයන් හෝ ප්‍රමිතීන් (උදා: පයිතන් 1, 2, 3) එකම ආරම්භක වර්ෂය සමඟ එකම භාෂාව ලෙස ගණන් ගනු ලැබේ.

එබැවින්, ඔබේ භාෂාවේ වර්ෂය 2015 නොවේ නම්, ඔබට ඔබේ පිළිතුර ඉදිරිපත් කළ හැක්කේ පිළිතුරක් ඉදිරිපත් කිරීමෙන් පසුව පමණි.

ඔබගේ වසර දැනටමත් වලංගු පිළිතුරක් තිබේ නම්, ඔබට පිළිතුරු දිය හැකිය. ඔබේ භාෂාව වසරකට පෙර හෝ පසුව වර්ධනය වී ඇත්ද යන්න ගැටළුවක් නොවේ.

කාර්යයන්

ඔබ කාර්යයන් 1 සිට 3 දක්වා සම්පූර්ණ කළ යුතුය. කාර්යය 0 අත්‍යවශ්‍ය නොවේ.

ක්‍රමලේඛනයේ වැදගත් අංශ තුනකට අනුරූප වන පරිදි මෙම කාර්යයන් වැඩි වශයෙන් හෝ අඩු වශයෙන් තෝරාගෙන ඇත: ප්‍රතිදානය සැපයීම (කාර්ය 1), ලූප (කාර්ය 2) සහ පුනරාවර්තනය (කාර්ය 3).

කාර්ය 0 - භාෂා ඉතිහාසය (අත්‍යවශ්‍ය නොවේ)

ඔබ තෝරාගත් ක්‍රමලේඛන භාෂාවේ ඉතිහාසය විස්තර කරන අවම වශයෙන් ඡේදයක් වත් ලියන්න: එය සංවර්ධනය කළේ කවුද, ඇයි, කෙසේද, යනාදිය. භාෂාව බිහිවන විට ඔබ පෞද්ගලිකව සිටියා නම් සහ විශේෂයෙන් එහි දියුණුවට දායක වූවා නම් මෙය විශේෂයෙන් දිරිමත් කරනු ලැබේ. භාෂාව ඔබට හෝ ඔබේ රැකියාවට ඇති කළ බලපෑම හෝ ඒ හා සමාන කිසිවක් පිළිබඳ පෞද්ගලික කථාන්තර සම්බන්ධ කිරීමට නිදහස් වන්න.

බොහෝ පර්යේෂණ නොමැතිව ඔබගේ භාෂාවේ ඉතිහාසය ගැන බොහෝ දේ දැන ගැනීමට ඔබ තරුණ නම්, පැරණි පරිශීලකයින්ට ඔබේ සටහන සංස්කරණය කළ හැකි යැයි පවසන සටහනක් තැබීම ගැන සලකා බලන්න.

කාර්යය 1 - "හෙලෝ, ලෝකය!" ප්‍රභේදය

මුද්‍රණය කරන වැඩසටහනක් ලියන්න

[language name] was made in [year made]!

ඔබගේ භාෂාවේ සම්මත නිමැවුම් ප්‍රදේශයට (නවතම භාෂා සඳහා stdout).

උදාහරණයක් ලෙස, භාෂාව පයිතන් නම්, ප්‍රතිදානය වනුයේ:

Python was made in 1991!

කාර්යය 2 - ASCII Art N.

අමුතු ධනාත්මක නිඛිලයකින් පරිශීලකයාට ඇතුළු වීමට ඉඩ සලසන වැඩසටහනක් ලියන්න (ආදානය සැමවිටම වලංගු යැයි ඔබ සිතිය හැකිය), සහ අක්ෂර භාවිතා කරමින් සාදන ලද ASCII කලා ලිපියක් මුද්‍රණය කරයි N.

ආදානය 1 නම්, ප්‍රතිදානය:

N

ආදානය 3 නම්, ප්‍රතිදානය:

N N
NNN
N N

ආදානය 5 නම්, ප්‍රතිදානය:

N   N
NN  N
N N N
N  NN
N   N

ආදානය 7 නම්, ප්‍රතිදානය:

N     N
NN    N
N N   N
N  N  N
N   N N
N    NN
N     N

රටාව මේ ආකාරයටම පවතී. ප්‍රතිදානයේ පසුපස අවකාශ තිබිය හැක.

කාර්ය 3 - ජීසීඩී

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

උදාහරණ:

8, 124
12, 84
3, 303
5689, 21
234, 8766

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

නීති

  • ඔබට කිහිප වතාවක් පිළිතුරු දිය හැකි නමුත් සෑම නව පිළිතුරක්ම ඔබේ අවසාන පිළිතුරේ භාෂාවට අවම වශයෙන් අවුරුදු 5 කට පෙර සාදන ලද භාෂාවක් භාවිතා කළ යුතුය. එබැවින් ඔබ 2015 භාෂාවෙන් පිළිතුරු දුන්නේ නම්, 2010 භාෂා වලට ඉඩ දෙන තෙක් ඔබට නැවත පිළිතුරු දිය නොහැක. ඔබ 2010 පිළිතුරකින් ආරම්භ කරන්නේ නම්, ඔබේ දෙවන පිළිතුරට 2015 පිළිතුරක් ලබා දිය නොහැක, මන්ද 2015 2010 ට පෙර නොවන බැවිනි.
  • හැකි නම්, ඔබේ කේතය ලියන්න එවිට එය ඔබේ භාෂාවේ පළමු අනුවාදයේම ක්‍රියාත්මක වනු ඇත (හෝ හැකි තරම් පැරණි අනුවාදයක්). (මෙය අවශ්‍යතාවයක් නොවේ, මන්ද සමහර භාෂාවන් සඳහා පැරණි සම්පාදකයින් / පරිවර්තකයන් සොයා ගැනීම දුෂ්කර විය හැකිය.)
  • පළ කරන ලද පිළිතුරෙහි සැලකිය යුතු දෝෂ තිබේ නම් හෝ ඔබට කාර්යයන් සම්පුර්ණ කිරීමට වඩා වෙනස් ක්‍රමයක් තිබේ නම් මිස දැනටමත් පළ කර ඇති භාෂාවක් පළ කිරීමෙන් වළකින්න.
  • ඔබේ කේතය ගොල්ෆ් කිරීම හොඳයි, නමුත් අවශ්‍ය නොවේ.
  • ඕනෑම වැඩසටහනක ප්‍රතිදානයේ පසුපසින් සිටින නව රේඛාවක් හොඳයි.
  • 2 සහ 3 කාර්යයන් සඳහා, 2 16 වැනි සාධාරණ උපරිමයට වඩා අඩු සියලුම ආදාන අගයන් ක්‍රියා කළ යුතුය (අවම වශයෙන් 256).
  • මෙම ප්‍රශ්නය පළ කිරීමට පෙර ඔබේ භාෂාව පැවතිය යුතුය.
  • අද අප සිතනවාට වඩා ඉතා පැරණි ක්‍රමලේඛන භාෂාවන්ට විවිධ ආකාරයේ ආදාන සහ ප්‍රතිදානයන් තිබිය හැකිය. මේක හොඳයි. ඔබේ භාෂාවේ සන්දර්භය තුළ ඔබේ හැකියාවෙන් උපරිම ලෙස කාර්යයන් සම්පූර්ණ කරන්න.

ලකුණු කිරීම

ඔබගේ ඉදිරිපත් කිරීමේ ලකුණු:

upvotes - downvotes + (2015 - languageYear) / 2 

මේ අනුව, 2015 ට පෙර සෑම වසරකම ඡන්ද ගණන් කිරීම සඳහා 0.5 ක් එකතු කරනු ලැබේ, පැරණි භාෂාවන්ට වාසිය ලබා දෙයි. වැඩිම ලකුණු සහිත ඉදිරිපත් කිරීම ජය ගනී.

පිළිතුරු ලැයිස්තුව

පහත දැක්වෙන ස්ටැක් ස්නිපටය ඔවුන්ගේ භාෂා වර්ෂය අනුව වලංගු පිළිතුරු ලැයිස්තුගත කරයි.

එය නිවැරදිව ලැයිස්තුගත කර ඇති බව සහතික කිරීම සඳහා ඔබ මෙම සටහන මෙම මාර්ක්ඩවුන් රේඛාව සමඟ ආරම්භ කළ යුතුය :

#[year] - [language name]

උදාහරණයක් වශයෙන්:

#1991 - Python

භාෂාවේ නම සබැඳියක තිබිය හැකිය (එය පිළිතුරු ලැයිස්තුවේ එකම සබැඳිය වනු ඇත):

#1991 - [Python](https://www.python.org/)

මෙම ආකෘතිය අනුගමනය නොකරන, හෝ තවමත් ඉඩ නොදුන් වසරක් හෝ පසුගිය වසර 5 තුළ දැනටමත් පිළිතුරු දුන් පරිශීලකයෙකුගෙන් ලැබෙන පිළිතුරු අවලංගු යැයි සලකුණු කර ඇත.

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script><script>$(function(){function e(e,r){var a="https://api.stackexchange.com/2.2/questions/48476/answers?page="+e.toString()+"&pagesize=100&order=asc&sort=creation&site=codegolf&filter=!YOKGPOBC5Yad160RQxGLP0r4rL";$.get(a,r)}function r(e){if(e.items.forEach(function(e){var r=e.link,a=e.owner.display_name,i=e.body.match(/<h1\b[^>]*>(\d{4}) - (.*?)<\/h1>/);if(i&&i.length>=3)var h=parseInt(i[1]),u=i[2];h&&u&&n>=h&&h>=t&&(!d.hasOwnProperty(e.owner.user_id)||d[e.owner.user_id]-h>=p)?(d[e.owner.user_id]=h,h==t&&--t,o.hasOwnProperty(h)||(o[h]=[]),o[h].push({language:u,user:a,link:r,score:e.score+(n-h)/2})):s.push(' <a href="'+r+'">'+a+"</a>")}),e.has_more)runQuery(++a,r);else{for(var i=n,h=[];o.hasOwnProperty(i);){for(var u=$("<tr>").append($("<td>").text(i.toString())),l=$("<td>"),c=$("<td>"),g=$("<td>"),f=0;f<o[i].length;f++){var v=o[i][f];l.append(v.language),c.append($("<a>").html(v.user).attr("href",v.link)),g.append(v.score),f+1<o[i].length&&(l.append("<br><br>"),c.append("<br><br>"),g.append("<br><br>"))}u.append(l).append(c).append(g),h.push(u),--i}$("#answers").find("tbody").append(h),s.length>0?$("#invalid").append(s):$("#invalid").remove()}}var a=1,n=2015,t=n-1,p=5,o={},s=[],d={};e(1,r)})</script><style>html *{font-family: Helvetica, Arial, sans-serif;}table{border: 4px solid #a4a; border-collapse: collapse;}th{background-color: #a4a; color: white; padding: 8px;}td{border: 1px solid #a4a; padding: 8px;}div{font-size: 75%;}</style><table id='answers'> <tr> <th>Year</th> <th>Language</th> <th>User (answer link)</th> <th>Score</th> </tr></table><div id='invalid'><br>Invalid Answers:</div>


2
මෙය උදව් විය යුතුය.
swish

21
විකිපීඩියාවේ සෑම දෙයක් සඳහාම ලැයිස්තුවක් ඇත: මෙය වසරක් පාසා එසෝටරික් නොවන භාෂා සඳහා වේ.
සැන්චයිස්

2
කාර්ය 3 ඇත්ත වශයෙන්ම පුනරාවර්තනය භාවිතා කළ යුතුද? නැතහොත් එය නිවැරදි ප්‍රති result ල ලබා දීමට ප්‍රමාණවත්ද? මට මගේම GCD ශ්‍රිතයක් ලිවීමට අවශ්‍ය නම් මම සාමාන්‍යයෙන් ලූපයක් භාවිතා කරන නමුත් මෙම අභියෝගය සඳහා විශේෂයෙන් පුනරාවර්තන එකක් ලිවීමි. ඉදිරිපත් කළ පිළිතුරු බොහොමයක් තිබේ.
සී. ජේ. ඩෙනිස්

5
1971 පසුකර අපව ලබා ගැනීම සඳහා දෙවන ගිණුමක් සෑදීමට මට හැඟේ.
marinus

6
අපට එය 1952 දක්වා ආපසු ලබා ගත හැකි නම්, 1951 (පෙගසස්) විසඳුම් කර ඒවා පරීක්ෂා කළ හැකි යන්ත‍්‍රයක් මා සතුව තිබේ.
බ්‍රයන් ටොම්ප්සෙට් - 汤 莱恩

Answers:


175

2013 - බල්ලාගේ පිටපත

ඩොග්ස්ක්‍රිප්ට් යනු 2013 දී සාක් බ ug ග්මන් විසින් නිර්මාණය කරන ලද භාෂාවකි. ජාවාස්ක්‍රිප්ට්, ෂිබා ඉනස්ගේ අභ්‍යන්තර ඒකපාර්ශවයන් මෙන් කියවීමට එය වාක්‍ය ඛණ්ඩයක් වෙනුවට වෙනත් දෙයක් නොවේ.

හෙලෝ ඩොජ්

console dose loge with "Dogescript was made in 2013!"

ASCII චිත්‍ර

such N much N
          much i as 0 next i smaller N next i more 1
              very doge is ("N" + " ".repeat(N-2) + "N").split('')
              s[i] is "N";
              console dose loge with doge.join('')
                              wow
                                      wow

GCD

such gcd_doge much doge, dooge
    rly dooge
              gcd_doge(dooge, doge % dooge)
  but
    rly doge smaller 0
           -doge
    but
          doge
  wow
        wow

114
වාව්, එවැනි +1. ඉතා පිළිතුරු. බොහෝ ගුණාත්මකභාවය.
ඇලෙක්ස් ඒ.

27
මම කෝඩ්ගොල්ෆ් සමඟ සම්බන්ධ වූයේ මෙම පිළිතුර ඉහළ නැංවීම සඳහා පමණි!
ඩෙරෙක් ටොම්ස්

21
මට සෘජු මුහුණකින් ජීසීඩී එක කියවීමටවත් නොහැකිය
කෝල් ජොන්සන්

16
මට gcd_doge good_dog ලෙස කියවිය නොහැක. උදව්
යාන්

නියමයි. කෙසේ වෙතත්, LANGUAGE.md ට අනුව, ද්විත්ව මිල ගණන් සඳහා සහය නොදක්වයි. s[i]බිට් පිළිබඳ පැහැදිලි කිරීමකටද කැමතිද !
ආචාර්ය

65

2015 - රෙටිනා

රෙටිනා යනු රීජෙක්ස් මත පදනම් වූ ක්‍රමලේඛන භාෂාවක් වන අතර, සමහර සත්කාරක භාෂාවලින් රීජෙක්ස් ඇමතීමේ අනවශ්‍ය පොදු කාර්යයක් නොමැතිව, පීපීසීජී අභියෝගයන්ට රීජෙක්ස් පමණක් පිළිතුරු සමඟ තරඟ කිරීමට හැකි වන ලෙස මම ලිවීමි. රෙටිනා ටියුරින්-සම්පූර්ණයි. එය ඔප්පු කිරීමට මම ක්‍රියාත්මක කර ඇත්තෙමි 2-ටැග් පද්ධති විසඳුම් සහ 110 වන රීතිය කර . එය C # හි ලියා ඇත, එබැවින් එය .NET රසය (පෙරනිමියෙන්) සහ ECMAScript රසය (ධජයක් හරහා) යන දෙකටම සහය දක්වයි.

රෙටිනාට විවිධ ආකාරවලින් ක්‍රියා කළ හැකි නමුත් ගණනය කිරීම් සඳහා වඩාත්ම අදාළ වන්නේ (සහ ටියුරින්-සම්පූර්ණ එක) ප්‍රතිස්ථාපන මාදිලියයි. ප්‍රතිස්ථාපන මාදිලියේදී ඔබ රෙටිනාට ඊටත් වඩා ප්‍රභව ලිපිගොනු සංඛ්‍යාවක් ලබා දේ. මේවා පසුව යුගලනය වන අතර, එක් එක් යුගලයෙන් පළමුවැන්න රීජෙක්ස් වන අතර දෙවැන්න ප්‍රතිස්ථාපනය වේ. මේවා පිළිවෙලින් ක්‍රියාත්මක වන අතර පියවරෙන් පියවර ආදානය හසුරුවයි. රීජෙක්ස් වින්‍යාසය මඟින් පූර්වයෙන් කළ හැකිය (සමඟ වෙන් කර ඇත `). වඩාත්ම වැදගත් විකල්පය (එමඟින් රෙටිනා ටියුරින්-සම්පුර්ණ කරයි)+ , එමඟින් result ලය වෙනස් වීම නවත්වන තුරු රෙටිනා ප්‍රතිස්ථාපනය ලූපයක යෙදේ. පහත දැක්වෙන උදාහරණ වලදී, මම ද භාවිතා කරමි ;, එය අතරමැදි අවධීන්හි ප්‍රතිදානය යටපත් කරයි.

පහත දැක්වෙන එක් එක් ඉදිරිපත් කිරීම් වලදී, සෑම පේළියක්ම වෙනම ප්‍රභව ගොනුවකට යයි. (විකල්පයක් ලෙස, ඔබට නව -sවිකල්පය භාවිතා කර සියලු රේඛා තනි ගොනුවකට දැමිය හැකිය.) හිස් ලිපිගොනු / රේඛා ලෙස දැක්වේ <empty>. තනි ඉඩක් සහිත ලිපිගොනු / රේඛා ලෙස දැක්වේ <space>.

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

වැඩසටහන්

"හෙලෝ වර්ල්ඩ්!" ප්‍රභේදය

<empty>
Retina was made in 2015!

ASCII Art N.

මෙය උපකල්පනය කරන්නේ STDIN නව රේඛාවකින් අවසන් වන බවයි.

;`^
#
;+`(\d*)#(?:(((((((((9)|8)|7)|6)|5)|4)|3)|2)|1)|0)
$1$1$1$1$1$1$1$1$1$1$2$3$4$5$6$7$8$9$10#
;`#
<empty>
;`\d
N
;`.(?<=(?=(.*\n)).*)|\n
$1
;`N(?=N\n.*\n.*\n`$)
<space>
;+`N(?=.?(.)+\n.* (?<-1>.)+(?(1)!)\n)
<space>
;`(?<=^.*\n.*\nN)N
S
;+`(?<=\n(?(1)!)(?<-1>.)+S.*\n(.)+N?)N
S
S
<space>

GCD

මේ සඳහා STDIN නව රේඛාවක් සමඟ අවසන් කිරීම අවශ්‍ය නොවේ .

;`\b(?=\d)
#
;+`(\d*)#(?:(((((((((9)|8)|7)|6)|5)|4)|3)|2)|1)|0)
$1$1$1$1$1$1$1$1$1$1$2$3$4$5$6$7$8$9$10#
;`#
<empty>
;`\d
1
;`^(.+)\1* \1+$
$1
;`$
#:0123456789
;+`^(?=1)(1*)\1{9}(#(?=.*(0))|1#(?=.*(?<3>1))|11#(?=.*(?<3>2))|111#(?=.*(?<3>3))|1111#(?=.*(?<3>4))|11111#(?=.*(?<3>5))|111111#(?=.*(?<3>6))|1111111#(?=.*(?<3>7))|11111111#(?=.*(?<3>8))|111111111#(?=.*(?<3>9)))
$1#$3
#|:.*
<empty>

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

"හෙලෝ වර්ල්ඩ්!" ප්‍රභේදය

මෙය තරමක් සුළු කාරණයකි. එය කිසිදු ආදානයක් නොගනී (එනම් හිස් නූලක්), කිසිවක් නොගැලපෙන අතර එය ප්‍රතිස්ථාපනය කරයි Retina was made in 2015!. රටාව ප්‍රතිස්ථාපනය කිරීමෙන් කෙනෙකුට එය අත්තනෝමතික ආදානය සඳහා වැඩ කළ හැකිය[\s\S]*නිදසුනක් ලෙස . එමඟින් STDIN ගිලිහී ගොස් ඒ සියල්ල ප්‍රතිදානය සමඟ ප්‍රතිස්ථාපනය වේ.

ASCII Art N.

මෙය තරමක් අදියරයන් ඇත. මෙහි අදහස නම් ආදානය ඒකීය බවට පරිවර්තනය කිරීම, Ns හි N x N බ්ලොක් එකක් නිර්මාණය කර ත්‍රිකෝණ දෙකක් "කැටයම් කිරීම" ය. අපි තනි අදියරයන් හරහා යමු. ;හුදෙක් අතරමැදි ප්‍රතිදානයන් යටපත් කරන නමුත් +ප්‍රතිස්ථාපනය ලූපයක් තුළ යෙදීමට හේතු වන බව මතක තබා ගන්න .

;`^
#

සරලයි: #ආදානයට a සූදානම් කරන්න. ඒකීය බවට පරිවර්තනය කිරීමේදී මෙය සලකුණු කාරකයක් ලෙස භාවිතා වේ.

;+`(\d*)#(?:(((((((((9)|8)|7)|6)|5)|4)|3)|2)|1)|0)
$1$1$1$1$1$1$1$1$1$1$2$3$4$5$6$7$8$9$10#

මෙය එක් ඉලක්කම් ඒකීය බවට පරිවර්තනය කරයි. එය දැනටමත් පරිවර්තනය කර ඇති ඉලක්කම් ගෙන (\d*)ඒවා 10 වතාවක් පුනරාවර්තනය කරයි. ඉන්පසු එය ඊළඟ ඉලක්කම් ගෙන සුදුසු ඉලක්කම් ගණන එකතු කරයි. ඉලක්කම්වල සත්‍ය වටිනාකම මෙම අවස්ථාවෙහිදී අදාළ නොවේ. වූ විට #එම අංකය, regex තවදුරටත් තරග අවසන් වන ළඟා, සහ පරිවර්තනය සිදු කරනු ලැබේ. උදාහරණයක් ලෙස, අංකය 127ලෙස සකසනු ලැබේ

#127
1#27
111111111122#7
1111111111221111111111221111111111221111111111221111111111221111111111221111111111221111111111221111111111221111111111227777777#

මෙහි අවසාන පේළියේ හරියටම අක්ෂර 127 ක් අඩංගු වේ.

;`#
<empty>
;`\d
N

එය ඉවත් කර #සියලු ඉලක්කම් බවට පරිවර්තනය කරන සරල අදියර දෙකක් N. පහත දැක්වෙන පරිදි මම ආදානය 7උදාහරණයක් ලෙස භාවිතා කරමි . ඉතින් දැන් අපිට තියෙනවා

NNNNNNN

ඊළඟ අදියර

;`.(?<=(?=(.*\n)).*)|\n
$1

සෑම එකක්ම Nසම්පූර්ණ නූලෙන් ප්‍රතිස්ථාපනය කරයි (එහි පිටුපසින් නව රේඛාවක් ඇති බව මතක තබා ගන්න), එසේම පසුපසින් එන නව රේඛාවම ඉවත් කරයි. එබැවින්, මෙය තනි පේළිය වර්ග ජාලයකට පරිවර්තනය කරයි:

NNNNNNN
NNNNNNN   
NNNNNNN
NNNNNNN
NNNNNNN
NNNNNNN
NNNNNNN

දැන් ඉහළ ත්රිකෝණය. පළමුව, අපි පහළ දකුණු කෙළවරේ N අවකාශයක් බවට පත් කිරීමෙන් දේවල් ආරම්භ කරමු:

;`N(?=N\n.*\n.*\n`$)
<space>

බැලූ බැල්මට අපි නිවැරදි දේ වෙනස් කරන බව සහතික කරයි N. මෙය ලබා දෙයි

NNNNNNN
NNNNNNN   
NNNNNNN
NNNNNNN
NNNNN N
NNNNNNN
NNNNNNN

සහ දැන්

;+`N(?=.?(.)+\n.* (?<-1>.)+(?(1)!)\n)
<space>

යනු අවකාශ අක්ෂරයක Nඉහළින් හෝ ඉහළ වම් කෙළවරේ ඇති හා ගැලපෙන රීජෙක්ස් ය. ප්‍රතිස්ථාපනය නැවත නැවත සිදු වන හෙයින්, මෙය අත්‍යවශ්‍යයෙන්ම ගංවතුර පිරවීමකි, එය ආරම්භක අවකාශයේ සිට 3 වන අෂ්ටකය වැඩි අවකාශයක් බවට පත් කරයි:

N     N
NN    N   
NNN   N
NNNN  N
NNNNN N
NNNNNNN
NNNNNNN

අවසාන වශයෙන්, අපි පහළ ත්රිකෝණය සමඟ එකම දේ පුනරාවර්තනය කරමු, නමුත් අපි වෙනස් අක්ෂරයක් භාවිතා කරමු, එබැවින් දැනටමත් පවතින අවකාශයන් වැරදි ගංවතුර පිරවීමක් ඇති නොකරයි:

;`(?<=^.*\n.*\nN)N
S

බීජ සකසයි:

N     N
NN    N   
NSN   N
NNNN  N
NNNNN N
NNNNNNN
NNNNNNN

ඉන්පසු

;+`(?<=\n(?(1)!)(?<-1>.)+S.*\n(.)+N?)N
S

ගංවතුර පිරවීම

N     N
NN    N   
NSN   N
NSSN  N
NSSSN N
NSSSSNN
NSSSSSN

අවසානයේ

S
<space>

ඒවා Sඅවකාශයට හරවන අතර අපි ඉවරයි:

N     N
NN    N   
N N   N
N  N  N
N   N N
N    NN
N     N

GCD

ඒකීයව ඇති GCD ඇත්ත වශයෙන්ම රීජෙක්ස් සමඟ ඉතා සුළුය. මෙයින් බොහොමයක් සමන්විත වන්නේ දශම සිට ඒකීය සහ ඒකීය සිට දශම පරිවර්තනය දක්වා ය. මෙය වඩාත් සංයුක්තව කළ හැකිය, නමුත් මෙය කේත ගොල්ෆ් නොවේ, එබැවින් ...

;`\b(?=\d)
#
;+`(\d*)#(?:(((((((((9)|8)|7)|6)|5)|4)|3)|2)|1)|0)
$1$1$1$1$1$1$1$1$1$1$2$3$4$5$6$7$8$9$10#
;`#
<empty>
;`\d
1

ආදාන සංඛ්‍යා දෙකම පරිවර්තනය කර ඇති අතර, ප්‍රති result ලය 1s වෙනුවට s භාවිතා කරයි N(එය වැදගත් නොවේ) හැර මෙම අදියරයන් අත්‍යවශ්‍යයෙන්ම ඉහත ආකාරයට සමාන වේ. එබැවින් ආදානය නම් 18 24, මෙය නිපදවනු ඇත

111111111111111111 111111111111111111111111

දැන්

;`^(.+)\1* \1+$
$1

සමස්ත GCD ගණනය කිරීම වේ. අපි පොදු බෙදුම්කරුවෙකුට ගැලපෙන්නේ 1s ගණනක් ග්‍රහණය කර ගැනීමෙන් පසුව, එම සංඛ්‍යා නැවත ලිවීමෙන් (සහ වෙනත් කිසිවක් නොවේ) සංඛ්‍යා දෙකම ලිවිය හැකි බව සහතික කිරීම සඳහා පසු විපරම් භාවිතා කිරීමෙනි. රීජෙක්ස් එන්ජිමෙහි (එනම් .+කෑදරකම) පසුගාමී ක්‍රියා කරන ආකාරය නිසා , මෙය සැමවිටම විශාලතම පොදු බෙදුම්කරු ස්වයංක්‍රීයව ලබා දෙනු ඇත. තරගය මුළු නූලම ආවරණය වන හෙයින්, අපගේ GCD ලබා ගැනීම සඳහා පළමු අල්ලා ගැනීමේ කණ්ඩායම නැවත ලියන්නෙමු.

අවසාන වශයෙන්, ඒකීය සිට දශම පරිවර්තනය ...

;`$
#:0123456789

සලකුණු කාරකයක් #, පරිසීමකය :සහ සියලු ඉලක්කම් නූල් එකතු කරන්න. රීජෙක්ස් ප්‍රතිස්ථාපනයකදී ඔබට නව අක්ෂර කොන්දේසි සහිතව නිෂ්පාදනය කළ නොහැකි නිසා මෙය අවශ්‍ය වේ. ඔබට කොන්දේසි සහිත ප්‍රතිස්ථාපනයක් අවශ්‍ය නම්, ඔබට අක්ෂරයෙන් නූල් අදින්න අවශ්‍යයි, එබැවින් අපි ඒවා එහි තබමු.

;+`^(?=1)(1*)\1{9}(#(?=.*(0))|1#(?=.*(?<3>1))|11#(?=.*(?<3>2))|111#(?=.*(?<3>3))|1111#(?=.*(?<3>4))|11111#(?=.*(?<3>5))|111111#(?=.*(?<3>6))|1111111#(?=.*(?<3>7))|11111111#(?=.*(?<3>8))|111111111#(?=.*(?<3>9)))
$1#$3

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

#|:.*
<empty>

අවසාන වශයෙන්, සලකුණු, පරිසීමක සහ සහායක ඉලක්කම් ඉවත් කිරීම සඳහා පිරිසිදු කිරීමේ පියවරක් පමණි.


මම හිතන්නේ ඔබ සංඛ්‍යාත්මක ආදානය ඒකීය නූල් බවට පරිවර්තනය කිරීම සඳහා උපදෙස් ද, ඒකීය නූල් නැවත සංඛ්‍යාත්මක ආදානය බවට පරිවර්තනය කිරීම සඳහා උපදෙස් ද එකතු කළ යුතු ය. පිරිසිදු රීජෙක්ස් සමඟ පරිවර්තනය සිසිල් නමුත් බොහෝ දුරට අවුල් සහගතය.
n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

8
+1 මට විශ්වාසයි 2015 ඉදිරිපත් කිරීම කෝඩ් ගොල්ෆ් භාවිතය සඳහා භාෂාවක් වනු ඇත.
Zero Fiber

̴̖̋ n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ මම කලින් සලකා බැලුවා. මම හිතන්නේ බොහෝ කේත ගොල්ෆ් සඳහා, මම බොහෝ විට යුනරි ආදානය ගන්නවා (අභියෝගය පැහැදිලිවම “දශම” හෝ වෙනත් දෙයක් නියම නොකරන්නේ නම් ...). මම මේ සඳහා එකම දේ කිරීමට සිතුවෙමි, නමුත් මෙය කේත ගොල්ෆ් එකක් නොවන අතර මට දශම ආදානය සහ ප්‍රතිදානය ද හැසිරවිය හැකි බව පෙන්වීමට අවශ්‍ය විය.
මාටින් එන්ඩර්

6
විශිෂ්ට වැඩ. රෙටිනා ඇත්තෙන්ම සිසිල් ය. අනෙක් අතට, ඔබේ නමට යාබදව ඇති දියමන්තිය දැකීම ඇත්තෙන්ම සිසිල් ය! :)
ඇලෙක්ස් ඒ.

මෙම තරඟය සඳහා පැරණි භාෂාවන් ප්‍රිය වුවද, මෙම ලාබාලම භාෂාව තවමත් ජයග්‍රහණය කර තිබීම
විහිළුවක්

60

2013 - සැණෙකින් !

සැණෙකින් ! යනු බර්ක්ලි විශ්ව විද්‍යාලයේ සාදන ලද සීරීම් මත පදනම් වූ භාෂාවකි . එය පළමු පන්තියේ දත්ත සහ අභිරුචි කොටස් (කාර්යයන්) ඇතුළත් වන සීරීමට යාවත්කාලීන කිරීමකි. සීරීම් මෙන්, එය පෙළ මත පදනම් වූවක් නොව, දෘශ්‍ය “කුට්ටි” මඟින් එකට ගසාගෙන යයි.

සැණෙකින් ! , ජාවාස්ක්‍රිප්ට් හි ලියා ඇති අතර, ස්කයික් ස්මාල්ටෝක් හි ලියා ඇති BYOB හි අනුප්‍රාප්තිකයා වේ. සැණෙකින් ! බීටා මහජන පරිභෝජනය සඳහා 2013 මාර්තු මාසයේදී නිකුත් කරන ලදී .

සැණෙකින් ! ඇත්ත වශයෙන්ම එසෝටරික් භාෂාවක් නොවේ. එය බර්ක්ලි හි බියුටි ඇන්ඩ් ජෝයි ඔෆ් කම්පියුටින් (බීජේසී) ඒපී සීඑස් පා course මාලාවේ වැඩසටහන් භාෂාව ලෙස භාවිතා කරයි .

පරීක්ෂා කිරීම සහ දේවල් සඳහා මම උදව් කළෙමි.

"හෙලෝ වර්ල්ඩ්" ප්‍රභේදය

ASCII Art "N"

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

මෙය සමහර කොටස් සඳහා stdlib භාවිතා කරයි.

මෙහි මූලික මූලික ලූප. ආදානයක් ගනී. එවිට අපි සියල්ලම එකට එකතු කර එය කියමු (ප්‍රති result ලය n = 5):

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

මම මෙහි නිදහස ගත්තේ 1 වෙනුවට අවකාශ 2 ක් භාවිතා කිරීමටයි, මන්ද Snap! මොනොස්පේස් වල දේවල් කියන්නේ නැහැ.

GCD

යුක්ලීඩියානු ඇල්ගොරිතම ඉතා වේගවත් නොවේ, නමුත් එය ක්‍රියාත්මක වන අතර එය ඉතා සරල ය. (කණගාටුයි, මම බ්ලොක් නාමයෙන් යතුරු ලියනය කළෙමි. දැන් මම සුරැකීමකින් තොරව ටැබ් එක වසා දැමුවෙමි. එයට රැඳී සිටීමට සිදුවනු ඇත.)

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

මෙම ශ්‍රිත අර්ථ දැක්වීම පසුව මෙම කොටස නිපදවනු ඇත:

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


3
මෙය ඇලිස් හි වැඩසටහන්කරණය මෙන් පෙනේ ...
mbomb007

4
බ්ලොක් පාදක කරගත් භාෂාවන්ගෙන් ඔබට ලැබෙන්නේ එයයි. ඒකට එන්න, භාෂා රාශියක් එක හා සමානයි. ;)
Scimonster

1
සීරීමට පවා මෝඩ් ශ්‍රිතයක් ඇත, එබැවින් (b == 0) මත පදනම්ව බ්ලොක් එකකින් ඔබට GCM / GCD ක්‍රියාකාරීත්වය වේගවත් කළ හැකි යැයි මම සිතමි. එවිට වෙනත් GCM (b, a% b)
ඇල්කයිමිස්ට්

55

2007 - ලොල්කෝඩ්

භාෂා ඉතිහාසය

LOLCODE 2007 දී ලැන්කැස්ටර් විශ්ව විද්‍යාලයේ පර්යේෂකයෙකු වන ඇඩම් ලින්ඩ්සේ විසින් නිර්මාණය කරන ලදී. එහි වාක්‍ය ඛණ්ඩය පදනම් වී ඇත්තේ චීස්බර්ගර්, ඉන්කෝපරේෂන් විසින් ජනප්‍රිය කරන ලද ලොල්කැට්ස් මේමස් මත ය.

"හෙලෝ වර්ල්ඩ්!" ප්‍රභේදය

HAI
VISIBLE "LOLCODE wuz maed in 2007!"
KTHXBYE

ASCII Art N.

HAI

BTW, read n from stdin
GIMMEH n

BTW, convert n from YARN to NUMBR
n R PRODUKT OF n AN 1

BOTH SAEM n AN 1, O RLY?
    YA RLY
        VISIBLE "N"
    NO WAI
        VISIBLE "N"!

        I HAS A butt ITZ 1
        IM IN YR toilet UPPIN YR butt TIL BOTH SAEM butt AN DIFF OF n AN 1
            VISIBLE " "!
        IM OUTTA YR toilet

        VISIBLE "N"

        I HAS A kat ITZ 2
        IM IN YR closet UPPIN YR kat TIL BOTH SAEM kat AN n
            VISIBLE "N"!
            BOTH SAEM kat AN 2, O RLY?
                YA RLY
                    VISIBLE "N"!
                NO WAI
                    I HAS A doge ITZ 1
                    IM IN YR l00p UPPIN YR doge TIL BOTH SAEM doge AN DIFF OF kat AN 1
                        VISIBLE " "!
                    IM OUTTA YR l00p
                    VISIBLE "N"!
            OIC

            I HAS A brd ITZ 1
            IM IN YR haus UPPIN YR brd TIL BOTH SAEM brd AN DIFF OF n AN kat
                VISIBLE " "!
            IM OUTTA YR haus

            VISIBLE "N"
        IM OUTTA YR closet

        VISIBLE "N"!

        I HAS A d00d ITZ 1
        IM IN YR lap UPPIN YR d00d TIL BOTH SAEM d00d AN DIFF OF n AN 1
            VISIBLE " "!
        IM OUTTA YR lap

        VISIBLE "N"
OIC

KTHXBYE

Stdin භාවිතයෙන් අගයන් නූල් (YARNs) ලෙස කියවනු ලැබේ GIMMEH. 1 න් ගුණ කිරීමෙන් ඒවා සංඛ්‍යාත්මක (NUMBRs) බවට පරිවර්තනය කළ හැකිය.

භාවිතයෙන් stdout වෙත අගයන් මුද්‍රණය කෙරේ VISIBLE. පෙරනිමියෙන් නව රේඛාවක් එකතු කරනු ලැබේ, නමුත් විශ්මය ජනක ලක්ෂ්‍යයක් එකතු කිරීමෙන් එය යටපත් කළ හැකිය.

GCD

HAI

GIMMEH a
a R PRODUKT OF a AN 1

GIMMEH b
b R PRODUKT OF b AN 1

I HAS A d00d ITZ 1
IM IN YR food UPPIN YR d00d TIL BOTH SAEM b AN 0
    I HAS A kitty ITZ a
    I HAS A doge ITZ b
    a R doge
    b R MOD OF kitty AN doge
IM OUTTA YR food

VISIBLE SMOOSH "gcd is " a

KTHXBYE

SMOOSH නූල් සමෝච්ඡකරණය සිදු කරයි.


13
අවසාන වශයෙන්, සෑම කෙනෙකුටම තේරුම් ගත හැකි භාෂාවක්.
ASCIIThenANSI

26
IM IN YR toilet UPPIN YR buttනියම විචල්‍ය නම්
කෝල් ජොන්සන්

13
@ColeJohnson: මම හැම විටම විචල්ය නම් වඩා තත්වය තුල පෙළඹෙනු අර්ථයෙන් තෝරා ගැනීමට උත්සාහ x1, x2ආදිය,
ඇලෙක්ස් ඒ

2
හාස්යජනකයි. මම මෙය රැකියා ස්ථානයේ කියවිය යුතු නැත.
ඇලන් හුවර්

Lan ඇලන්හවර්: පැහැදිලිවම ටෙ ජොල්ස් ටෙහ් ජොබ්ස් වලට වඩා වැදගත් ය.
ඇලෙක්ස් ඒ.

44

1982 - තැපැල් පිටපත

PostScript යනු දෛශික ග්‍රැෆික් නිර්මාණය කිරීම සහ මුද්‍රණය කිරීම සඳහා වූ භාෂාවකි.

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

පෝස්ට් ස්ක්‍රිප්ට් වෙනුවට ආදේශ කළ ප්‍රමිතිය පී.ඩී.එෆ්.

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

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

කාර්යය 1

/Courier findfont
12 scalefont
setfont
newpath

100 370 moveto
(PostScript was made in 1982!\n) show

පළමු පේළි කිහිපය ඇඳීමට කැන්වස් එකක් සකසයි. ඉන්පසු movetoවිධානය PS ට නිශ්චිත ස්ථානයකට ඇද ගන්නා ලෙස පවසන අතර, showඑම නූල පිටුවට මුද්‍රණය කරයි. වරහන් වර්‍ගයන් පෝස්ට් ස්ක්‍රිප්ට් හි සලකුණු කරන බව සලකන්න, උද්ධෘත ලකුණු නොවේ.

කාර්යය 2

/asciiartN {% stack: N row col
            % output: draws an "ASCII art" N

  % PostScript doesn't allow you to pass variables directly into a function;
  % instead, you have to pass variables via the global stack. Pop the variables
  % off the stack and define them locally.
  6 dict begin
  /row exch def
  /col exch def
  /N exch def

  % Define how much space will be between each individual "N"
  /spacing 15 def

  % Get the width of the "N". We need this to know where to draw the right-hand
  % vertical
  /endcol col spacing N 1 sub mul add def

  % One row is drawn at a time, with the bottom row drawn first, and working
  % upwards. This stack variable tracks which column the diagonal is in, and so
  % we start on the right and work leftward
  /diagcol endcol def

  % Repeat N times: draw one row at a time
  N {
    % Left-hand vertical of the "N"
    col row moveto
    (N) show

    % Right-hand vertical of the "N"
    endcol row moveto
    (N) show

    % Diagonal bar of the "N"
    diagcol row moveto
    (N) show

    % Advance to the next row. This means moving the row one space up, and the
    % diagonal position one place to the left.
    /row row spacing add def
    /diagcol diagcol spacing sub def

  } repeat

  end
} def

1 100 200 asciiartN
3 150 200 asciiartN
5 230 200 asciiartN

“ASCII art” N ඇඳීම සඳහා මම ශ්‍රිතයක් ලිවුවෙමි, නමුත් PostScript ශ්‍රිතයන්ට තර්කයක් ගැනීමට ක්‍රමයක් නොමැත. ඒ වෙනුවට, ඔබ ඔබේ තර්ක තොගයට තල්ලු කර නැවත ඒවා ඉවත් කරන්න. ඒක තමයි /x exch defරේඛාව.

උදාහරණයක්: තොගය යැයි සිතමු 8 9 2. මුලින්ම අපි නම තල්ලු /xඅඩුක්කුව සඳහා, එසේ සිරස් එකතුවේ 8 9 2 /x. මෙම exchක්රියාකරු එසේ දැන් සිරස් එකතුවේ, අඩුක්කුව වටිනාකම් දෙකක් හුවමාරු ගිවිසුම් 8 9 /x 2. ඉන්පසු defඉහළම සිරස් අගයන් දෙක මතු /xවී අගය ඇති බව අර්ථ දක්වයි 2. තොගය දැන්8 9 .

මම PostScript භාවිතා කිරීමට පටන් ගත් විට, මෙය ටිකක් අවුල් සහගත බව මට පෙනී ගියේය. න්‍යායාත්මක සංකල්පයක් ලෙස මම තොගය ගැන කියවමි, නමුත් මම එය ප්‍රායෝගිකව භාවිතා කළ පළමු අවස්ථාව මෙයයි.

ඉතිරි ශ්‍රිතය යම් චිත්‍ර ඇඳීමේ කේතයකි: පහළ දකුණේ කෙළවරේ සිට ආරම්භ කරන්න, වරකට පේළියක් පුරවා වමේ සිට දකුණට විකර්ණය කරන්න.

කාර්යය 3

/modulo {% stack: x y
         % output: returns (x mod y)
  3 dict begin
  /y exch def
  /x exch def

  % If x = y then (x mod y) == 0
  x y eq {0} {

    % If x < y then (x mod y) == x
    x y lt {x} {

      % If x > y then subtract floor(x/y) * y from x
      /ycount x y div truncate def
      /x x ycount y mul sub def

      /x x cvi def
      x

    } ifelse
  } ifelse
} def

/gcd {% stack: a b
      % returns the gcd of a and b
  2 dict begin
  /b exch def
  /a exch def

  % I'm using the recursive version of the Euclidean algorithm

  % If b = 0 then return a
  b 0 eq {a} {

    % Otherwise return gcd(b, a mod b)
    /a a b modulo def
    b a gcd
  } ifelse

} def

/displaygcd {% stack: a b xcoord ycoord
             % displays gcd(a,b) at position (xcoord, ycoord)
  5 dict begin
  /ycoord exch def
  /xcoord exch def
  /b exch def
  /a exch def
  /result a b gcd def

  xcoord ycoord moveto
  result 20 string cvs show

  % end
} def

8 12 100 80 displaygcd
12 8 150 80 displaygcd
3 30 200 80 displaygcd
5689 2 250 80 displaygcd
234 876 300 80 displaygcd

නැවතත්, මම යුක්ලිඩ්ගේ ඇල්ගොරිතමයේ ආකාරයක් භාවිතා කළෙමි, නමුත් මට අමතක වුයේ පෝස්ට් ස්ක්‍රිප්ටයේ මොඩියුලෝ ක්‍රියාකරු ගොඩනගා ඇති බවය, එබැවින් මට මගේම ලිවීමට සිදු විය. මෙය තොග පදනම් කරගත් ක්‍රමලේඛනයේ අවහිරතා පිළිබඳ ප්‍රයෝජනවත් මතක් කිරීමක් විය. මගේ පළමු ක්‍රියාත්මක කිරීම moduloපදනම් වූයේ පුනරාවර්තනය මත ය:

modulo(x, y)
    if (x = y) return 0
    elif (x < y) return x
    else return module(x - y, y)

xවිශාල හා yකුඩා වූ විට මෙය ක්‍රියාත්මක කිරීමට ඔබ උත්සාහ කරන තෙක් එය හොඳයි (උදා: 5689 සහ 2). ඔබට තිබිය හැක්කේ මූලද්‍රව්‍ය 250 ක් පමණයි, ඒ නිසා මම තොග සීමාව ඉක්මවා ගියෙමි. අපොයි. මට නැවත එහි ඇඳීම් පුවරුවට යාමට සිදු විය.

GCD කේතයම තරමක් සරල ය. නමුත් ශ්‍රිතයන්ට තර්ක ගත නොහැකි සේම ඒවාට ප්‍රතිලාභ අගයන් නොමැත. ඒ වෙනුවට, ඔබට ප්‍රති result ලය වෙනත් කෙනෙකුට පසුව ඉවත් කළ හැකි තැනට තල්ලු කළ යුතුය. ඒකයි aසහb a gcd මාර්ග කරන්න: ඔවුන් ඇගයීමට ලක් කර අවසන් කර ඇත විට, ඔවුන් අඩුක්කුව සඳහා වටිනාකම තල්ලු.

ඔබ සියලු කේත ලේඛනයක තබා මුද්‍රණය කරන්නේ නම්, ප්‍රතිදානය මෙයයි:

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


8
හහා මම මුද්‍රිත කඩදාසි කැබැල්ලේ ඡායාරූපයට කැමතියි. 1982 සඳහා සුදුසු යැයි හැඟේ.
ඇලෙක්ස් ඒ.

1
එසේම, ඔබට (වචනානුසාරයෙන්) තොග පිටාර ගැලීමක් ලැබුණේ කෙසේද යන්න පිළිබඳ ඔබේ විස්තරයට ස්තූතියි - භාෂාවන්ට උපරිම පුනරාවර්තන ගැඹුරක් ඇත්තේ මන්දැයි දැන් මම වඩාත් අවබෝධයෙන් තේරුම් ගතිමි.
DLosc

2
Lex ඇලෙක්සා: ඔව්, නමුත් තිත්-අනුකෘති මුද්‍රිත පිටපතක් (කඩදාසි දෙපස සිදුරු සහිතව) ඊටත් වඩා සුදුසු වනු ඇත . ;-)
ආමොස් එම්. වඩු කාර්මිකයා

@ AmosM.Carpenter: ඇත්ත වශයෙන්ම නොවේ, කිසිදු තිත්-අනුකෘති මුද්‍රණ යන්ත්‍රයක් මෙතෙක් PostScript සඳහා සහය නොදක්වයි. එය සෑම විටම ලේසර් මුද්‍රණ යන්ත්‍ර සමඟ බැඳී ඇත.
නින්ජල්ජ්

42

2009 - > <>

Befunge විසින් දේවානුභාවයෙන්,> <> (මාළු) යනු එසෝටරික් ස්ටක් මත පදනම් වූ 2D භාෂාවකි, එනම් වැඩසටහන් ප්‍රවාහය ඉහළට, පහළට, වමට හෝ දකුණට විය හැකිය. > <> හි ආරම්භක අනුවාදයේ බහු තෙරපුම කොතැනද [සහ] නිර්මාණය හා කැටි නූල් අවසන්, නමුත් සරල හේතු මෙම උපදෙස් පිළිවෙළින් නව අට්ටි නිර්මාණය කිරීම සහ ඉවත් කිරීමට වෙනස් විය.

> <> සඳහා වර්තමාන නිල පරිවර්තකය මෙහි සොයාගත හැකිය . අවාසනාවට, එසොලැන්ග් විකියේ පැරණි පරිවර්තකයා වෙත සබැඳිය කැඩී ඇත.

"හෙලෝ වර්ල්ඩ්!" ප්‍රභේදය

"!9002 ni edam saw ><>"l?!;obb+0.

නූල පිටුපසට ලියා ඇති ආකාරය සැලකිල්ලට ගන්න -> <> තාක්‍ෂණිකව නූල් නොමැත, එකම දත්ත වර්ගය වන්නේ චාර්, ඉන්ට් සහ ෆ්ලෝට් යන අමුතු මිශ්‍රණයකි. "නූල් විග්‍රහ කිරීම ටොගල් කරයි, වසා දැමීමක් සිදු වන තුරු එක් එක් අක්ෂර තොගයට තල්ලු "කරයි.

කේතයේ දෙවන භාගය පසුව තොගයේ දිග තල්ලු කරයි l පරීක්ෂා කරයි ?!, එසේ නම් වැඩසටහන අවසන් වේ ;. එසේ නොමැතිනම් උපදෙස් දර්ශකය අඛණ්ඩව oක්‍රියාත්මක bb+0.වන අතර එය ක්‍රියාත්මක කිරීමට පෙර තොගයේ මුදුන ප්‍රතිදානය කරයි (22, 0).l කර ලූපයක් නිර්මාණය කරයි.

ASCII Art N.

&0 > :&:&:*=?;  :&:&%  :0=?v  :&:&1-=?v  :{:{-&:&,{=?v   " " o   \

                           > ~"N"o                           v    
   +                                  > ~"N"oao              v    
   1                                                 >"N"o   v    

   \                                                         <   /

පැහැදිලිකම සඳහා පරතරය සමඟ. ඔබට නව සබැඳි පරිවර්තකයෙන් මෙය අත්හදා බැලිය හැකිය මෙහි බැලිය හැකි අතර උපදෙස් දර්ශකය අවට හා අවට යන බව බලන්න - "ආරම්භක සිරස්" පෙළ කොටුව තුළ අංකයක් ඇතුළත් කිරීමට මතක තබා ගන්න. ඔබ පයිතන් පරිවර්තකය හරහා ධාවනය කරන්නේ නම්, -vතොගය ආරම්භ කිරීමට ධජය භාවිතා කරන්න , උදා

py -3 fish.py ascii.fish -v 5

මෙම වැඩසටහන සඳහා, අපි ආදානය තබමු n ඇති ලේඛනය බවට සමග &අපි කතා කරන්නම් වන සහ 0 තල්ලු, i"අනුකරණ" සඳහා. වැඩසටහනේ ඉතිරි කොටස යෝධ පුඩුවක් වන අතර එය මේ ආකාරයට ය:

:&:&:*=?;          If i == n*n, halt. Otherwise ...
:&:&%              Push i%n
:0=?v              If i%n == 0 ...
>~"N"o               Print "N"
:&:&1-=?v          Else if i%n == n-1 ...
>~"N"oao             Print "N" and a newline
:{:{-&:&,{=?v      Else if i%n == i//n, where // is integer division...
>~"N"o               Print "N"
" "o               Otherwise, print a space
1+                 Increment i

ඉන්පසු අපි මුල සිටම ලූපය නැවත කියමු.

ඊතල ^>v<මඟින් වැඩසටහන් ප්‍රවාහයේ දිශාව වෙනස් වන අතර දර්පණ /\මඟින් වැඩසටහන් ප්‍රවාහයේ දිශාව පිළිබිඹු වේ.

GCD

>:{:}%\
;n{v?:/
v~@/

ගොල්ෆ් කළ> <> වැඩසටහනක පෙනුම කුමක් විය හැකිද යන්න පිළිබඳ උදාහරණයක් මෙන්න. නැවත වරක්, ඔබට මෙය සබැඳි පරිවර්ථකය තුළ උත්සාහ කළ හැකිය (කොමා වලින් වෙන් කළ අගයන් දෙකක් "ආරම්භක තොගය" කොටුවේ ඇතුළත් කරන්න, උදා 111, 87) හෝ භාවිතා කිරීමෙන්-v පයිතන් පරිවර්තකයාගේ ධජය , උදා.

py -3 fish.py gcd.fish -v 111 87

මෙම වැඩසටහන යුක්ලීඩියානු ඇල්ගොරිතම භාවිතා කරයි. මෙන්න මම කලින් සූදානම් කළ GIF එකක්:

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

> <> ටොරොයිඩල් බව සලකන්න, එබැවින් පහළ වම්පස ඇති විට v උපදෙස් ක්‍රියාත්මක කරන විට උපදෙස් දර්ශකය පහළට ගොස්, එතී, නැවත ඉහළින් දිස් වේ.


සංස්කරණය කරන්න: කේතය මුළුමනින්ම දකුණේ සිට වමට ධාවනය කිරීමෙන් @ රැන්ඩොම්රාට බයිට් තුනක් රැවුල බෑමට හැකි විය

<~@v!?:%}:{:
;n{/

අනුමාන කරන්න මම එය ගොල්ෆ් කළේ නැහැ :)


27
නම ><>පාලින්ඩ්‍රෝම් බව මම දැනගත්තේ එලෙසිනි.
සෙව් අයිසන්බර්ග්

33

2012 - මූලද්රව්යය

මෙය සරල ගොල්ෆ් භාෂාවක් ලෙස 2012 මුලදී මා විසින් නිර්මාණය කරන ලද භාෂාවකි. මෙයින්, මම අදහස් කරන්නේ ක්‍රියාකරුගේ බර පැටවීම ඉතා අල්ප බවයි. බොහෝ නවීන ගොල්ෆ් ක්‍රීඩා වලට වඩා ක්‍රියාකරුවන් සරල හා සංඛ්‍යාත්මකව අඩුය.

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

අංක ගණිතය සහ වෙනත් බොහෝ මෙහෙයුම් සිදු වන ප්‍රධාන තොගය m-stack වේ. දත්ත ආදානය කරන විට හෝ මුද්‍රණය කරන විට, එය යන්නේ හෝ ලබාගන්නා ස්ථානය මෙයයි.

සී-ස්ටැක් යනු පාලක තොගයයි. බූලියන් අංක ගණිතය සිදු වන්නේ මෙහිදීය. C-stack හි ඉහළ අගයන් If සහ while loops විසින් කොන්දේසිය ලෙස භාවිතා කරයි.

හැෂ් යනු විචල්යයන් ගබඩා කර ඇති ස්ථානයයි. මෙම ;සහ~ ගබඩා කිරීමට, සහ පිළිවෙලින්, හැෂ් සිට දත්ත ලබා.

මූලද්රව්යය ඉතා දුර්වල ලෙස ටයිප් කළ භාෂාවකි. සංඛ්‍යා නූල් ලෙස නිදහසේ අර්ථ නිරූපණය කිරීමට පර්ල්ට ඇති හැකියාව සහ අනෙක් අතට එය භාවිතා කරයි.

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

OP    the operator.  Each operator is a single character
STACK tells what stacks are affected and how many are popped or pushed
      "o" stands for "other effect"
HASH  tells if it involves the hash
x & y represent two values that are already on the stack, so the effect of
      the operator can be more easily described

OP     STACK  HASH   DESCRIPTION
text     ->m         --whenever a bare word appears, it pushes that string onto 
                       the main stack
_       o->m         --inputs a word and pushes onto main stack
`       m->o         --output.  pops from main stack and prints
xy;    mm->    yes   --variable assignment.  the top stack element y is assigned 
                       the value x
~       m->m   yes   --variable retrieval.  pops from main stack, pushes contents 
                       of the element with that name
x?      m->c         --test. pops x and pushes 0 onto control stack if x is '0' or 
                       an empty string, else pushes 1
><=     m->c         --comparison. pops two numbers off of stack and performs 
                       test, pushes 1 onto control stack if true and 0 if false
'       m->c         --pops from main stack and pushes onto control stack
"       c->m         --pops from control stack and pushes onto main stack
&|     cc->c         --AND/OR. pops two items from control stack, performs and/or 
                       respectively, and pushes result back onto control stack
!       c->c         --NOT. pops a number off of control stack, pushes 1 if 0 or 
                       empty string, 0 otherwise
[]       c           --FOR statement (view the top number number from control stack 
                       and eval those many times)
{}       c           --WHILE (loop until top number on control stack is 0, also 
                       does not pop)
#       m->          --discard. pops from main stack and destroys
(       m->mm        --pops from main stack, removes first character, pushes the 
                       remaining string onto stack, and pushes the removed character 
                       onto stack
)       m->mm        --pops from main stack, removes last character, pushes the 
                       remaining string onto stack, and pushes the removed character 
                       onto stack
+-*/%^ mm->m         --arithmetic. pops two most recent items, adds/negates
                       /multiplies/divides/modulates/exponentiates them, and places 
                       the result on the stack 
xy@    mm->o         --move. pops x and y and moves xth thing in stack to move to 
                       place y in stack
x$      m->m         --length. pops x and pushs length of x onto the stack
xy:    mm->o         --duplication. pops x and y and pushes x onto the stack y times
xy.    mm->m         --concatination. pops x and y and pushes x concatonated with y
\        o           --escapes out of next character, so it isn't an operator and can
                       be pushed onto the stack
,      m->mm         --character conversion. pops from main stack, coverts it to char
                       and pushes, and converts to num and pushes
Newlines and spaces separate different elements to be pushed 
onto the stack individually, but can pushed onto the stack using \

කාර්ය 1 - පෙළ මුද්‍රණය කරන්න

Element\ was\ made\ in\ 2012\!`

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

කාර්යය 2 - ASCII Art N.

_+'[y~1+y;0[1+4:"2:'=1=|y~=|\ [#N]`"#]\
`]

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

_+'[y~1+y;0[1+4:"2:'=1=|y~=|\S[#N]`"#]\L`]
_+'      input line, convert to #, move to c-stack
[        FOR loop
 y~1+y;  increment the y-pos
 0       set the x-pos (the top # on the stack) to zero
 [       FOR loop
  1+4:   increment x-pos and make 3 additional copies (4 is total #)
  "2:'   make a copy of the N size on the main stack
  =      if x-pos == size
  1=     or if x-pos == 1
  y~=|   of if x-pos == y-pos
  \S     (always) push a space
  [      the IF body (technically a FOR loop)
   #N    if true, remove the space and push an N
  ]      end IF
  `      output the pushed character
  "#     remove the result of the conditional
 ]       end x-pos FOR
 \L`     output a newline
]        end y-pos FOR

මෙම පිළිතුරෙහි අතිශය ගොල්ෆ් ක්‍රීඩා කිරීමෙන් පසුව, බයිට් 39 ක විසඳුමක් මට හමු විය, එය වඩාත් සංකීර්ණ වුවද.

_'1[y~+y;[#1+3:"2:'%2<y~=|\ [#N]`"]\
`]

කාර්ය 3 - ජීසීඩී

__'{"3:~2@%'}`

මෙය තොග පදනම් කරගත් ක්‍රමයකි.

__                 input the two numbers
  '                use one of the number as a condition so the WHILE loop starts
   {        }      a WHILE loop. Repeats while the c-stack has a true value on top
    "              get the number back from the c-stack to do operations on it
     3:            make it so that there are threes copies on the stack
       ~           takes one of the copies from earlier and converts it to a zero
        2@         take the top item on the stack and move it behind the other two #s
          %        modulo operation
           '       use this number as the condition
             `     since one number is zero (and on the c-stack) print the 
                   other number, which is on m-stack

29

2012 - ජූලියා

භාෂා ඉතිහාසය

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

"හෙලෝ වර්ල්ඩ්!" ප්‍රභේදය

println("Julia was made in 2012!")

ජූලියා හි STDOUT වෙත මුද්‍රණය කිරීම තරමක් සරල ය!

ASCII Art N.

function asciin(n)
    # Create an nxn matrix of spaces
    m = fill(" ", (n, n))

    # Fill the first and last columns with "N"
    m[:,1] = m[:,n] = "N"

    # Fill the diagonal elements with "N"
    setindex!(m, "N", diagind(m))

    # Print each row of the matrix as a joined string
    for i = 1:n
        println(join(m[i,:]))
    end
end

කේතය කියවීමේ හැකියාව සඳහා මුද්‍රණය කර ඇත, නමුත් ජූලියා සුදු අවකාශයට කිසිදු සීමාවක් පනවන්නේ නැත.

GCD

function g(a, b)
    b == 0 ? a : g(b, a % b)
end

ශ්‍රිතයේ ලැයිස්තුගත කර ඇති අවසාන දෙය ව්‍යංගයෙන් ආපසු ලබා දෙනු ලැබේ.


28

1988 - ගණිතය

නැත්නම් මම එය වුල්ෆ්රාම් භාෂාව ලෙස හැඳින්විය යුතුද?

කාර්යය 0

ගණිතයේ නිර්මාතෘ වන්නේ වුල්ෆ්රාම් පර්යේෂණයේ නිර්මාතෘ සහ ප්‍රධාන විධායක නිලධාරී ස්ටීවන් වුල්ෆ්රාම් ය. ගණිතයේ දියුණුවට පෙර ඔහු භෞතික විද්‍යා was යෙකි. භෞතික විද්‍යාවේ වීජීය ගණනය කිරීම් විශාල ප්‍රමාණයක් තිබූ බැවින් ඔහු මැක්සිමා භාවිතා කරන්නෙකු බවට පත් විය .

1979 දී වොල්ෆ්‍රම්ට ඔහුගේ පීඑච්ඩී උපාධිය ලැබුණේ වයස අවුරුදු 20 දී ය. භෞතික විද්‍යාව කිරීමට මැක්සිමාට වඩා හොඳ CAS අවශ්‍ය යැයි ඔහු සිතුවේය, එබැවින් ඔහු SMP ලිවීමට පටන් ගත්තේය ("සංකේතාත්මක හැසිරවීමේ වැඩසටහන") . SMP හි පළමු අනුවාදය 1981 දී නිකුත් කරන ලදී. SMP යනු ගණිතයේ පූර්වගාමියා විය. එය ගණිතයට ගැඹුරු බලපෑමක් ඇති කළද, එහි කේත කිසිවක් ගණිතමය සඳහා භාවිතා කර නොමැත.

1986 දී වුල්ෆ්රාම් "අවසාන ගණනය කිරීමේ පද්ධතියක්" ලිවීමට තීරණය කළේය. ඔහු 1986 දී කේතය ලිවීමට පටන් ගත් අතර 1987 දී වුල්ෆ්රාම් පර්යේෂණ ආරම්භ කළේය. අවසාන වශයෙන් ගණිතය 1.0 1988 ජුනි 23 දින නිකුත් කරන ලදී.

ගණිතය 1.0

මට ගණිතය 1.0 හමු නොවීය. ඇත්ත වශයෙන්ම, ගණිත 1.0 හි වින්ඩෝස් හෝ ලිනක්ස් අනුවාදයක් නොතිබුණි. නමුත් මට චීන වෙබ් අඩවියකින් ගණිතය 2.0 හමු විය. එය තවමත් වින්ඩෝස් එක්ස්පී මත ධාවනය කළ හැකිය.

ගණිතමය 2.0

කාර්යය 1

Print["Mathematica was made in 1988!"]

හෝ සරලව:

"Mathematica was made in 1988!"

කාර්යය 2

වර්තමාන ගණිතයේ අපට මෙසේ ලිවිය හැකිය:

asciiArtN[n_] := Print @@@ SparseArray[{i_, 1 | i_ | n} -> "N", {n, n}, " "]

වගේ ජූලියා සහ ආර් , මෙම න්යාසය විසඳුම. ගණිතයේ දී, රටා ගැලපීම භාවිතා කරමින් ඔබට විරල අනුකෘතියක් අර්ථ දැක්විය හැකිය.

කෙසේ වෙතත්, SparseArrayගණිත 5.0 හි හඳුන්වා දෙන ලදි, එබැවින් අපට එය ගණිත 1.0 හි භාවිතා කළ නොහැක.

ගණිත 1.0 හි ක්‍රියාත්මක වන විසඳුමක් මෙන්න:

asciiArtN[n_] := Block[{f},
  f[i_, 1]  = "N";
  f[i_, i_] = "N";
  f[i_, n]  = "N";
  f[__]     = " ";
  Apply[Print, Array[f, {n, n}], 1];
]

ගණිතමය 2.0 හි හඳුන්වා දුන් f[i_, 1 | i_ | n] = "N"නිසා අපට ලිවිය නොහැක Alternatives.

කාර්යය 3

අපට ගොඩනංවන ලද ශ්‍රිතය භාවිතා කළ හැකිය:

gcd = GCD

නැතහොත් අපට GCD හි අර්ථ දැක්වීම භාවිතා කළ හැකිය:

gcd = Max[Intersection @@ Divisors[{##}]] &;

GCD වලින් වඩාත් සාමාන්‍යයෙන් LCM ගණනය කළද අපට LCM භාවිතා කළ හැකිය :

gcd = Times[##]/LCM[##] &;

හෝ අපට රටා ගැලපීම සමඟ යුක්ලීඩියානු ඇල්ගොරිතම භාවිතා කළ හැකිය:

gcd[a_, 0] := a
gcd[a_, b_] := gcd[b, Mod[a, b]]

හෝ නිර්නාමික ශ්‍රිතයක් ලෙස:

gcd = If[#2 == 0, #1, #0[#2, Mod[##]]] &;

ඉහත සියළු කාර්යයන් ගණිතමය 1.0 හි හඳුන්වා දී ඇත.


3
මෙය මට වඩා හොඳ පිළිතුරකි. මම මගේ මකා දමමි.
මාටින් එන්ඩර්

24

2014 - සී

සීජෑම් පීපීසීජී පරිශීලක ඇඩිට්සු විසින් නිර්මාණය කරන ලද අතර එය 2014 අප්‍රේල් මාසයේදී නිකුත් කරන ලදී .

"හෙලෝ වර්ල්ඩ්!" ප්‍රභේදය

"CJam was made in 2014!"

වැඩසටහන අවසානයේ CJam ස්වයංක්‍රීයව තොගයේ අන්තර්ගතය මුද්‍රණය කරයි

ASCII Art N.

ri:R'#*a_R2-,{_)S*'#+\R((-zS*+}%+\+R<zN*

කේත පැහැදිලි කිරීම:

ri:R                                       "Read the input as integer in R";
    '#*a                                   "Get a string of R # and wrap it in an array";
        _R2-,{                }%           "Copy that string and then run this loop R-2";
                                           "times for the diagonal";
              _)S*                         "Get iteration index + 1 spaces";
                  '#+                      "Append the hash";
                     \R((-zS*+             "Append remaining spaces";
                                +\+        "Append and prepend the initial # string";
                                   R<      "Take only R columns/rows. This is for";
                                           "tackling input 1";
                                     zN*   "Transpose and join with new lines";

STDIN හරහා N හි උස / පළල ආදානය ලෙස ගනී. අන්තර්ජාලය හරහා එය උත්සාහ කරන්න

GCD

l~{_@\%}h;

STDIN හරහා අංක දෙක ආදානය ලෙස ගනී. අන්තර්ජාලය හරහා එය උත්සාහ කරන්න


මෙය [කේත-ගොල්ෆ්] නොවන බව මට වැටහී ඇත, නමුත් ඔබට ASCII-art N වැඩසටහන ri_S*0'NtW'Nta1$*\,Sf*'Nf+..e>N*නූතන CJam හි කෙටි කළ හැකිය .
පලතුරු වෙන් කිරීම

24

1990 - හැස්කෙල්

හස්කල් යනු ජනප්‍රිය (හෝ මා කිව යුතුද: වඩාත්ම ජනප්‍රියද ?) පිරිසිදු ක්‍රියාකාරී භාෂාවකි. එහි අසාමාන්‍ය ඇගයීම් ආකෘතියෙන් එය ප්‍රධාන ධාරාවෙන් ඉවත්ව යයි (පෙරනිමියෙන් සියල්ල කම්මැලි ය හෝ, තාක්ෂණික වශයෙන්, දැඩි නොවන) සහ එහි හින්ඩ්ලි-මිල්නර් පදනම් කරගත් ක්‍රමවේදය කැපී පෙනේ.

කාර්යය 1

main = putStrLn "Haskell was made in 1990!"

කාර්යය 2

-- Infinite list of growing letters 'N'
bigNs :: [[[Char]]]
bigNs = ["N"]
      : ["NN","NN"]
      : [ ins (ins 'N' t) $ map (ins ' ') n | n@(t:_) <- tail bigNs ]

-- Insert a new element after the head (i.e. at the second position).
ins :: a -> [a] -> [a]
ins x (l:ls) = l:x:ls

නිරූපණය, සම්පූර්ණ අසීමිත ලැයිස්තුව මුද්‍රණය කරන්න (පරිශීලකයා ගබ්සා වන තුරු හෝ ලෝකය අවසන් වන තුරු ...)

GHCi> mapM_ (putStrLn . unlines) bigNs
N

NN
NN

N N
NNN
N N

N  N
NN N
N NN
N  N

N   N
NN  N
N N N
N  NN
N   N

N    N
NN   N
N N  N
N  N N
N   NN
N    N

...

ඇත්ත වශයෙන්ම, අනන්ත ලැයිස්තුවේ එක් අංගයකට පමණක් ප්‍රවේශ වීමෙන් ඔබට පහසුවෙන් මේ එකකට යා හැකිය:

main :: IO ()
main = do
   i <- readLn
   putStrLn . unlines $ bigNs!!i

කාර්යය 3

gcd' :: Integer -> Integer -> Integer
gcd' a 0 = a
gcd' a b = gcd' b $ a`mod`b

24

1972 - ඉන්ටර්කල්

ඔයා හිතුවේ ෆෝට්රාන් සහ කොබෝල් අමුතුයි කියලා. මෙය උමතුවකි!

කාර්යය 1

DO ,1 <- #27
DO ,1SUB#1 <- #110
DO ,1SUB#2 <- #32
DO ,1SUB#3 <- #72
PLEASE DO ,1SUB#4 <- #136
DO ,1SUB#5 <- #88
DO ,1SUB#6 <- #136
PLEASE DO ,1SUB#7 <- #64
DO ,1SUB#8 <- #80
DO ,1SUB#9 <- #46
PLEASE DO ,1SUB#10 <- #22
DO ,1SUB#11 <- #104
DO ,1SUB#12 <- #184
PLEASE DO ,1SUB#13 <- #202
DO ,1SUB#14 <- #78
DO ,1SUB#15 <- #48
PLEASE DO ,1SUB#16 <- #96
DO ,1SUB#17 <- #128
DO ,1SUB#18 <- #162
PLEASE DO ,1SUB#19 <- #110
DO ,1SUB#20 <- #32
DO ,1SUB#21 <- #114
PLEASE DO ,1SUB#22 <- #120
DO ,1SUB#23 <- #240
DO ,1SUB#24 <- #128
PLEASE DO ,1SUB#25 <- #208
DO ,1SUB#26 <- #200
DO ,1SUB#27 <- #52
DO READ OUT ,1
DO GIVE UP

INTERCAL හි ආදාන සහ ප්‍රතිදාන පද්ධතිය පැහැදිලි කිරීමට මම උත්සාහ නොකරමි; මෙය කියවා ඔබ මිය නොයනු ඇතැයි සිතමි.

කාර්යය 2

DO WRITE IN 7
DO .1 <- .7
DO .2 <- #1
PLEASE DO (1010) NEXT
DO .8 <- .3
DO .5 <- .7
DO .6 <- .8
DO ,9 <- #2

DO (100) NEXT
DO (1) NEXT

(100) DO (99) NEXT
DO ,9SUB#1 <- #142
DO ,9SUB#2 <- #114
PLEASE DO READ OUT ,9
DO ,9SUB#1 <- #176
DO ,9SUB#2 <- #80
PLEASE DO READ OUT ,9
PLEASE GIVE UP

(99) DO .1 <- .7
DO .2 <- #1
PLEASE DO (1010) NEXT
DO .1 <- '.3~.3'~#1
PLEASE DO FORGET .1
DO RESUME #1

(1) PLEASE DO (3) NEXT
PLEASE DO FORGET #1
DO (1) NEXT

(3) DO (4) NEXT
PLEASE GIVE UP

(4) DO (8) NEXT
DO ,9SUB#1 <- #176
DO ,9SUB#2 <- #80
PLEASE DO READ OUT ,9
DO .6 <- .8
DO .1 <- .5
DO .2 <- #1
DO (1010) NEXT
DO .5 <- .3
DO .1 <- '.5~.5'~#1
PLEASE DO FORGET .1
DO RESUME #1

(8) DO (5) NEXT

(5) PLEASE DO (6) NEXT
PLEASE DO FORGET #1
DO (5) NEXT

(6) PLEASE DO (7) NEXT
DO RESUME #2

(7) DO (10) NEXT
DO .1 <- .6
DO .2 <- #1
PLEASE DO (1010) NEXT
DO .6 <- .3
DO .1 <- '.6~.6'~#1
PLEASE DO FORGET .1
DO RESUME #1

(10) DO (11) NEXT
DO (13) NEXT
DO (14) NEXT
DO (15) NEXT

(11) DO (111) NEXT
DO (112) NEXT

(13) DO (113) NEXT
DO (112) NEXT

(14) DO (114) NEXT
DO (112) NEXT

(111) DO .1 <- .6
DO .2 <- .8
DO (1010) NEXT
DO .1 <- '.3~.3'~#1
PLEASE DO FORGET .1
DO RESUME #1

(112) DO ,9SUB#1 <- #142
DO ,9SUB#2 <- #114
PLEASE DO READ OUT ,9
DO RESUME #3

(113) DO .1 <- .6
DO .2 <- #1
DO (1000) NEXT
DO .1 <- .5
DO .2 <- .3
DO (1010) NEXT
DO .1 <- '.3~.3'~#1
PLEASE DO FORGET .1
DO RESUME #1

(114) DO .1 <- '.6~.6'~#1
PLEASE DO FORGET .1
DO RESUME #1

(15) DO ,9SUB#1 <- #252
DO ,9SUB#2 <- #4
PLEASE DO READ OUT ,9
DO RESUME #2

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

කාර්යය 3

DO WRITE IN .5
DO WRITE IN .6

DO (1) NEXT

(1) PLEASE DO (3) NEXT
DO FORGET #1
DO (1) NEXT

(3) DO (4) NEXT
DO READ OUT .5
PLEASE GIVE UP

(4) DO .1 <- .5
DO .2 <- .6
PLEASE DO (1040) NEXT
DO .1 <- .3
DO .2 <- .6
PLEASE DO (1039) NEXT
DO .2 <- .3
DO .1 <- .5
DO (1010) NEXT
DO .5 <- .6
DO .6 <- .3
DO .1 <- '.6~.6'~#1
PLEASE DO FORGET .1
DO RESUME #1

මෙය ඉතා සරල ය. INTERCAL හි ... අමුතුකම නිසා, ඔබට මේ වගේ අංක ඇතුළත් කළ යුතුය:

THREE FIVE

උදාහරණයක් ලෙස, 42 සහ 16 යන GCD ලබා ගැනීම සඳහා, මම ඇතුළු වන්නේ:

FOUR TWO
ONE SIX

එය රෝමානු ඉලක්කම්වල අංකය ද මුද්‍රණය කරයි ... මන්ද එය ඔබට අන්තර් ක්‍රියාකාරී වේ!


2
එය 19 7 2 විය යුතු නොවේද? (මෙය ලිවීමෙන් පසු ඔබ ටිකක් කරකැවිල්ලෙන් සිටින බව මට තේරුම් ගත හැකිය: P) මෙම වැරැද්ද නිසා ඔබේ පිළිතුර අවලංගු යැයි සලකනු ලැබේ, එය ලැජ්ජාවකි.
marinus

@marinus ස්තූතියි! ස්ථාවරයි!
kirbyfan64sos

5
කරුණාකර පැහැදිලි කරන්න. (ඔබට කාලය ඇති විට, ඇත්ත වශයෙන්ම .;)
DLosc

1
ඉන්ටර්කාල් යනු මම කවදාවත් ඉගෙන නොගත් මගේ ප්‍රියතම භාෂාවයි!
සී. ජේ. ඩෙනිස්

1
PLEASE GIVE UP. මම දැනටමත් එය කර ඇත්තෙමි .-.
රෙඩ්ක්ලෝවර්

24

1967 - ඒපීඑල්

1957 දී හාවඩ් විශ්ව විද්‍යාලයේ කෙන් අයිවර්සන් අරා හැසිරවීම සඳහා ගණිතමය අංකනයක් වර්ධනය කිරීම ආරම්භ කළේය. 1960 දශකය තුළ ඔහුගේ අංකනය IBM හි ක්‍රමලේඛන භාෂාවක් දක්වා වර්ධනය විය. පළමු අර්ධ ක්‍රියාත්මක කිරීම 1963 දී නිර්මාණය කරන ලද අතර එය උසස් පාසලක දී පවා අත්‍යුත්තර ක්‍රියාකාරකම් පිළිබඳව සිසුන්ට ඉගැන්වීමට භාවිතා කරන ලදී. පූර්ණ, භාවිතයට ගත හැකි ක්‍රියාත්මක කිරීමක් 1965 වන තෙක් බලා සිටීමට සිදු විය. වසර දෙකක් තිස්සේ එය අභ්‍යන්තරව භාවිතා කළේ අයි.බී.එම්. 1967 දී අවසන් කරන ලද අයිබීඑම් 1130 පරිගණකයේ ධාවනය වූ ඒපීඑල් පරිවර්තකය 1967 දී අයිබීඑම් මහජනයාට නිකුත් කළේය. ඒ සඳහා වසරක් තෝරා ගැනීම තරමක් අපහසු වන්නේ කෙසේදැයි ඔබට තේරුම් ගත හැකිය, කෙසේ වෙතත්, එය 1967 විය යුතු යැයි මම සිතමි. මෙය පළමු වසර වන බැවින් පූර්ණ ලෙස ක්‍රියාත්මක කිරීම මහජනයාට ලබා දෙන ලදී. කවුරුහරි ඇත්තටම එකඟ නොවන්නේ නම්, මට එය වෙනස් කළ හැකිය.

APL \ 360 සඳහා වන ප්‍රභව කේතය, ඉමුලේටරයක් මෙන් මාර්ගගතව ඇත. මෙම උදාහරණ පරීක්ෂා කිරීමට මා භාවිතා කර ඇත්තේ මෙයයි. එය 1967 සිට ආරම්භ වන අතර ඒපීඑල් \ 1130 සමඟ (ඉහත සඳහන් කළ අයිබීඑම් 1130 සඳහා) එය සත්‍ය මුල් පිටපතට වඩා අඩු හෝ අඩුය. අපේක්ෂා කළ පරිදි, එය ඉතා ප්රාථමික ය. සිම්පල් අකුරු වැනි ලස්සන සඳහා එය සහාය නොදක්වයි, ඕනෑම ක්‍රියාකරුවෙකු වැඩ කරන්නේ බිල්ඩින් ශ්‍රිත සමඟ පමණි , සහ බිල්ඩින් ශ්‍රිත සමූහය ඉතා විරල ය (විශේෂයෙන්, එය පමණක් or වන අතර දෙගුණයක් නොවේgcd ). මුල්, සම්පූර්ණ විස්තරය මෙතැනින් ලබා ගත හැකිය , කෙසේ වෙතත්, මා සතුව තිබූ අනුවාදය එම ලේඛනයට සාපේක්ෂව සම්පූර්ණ නොවන බවත් අනෙක් ඒවා අතර නොමැති බවත් මම දුටුවෙමි .

මම වැඩසටහන් යුනිකෝඩ් ආකෘතියෙන් ලබා දී ඇත (එබැවින් ඔබට ඒවා කියවිය හැකිය), සහ මුල් කේතන ක්‍රමයේදී (එබැවින් ඔබට ඒවා කපා එමුලේටරයේ ඒපීඑල් කවුළුව තුළට ඇලවිය හැකිය).

ඩයලොග්, NARS2000, සහ GNU APL හි නවීන සංස්කරණ වල කිසිදු වෙනසක් නොමැතිව (කේතන ක්‍රමය හැර) මෙම වැඩසටහන් නිවැරදිව ක්‍රියාත්මක වේ. ඒ නිසා මම හිතන්නේ මම අතේ ගෙන යා හැකි ඒපීඑල් ලිවීමට ක්‍රමයක් සොයාගෙන ඇත: එය 1967 යැයි මවාපාමින්!

කාර්යය 1:

යුනිකෝඩ්:

⎕←'APL WAS MADE IN 1967!'

APL \ 360:

L[Kapl was made in 1967ÝK

කාර්යය 2:

යුනිකෝඩ්:

⎕←' N'[1+((2⍴N)⍴(⍳N)∊1,N)∨(⍳N)∘.=⍳N←⎕]

APL \ 360:

L[K nK;1-::2Rn"R:In"E1,n"(:In"J.%In[L'

කාර්යය 3:

මම මෙය සම්මත පුනරාවර්තන ක්‍රමය විසඳා ඇත්තෙමි. න්‍යාය අනුව, ඔබට ජේ පිළිතුර වැනි දක්ෂ හා අරාව-නැඹුරු යමක් කළ හැකිය; කෙසේ වෙතත්, ප්‍රායෝගිකව, එය O (N) මතක භාවිතයක් ඇති අතර, මල්-බල-යුගයේ දෘඩ හා මෘදුකාංග ඉක්මනින් යටපත් කරයි.

යුනිකෝඩ්:

∇R←A GCD B
R←A
→(B=0)/0
R←B GCD B|A
∇

⎕←⎕ GCD ⎕

APL \ 360:

Gr[a gcd b
r[a
{:b%0"/0
r[b gcd bMa
G

L[L gcd L

මේක නම් නියමයි.
ඇලෙක්ස් ඒ.

24

1999 - එක්ස්එස්එල්ටී

මෙම පුළුල් ලෝක Web මූල්යායනනය (W3C) HTML, පෙළ බවට XML පරිවර්තනය සඳහා XSLT, ආදිය නිර්මාණය කරන ලද පහත සඳහන් උදාහරණ ආදාන බහා ඇත උපකල්පනය <input>..</input>ටැග්.

කාර්යය 1

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:output method="text" indent="no"/>
  <xsl:template match="/input">XSLT was made in 1999!</xsl:template>
</xsl:stylesheet>

මෙය සරලයි. එය inputඉහළ මට්ටමේ ටැගයකට ගැලපෙන අතර එය අපේක්ෂිත ප්‍රතිදානය සමඟ ප්‍රතිස්ථාපනය කරයි.

කාර්යය 2

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:output method="text" indent="no"/>
  <xsl:template match="/input">
    <xsl:call-template name="loop">
      <xsl:with-param name="i">1</xsl:with-param>
      <xsl:with-param name="n">
        <xsl:value-of select="."/>
      </xsl:with-param>
    </xsl:call-template>
  </xsl:template>
  <xsl:template name="loop">
    <xsl:param name="i"/>
    <xsl:param name="n"/>
    <xsl:choose>
      <xsl:when test="$i = 1 or $i = $n">
        <xsl:text>N</xsl:text>
        <xsl:call-template name="spaces">
          <xsl:with-param name="n">
            <xsl:value-of select="$n - 2"/>
          </xsl:with-param>
        </xsl:call-template>
        <xsl:text>N&#13;&#10;</xsl:text>
      </xsl:when>
      <xsl:otherwise>
        <xsl:text>N</xsl:text>
        <xsl:call-template name="spaces">
          <xsl:with-param name="n">
            <xsl:value-of select="$i - 2"/>
          </xsl:with-param>
        </xsl:call-template>
        <xsl:text>N</xsl:text>
        <xsl:call-template name="spaces">
          <xsl:with-param name="n">
            <xsl:value-of select="$n - $i - 1"/>
          </xsl:with-param>
        </xsl:call-template>
        <xsl:text>N&#13;&#10;</xsl:text>
      </xsl:otherwise>
    </xsl:choose>
    <xsl:if test="$i &lt; $n">
      <xsl:call-template name="loop">
        <xsl:with-param name="i">
          <xsl:value-of select="$i + 1"/>
        </xsl:with-param>
        <xsl:with-param name="n">
          <xsl:value-of select="$n"/>
        </xsl:with-param>
      </xsl:call-template>
    </xsl:if>
  </xsl:template>
      <xsl:template name="spaces">
    <xsl:param name="n"/>
    <xsl:if test="$n &gt; 0">
      <xsl:text> </xsl:text>
      <xsl:call-template name="spaces">
        <xsl:with-param name="n">
          <xsl:value-of select="$n - 1"/>
        </xsl:with-param>
      </xsl:call-template>
    </xsl:if>
  </xsl:template>
</xsl:stylesheet>

මෙය පුනරාවර්තන සැකිලි 2 ක් අර්ථ දක්වයි, loopසහ spaces. loopපරාමිතීන් සමඟ iසහ ස්ථානයෙන් ආරම්භ කර nඅපේක්ෂිත ප්‍රතිදානය ජනනය කරනු ඇත . පරාමිතිය සමඟ අවකාශය ජනනය වේ.nispacesnn

කාර්යය 3

මේ සඳහා ආදානය <input><num>..</num><num>..</num></input>ටැග් වල තිබිය යුතුය .

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:output method="text" indent="no"/>
  <xsl:template match="/input">
    <xsl:call-template name="gcd">
      <xsl:with-param name="a"><xsl:value-of select="num[1]"/></xsl:with-param>
      <xsl:with-param name="b"><xsl:value-of select="num[2]"/></xsl:with-param>
    </xsl:call-template>
  </xsl:template>
  <xsl:template name="gcd">
    <xsl:param name="a"/>
    <xsl:param name="b"/>
    <xsl:choose>
      <xsl:when test="$b = 0"><xsl:value-of select="$a"/></xsl:when>
      <xsl:otherwise>
        <xsl:call-template name="gcd">
          <xsl:with-param name="a"><xsl:value-of select="$b"/></xsl:with-param>
          <xsl:with-param name="b"><xsl:value-of select="$a mod $b"/></xsl:with-param>
        </xsl:call-template>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:template>
</xsl:stylesheet>

මෙය gcdයුක්ලීඩියානු ඇල්ගොරිතම භාවිතා කරන පුනරාවර්තන අච්චුවක් පමණි .


ඔවුන් කියනවා INTERCAL අමුතුයි කියලා!
kirbyfan64sos

2
ir kirbyfan64sos සාධාරණ වීමට නම්, එය කෙසේ හෝ මෙම දේවල් සඳහා භාවිතා නොකළ යුතුය ...
LegionMammal978

22

1996 - ඔකාම්

1996 දී යමෙකු පුරවන තෙක් දිනකට වඩා බලා සිටි නිසා මට රූබි පුරවන්නට හැකි විය. හොඳයි ඇයි එහෙනම් OCaml ඉගෙන නොගන්නේ, හැස්කෙල් හා සමාන බව පෙනේ ...

හෙලෝ වර්ල්ඩ්

print_endline "OCaml was made in 1996!";;

ASCII

let ascii n =
  let rec ascii' = function
    | 0 -> ()
    | i ->
        let s = "N" ^ String.make (n-2) ' ' ^ "N" in
        String.fill s (n-i) 1 'N';
        print_endline s;
        ascii' (i-1)
  in ascii' n;;

විකෘති නූල්!

GCD

let rec gcd a b = if b = 0 then a else gcd b (a mod b);;

නෑ ==, අනන්තය mod, ඒක හුරුබුහුටියි


මට කණගාටුයි, මම රූබි වලින් පුරවා ගතිමි :)
Zero Fiber

4
මෙම අභියෝගයට පිළිතුරු සැපයීම සඳහා භාෂාවක් ඉගෙනීම සඳහා +1. :)
ඇලෙක්ස් ඒ.

ඔබත් F # ඉගෙන ගත්තා! (එය සීඑල්ආර් හි OCaml සහ අමතර කිහිපයක්).
රොබට් ෆ්‍රේසර්

22

2005 - පෙරවදන

පෙරවදන ඉතා විනෝදජනක භාෂාවක් වන අතර, එහි ප්‍රභව කේතය සමාන්තරව ක්‍රියාත්මක වන “හ o වල්” කිහිපයකින් සමන්විත වන අතර ගැටළු විසඳීමට මම සැබවින්ම ප්‍රිය කරමි . එහි සහෝදර භාෂාව වන ෆියුගු හි ASCII නිරූපණය ලෙස අදහස් කෙරේ අතර එය ඇත්ත වශයෙන්ම .midi ගොනු එහි ප්‍රභව කේතය ලෙස ගෙන පෙරවදනෙහි ඇති උපදෙස් හ ices වල තනු වල කාල පරතරයන් ලෙස සංකේතවත් කරයි.

පෙරවදන තරමක් අවම වන නමුත් ටියුරින් කිරීම සම්පූර්ණයි (ඔබ අවම වශයෙන් කටහ 2 වල් දෙකක් භාවිතා කරන්නේ නම්). මා පැවසූ පරිදි, කටහ (වල් (කේත රේඛා) එකවර ක්‍රියාත්මක වේ. සෑම හ voice ක්ම ක්‍රියාත්මක වන්නේ තමන්ගේම තොගයක් මත වන අතර එය අසීමිත ශුන්‍ය සංඛ්‍යාවක් දක්වා ආරම්භ වේ. පෙරවදන පහත සඳහන් උපදෙස් සඳහා සහය දක්වයි:

0-9 ... Push the corresponding digit.
+   ... Add the top two numbers on the stack.
-   ... Subtract the top number from the one beneath.
#   ... Discard the top of the stack.
^   ... Copy the top value from the voice above.
v   ... Copy the top value from the voice below.
?   ... Read a number and push it onto the stack.
!   ... Print the top number (and pop it from the stack).
(   ... If the top of the stack is zero, jump past the matching ')'.
)   ... If the top of the stack is zero, jump to the column after the matching '('.

අමතර සටහන් කිහිපයක්:

  • කටහ cycle චක්‍රීය ය, එබැවින් ^ ඉහළ හ voice පිටපත් පහළ හ voice ින් (සහ අනෙක් අතට).
  • බහුවිධ ?හා !එකම තීරුවේ ඉහළ සිට පහළට ක්‍රියාත්මක වේ.
  • අනුව භාෂා පිරිවිතර , ?සහ !අදාල චරිත කේතය සමඟ කියවීමේ හා ලිවීම් අක්ෂර. කෙසේ වෙතත්, පයිතන් පරිවර්තකයට එහි කේතයේ ස්විචයක් ඇත, ඒ වෙනුවට සංඛ්‍යා මුද්‍රණය කිරීම. පරීක්ෂණ අරමුණු සඳහා මම ඇත්ත වශයෙන්ම භාවිතා කරන්නේ අක්ෂර වෙනුවට අංක කියවිය හැකි නවීකරණය කරන ලද අනුවාදයකි . නමුත් මෙහි ඇති එකඟතාවය නම් සංඛ්‍යාත්මක ආදානය / ප්‍රතිදානය ඇත්ත වශයෙන්ම බයිට් අගයන් ලෙස ලබා දිය හැකි බැවින් සංඛ්‍යා සමඟ කටයුතු කරන වලංගු වැඩසටහන් කිරීමට මෙම වෙනස් කිරීම් අවශ්‍ය නොවේ.
  • ගැලපීම (සහ )එකම කටහ on ක් තිබිය යුතු නොවේ. තත්වය සඳහා භාවිතා කරන කටහ always සෑම විටම( දිස්වන ස්ථානයයි . එබැවින් සිරස් පිහිටීම )සම්පූර්ණයෙන්ම අදාල නොවේ.
  • Prelude එකවර ක්‍රියාත්මක කිරීමේ ස්වභාවය නිසා, එකම තීරුවේ ඇති ඕනෑම උපදෙස් (ක්‍රියාත්මක වන්නේ ලූපය ආරම්භ වීමට පෙර එක් වරක් පමණක් වන අතර, ලූපය ඇතුලත් කර ඇත්ද යන්න නොසලකා. ඒ හා සමානව, )මෙම පුනරාවර්තනයෙන් පසුව ලූපය පිටව යනු ඇත්ද යන්න නොසලකා, එකම තීරුවේ ඇති ඕනෑම උපදෙස් එක් එක් නැවතීමේ අවසානයේ ක්‍රියාත්මක වේ.

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

වැඩසටහන්

"හෙලෝ වර්ල්ඩ්!" ප්‍රභේදය

9(1-)v98+^++!9v+!  v88++2+!^  ! ^9-3-! v      !    v2-!55+!
8 8+ !     7v+! 1v+!88+^+!^4-!^ v8-^ !!!9v+  !^9+9+!  v5+!
     ^98++4+! ^8-! ^4-   ^ #!^6-!    ^^  #5+! v    ^2-!1+!

ඔබ පයිතන් පරිවර්තකය භාවිතා කරන්නේ නම්, එය තහවුරු කරගන්න NUMERIC_OUTPUT = False.

ASCII Art N.

      v2-(1-)v         
9(1-)?1-( v!  (1-55+!      0     (0)#  ))55+!
4-4+                  v^-#
     v!      v! v1-v!(1- ^(#^!0)# v! )v!
6 8+           v#

භාවිතයේ පහසුව සඳහා, මෙම වැඩසටහන ආදාන සංඛ්‍යා ලෙස කියවීමෙන් ප්‍රතිලාභ ලබන නමුත් ප්‍රතිදානය සංඛ්‍යාත්මක නොවිය යුතුය. එබැවින් ඔබ නවීකරණය කරන ලද පයිතන් පරිවර්තකය භාවිතා කරන්නේ නම්, සකසන්න

NUMERIC_INPUT = True
NUMERIC_OUTPUT = False

GCD

?(                         v)
? (^-(0 # v   #       ^+0)#^ !
     ^^ (##v^v+)#  0 (0 )   
      1) ^ #  - 1+(#)#

මෙය සියලු සංඛ්‍යාත්මක ආදානය / ප්‍රතිදානය සමඟ වඩාත් සුදුසු වේ

NUMERIC_INPUT = True
NUMERIC_OUTPUT = True

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

"හෙලෝ වර්ල්ඩ්!" ප්‍රභේදය

මෙය තරමක් forward ජුව ඉදිරියට ය. තුළ ඇති සියලුම අක්ෂර සඳහා අනුලකුණු කේත අනුක්‍රමිකව ජනනය කිරීමට මම හ 3 3 ක් භාවිතා කරමි Prelude was made in 2005!. මම ගණනය කිරීමෙන් ආරම්භ කරමි 8 + 9*8 = 80, එහි අක්ෂර කේතය මෙයයි P:

 9(1-)
 8 8+

ඊට පසු මම බොහෝ දුරට පෙර අක්ෂර කේතය පිටපත් කර වෙනස ඊළඟට එකතු කරන්න හෝ අඩු කරන්නෙමි. මෙන්න කේතය, නමුත් සෑම එකක්ම !මුද්‍රණය කර ඇති අක්‍ෂරය සමඟ ප්‍රතිස්ථාපනය කර ඇත (සහ _අවකාශයන් සහ %ඉලක්කම් සඳහා):

9(1-)v98+^++r9v+u  v88++2+w^  _ ^9-3-a v      _    v2-%55+!
8 8+ P     7v+l 1v+e88+^+_^4-s^ v8-^ de_9v+  n^9+9+%  v5+%
     ^98++4+e ^8-d ^4-   ^ #a^6-m    ^^  #5+i v    ^2-%1+!

අවසාන 55+!මුද්‍රණය නව රේඛාවක් මුද්‍රණය කරයි.

පැති සටහනක් ලෙස, හ task ගණන මෙම කාර්යය සඳහා අත්තනෝමතික ය, නමුත් 3 තරමක් පහසු බැවින් එය සෑම හ voice කටම එකිනෙකාට කෙලින්ම ප්‍රවේශ විය හැකි විශාලතම සංඛ්‍යාව වේ.

ASCII Art N.

      v2-(1-)v         
9(1-)?1-( v!  (1-55+!      0     (0)#  ))55+!
4-4+                  v^-#
     v!      v! v1-v!(1- ^(#^!0)# v! )v!
6 8+           v#

කටහ 5 වල් 5 ක් සමඟින්, මෙය නියත වශයෙන්ම මා මෙතෙක් ලියා ඇති වඩාත්ම සංකීර්ණ වැඩසටහන් වලින් එකකි. කටහ දළ වශයෙන් පහත අරමුණු ඇත:

  1. හුදෙක් උපකාරක හ voice ක් ගබඩා කරයි N-1අභ්‍යන්තර පුඩුවේ භාවිතය සඳහා .
  2. මෙය ආදාන කියවන, වැදගත් ස්විචයක් සහ පිටත ලූපය (එනම් පේළි වලට ඉහළින් ඇති) අඩංගු “ප්‍රධාන” හ voice වර්ග කිරීමකි.
  3. මෙය ගබඩා කරයි a 32 පහසුවෙන් මුද්‍රණය කළ හැකි අවකාශයක් .
  4. මෙහි අභ්‍යන්තර පුඩුවක් (තීරු වලට ඉහළින් ඇති) අඩංගු වේ.
  5. මෙය 78පහසුවෙන් මුද්‍රණය කළ හැකි දෑ ගබඩා කරයි N.

අපි කේතයෙන් කොටසින් යමු. පළමුව, මම නිර්මාණය කරනවා 32ලෙස -4 + 9*4හා 78ලෙස 6 + 9*8:

9(1-)
4-4+

6 8+

Nආදානය කියවන විට Nසහ ගබඩා කරන විට N-1සහ N-2පළමු කටහ two දෙකේදී මම දැන් තනි එකක් මුද්‍රණය කරමි (අපට සැමවිටම එකක් අවශ්‍ය නිසා) :

      v2-
     ?1-

     v!

ඊළඟට, "ලූප්" කොන්දේසියක් ඇත N-1. ලූපය අවසානයේ, දෙවන කටහ always සෑම විටම අඩු වන 0අතර පළමු පුනරාවර්තනයෙන් පසුව ලූපය පිටවෙයි. එබැවින් මූලික වශයෙන්, මෙය පමණි if(N > 1){...}. ලූපයෙන් පසුව අපි තනි පසුපස නව රේඛාවක් මුද්‍රණය කරමු. නැවත බැලීමට, අපට දැන් පහත රාමුව ඇත:

      v2-
9(1-)?1-(                               )55+!
4-4+
     v!
6 8+

මෙම කොන්දේසිය ඇතුළත, පළමු පේළිය සම්පුර්ණ කිරීම සඳහා අපි පළමු N-2අවකාශයන් සහ තනි එකක් වන අතර අනාගත භාවිතය සඳහා පළමු හ voice Nද ගබඩා කරමු N-1:

         (1-)v         
          v!  

             v!

දැන් කේතයේ නියම මස්. පළමුව, පිටත ලූපයක් ඇත, එය N-1පේළි මුද්‍රණය කරයි . සෑම පේළියක් සඳහාම, අපි පළමුව නව රේඛාවක් මුද්‍රණය කරමු N. ඉන්පසු අපි N-2වේලාවන් ලූප් කර , අවකාශයන් හෝ Ns මුද්‍රණය කරමු (පසුව වැඩි විස්තර). අවසාන වශයෙන් අපි තවත් එකක් මුද්‍රණය කරමු N:

               1-55+!  

                v1-v!(               )v!
               v#

අවසාන වශයෙන්, විනෝදජනක කොටස: සෑම පේළියක්ම මුද්‍රණය කිරීම (සහ Nදකුණේ ස්ථානය ලබා ගැනීම ). පෙරවදනෙහි ඇත්ත වශයෙන්ම if / else නොමැත, එබැවින් විවිධ කටහ on වල් මත ලූප දෙකක් භාවිතා කර එය මා විසින්ම ගොඩනගා ගත යුතුය. අභ්‍යන්තර හා පිටත ලූප විචල්‍යය අඩු කිරීමෙන් තත්වය පහසුවෙන් ලබා ගත හැකිය - අපට 0මුද්‍රණය කිරීමට අවශ්‍ය නම් Nසහ අවකාශයක් මුද්‍රණය කිරීමට අවශ්‍ය නම් ශුන්‍ය නොවන යමක් අපට ලැබේ.

පෙරවදනෙහි if / else හි මූලික අදහස නම් අදාළ අගයට පසුව ලූපයක් තැබීමයි - “if” (හෝ ශුන්‍ය නොවන) කේතයට පසුව එය තල්ලු කිරීමෙන් වහාම පිටවීම 0. තවත් කටහ on ක් මත, ඔබ ශුන්‍ය නොවන අගයක් තබා ඇති අතර, "if" ලූපයට පසුව තවත් ලූපයක් තබා ගන්න. තුළ කම්බියක් ඔබ ශුන්ය වෙනත් හඬ මත, ක්රියාත්මක කරමින් සිට "වෙන" වැලැක්වීමට එසේ ය. "නම්" ඔබ ශුන්‍ය නොවන අගයන්ට ඉහළින් ශුන්‍ය අගයන් තල්ලු කරනවාද නැතිනම් පහළින් ශුන්‍යයක් තිබේ නම් ශුන්‍ය නොවන අගය ඉවතලන්නේද යන්න පිළිබඳ යම් නම්‍යතාවයක් ඇත, නමුත් මෙය සාමාන්‍ය අදහසයි. අදාළ හ. දිගටම භාවිතා කිරීමට ඔබට අවශ්‍ය නම් ඔබට පසුව පිරිසිදු කිරීමක් කිරීමට සිදු විය හැකිය. කේතය පෙනෙන්නේ මෙයයි:

                           0     (0)#
                      v^-#
                      1- ^(#^!0)# v! 

ඒක තමයි!

GCD

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

?(                         v)
? (^-(0 # v   #       ^+0)#^ !
     ^^ (##v^v+)#  0 (0 )   
      1) ^ #  - 1+(#)#

ඉතින් අපිට මේ වතාවේ කටහ four වල් හතරක් ලැබුණා. පළමු හඬ හුදෙක් මාර්ගය කරයි bහා ප්රධාන අවසන් කළ තත්ත්වය (කම්බියක් පිටවීම් දොරටු එනම් විට අඩංගු bබවට පත් 0). දෙවන හ voice අඩංගු වන aඅතර, කටහ three වල් තුන සහ හතරේ ආධාරයෙන් a % b, පෙර ප්‍රති with ලය හුවමාරු කර ගැනීමට පෙර b. අවසාන වශයෙන්, !මුද්‍රණය කරන්නේ aකවදාද b == 0.

අපි මුලින්ම සං sign ා කොටස දෙස බලමු :

     (0 # v   #
     ^^ (##v^v+)#
      1) ^ #  -

ආදාන අංකය nඑම හ of වලින් පළමුවැන්නෙහි දක්නට ලැබේ (සම්පූර්ණ වැඩසටහනේ දෙවන හ voice). ප්‍රති result ලය පහළ හ .ින් අවසන් වේ. අනෙක් හ two දෙක හිස් වනු ඇතැයි අපේක්ෂා කෙරේ (එනම් ශුන්‍යයෙන් පිරී ඇත). එසේ නම් n == 0, ලූප දෙකම මඟ හැරී ඇති අතර පහළ හ voice තවමත් 0අපට අවශ්‍ය දේ පමණක් ඇති බව සලකන්න .

නම් nශූන්ය නොවන, පළමු කුඩා පුඩුවක් ඇතුළු කර ඇත. එය වහාම පිටවීම සඳහා අපි බිංදුවක් තල්ලු nකර, මැද හ voice ට පිටපත් දෙකක් සහ 1පහළ හ .ට දමමු. දැන් මූලික අදහස නම්, එක් nපිටපතක් nශුන්‍යයට වැටෙන තෙක් අනෙක් පිටපත අඩු කරන අතරම එහි එක් පිටපතක් වැඩි කිරීමයි . එසේ කරන අතරතුර, 1පහළ හ voice සෑම විටම එහි ලකුණ පෙරළයි (එය පහසුවෙන් 0එය තොගයේ පහළට අඩු කිරීමෙන් පහසුවෙන් කළ හැකිය ). මෙය සකසා ඇත්තේ කවදාද යන්නයි සංඛ්යා පහර එක් ශුන්ය, පහළ හඬ නිවැරදි සංඥා අඩංගු වනු ඇත.

ප්‍රති mod ලය .ණ වන තෙක් අඩු bකිරීමෙන් දැන් මොඩියුලෝ ක්‍රියාත්මක aවේ. එය සිදු වූ විට, අපි bනැවත එකක් එකතු කරමු . ඒක තමයි මේ:

  (^-  signum         ^+0)#
       signum      0 (0 )   
       signum   1+(#)#

පතුලේ ඇති if / else ඉදිකිරීම් සැලකිල්ලට ගන්න, එය මා කාර්ය 2 සඳහා භාවිතා කළ ආකාරයටම සමාන වේ.


2
මෙය සැබවින්ම පෙරවදන නිබන්ධනයක කොටසක් විය යුතුය.
ඇලෙක්ස් ඒ.

21

2007 - සීරීම

සීරීම යනු අධ්‍යාපන අරමුණු සඳහා MIT විසින් සාදන ලද භාෂාවකි. මම අවුරුදු 5 ක් තිස්සේ ඒ සමඟ බොහෝ සම්බන්ධ වී සිටිමි. පසුව වැඩි විස්තර.

මේ සියල්ල මෙහි නැරඹිය හැකිය .

මම දැන් ඉතා ඉක්මන් වී පසුව ස්නිපෙට් පසුව විස්තර කරමි. ඔවුන් ස්වයං පැහැදිලි කිරීමක් වුවද බලාපොරොත්තු විය හැකිය.

කාර්යය 1

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

කාර්යය 2

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

කාර්යය 3

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


එය පසුවද?
dfeuer

21

1972 - සී

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

C යනු B හි පැවත එන්නෙකු වන අතර, මෙම ලැයිස්තුවේ ද එය අවසන් වනු ඇතැයි මම බලාපොරොත්තු වෙමි. 'ඒ' ක්‍රමලේඛන භාෂාවක් නොතිබුණි: බී යනු බීසීපීඑල් හි ප්‍රභේදයක් වන අතර එය සීපීඑල් ඉවත් කර ඇත. මෙම භාෂා කිසිවක් එතරම් ජනප්‍රිය නොවීය. කෙසේ වෙතත්, BCPL යනු පළමු "හෙලෝ වර්ල්ඩ්" වැඩසටහන ලියන ලද භාෂාවයි. තවත් වැදගත් කාරණයක් බී දෙකම බවය /* */සහ //අදහස්, නමුත් සී අතහැර// අදහස්. පසුව ඒවා C99 ප්‍රමිතිය සමඟ C වෙත නැවත හඳුන්වා දෙන ලදී.

මෙහි සී වැඩසටහන් 1974 සිට යුනික්ස් වී 5 සී සම්පාදකයා සමඟ අත්හදා බලන ලදී. මෙය මට සොයා ගත හැකි හා වැඩ කිරීමට හැකි පැරණිතම සී සම්පාදකයා වූ අතර මෙම වැඩසටහන් නවීන සී සම්පාදකයෙකු මත සම්පාදනය නොකරනු ඇත. (සිදු කරන ලද එක් වෙනසක් නම් +=ලිවීමට පෙර විකෘති ක්‍රියාකරුවන් වීමයි =+.)

#include <... >තවමත් නොපවතී. සම්මත පුස්තකාලයෙන් වැඩි ප්‍රමාණයක් ද කළේ නැත. මට මගේම ලිවීමට සිදු විය atoi. මම V5 ප්‍රභව කේත කිහිපයක් හරහා ගොස් අවසර දී ඇති දේ සහ නැති දේ සොයා ගැනීමට ගියෙමි. මා භාවිතා කළ අනුවාදය පළමුව structs ඇතුළත් කළ නමුත් මම ඒවා භාවිතා නොකළ නිසා සහ V7 (K&R C ලෙස) තෙක් සින්ටැක්ස් බොහෝ වෙනස් වී ඇති බවක් නොපෙනේ, මෙය පෙර සංස්කරණ සමඟද ක්‍රියා කරයි.

V5 ප්‍රභව කේතය භාවිතා කරන ආකාරයටම මගේ කේතය ලිවීමට මම උපරිම උත්සාහයක් ගත්තෙමි. (එය දරුණු ලෙස අනුකූල වන බව නොවේ.)

යුනික්ස් වී 5, ඉමුලේටරයක් ​​සහ නවීන පරිගණකයකින් එය ක්‍රියාත්මක කිරීම සඳහා උපදෙස් සඳහා මෙහි බලන්න .

කාර්යය 1

main()
{
   write(1, "C was made in 1972!\n", 20);
}

කාර්යය 2

atoi(str)
char *str;
{
    register num, digit;
    while (digit = *str++) {
        num =* 10;
        num =+ digit - '0';

    }
    return num;
}

N(n)
{
    register x, y;
    for (y=1; y<=n; y++) {
        for (x=1; x<=n; x++) {
            write(1, " N"+(x==1||x==y||x==n), 1);
        }
        write(1, "\n", 1);
    }
}

main(argc, argv)
char *argv[];
{
    N(atoi(argv[1]));
}

කාර්යය 3

atoi(str)
char *str;
{
    register num, digit;
    while (digit = *str++) {
        num =* 10;
        num =+ digit - '0';
    }
    return num;
}

gcd(a, b)
{
    return b ? gcd(b, a%b) : a;
}

main(argc, argv)
char *argv[];
{
    printf("%d\n", gcd(atoi(argv[1]), atoi(argv[2])));
}

සී, කොතරම් වෙනස් වී ඇත්දැයි මට කවදාවත් වැටහුණේ නැත ... ඔබ එම සම්පාදකයා ලබාගත්තේ කොහෙන්ද?
kirbyfan64sos

1
සම්පාදකයා යුනික්ස් වී 5 සමඟ ඇතුළත් කර ඇත. බ්ලොග් සටහනකට විස්තරයේ සබැඳියක් ඇත, එය ලිපිගොනු ලබා ගන්නේ කොහෙන්ද සහ නවීන පරිගණකයකින් එය ක්‍රියාත්මක කරන්නේ කෙසේද යන්න පෙන්වයි. (එය මෙහි ඇත ). ඔබ එය ක්‍රියාත්මක කළ පසු, ඔබට එය භාවිතයෙන් කේතය ලබා ගත හැකිය cat > file.c. (සෑම විටම මෙන් Ctrl-D සමඟ අවසන් කරන්න). ද, සී ඔබට අඩු සිතනු වඩා වෙනස් වී ඇත: ඔබ හුවමාරු නම් =*සහ =+තුළ atoiනූතන සමාන කාර්යයන් *=හා +=, නවීන සහ ගල්ෆ් ද දැන් හොදින් ඔවුන් සම්පාදනය හා ඒවා ක්රියාත්මක වනු ඇත. අනතුරු ඇඟවීම් පවා නැත.
marinus

2
minnie.tuhs.org/cgi-bin/utree.pl?file=V2/c යනු මට සොයාගත හැකි පැරණිතම C සම්පාදකයා වේ (V2 සිට, '72 දිනැති).
ඔබෙරොන්

20

2009 - ඉඩ්‍රිස්

ඉඩ්‍රිස් යනු යැපෙන වර්ග සමඟ ළඟා කර ගත හැකි අතිශය දැඩි සාක්‍ෂි හැකියාවන් ඉදිරිපත් කිරීමට අමතරව තථ්‍ය-ලෝක යෙදුම් සඳහා ප්‍රායෝගිකව භාවිතා කළ හැකි බව අවධාරණය කරන යැපෙන-ටයිප් කළ පිරිසිදු ක්‍රියාකාරී භාෂාවකි.

කාර්යය 1

module Main

main : IO ()
main = putStrLn "Idris was made in 2009!"

කාර්යය 2

module InN

import Data.Fin
import Data.Vect

genN : Vect n (Vect n Char)
genN = [[ if inN x y then 'N' else ' ' | x<-range ]| y<-range ]

||| Helper function, determines whether the char at coordinate (x,y)
||| is part of the letter:
inN : Fin n -> Fin n -> Bool
inN {n=S _} x y = x==0 || x==y || x==last

මෙය වැඩසටහනක් නොව හුදෙක් ශ්‍රිතයක් (වඩාත් නිවැරදිව, යැපෙන අගය ), අපේක්ෂිත අක්ෂරය ද්විමාන අරාව ලෙස නිපදවයි.

$ idris ascii-n.idr 
     ____    __     _                                          
    /  _/___/ /____(_)____                                     
    / // __  / ___/ / ___/     Version 0.9.17.1-
  _/ // /_/ / /  / (__  )      http://www.idris-lang.org/      
 /___/\__,_/_/  /_/____/       Type :? for help               

Idris is free software with ABSOLUTELY NO WARRANTY.            
For details type :warranty.
Type checking ./ascii-n.idr
*ascii-n> genN {n=4}
[['N', ' ', ' ', 'N'],
 ['N', 'N', ' ', 'N'],
 ['N', ' ', 'N', 'N'],
 ['N', ' ', ' ', 'N']] : Vect 4 (Vect 4 Char)

කාර්යය 3

module gcd

gcd' : Nat -> Nat -> Nat
gcd' a Z = a
gcd' a b = gcd' b $ a`mod`b

මම නම තෝරා ගැනීමට තිබූ බව සටහන gcd'ලෙස නිසා gcdඑය මේ වන විටත් ශාස්ත්රඥයකු වූ අයිඩ්රිස් පූර්විකාවක් අර්ථ දක්වා ඇත.

Type checking ./gcd.idr
*gcd> gcd' 8 12
4 : Nat
*gcd> gcd' 12 8
4 : Nat
*gcd> gcd' 234 876
6 : Nat

ඔවුන් හස්කල්ව රැගෙන, මාරු :වී ::, වෙනස් _කළ බවක් පෙනේ Z.
wchargin

@ ඩබ්ලිව් චාර්ජින් Zඇත්ත වශයෙන්ම එහි ඉදිකිරීම්කරු වේ 0 : Nat. යටි ඉරි ලකුණු හැඩ්කෙල්හි මෙන් අයිඩ්‍රිස් හි භාවිතා වේ.
හැරීම නැවැත්වීම

ඔහ්, හොඳයි, ඔබ යන්න! :)
wchargin

19

2014 - පයිත්

අපට CJam ඇති බැවින්, අපට සම්පූර්ණත්වය සඳහා පයිත් ද තිබිය හැකිය :)

පයිත් යනු අයිසැක් විසින් ගොල්ෆ් කරන භාෂාවක් වන අතර එය පයිතන් දක්වා සම්පාදනය කරයි. කාර්ය පටිපාටික වීම සහ උපසර්ග අංකනය භාවිතා කිරීම කැපී පෙනේ. පයිත් මුලින්ම දර්ශනය වූයේ 2014 ජුනි මාසයේදීය .

"හෙලෝ වර්ල්ඩ්!" ප්‍රභේදය

"Pyth was made in 2014!

සංවෘත උපුටා දැක්වීමක් නොමැති බව සලකන්න, පයිත් වැඩසටහනක් නූලකින් අවසන් වුවහොත් එය අත්‍යවශ්‍ය නොවේ.

ASCII Art N.

VQ+\Nt+P++*Nd\N*t-QNd\N

එය මාර්ගගතව උත්සාහ කරන්න . සමාන පයිතන්:

Q = eval(input())
for N in range(Q):
    print("N"+((" "*N+"N"+(Q-N-1)*" ")[:-1]+"N")[1:])

හෝ පුළුල් (පළමු හා තෙවන පේළි ව්‍යංගයෙන්):

Q = eval(input())                                        # 
for N in range(Q):                                       #   VQ
    print(                                          )    # 
          "N"+                                           #     +\N
              (                                )[1:]     #        t
                                           +"N"          #         +              \N
               (                     )[:-1]              #          P
                         +(Q-N-1)*" "                    #           +      *t-QNd
                     +"N"                                #            +   \N
                " "*N                                    #             *Nd

GCD

=GvwWQAGQ,Q%GQ)G

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

Q = eval(input())     #
G = eval(input())     #    =Gvw
while Q != 0:         #        WQ
  G, Q = Q, G % Q     #          AGQ,Q%GQ)
print(G)              #                   G

i.uQඅපි GCD සඳහා බිල්ඩින් භාවිතා කරන්නේ නම් ඊටත් වඩා කෙටි වේ. මෙය සමාන වේ print(gcd(*eval(input())))(කොමා මඟින් වෙන් කරන ලද සංඛ්‍යා දෙකක් ආදානය ලෙස ගැනීම).


Drat - මම කරන්න ගියේ Pyth xP
theonlygusti

@isaacg මට පුදුම විය නොහැක, පුදුම විය හැකි අතර, මෙහි දී ද එය ඇසිය හැකිය: පයිත් කිසියම් ආකාරයකින්, හැඩයකින් හෝ ආකාරයකින් පිග් විසින් දේවානුභාවයෙන්ද?
ɐɔıʇǝɥʇuʎs

P ɐɔıʇǝɥʇuʎs මම පයිත් සෑදීමට පෙර PYG දැක ඇති අතර එය චරිත 1 සංකල්ප 1 ප්‍රවේශයට බලපෑම් කරන්නට ඇත. කෙසේ වෙතත්, කිසියම් දෙයක් පයිත්ට ආශ්වාදයක් ලබා දුන්නේ නම් එය බොහෝ විට ගොල්ෆ් පිටපතක් විය හැකිය.
isaacg

18

1964 - ඩාර්ට්මූත් බේසික්

BASIC යනු පොදු අරමුණු සහිත, ඉහළ මට්ටමේ ක්‍රමලේඛන භාෂාවන්ගෙන් යුත් පවුලකි, එහි නිර්මාණ දර්ශනය භාවිතයේ පහසුව අවධාරණය කරයි. 1964 දී ජෝන් ජී. කෙමනී සහ තෝමස් ඊ. කර්ට්ස් නිව් හැම්ප්ෂයර් හි ඩාර්ට්මූත් විද්‍යාලයේ මුල් බේසික් භාෂාව නිර්මාණය කළහ. ඔවුන්ට අවශ්‍ය වූයේ විද්‍යාව හා ගණිතය හැර වෙනත් ක්ෂේත්‍රවල සිසුන්ට පරිගණක භාවිතා කිරීමට අවස්ථාව ලබා දීමයි.

මම මේ ඉන්නේ අත්පොත 1964 සිට මූලික මත, මේ ප්රොජෙක්ට් මෙම Darthmouth කාල දැන්වීම බෙදා ගන්න විද්යුත් පද්ධතිය එය මත දිව ගියේය. සේවාදායකය තවමත් ක්‍රියාත්මකයි, නමුත් කනගාටුවට කරුණක් නම්, ගිණුමක් ලියාපදිංචි කිරීම කළ නොහැකි බවයි. දැනට, මෙම වැඩසටහන් න්‍යායාත්මකව ක්‍රියාත්මක විය යුතුය:

කාර්යය 1

10 PRINT "BASIC WAS MADE IN 1964"
20 END

කාර්යය 2

10 READ N
15 FOR Y = 1 TO N STEP 1
20 FOR X = 1 TO N STEP 1
25 IF X = 1 THEN 50
30 IF X = N THEN 50
35 IF X = Y THEN 50
40 PRINT " ",
45 GO TO 55
50 PRINT "N",
55 NEXT X
60 PRINT
65 NEXT Y
70 DATA 5
75 END

වැනි දෙයක් ප්‍රතිදානය කිරීම:

N                       N
N     N                 N
N           N           N
N                 N     N
N                       N

වැඩසටහනේ ( 70 DATA 5) කොටසක් ලෙස ආදානය ටයිප් කරන ආකාරය සැලකිල්ලට ගන්න ; READඉහළින් ඇති උපදෙස් මාර්ගය එතැන් සිට දත්ත ලබා ගනී. නූල් සම්මුතියක් නොමැත, නමුත් අත්පොතේ 3.1 වගන්තිය විස්තර කරන්නේ කෙසේදPRINT මඟින් ප්‍රතිදානයේ වගුගත “කලාප” වෙත ප්‍රති results ලියා ඇති .

කාර්යය 3

යුක්ලිඩ්ගේ ඇල්ගොරිතමයේ මන්දගාමී අනුවාදය:

10 READ A, B
20 IF A = B THEN 80
30 IF A < B THEN 60
40 LET A = A - B
50 GO TO 20
60 LET B = B - A
70 GO TO 20
80 PRINT A
85 DATA 144, 250
90 END

ප්‍රතිදානය:

2

අන්තිමට කවුරුහරි බේසික් කළා.
marinus

17

1991 - පයිතන්

භාෂා ඉතිහාසය

1980 දශකයේ අගභාගයේදී ගයිඩෝ වැන් රොසුම් පයිතන් විනෝදාංශයක් ලෙස නිර්මාණය කිරීමට පටන් ගත්තේය. එහි නම පැමිණියේ මොන්ටි පයිතන්ගේ පියාසර සර්කස් නම් බ්‍රිතාන්‍ය රූපවාහිනී වැඩසටහන වන රොසුම් රසිකයෙක්. පළමු පයිතන් ක්‍රියාත්මක කිරීම 1989 දී ආරම්භ වූ අතර එය 1991 දී නිකුත් කරන ලදී. එය වසර ගණනාවක් පුරා ජනප්‍රියත්වයට පත්ව ඇති අතර බොහෝ හඳුන්වාදීමේ පරිගණක විද්‍යා පා .මාලා සඳහා තෝරා ගැනීමේ භාෂාව බවට පත්විය.

"හෙලෝ වර්ල්ඩ්!" ප්‍රභේදය

print("Python was made in 1991!")

ආදානය වටා ඇති වරහන් සටහන් කරන්න print. මෙම වාක්‍ය ඛණ්ඩය පයිතන් 2 හි ක්‍රියාත්මක වුවද, සාමාන්‍යයෙන් පයිතන් 2 හි ඔබ මෙම වරහන් ඉවත් කරනු ඇත. කෙසේ වෙතත්, ඒවා පයිතන් 3 හි අවශ්‍ය වේ. සාක් ගේට්ස් යෝජනා කළ පරිදි, මෙහි ඉදිරිපත් කර ඇති කේතය අනුවාද හරහා ක්‍රියාත්මක වන බව සහතික කිරීම සඳහා වරහන් වර්‍ග පුරාම භාවිතා වේ.

ASCII Art N.

def asciin(n):
    if n == 1:
        print("N")
    else:
        print("N" + " "*(n-2) + "N")

        for i in range(2, n):
            print("N" + " "*(i-2) + "N" + " "*(n-i-1) + "N")

        print("N" + " "*(n-2) + "N")

භාවිතයෙන් කාර්යයන් අර්ථ දක්වා defඇත. +නූල් සමෝච්ඡකරණය සිදු කරනුයේ සහ නූල් පුනරාවර්තනය කිරීමෙනි *.

GCD

def gcd(a, b):
    if b == 0:
        return(a)
    else:
        return(gcd(b, a % b))

පයිතන්ට ව්‍යුහාත්මක සුදු අවකාශයක් අවශ්‍ය බව සලකන්න.


17

1968 - ඇල්ගෝල් 68

ඇල්ගෝල් 68 හි අනුප්‍රාප්තිකයෙකු ලෙස අයිඑෆ්අයිපී ක්‍රියාකාරී කණ්ඩායම 2.1 විසින් ඇල්ගෝල් 68 අර්ථ දැක්වීය.

එය සෑම දෙයකටම වටිනාකමක් ඇති ප්‍රකාශන නැඹුරු භාෂාවකි. එය ද විකලාංග වේ, ඔබට ඕනෑම ඉදිකිරීමක් ඕනෑම ආකාරයකින් භාවිතා කළ හැකිය. මෙයින් අදහස් කරන්නේ ප්‍රකාශන පැවරුමක RHS සහ LHS මත විය හැකි බවයි.

සියළුම පාලන ව්‍යුහයන්ට සංක්ෂිප්ත ස්වරූපයක් මෙන්ම ප්‍රකාශන භාවිතා කරන දිගු ස්වරූපයක් ඇත. එය ක්‍රියාකරුවන්ගේ අර්ථ දැක්වීම් සඳහා ද අවසර දෙයි.

භාෂාවේ අරමුණු පහත පරිදි වේ.

ඇල්ගෝල් 68 හි සැලසුමේ ප්‍රධාන අරමුණු හා මූලධර්ම:

  • විස්තරයේ සම්පූර්ණත්වය සහ පැහැදිලිකම
  • විකලාංග නිර්මාණය,
  • ආරක්ෂාව,
  • කාර්යක්ෂමතාව
  • ස්ථිතික මාදිලි පරීක්ෂා කිරීම
  • ප්‍රකාරයෙන් ස්වාධීනව විග්‍රහ කිරීම
  • ස්වාධීන සම්පාදනය
  • ලූප් ප්‍රශස්තිකරණය
  • නිරූපණයන් - අවම සහ විශාල අක්ෂර කට්ටල වලින්

මෙම වැඩසටහන් ඇල්ගොල් 68 ජෙනී පරිවර්තකය සමඟ අත්හදා බලා ඇති අතර එය භාෂාව සම්පූර්ණයෙන්ම ක්‍රියාත්මක කිරීමකි.

නූතන ක්‍රමලේඛකයන්ට වෙනස් ලෙස පෙනෙන සමහර අංග නම් හිස් ප්‍රකාශයන්ට අවසර නැත. ඔබට ;සෑම තැනකම එකතු කළ නොහැක . ඔබට SKIPපැහැදිලිවම කිසිවක් නොමැති නම් ප්‍රකාශය භාවිතා කළ යුතුය. සමගාමී වැඩසටහන් කේතනය කිරීම ද ඉතා පහසුවෙන් සිදු විය. ඇල්ගොල් 68, විශේෂයෙන්, එසැක් , ඔඩ් , ෆයි වැනි පර්යන්ත ලෙස පසුපසට යන වචන භාවිතා කරයි .

කේත ලිවීම සඳහා භාෂාවට නිරූපණයක් තිබී ඇති අතර එය බොහෝ අකුරු තද අකුරින් භාවිතා කරන අතර අකුරු අකුරු ඇල අකුරු වලින් භාවිතා කරයි. එකල, බොහෝ විට තවමත්, කිසිදු සම්පාදකයෙකු නිර්මාණයේ මෙම අංගය ක්‍රියාත්මක කර නැත. ස්ට්‍රොපිං ප්‍රකාර භාවිතා කරමින් වැඩසටහන් වල විවිධ සංයුක්ත නිරූපණයන් සඳහා භාෂාව අවසර දී ඇත . මෙය 1960 ගණන්වල පරිගණකවල සොයාගත හැකි සීමිත අක්ෂර කට්ටල භාවිතයෙන් වැඩසටහන් සකස් කිරීමට ඉඩ ලබා දුන්නේය. කෙටි වැඩසටහන් කැබැල්ලක් සලකා බලන්න, එය පහත පරිදි දැක්වේ:

නම් මම < 0 නම් මඟ fi

ප්‍රයිම් ස්ට්‍රොපිං ප්‍රකාරයේ සම්පාදකයෙකු සඳහා මෙය සකස් කළ හැකිය :

'IF' I 'LT' 0 'THEN' 'SKIP' 'FI'

දී තිතක් stropping මාදිලිය මෙය වනු ඇත:

.IF I .LT 0 .THEN .SKIP .FI

දී නඩුව stropping මාදිලිය මෙය වනු ඇත:

IF i < 0 THEN SKIP FI

මම එක් භාෂාවක් සම්පාදනය කිරීමේ ක්‍රියාවලියක වැඩ කළ නිසාත්, වසර ගණනාවක් තිස්සේ එහි වැඩසටහන්කරණය කළ නිසාත් මට මෙම භාෂාව කෙරෙහි දැඩි ඇල්මක් ඇත.

කාර්යය 1

print (("ඇල්ගෝල් 68 1968 දී සාදන ලදී!", නව රේඛාව ))

මෙහිදී සැලකිල්ලට ගත යුතු කරුණ වන්නේ ද්විත්ව වරහන් ය. මෙයට හේතුව මුද්‍රණය යනු සියලු වර්ගවල එකමුතුවේ විචල්‍ය දිග අරාව වන තනි තර්කයක් ගන්නා ශ්‍රිතයකි. අභ්‍යන්තර වරහන් යනු අරාව සාදන්නා ය. තදින් ටයිප් කළ මෙම භාෂාවෙන් බහුමාපකය හසුරුවන ආකාරය මෙයයි.

ස්ට්‍රොපිං ප්‍රකාරයේදී:

print (("Algol 68 was made in 1968!", newline))


C:\>a68g HelloWorld.a68
Algol 68 was made in 1968!

කාර්යය 2

     int n ;
     කියවන්න (( n ));
     සඳහා i සිට 1 දක්වා n කරන්න
          සඳහා j සිට 1 දක්වා n කරන්න
               ¢ මෙතන අපි නම් සංක්ෂිප්ත වගන්තිය භාවිතා ¢
               මුද්රණය ((( j = 1 හෝ j = i හෝ j = n |
                    "N"
               |
                    ""
               )))
          පෙනී සිටියෝ ;
     මුද්‍රණය (( නව රේඛාව)))
     od

ස්ට්‍රොපිං ප්‍රකාරයේදී:

 INT n;
 read ((n));
 FOR i FROM 1 TO n DO
        FOR j FROM 1 TO n DO
            CO here we use an abbreviated IF clause CO
            print (( ( j = 1 OR j = i OR j = n |
                 "N"
            |
                 " "
            ) ))
        OD ;
        print ((newline))
    OD

C:\>a68g ASCIIart.a68
8
N      N
NN     N
N N    N
N  N   N
N   N  N
N    N N
N     NN
N      N

කාර්යය 3

     Al අපට ඇල්ගෝල් 68 හි අපගේම ක්‍රියාකරුවන් අර්ථ දැක්විය හැකිය ¢
     op % = ( int a , b ) int :
          (( b = 0 |
               a
          |
               b % ( a mod b )
          ));
     int i , j ;
     කියවන්න (( i , j ));
     මුද්‍රණය කරන්න (( i % j , newline ))

ස්ට්‍රොපිං ප්‍රකාරයේදී:

COMMENT we can define our own operators in Algol 68 COMMENT
OP % = ( INT a, b) INT:
    ((b = 0 |
        a
    |
       b % (a MOD b)
    ));
INT i,j;
read((i,j));
print(( i % j , newline))


C:\>a68g GCD.a68
4 12
         +4

7
වසර 30 කට වැඩි කාලයක් තුළ මා විසින් ලියන ලද සහ ක්‍රියාත්මක කරන ලද පළමු ඇල්ගොල් 68 වැඩසටහන් මේවා විය හැකිය. එය එතරම් චලනය වන බව මට පෙනී ගියේය, එය ඇත්තෙන්ම මා කඳුළු සලයි. මම කවදාවත් "හෙලෝ වර්ල්ඩ්!" වැඩසටහන එතරම් හැඟීම්බර විය හැකිය!
බ්‍රයන් ටොම්ප්සෙට් - 汤 莱恩

1
මම 60 දශකයේ භාෂාවන් දෙස බලා සිටි අතර BCPL, Simula, CORAL66, Fortran 66, PL / 1, SNOBOL4, POP-1 සහ තවත් පරාලයක් සමඟ සූදානම්ව සිටියෙමි, නීති රීති මා සතුව ඇති බව සොයා ගැනීමට පමණි අවුරුදු 5 ක භාෂාවක් බලා සිටීමට ... අවම වශයෙන් වෙනත් කෙනෙකුට සීසෑමට පොහොසත් විලි ඇත.
බ්‍රයන් ටොම්ප්සෙට් - 汤 莱恩

ෆෝට්රාන් 66 (පන්ච්කාඩ් හිංසනයේ මුලු අවුල), ඒපීඑල් (සුපිරි බල සංකේතවල අමුතු කැළඹීම) සහ ඇල්ගොල් 68 අතර ඇති වෙනස්කම් දැකීම ඇත්තෙන්ම සුන්දරයි. අද, ඔබ විවිධාකාර විවිධාකාර ප්‍රවේශයන් සොයා ගැනීම සඳහා එසෝටරික් භාෂා සොයා බැලිය යුතුය ... එවකට මෙය තරමක් ප්‍රධාන ධාරාව විය, එසේ නොවේ ද?
හැරීම නතර විය

ඇත්ත වශයෙන්ම, සංශෝධිත වාර්තාව 1976 වන තෙක් ප්‍රකාශයට පත් නොවීය. අවම වශයෙන් එය ස්ප්‍රින්ගර් ලබා දෙන ප්‍රකාශන හිමිකම් වර්ෂය වේ. මා සොයාගත් ස්කෑන් පරීක්ෂණයෙන් 1978 ගැන සඳහන් වේ.
රියාල්ටෝ මොනිකා

[1] ඒ. වැන් විජ්ගාර්ඩන් (සංස්.), බ්ලූ මයිලූක්ස්, 1.ඊඑල් පෙක්, සීබීඒ කොස්ටර්, ඇල්ගොරිතම භාෂාව පිළිබඳ වාර්තාව ALGOL 68, සංඛ්‍යා. ගණිතය. 14 (1969) 79-218; කිබෙනෙටිකා 6 (1969) සහ 7 (1970) හි ද. ඒ. 5 (1975) කොටස් 1-3 (බර්ලින්හි ස්ප්‍රින්ගර් විසින් නැවත මුද්‍රණය කරන ලද අතර ඇම්ස්ටර්ඩෑම් හි ගණිත කේන්ද්‍රය විසින් ගණිත මධ්‍යස්ථාන පත්‍රිකා 50 ලෙසද); SIGPLAN දැන්වීම් 12 (5) (1977)
බ්‍රයන් ටොම්ප්සෙට් - 汤 莱恩

17

1962 - ස්නොබෝල්

"StriNg Oriented and symBOlic Language". මුලදී සංකේතාත්මක ප්‍රකාශන පරිවර්තකය ලෙස හැඳින්වූ 'සෙක්සි', 1960 ගණන්වල යුගයේ නර්ඩ්ස් ඔවුන්ගේ රැකියා ඉදිරිපත් කිරීමේදී ලජ්ජාවට පත්වීම වැළැක්වීම සඳහා වෙනස් කළ යුතුව තිබුණි. සත්ය කථාව.

දේශීයව නූල් හා රටා සමඟ කටයුතු කළ හැකි පළමු භාෂාවන්ගෙන් එකක් මෙය විය. ඇත්ත වශයෙන්ම, SNOBOL හි පළමු අනුවාදය එහි එකම දත්ත සමුදාය ලෙස නූල තබා තිබුණි . ගණිතය පසුව විග්‍රහ කිරීමෙන් සිදු කරන ලදී. මූලික ක්‍රියාත්මක කිරීම IBM 7090 මත සිදු කරන ලදී. එය බොහෝ කලක් ගෙවී ගොස් ඇති බව පෙනේ, අවම වශයෙන් මට එය සොයාගත නොහැකි විය. මා සොයාගත්තේ එය විස්තර කරන මුල් කඩදාසි මෙන්ම නවීන පරිගණකයක ධාවනය කළ හැකි ජාවාහි SNOBOL3 පරිවර්තකයයි .

පළමු SNOBOL සතුව ඇත්තේ රටා ගැලපීම සහ මූලික ගණිතය පමණි. SNOBOL 3 පසුව ශ්‍රිත එකතු කර I / O වෙනස් කළ නමුත් වෙනත් ආකාරයකින් පසුපසට අනුකූල වන බව පෙනේ. SNOBOL 4 වාක්‍ය ඛණ්ඩය වෙනස් කළ අතර එතැන් සිට එය අයිකනය දක්වා වර්ධනය වූ අතර එමඟින් රටාව ගැලපෙන නමුත් වෙනත් ආකාරයකින් “සාමාන්‍ය” ක්‍රමලේඛන භාෂාවක් මෙන් පෙනේ.

මා විසින් ලියන ලද වැඩසටහන් භාවිතා කරන්නේ මුල් කඩදාසි වල විස්තර කර ඇති ක්‍රියාකාරිත්වය පමණි, එබැවින් ජාවා පරිවර්තකයාට ඒවා ක්‍රියාත්මක කිරීමට හැකි වන පරිදි මම SNOBOL3 ශෛලියෙන් කළ I / O හැරුණු විට මුල් SNOBOL සමඟ වැඩ කළ යුතුය. කඩදාසි වලින් බැලූ විට වෙනස වන්නේ SNOBOL1 විශේෂ SYSවිචල්‍යයක් සමඟ රටා ගැලපීම භාවිතා කරන අතර SNOBOL3 ආදාන සහ ප්‍රතිදාන විචල්‍යයන් භාවිතා කරන බවයි:

  • ආදානය:
    • 1 SYS .READ *DATA*
    • 3 DATA = SYSPPT
  • ප්‍රතිදානය:
    • 1 SYS .PRINT 'A STRING' AND VARIABLES
    • 3 SYSPOT = 'A STRING' AND VARIABLES

මෙම ආදේශක සෑදීමෙන් ඔබට 'සැබෑ' SNOBOL ලැබෙනු ඇත 1. ඇත්ත වශයෙන්ම ඔබට එය ක්‍රියාත්මක කළ නොහැක.

කාර්යය 1

START   SYSPOT = 'SNOBOL WAS MADE IN 1962!'

කාර්යය 2

මෙය ගණිතය, නූල් හැසිරවීම සහ ප්‍රවාහ පාලනය පෙන්වයි. SNOBOL3 EQසමානාත්මතාවය පරීක්ෂා කිරීම වැනි ප්‍රයෝජනවත් කාර්යයන් ඇත ; මුල් SNOBOL භාවිතා නොකළ නිසා මම ඒවා භාවිතා කර නැත.

* READ N FROM INPUT
START   SYSPOT = 'SIZE?'
        SZ = SYSPPT

* INITIALIZE
        CS = ''
        ROW = '0'

* OUTPUT PREVIOUS ROW AND START NEXT ONE
ROW     COL = '0'
        SYSPOT = CS
        CS = ''

COL     SUCC = 'N'
        EQ1 = COL
        FAIL = 'CHKE'
        EQ2 = '0'         /(EQUAL)
CHKE    FAIL = 'CHKR'
        EQ2 = SZ - '1'    /(EQUAL)
CHKR    FAIL = 'SPACE'
        EQ2 = ROW         /(EQUAL)

* CONCATENATE THE RIGHT CHARACTER TO THE CURRENT LINE         
SPACE   CS = CS ' '       /(NEXT)
N       CS = CS 'N'       /(NEXT)

* FOR NUMBERS, SUBSTRING MATCH IS ENOUGH IF IT IS KNOWN A<=B
NEXT    COL = COL + '1'
        COL SZ            /F(COL)
        ROW = ROW + '1'
        ROW SZ            /F(ROW)S(FIN)

* THERE SEEMS TO BE NO EQUALITY CHECK, JUST SUBSTRING MATCHING
* OF COURSE, EQ1 == EQ2 IFF EQ1 CONTAINS EQ2 AND VICE VERSA
* THIS ALSO ILLUSTRATES INDIRECTION
EQUAL   EQ1 EQ2           /F($FAIL)
        EQ2 EQ1           /S($SUCC)F($FAIL)

* OUTPUT THE LAST LINE
FIN     SYSPOT = CS     

කාර්යය 3

පළමුව, කම්මැලි එක. සටහන් කළ යුතු එකම දෙය නම් කුඩා-චෙක්පතකි, එය හරියටම නූල්-නැඹුරු SNOBOL සැබවින්ම කෙතරම්ද යන්න පෙන්වයි: (B - A) '-'එයින් අදහස් වන්නේ "BA හි ප්‍රති result ලයෙහි us ණ අගයක් තිබේද?". SNOBOL3 ටද කළ හැකිය LE(B,A), නමුත් SNOBOL 1 ට නොහැකි විය (අවම වශයෙන් කඩදාසි වල එය සඳහන් නොවේ).

* READ A AND B
START   SYSPOT = 'A?'
        A = SYSPPT
        SYSPOT = 'B?'
        B = SYSPPT

* GCD LOOP
STEP    '0' (A - B)          /S(DONE)
        (B - A) '-'          /S(AB)F(BA)
AB      A = A - B            /(STEP)
BA      B = B - A            /(STEP)
DONE    SYSPOT = 'GCD: ' A

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

* READ A AND B
START   SYSPOT = 'A?'
        A = SYSPPT
        SYSPOT = 'B?'
        B = SYSPPT

* CONVERT TO UNARY
        UNA.IN = A
        UNA.FIN = 'ADONE'          /(UNA)
ADONE   A = UNA.R
        UNA.IN = B
        UNA.FIN = 'BDONE'          /(UNA)
BDONE   B = UNA.R


* USE STRING MATCHING TO FIND GCD
STEP    '' B                       /S(GDONE)
MATCH   A B =                      /S(MATCH)
        C = B
        B = A
        A = C                      /(STEP)

* CONVERT BACK TO DECIMAL
GDONE   DEC.IN = A
        DEC.FIN = 'DONE'           /(DEC)
DONE    SYSPOT = 'GCD: ' DEC.R     /(FIN)

***************************** 
* DECIMAL TO UNARY SUBROUTINE
UNA     UNA.R =
UNA.DGT UNA.IN *.DGT/'1'* =        /F($UNA.FIN)
        .X = UNA.R
        UNA.R =
UNA.MUL .X *.Y/'1'* =              /F(UNA.ADD)
        UNA.R = UNA.R '##########' /(UNA.MUL)
UNA.ADD '1' .DGT                   /S(UNA.1)
        '2' .DGT                   /S(UNA.2)
        '3' .DGT                   /S(UNA.3)
        '4' .DGT                   /S(UNA.4)
        '5' .DGT                   /S(UNA.5)
        '6' .DGT                   /S(UNA.6)
        '7' .DGT                   /S(UNA.7)
        '8' .DGT                   /S(UNA.8)
        '9' .DGT                   /S(UNA.9)
        '0' .DGT                   /S(UNA.DGT)
UNA.1   UNA.R = UNA.R '#'          /(UNA.DGT)
UNA.2   UNA.R = UNA.R '##'         /(UNA.DGT)
UNA.3   UNA.R = UNA.R '###'        /(UNA.DGT)
UNA.4   UNA.R = UNA.R '####'       /(UNA.DGT)
UNA.5   UNA.R = UNA.R '#####'      /(UNA.DGT)
UNA.6   UNA.R = UNA.R '######'     /(UNA.DGT)
UNA.7   UNA.R = UNA.R '#######'    /(UNA.DGT)
UNA.8   UNA.R = UNA.R '########'   /(UNA.DGT)
UNA.9   UNA.R = UNA.R '#########'  /(UNA.DGT)

*****************************
* UNARY TO DECIMAL SUBROUTINE
DEC     DEC.R =
DEC.DGT '' DEC.IN                  /S($DEC.FIN)
        .X = DEC.IN
        DEC.IN =
DEC.DIV .X '##########' =          /F(DEC.ADD)
        DEC.IN = DEC.IN '#'        /(DEC.DIV)
DEC.ADD '' .X                      /S(DEC.0)
        '#' .X                     /S(DEC.1)
        '##' .X                    /S(DEC.2)
        '###' .X                   /S(DEC.3)
        '####' .X                  /S(DEC.4)
        '#####' .X                 /S(DEC.5)
        '######' .X                /S(DEC.6)
        '#######' .X               /S(DEC.7)
        '########' .X              /S(DEC.8)
        '#########' .X             /S(DEC.9)
DEC.0   DEC.R = '0' DEC.R          /(DEC.DGT)
DEC.1   DEC.R = '1' DEC.R          /(DEC.DGT)
DEC.2   DEC.R = '2' DEC.R          /(DEC.DGT)
DEC.3   DEC.R = '3' DEC.R          /(DEC.DGT)
DEC.4   DEC.R = '4' DEC.R          /(DEC.DGT)
DEC.5   DEC.R = '5' DEC.R          /(DEC.DGT)
DEC.6   DEC.R = '6' DEC.R          /(DEC.DGT)
DEC.7   DEC.R = '7' DEC.R          /(DEC.DGT)
DEC.8   DEC.R = '8' DEC.R          /(DEC.DGT)
DEC.9   DEC.R = '9' DEC.R          /(DEC.DGT)

FIN     START

විශිෂ්ට පසුබිම් වැඩ! 1961 සඳහා එතරම් නොවේ
- COMIT

@ බ්‍රයන් ටොම්ප්සෙට්- 汤 CO ඔබට COMIT වෙත සබැඳියක් / වෙබ් අඩවියක් තිබේද?
Λ̸̸


16

2010 - WTFZOMFG

WTFZOMFG යනු බ්‍රේන්ෆක් මත පදනම් වූ ව්‍යාකූල භාෂාවකි. එය 2010 දී ජේ සොන්ග්ඩාල් විසින් සාදන ලදී. "WTFZOMFG" යනු "එම කාර්යය කුමක්ද? සෙන් ප්‍රශස්තකරණය කළ අනිෂ්ට ගොනු ගොපර්ස්!" .

මෙන්න * නික්ස් පද්ධති සඳහා සම්පාදකය .

කාර්යය 1

'WTFZOMFG was made in 2010!\n"

කාර්යය 2

/&(-.N%3 >&>s-{-(-. ).N}>{-(-. ).N}_0 '\n")

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

සමාවන්න. මම පැහැදිලි කිරීම් ලිවීමට දක්ෂ නැත.

/                                           # read the number and store it in cell 0
 &                                          # copy it to cell 1
  (                                         # loop while cell 0 isn't 0
   -                                        # decrease the value of cell 0
    .N                                      # print "N"
      %3                                    # copy cell 0 to cell 3
                                            # a space must be added after the number. I don't know if it's a bug of the compiler or a feature.
         >                                  # move to cell 1
          &                                 # copy cell 1 to cell 2
           >                                # move cell 2
            s                               # let cell 2 = cell 2 - cell 3
             -                              # decrease the value of cell 2
              {                             # if cell 2 isn't 0
               -                            # decrease the value of cell 2
                (-. )                       # while cell 2 isn't 0, decrease it and print " "
                     .N                     # print "N"
                       }                    # end if
                        >                   # move cell 3
                         {                  # if cell 3 isn't 0
                          -                 # decrease the value of cell 3
                           (-. )            # while cell 3 isn't 0, decrease it and print " "
                                .N          # print "N"
                                  }         # end if
                                   _0       # move to cell 0
                                      '\n"  # print a newline
                                          ) # 

කාර්යය 3

/>>/(<<&>dm<s&>>%0 <&>)<<\

යුක්ලීඩියානු ඇල්ගොරිතම. WTFZOMFG ට mod සඳහා විධානයක් නොමැත, එබැවින් මට d(බෙදීමට), m(ගුණ කිරීමට) සහ s(අඩු කිරීමට) භාවිතා කිරීමට සිදුවේ .


16

2009 - යන්න

Go යනු ගූගල් විසින් වැඩි දියුණු කරන ලද ක්‍රමලේඛන භාෂාවකි. සංවර්ධනය 2007 දී ආරම්භ වූ නමුත් 2009 නොවැම්බර් මාසයේදී ගෝ නිවේදනය කරන ලදී.

Go යනු සංක්ෂිප්තභාවය, සරල බව සහ ආරක්ෂාව අවධාරණය කරන C මගින් බලපෑමට ලක්වූ සංඛ්‍යාත්මකව ටයිප් කළ භාෂාවකි.

කාර්යය 1:

package main
import "fmt"

func main(){
    fmt.Println("Go was made in 2009!")
}

පළමු පේළිය කේතයේ පැකේජය ප්‍රකාශ කරයි. එක් පේළියක් මුද්‍රණය කිරීම වැනි සරල උදාහරණයක් පවා එක් පැකේජයක කොටසක් විය යුතුය. ක්‍රියාත්මක කළ හැකි සෑම විටම හැඳින්වේ main.

කාර්යය 2:

package main

import (
        "fmt"
        "strings"
)

func main(){
    var n int
    fmt.Scan(&n)

    for i := 0; i < n; i++ {
        a := make([]string, n, n)
        for j := 0; j < n; j++ { a[j] = " " }

        a[0] = "N"
        a[i] = "N"
        a[n-1] = "N"

        s := strings.Join(a, "")
        fmt.Println(s)
    }
}

Go හි තරමක් සංක්ෂිප්ත විචල්‍ය ප්‍රකාශයක් ඇත ( i := 0සමාන වේ var i int = 0), සහ සම්පාදකයා වර්ගය තීරණය කරයි. මෙය සාමාන්‍යයෙන් ගතික භාෂාවල බහුලව දක්නට ලැබෙන ලක්ෂණයකි. මෙම කෙටි අංකනය භාවිතා කරමින් විචල්‍යයන්ට ( f := func(x int) int {/* Code */}) ශ්‍රිත පැවරීම සහ වසා දැමීම් නිර්මාණය කිරීමද පහසුය .

කාර්යය 3:

package main

import "fmt"

func gcd(a, b int) int {
    for b != 0 {
        a, b = b, a%b
    }
    return a
}

func main(){
    var a, b int
    fmt.Scan(&a)
    fmt.Scan(&b)

    fmt.Println(gcd(a, b))
}

මෙන්න ඔබට a, b = b, a%bසින්ටැක්ස් දැක ගත හැකිය , එය ඇත්තෙන්ම හොඳයි. මම හරියටම නම නොදනිමි, නමුත් පයිතන්හි එය ටුපල් ඉවත් කිරීම ලෙස හැඳින්වේ. එකම ආකාරයකින් භාවිතා කිරීමෙන් ඔබට ශ්‍රිතයකින් බහු අගයන් ආපසු ලබා දිය හැකිය (func f() (int, string) { return 42, "Hallo"} ) .

මෙම කේතයේ සිදුවන තවත් දෙයක් වන්නේ ලූපයයි. Go හි ඇති එකම පුඩුවක් for for loop වේ. අතර-ලූප හෝ කළ යුතු අතරතුර ලූප නොපවතී. නමුත් ඔබට පහසුවෙන් කාල ලූපයට for condition {}හෝ අනන්ත පුඩුවට සමාන ප්‍රමාණයක් නිර්මාණය කළ හැකිය for {}.


16

1965 - ඇට්ලස් ඔටෝකෝඩ්

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

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

AA හි සිත්ගන්නාසුලු ලක්ෂණයක් වන්නේ එය විශේෂයෙන් නිර්මාණය කර ඇත්තේ ෆ්‍රීඩන් ෆ්ලෙක්සොව්රයිටර් ලෙස හඳුන්වන ආදාන උපාංගයක් සඳහා වන අතර අක්ෂර කට්ටලය එම උපාංගය පිළිබිඹු කරයි. විශේෂයෙන් වෙන් කර ඇති වචන අවධාරනය කර ඇත.

කාර්යය 1

b̲e̲g̲i̲n̲
i̲n̲t̲e̲g̲e̲r̲ y
y = 1965
c̲a̲p̲t̲i̲o̲n̲ ඇට්ලස් s / Autocode s / was s / made s / in; මුද්‍රණය (y, 4,0); නව රේඛාව
s̲t̲o̲p̲
e̲n̲d̲_o̲f̲_p̲r̲o̲g̲r̲a̲m̲

කාර්යය 2

ආරම්භ
පූර්ණ සංඛ්යාමය n
(n) කියවීමට
අදහස් මෙම චක්රය ප්රකාශය හුරු පුරුදු DO වේ
චක්රය i = 1, 1, n
   චක්රය j = 1, 1, n
     j = 1 හෝ j = i හෝ j = n පසුව නම්
       ශීර්ෂ පාඨය එන්
     අදහස් එහෙත් නම්
     u̲n̲l̲e̲s̲s̲ j = 1 o̲r̲ j = i o̲r̲ j = n t̲h̲e̲n̲
       c̲a̲p̲t̲i̲o̲n̲ s /
   r̲e̲p̲e̲a̲t̲
   newline
r̲e̲p̲e̲a̲t̲ නම් වෙනත් වගන්තියක් නොමැති බැවින් ප්‍රකාශය භාවිතා කළ යුතුය.
නැවතුම්
end_of_program

කාර්යය 3

ආරම්භ
(අ, ආ පූර්ණ සංඛ්යාමය) පූර්ණ සංඛ්යාමය ෙල gcd
    a = 0 නම් ප්රතිඵලය = ආ
    ආ = 0 නම් = ප්රතිඵලයක්
    ප්රතිඵලයක් = gcd (ආ, a - ආ)
    අවසන්

පූර්ණ සංඛ්යාමය i, j
කියවන්න (i, j)
මුද්රණය (gcd (i, j), 4,0); newline
s̲t̲o̲p̲
e̲n̲d̲_̲o̲f̲_̲p̲r̲o̲g̲r̲a̲m̲


යටි ඉරි ඇඳීම සියලු බ්‍රව්සර් මත නිවැරදිව ලබා ගැනීම දුෂ්කර ය. එය නිසියාකාරව දර්ශනය නොවන්නේ නම් - වෙනත් බ්‍රව්සරයක් උත්සාහ කරන්න. ඔබ එය කරන්නේ කෙසේදැයි හොඳින් දන්නේ නම් මට දන්වන්න!
මැන්චෙස්ටර් MUSS ආදි ශිෂ්‍ය

බාෂ් (ksh හෝ zsh) වැනි ශ්‍රිතයක් නිර්මාණය කළ හැකිය: underline is a function underline () { while (($#)); do a=$1; for ((i=0; i<${#a}; i++)) do printf '%s\u0332' "${a:i:1}"; done; printf " "; shift; done; echo }ඉන්පසු underline begin integer stopඅවිනිශ්චිත සමානකම් ලබා ගැනීමට කරන්න. ඉන්පසු පිටපත් කර අලවන්න.
අයිසැක්

15

2012 - ටයිප්ස්ක්‍රිප්ට්

ටයිප්ස්ක්‍රිප්ට් යනු මයික්‍රොසොෆ්ට් විසින් සංවර්ධනය කර නඩත්තු කරන නිදහස් හා විවෘත කේත ක්‍රමලේඛන භාෂාවකි.

ප්‍රධාන ඉලක්කය: ඕනෑම බ්‍රව්සරයක්. ඕනෑම සත්කාරක සමාගමක්. ඕනෑම මෙහෙයුම් පද්ධතියක්. විවෘත මූලාශ්‍රය. එය 2012 ඔක්තෝම්බර් මස නිකුත් කරන ලදී

හෙලෝ ටයිප්ස්ක්‍රිප්ට්

Task1(name:string,year:number) {
    return name + " was made in "+ year +"!";
}

ASCII චිත්‍ර

Task2(n:number,separator:string,space:string) {
    var result:string = "";
    for (var k = 0; k < n; k++)
    {
        for (var j = 0; j < n; j++)
        {
            var i = ((n * k) + j) % n;
            result+=(i == 0 || i == n - 1 || i == k) ? "N" : space;
        }
        result+=separator;
    }
    return result;
}

GCD

Task3(a:number,b:number) {
    while (a != 0 && b != 0)
        {
            if (a > b)
                a %= b;
            else
                b %= a;
        }

        if (a == 0)
            return b;
        else
            return a;
}

සබැඳිව එය උත්සාහ කරන්න , සහ screencast එය.


4
ඔබට එක් දෙයක් සඳහන් කිරීමට අමතක විය: ටයිප්ස්ක්‍රිප්ට් යනු ජාවාස්ක්‍රිප්ට් හි සුපර්සෙට් එකක් වන අතර එය සින්ටැක්ස් වෙනස්කම් කිහිපයක් ඇති අතර (?) ශක්තිමත්-ටයිප් කළ විචල්‍යයන් සහ තර්ක වලට ඉඩ දෙයි.
ඉස්මයිල් මිගෙල්

1
දෙවියනේ, එම්.එස්.
මෙගා මෑන්

15

2011 - ඩාර්ට්

ඩාර්ට් යනු ගූගල් විසින් සංවර්ධනය කරන ලද විවෘත මූලාශ්‍ර ක්‍රමලේඛන භාෂාවකි, එය ජාවාස්ක්‍රිප්ට් වෙනුවට ආදේශකයක් ලෙස සංවර්ධනය කර ඇත (එය ජාවාස්ක්‍රිප්ට් සමඟ සම්පාදනය කරයි). එය ගූගල් විසින් 2011 දී GOTO සමුළුවේදී එළිදක්වන ලදී.

"හෙලෝ වර්ල්ඩ්!" ප්‍රභේදය:

main() {
  print('Dart was made in 2011!');
}

ASCII Art N:

බ ut ට්ෆෝර්ස් ක්‍රමය, 0 (n²) දී ධාවනය වේ, නමුත් ඔබ යෝධ අංකයක් භාවිතා නොකරන්නේ නම් එය ඇත්ත වශයෙන්ම වැදගත් නොවේ.

asciiN(int number){
    if(number == 1){
        print('N');
    }else{
        for(var i = 1; i <= number; i++){
            String currentLine = "";
            for(var j = 1; j <= number; j++){
                if(j==1 || j == number || j == i){
                    currentLine = currentLine + "N";
                }else{
                    currentLine = currentLine + " ";
                }
            }
            print(currentLine);
        }
    }
}

GCD

සැණෙකින් ගෙන එන ලද සරල යුක්ලිඩ් ක්‍රමය! ඉහත උදාහරණය.

int gcd(int first, int second){
if(second > first){
   return gcd(second, first);
    }else{
        if(first == 0){
            return second;
        }else{
            if(second ==0){
                return first;
            }else{
                return gcd(second, first-second);
            }
        }
    }
}

5
ඔබට (n ASCII කලාවක් O (n²) ට වඩා අඩුවෙන් ප්‍රතිදානය කළ හැකි යැයි මම නොසිතමි.
Paŭlo Ebermann

@ PaŭloEbermann මට විශාල O අංකනය හෝ සංකීර්ණත්වය ගණනය කරන්නේ කෙසේද යන්න ගැන එතරම් හුරුපුරුදු නැත, නමුත් ජූලියා උදාහරණය පෙනෙන්නේ එය O (n²) නොවන බවයි.
Nzall

Lex ඇලෙක්සා. Println () ශ්‍රිතය අක්ෂර n පේළියක් මුද්‍රණය කරයි. මම හිතන්නේ ශ්‍රිත ඇමතුම ක්‍රියාත්මක කිරීමට අවම වශයෙන් O (n) කාලයක් අවශ්‍ය වේ. ලූපය තුළ, එබැවින් සමස්ත වැඩසටහන සඳහා O (n²).
Paŭlo Ebermann

Lex ඇලෙක්සා. මම හිතන්නේ එබර්මාන් කතා කරන්නේ ඔබේ මුද්‍රණ ශ්‍රිතයේ N string concatenation මෙහෙයුම් ඇති බවයි. අපි දෙදෙනාම අපගේ කාර්යයන් වලදී නූල් සම්මුතියක් නොකරමු. අභ්‍යන්තර ලූප පුනරාවර්තනයකට වරක් මම ඒවා කරන්නෙමි, ඔබ ඒවා සෑම මුද්‍රණ යන්ත්‍රයක් සඳහාම කරන්න.
Nzall

1
මෙය අසයි කලාවක් නොවේ නම් එය එන් (එන්) පෙන්වීම (තිරයට පේළි 3 ක් අඳින්න, සෑම පේළියක්ම ඕ (එන්) එබැවින් ඕ (එන්) සංකීර්ණතාව) වේ. නැතහොත්, ඔබට කිව හැකිය, N විදැහුම්කරණයට O (N) සංකීර්ණතාවයක් ඇත ...
hehe

15

2015 - මෆින් එම්.සී.

මෆින් එම්සී යනු 2015 පෙබරවාරි මස මැද භාගයේදී ෆ්‍රෑන්ක් පෝර්චර් ( http://franckys.com ) විසින් රචිත ටියුරින්-සම්පූර්ණ, විහිලු (නමුත් බැරෑරුම්) ක්‍රියාකාරී හා අවම සාර්ව භාෂාවක් වන අතර එය බල ගැන්වීම සඳහා (ඉක්මන්) මෙවලමක් ලෙස අවශ්‍ය නොවේ. : නියමු එකම ඉදිරි-අන්තයක් පාලකය ලෙස භාවිතා කිරීමට හා නව ටාහිටියානු විලාසිතා සන්නාමය සඳහා Prestashop මත පදනම් වෙළෙඳ අඩවිය සමග සම්බන්ධ සියලු තොග-ආශ්රිත මෙහෙයුම් පැදවීමට පැතුරුම්පත් කැරැල්ල ටහිටි ( http://mutinytahiti.com - ඉක්මනින් විය දියත් කරන ලදි).

Muffin MC යනු MU කුඩා F unctional F lexible IN line M acro C සඳහා සංක්ෂිප්තයකි ommand භාෂාවේ සංක්ෂිප්තයකි.

අපගේ අවශ්‍යතා සපුරාලීම සඳහා, මෆින් එම්සී හි මූලික අංග සැලසුම් කර ඇත්තේ නම්‍යශීලී හා කාර්යක්ෂම 1 වන පන්තියේ ඉන්ටරේටර් , කම්මැලි-ඇගයීම , බහු-ෆන්ක්ටර් , නූල්-නිෂ්පාදන වැනි අර්ථකථන ව්‍යුහයන් වටා ය .

මෆින් එම්සී එහි මූලයන් (ප්‍රායෝගික) ක්‍රියාකාරී ක්‍රමලේඛන, එෆ්ලිස්ප් සහ පර්ල් වලින් ඇද ගනී. එය පුනරාවර්තනයට පූර්ණ සහය දක්වයි (කිසිදු ප්‍රශස්තිකරණයකින් තොරව), ගතිකව ටයිප් කර ගතිකව විෂය පථයට (නොගැඹුරු බන්ධන). මූලික දත්ත වර්ග පරමාණු (පරමාණු, නූල්, ඉලක්කම්) හැරුණු විට එය සිය පරිශීලකයින්ට එක් දත්ත ව්‍යුහයක් පමණක් ලබා දෙයි: ලැයිස්තු!

මෆින් එම්සී ලැයිස්තු අර්ථ නිරූපණයන් (යම් ආකාරයක) බලය සකසන ලද අර්ථ නිරූපණයන් මත ණයට ගනී , එනම්:

  1. සියලුම මෆින් එම්සී මෙහෙයුම් ලැයිස්තුවක් ලබා දෙයි, සමහර විට හිස් ය.
  2. ඕනෑම තනි ලැයිස්තු මූලද්‍රව්‍යයකට ප්‍රවේශ වීම සැමවිටම එම මූලද්‍රව්‍යයෙන් සාදන ලද එක්-වටිනාකම් ලැයිස්තුවක් ලබා දෙයි (එය සිංගල්ටන් ලෙස සිතන්න).
  3. හිස් ලැයිස්තුව යනු ලැයිස්තු මෙහෙයුම් වල උදාසීන අංගයකි.

මෙය සමඟි කිරීම සඳහා, පහත සඳහන් දෑ උපකාරී වේ:

  • විශාලතම කාඩිනල් බව ඇති ලැයිස්තුවේ බල කට්ටලයේ අංගයක් ලෙස යමෙකුට ලැයිස්තුවක් දෘශ්‍ය කළ හැකිය.
  • ලැයිස්තුවේ මූලද්‍රව්‍යයේ ලැයිස්තුවේ බල කට්ටලයේ මූලද්‍රව්‍යය දෘශ්‍යමාන කරන්න.
  • හිස් ලැයිස්තුවක් හිස් කට්ටලයක් ලෙස දර්ශනය කරන්න; එනම්, හිස් කට්ටලයේ බල කට්ටලයේ එකම අංගයයි.

එනිසා හිස් ලැයිස්තු මූලද්‍රව්‍යයකට ප්‍රවේශ වීමෙන් හිස් ලැයිස්තුව ලැබෙනු ඇත, දෝෂයක් නොවේ! ඇත්ත වශයෙන්ම, මෆින් එම්.සී.බොහෝ සාම්ප්‍රදායික මෙහෙයුම් වල අර්ථ නිරූපණය ඒ ආකාරයෙන් හැකි තරම් දෝෂ කිහිපයක් විසි කිරීමට දැඩි උත්සාහයක් දරයි.

කාර්යය 1

#(say "MuffinMC was born in 2015 out of necessity !")

#(...)යනු මෆින් එම්සී මැක්‍රෝ විධානයයි say.

#(say 1 2 3 ...) ක්‍රියාකාරී ලෙස සමාන වේ map {say $_} (1,2,3,...)

කාර්යය 2

ශ්‍රිතය නිර්වචනය කරන්න ascii-art():

=(ascii-art
    '( =(*  x   #(2- $(_1))
        I   I( *($(x) " ") N)
            foo '( #(. #(I $(x))) ))
    #(say ?( #(== $(_1) 1) N "N#(map foo #(.. 1 $(_1)))N" ))
 ))

Ascii-art()කෙටිම වැඩ කරන ආකාරය (බයිට් 88):

=(f'(=(* x#(2-)I I(*($(x)" ")N)g'(#(.#(I$(x)))))#(say?(#(==$(_1)1)N"N#(map g#(..))N"))))
  • =(var val...)යනු විචල්‍යයක් නිර්වචනය කිරීමට හෝ එය නැවත පැවරීමට මෆින් එම්සී මැක්‍රෝ විධානයයි .

  • $(var)යනු විචල්‍යයක අගයට ප්‍රවේශ වීම සඳහා වන මෆින් එම්සී මැක්‍රෝ විධානයයි . $(v1 v2 ...)එකවර බොහෝ විචල්‍යයන්ට ප්‍රවේශ වීම සඳහා එය ස්වභාවිකවම පෝරමය පිළිගනී .

  • =(* var1 val1 var2 val2 ...)සමාන්තර පැවරුම් සමඟ කටයුතු කිරීම සඳහා මෆින් එම්සී මැක්‍රෝ විධානයෙහි දිගුව වේ =(...).

  • විචල්‍යයන් _1, _2, ... ගතිකව විෂය පථය (නොගැඹුරු බන්ධන යාන්ත්‍රණය) වන අතර ස්වයංක්‍රීයව ශ්‍රිතයේ තර්ක සමඟ බැඳීමට සකසා ඇත. පර්ල් 5 වෙතින් ණයට ගත්, පද්ධති විචල්‍යයන් #(තර්ක ගණන) සහ @(තර්ක ලැයිස්තුව) ස්වයංක්‍රීයව සකසා ඇත.

  • කාර්යයන් යනු ඕනෑම මෆින් එම්සී ප්‍රකාශ ගණනකට බැඳී ඇති විචල්‍යයන්ය .

මෙම සිත්ගන්නා විසඳුම ලැබෙන්නේ ස්වාභාවික මෆින් එම්සී බිල්ට් විශේෂාංග දෙකක් ඒකාබද්ධ කිරීමෙනි :

  1. පසුකාලීනව ක්‍රියාකාරී ස්වරූපය සමඟ භාවිතා කරන පාපැදි-ඉරේටර නිර්වචනය කිරීමට මෆින් එම්සී I(...) මැක්‍රෝ විධානය #(my-iterator want-number-of-values),

  2. මෙම මෆින් මහ නගර string-නිෂ්පාදන කිසිදු සංගීත ලබා ඇති, ඉදිකිරීමක්, ස්වභාවික විචල්ය අන්තර්නිවේෂණය දිගුවක්, "F1 F2 F3..."එෆ් කොහේද, මම ගේ මෆින් එක්කෝ මහ නගර string literals හෝ මෆින් මහ නගර ලෙස බොහෝ නූල් ලෙස සටහන් වනු ඇත, සාර්ව විධාන (කාර්ය ආකාර හෙවත්) නිෂ්පාදන කාදිනල් (F1) x කාර්දිනල් (F2) x විසින් ලබා දී ඇත.

නිදසුනක් ලෙස, අගයන් 2 ක් ඇති xa විචල්‍යය, a සහ b යැයි කියනු ලැබේ, සහ y අගයන් 3 ක් ඇති තවත් විචල්‍යයක් යැයි කියනු ලැබේ, 1 2 3, එවිට නූල් ඇගයීම "x=$(x) y=$(y))"මඟින් විවිධ අගයන් 6 ක් නිපදවනු ඇත, එනම්, එම අනුපිළිවෙලට:

  • "x = ay = 1"
  • "x = ay = 2"
  • "x = ay = 3"
  • "x = by = 1"
  • "x = by = 2"
  • "x = by = 3"

මෙය MUTINY ව්‍යාපෘතියේ අතිශයින්ම ප්‍රියමනාප අංගයක් වන Muffin MC නිර්මාණය කර ඇත.

එය ධාවනය කරන්න!

#(ascii-art 1)

N


#(ascii-art 3)

N N  
NNN  
N N 


#(map '( #(ascii-art $(_1))) 5 7 9)

N   N
NN  N
N N N
N  NN
N   N

N     N
NN    N
N N   N
N  N  N
N   N N
N    NN
N     N

N       N
NN      N
N N     N
N  N    N
N   N   N
N    N  N
N     N N
N      NN
N       N

එය ක්‍රියාත්මක වන්නේ කෙසේද?

අපගේ ඇල්ගොරිතම පහත සඳහන් කරුණු මත පදනම් වේ:

Ascii-art (n) වෙත ඇමතුමක් ලබා දී, {n = 2p + 1 | p නිඛිල, p> = 0}, උත්පාදනය කිරීමේ කලාව අක්ෂර n කින් සමන්විත වන අතර, ඒ අතර, වම් හා දකුණ යන දෙක ස්ථාවර වන අතර සෑම විටම එක හා සමාන වේ: 'N'. මැද නූල් පමණක් නිපදවීමේ ගැටළුව අවම කිරීමට මෙය ඉඩ දෙයි. නිදසුනක් ලෙස, n = 5 ලබා දී ඇති විට, පහත දැක්වෙන මැද නූල් 5 නිපදවීමට අපි වල්පැලෑටි තබන්නෙමු, ඒවා සෑම එකක්ම n-2 අක්ෂර වලින් සාදා ඇත (වඩා හොඳ දෘශ්‍යකරණය සඳහා අපි අවකාශය '_' මගින් ප්‍රතිස්ථාපනය කර ඇත):

    The 5 strings :
        _ _ _
        N _ _ 
        _ N _
        _ _ N
        _ _ _

    can be seen as resulting from splitting in groups of 3 characters
    the following infinite sequence of 4 characters :


        /---- < _ _ _ N > ----\
       |                       |
        \---------------------/    


    which, once unfolded, yields the infinite ruban : 

        _ _ _ N _ _ _ N _ _ _ N _ _ _ N _ _ _ N _ _ _ N ...
              ^     ^     ^     ^     
        _ _ _ |     |     |     |
              N _ _ |     |     | 
                    _ N _ |     |
                          _ _ N |
                                _ _ _
  • ('_' '_' '_' 'N')3 කාණ්ඩ 5 කින් මූලද්‍රව්‍ය 4 අනුක්‍රමය හරහා පාපැදි පැදීමෙන් එවැනි මැද නූල් පහසුවෙන් නිපදවිය හැකිය ; n ලබා දී ඇති විට, ශ්‍රිතයේ ආදානය, එවැනි අනුක්‍රමය n-2 අක්ෂර වලින් සාදා ඇති අතර '_'පසුව අක්ෂරයෙන් 'N'. මෙම අනුක්‍රමය හරහා බයිසිකල් පැදීම සඳහා මෆින් එම්සී I(sequence) බිල්ට්-ඉරේටරය තුළ අනුක්‍රමය කාවැද්දීම හැර වෙන කිසිවක් අවශ්‍ය නොවේ (එහි ආරම්භක අගයන් අනුපිළිවෙලට වඩා සදහටම චක්‍රීය කරන අනුකාරකය).

  • ඉන්පසුව අපි සරලවම n-2 දිග මැද නූල් නිපදවමු. අපේක්ෂිත මැද නූල නිපදවීම සඳහා එකට එකතු වී ඇති එහි ඊළඟ n-2 අගයන් (n - 2 අක්ෂර) අපට ලබා දෙන ලෙස අපගේ අනුකාරකවරයාගෙන් ඉල්ලා සිටිමු.

  • ඉහත ක්‍රියාවලියට වඩා n ගුණයක් පුනරාවර්තනය කිරීමෙන් n ප්‍රති results ල එකතු කිරීම සඳහා සිතියමක් භාවිතා කරමින් (n-2 අක්ෂරවල නූල්) n මැද නූල් නිපදවනු ලැබේ.

  • අවසාන නූල් නිෂ්පාදනය කිරීම සඳහා අපි තවත් ප්‍රබල මෆින් එම්සී බිල්ට් ඉදි කිරීම්, එනම් නූල් නිෂ්පාදනය භාවිතා කරමු : "N#(map...)N".

  • ඒක තමයි!

    Commented script  
    
    =(ascii-art                    Define the 'ascii-art' variable to hold
                                   the function's definition.
                                   When called, its argument, the actual
                                   value of n, will be bound to the system
                                   variable _1, accessed as $( _1 ).
    
        '(                         '(...) quote macro-command -- protects 
                                   its arguments, here the function 
                                   definition, from being evaluated.
                                   We want to keep it literally for further evaluation.
    
           =(*                     =(*...) // assignment macro-command.
                                   Similar to the Lisp (let (...)...),
                                   not the let* !
    
               x #(2- $(_1))       Define the variable x to hold the value 
                                   n-2.   
    
               I I(                Define I to be an iterator over the 
                                   the x+1 characters sequence :
                    *( $(x) " ")   . x white-space characters
                    N              . 1 'N' character (here the atom N)
                 )
    
               foo '(              Define the variable foo as a function 
                      #(.          to catenate ( #(. s1...) )
                         #(I $(x)) the iterator's next x elements.
                       )            
               )
           )                       End of =(*...
    
        #(say                      Print each element of:
           ?(                      If
              #(== $(_1) 1)        n equals 1
      N                    the atom N,
      "N#(map foo #(.. 1 $(_1)))N" else the n strings as a string-product 
                                   resulting from foo-computing the  
           )                       n middle-strings.
         )
     ))
    

කාර්යය 3

ශ්‍රිතය නිර්වචනය කරන්න gcd():

=(gcd '( ?( #(== $(_2) 0)
        $(_1)
            #(self $(_2) #(mod $(_1) $(_2)))) ))

gcd()'S සැබෑ කෙටිම ආකෘති පත්රය (- 2bytes Rodolvertice ස්තුති ලබා 37 bytes)

=(g'(?(#(z$(_2))$(_1)#(g$(_2)#(mod)))))

එය ධාවනය කරන්න!

#(gcd 225 81)

අස්වැන්න 9.

ඒක තමයි.

ලස්සන ක්‍රීඩාවට ස්තූතියි, සමහරවිට ඔබේ උනන්දුව සඳහා. සෙල්ලම් කිරීමට, භාවිතා කිරීමට හෝ එය දිගු කිරීමට කැමති ඕනෑම කෙනෙකුට භාෂාව ලබා ගත හැකිය. එය ඉල්ලන්න, මම එය ඇතුළට යැවීමට සතුටු වෙමි.

චියර්ස්

ෆ්රෑන්ක්


පීඑස්. මෆින් එම්සී හි වර්තමාන ක්‍රියාත්මක කිරීම පර්ල් 5 හි ඇත. මූලාශ්‍ර කේතය අදහස් දැක්වීම ඇතුළුව නූතන පර්ල්හි පේළි 2000 ක් පමණ වන අතර එය ප්‍රතිගාමී නොවන පරීක්ෂණ කට්ටලයක් සමඟ බැඳී ඇති අතර එය මෆින් එම්සී ඉදිකිරීම් සහ අර්ථකථන ඉගෙන ගැනීමට මහත් වේ .


ඇත්තෙන්ම හොඳයි! Ascii-art හි කෙටිම ස්වරූපයට කෙටි ශ්‍රිත නාමයක් ඇත, නමුත් GCD කෙටිම නොවේ. මෙය හිතාමතාමද, මන්ද එසේ නොවේ නම් ඔබට තවත් බයිට් 2 ක් කපා දැමිය හැකිය. +1
රොඩොල්ෆිටෝ

ෂුවර්, එය හිතාමතා ය. මා කළ යුතුද? ඔව්, අපි එය කරමු;) තනතුරට ස්තූතියි, සහ ඔබේ අගය කිරීම.
ෆ්‍රෑන්ක් පෝර්චර්

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.