මෙම අංකය ප්‍රමුඛද?

204

එය විශ්වාස කරන්න හෝ නොවන්න, සරල ප්‍රාථමික පරීක්ෂණයක් සඳහා අපට තවමත් කේත ගොල්ෆ් අභියෝගයක් නොමැත . එය වඩාත් සිත්ගන්නාසුලු අභියෝගයක් නොවිය හැකි අතර, විශේෂයෙන් “සුපුරුදු” භාෂාවන් සඳහා, එය බොහෝ භාෂාවලින් අවිධිමත් විය හැකිය.

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

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

කාර්ය

ලියා පළ පූර්ණ වැඩසටහන තදින්ම ධන නිඛිලයක් ලබා දී ඇති n ආදාන ලෙස, යන්න තීරණය n ප්රථමක වන අතර මුද්රණය කරයි truthy හෝ falsy අගය අනුව.

මෙම අභියෝගයේ අරමුණ සඳහා, නිඛිලයකට හරියටම ධනාත්මක බෙදුම්කරුවන් දෙදෙනෙකු සිටී නම් එය ප්‍රමුඛ වේ. මෙය එකම ධනාත්මක බෙදුම්කරු වන 1 බැහැර කරන බව සලකන්න .

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

ආදානය

  • ඔබේ භාෂාවට STDIN වෙතින් කියවීමට, විධාන රේඛා තර්ක හෝ වෙනත් විකල්ප පරිශීලක ආදානයක් පිළිගැනීමට හැකි නම්, ඔබට නිඛිලය එහි දශම නිරූපණය, ඒකීය නිරූපණය (ඔබේ අභිමතය පරිදි අක්ෂරයක් භාවිතා කිරීම), බයිට් අරාව (විශාල හෝ කුඩා එන්ඩියන්) හෝ තනි බයිට් (මෙය ඔබේ භාෂාවන් විශාලතම දත්ත වර්ගය නම්).

  • ඔබේ භාෂාවට කිසිදු ආකාරයක පරිශීලක ආදානයක් පිළිගැනීමට නොහැකි නම් (සහ පමණක් නම්), ඔබේ වැඩසටහනේ ආදානය දෘඩ කේත කළ හැකිය.

    මෙම අවස්ථාවේ දී, දෘ c කේත කරන ලද නිඛිලය පහසුවෙන් හුවමාරු කර ගත යුතුය. විශේෂයෙන්, එය සමස්ත වැඩසටහනේ එකම ස්ථානයක පමණක් දිස්විය හැකිය.

    ලකුණු කිරීමේ අරමුණු සඳහා, ආදාන 1 ට අනුරූපී වැඩසටහන ඉදිරිපත් කරන්න .

ප්‍රතිදානය

ප්‍රතිදානය STDOUT හෝ ආසන්නතම විකල්පයට ලිවිය යුතුය.

හැකි නම්, ප්‍රතිදානය තනිකරම සත්‍ය හෝ ව්‍යාජ අගයකින් සමන්විත විය යුතුය (හෝ එහි නූල් නිරූපණය), විකල්පයක් ලෙස තනි නව රේඛාවක් අනුගමනය කළ යුතුය.

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

අතිරේක නීති

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

  • සාමාන්‍යයෙන් (නමුත් අවශ්‍ය නොවේ) UTF-8 බොහෝ භාෂාවලින් ඉදිරිපත් කිරීම් සුදුසු පූර්ව පවතින කේතන ක්‍රමයකින් බයිට් වලින් ලකුණු කරනු ලැබේ .

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

    ෆෝල්ඩර වැනි සමහර භාෂා ලකුණු කිරීමට ටිකක් උපක්‍රමශීලී ය. සැකයක් ඇත්නම්, කරුණාකර මෙටාගෙන් විමසන්න .

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

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

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

  • තිළැලි primality පරීක්ෂා කටයුතු කරන ඉඩ දුන්නා. මෙම අභියෝගය එක් එක් භාෂාවෙන් හැකි කෙටිම විසඳුම ලැයිස්තුගත කිරීම සඳහා අදහස් කරන අතර, එබැවින් ඔබේ භාෂාවෙන් සාදන ලද එකක් භාවිතා කිරීම කෙටි නම්, ඒ සඳහා යන්න.

  • ඒවා කලින් අවලංගු කර නොමැති නම් , http://meta.codegolf.stackexchange.com/q/1061 ඇතුළුව සියලුම සම්මත කේත-ගොල්ෆ් නීති අදාළ වේ.

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

නාමාවලිය

මෙම ලිපියේ පතුලේ ඇති ස්ටැක් ස්නිපටය පිළිතුරු වලින් නාමාවලිය උත්පාදනය කරයි. අ) එක් භාෂාවකට කෙටිම විසඳුම් ලැයිස්තුවක් ලෙස සහ ආ) සමස්ත ප්‍රමුඛ පුවරුවක් ලෙස.

ඔබගේ පිළිතුර පෙන්වන බව සහතික කර ගැනීමට, කරුණාකර පහත දැක්වෙන මාර්ක්ඩවුන් අච්චුව භාවිතා කරමින් ඔබේ පිළිතුර සිරස්තලයකින් ආරම්භ කරන්න:

## Language Name, N bytes

Nඔබගේ ඉදිරිපත් කිරීමේ ප්‍රමාණය කොහිද ? ඔබ ඔබේ ලකුණු වැඩි දියුණු කරන්නේ නම්, ඔබට පැරණි ලකුණු සිරස්තලයට තබා ගත හැකිය . උදාහරණයක් වශයෙන්:

## Ruby, <s>104</s> <s>101</s> 96 bytes

ඔබේ ශීර්ෂයට බහු සංඛ්‍යා ඇතුළත් කිරීමට ඔබට අවශ්‍ය නම් (උදා: ඔබේ ලකුණු ලිපිගොනු දෙකක එකතුව හෝ ඔබට පරිවර්තක ධජ ද ties ුවම් වෙන වෙනම ලැයිස්තු ගත කිරීමට අවශ්‍ය නිසා), සත්‍ය ලකුණු ශීර්ෂයේ අවසාන අංකය බවට වග බලා ගන්න :

## Perl, 43 + 2 (-p flag) = 45 bytes

ඔබට භාෂාවේ නම සබැඳියක් බවට පත් කළ හැකි අතර එය ස්නිපටයේ පෙන්වනු ඇත:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

කේත ස්නිපටය පෙන්වන්න

code-golf  number  number-theory  primes  decision-problem 
— ඩෙනිස්
source
මට ආදාන negative ණ සංඛ්‍යා ලෙස ගත හැකිද, එහිදී මම පරීක්ෂා කරන අංකය abs (ආදානය) විය හැකිද?
— ස්ටැන් ස්ට්‍රම්
1
පෙරනිමි ආදාන වර්ගවල සම්පූර්ණ පරාසයට ඉඩ දෙනවාට වඩා සම්පූර්ණ වැඩසටහන් අවශ්‍යතාවයට හේතුවක් තිබේද? උදා: එහි ආදානය තර්කයක් ලෙස සලකන ශ්‍රිතයක් සමඟ පිළිතුරු සැපයීම දැනට තහනම් කර තිබේද? codegolf.meta.stackexchange.com/questions/2447/…
— ලින්ඩන් වයිට්
2
Y ලින්ඩන් වයිට් මෙය ප්‍රාථමික පරීක්ෂණවල නාමාවලියක් ලෙස ( “හෙලෝ, වර්ල්ඩ්!” වැනි ) අදහස් කරන ලදි, එබැවින් ඒකාබද්ධ ඉදිරිපත් කිරීමේ ආකෘතියක් වඩාත් සුදුසු බව පෙනේ. මෙම අභියෝගය පිළිබඳ තීරණ දෙකෙන් එකක් මම කනගාටු වන අතර අනෙක තීරණාත්මක ප්‍රාථමික පරීක්ෂණ සඳහා පමණක් ඉඩ දීමයි.
— ඩෙනිස්
1
Ha ෂැගී මෙටා සඳහා ප්‍රශ්නයක් සේ පෙනේ.
— ඩෙනිස්
1
ඔව්, ඒකයි මම හිතුවේ. ගෞරවය කිරීමට මම ඔබට ඉඩ දෙන්නෙමි, එය ඔබගේ අභියෝගය බැවින්.
— ෂැගී

Answers:

234

හෙලෝ වර්ල්ඩ්! , 13

hello, world!
— හිස්ටොක්‍රැට්
source
85
ඔබ වැනි කළා, හුදෙක් , මෙම භාෂාව නිර්මාණය හුදෙක් මෙම ඉදිරිපත් කිරීම සදහා? ;)
— ETHproductions
41
@ETHproductions නවතම කැපවීම දින 10 කට පෙර සිදු වූ බව පෙනේ.
— Geobits
39
ඕනෑම තැනකට සම්බන්ධ වීමට පෙර භාෂාව තරමක් හොඳ හැඩයකින් ලබා ගැනීමට මම බලාපොරොත්තුවෙන් සිටියෙමි, නමුත් මෙම අභියෝගය පළ කරන ලද අතර මට එයට විරුද්ධ විය නොහැක.
— හිස්ටොක්‍රැට්
32
1 ආදානය මත එල්ලීම නිවැරදි ක්‍රියාකාරිත්වය බව මම බොහෝ දුරට කියමි.
— මොනිකා නැවත ස්ථාපනය කරන්න - නොට්මේනාර්ඩ්
25
මෙහි ඇති හොඳම කොටස නම්, වැඩසටහන හුදෙක් ගොඩනඟන ලද එකක් නොවන අතර, නිවැරදි ප්‍රති .ල ලබා ගැනීම සඳහා සෑම චරිතයක්ම තමන්ගේම කාර්යභාරයක් ඉටු කරයි.
— ETHproductions
160

ෂඩාස්රාකාර , බයිට් 29 යි

.?'.).@@/'/.!.>+=(<.!)}($>(<%

මෙම කේතයේ කියවිය හැකි අනුවාදය වන්නේ:

   . ? ' .
  ) . @ @ /
 ' / . ! . >
+ = ( < . ! )
 } ( $ > ( <
  % . . . .
   . . . .

පැහැදිලි කිරීම: n බෙදන 2 සිට n-1 දක්වා සංඛ්‍යාවක් තිබේදැයි පරීක්ෂා කරයි.

ආරම්භ කිරීම:

එක් මතක සෛලයක n සහ අනෙක n-1 ලියන්න:

   . ? ' .
  . . . . .
 . . . . . .
+ = ( . . . .
 . . . . . .
  . . . . .
   . . . .

විශේෂ නඩුව n = 1:

0 මුද්‍රණය කර අවසන් කරන්න

   . . . .
  . . . @ .
 . . . ! . .
. . . < . . .
 . . . . . .
  . . . . .
   . . . .

ලූපය

N% a ගණනය කර a අඩු කරන්න. A = 1 හෝ n% a = 0 නම් අවසන් කරන්න.

   . . . .
  ) . . . /
 ' / . . . >
. . . . . . .
 } ( $ > ( <
  % . . . .
   . . . .

නඩුව a = 1:

0 සිට 1 දක්වා වැඩි කරන්න, එය මුද්‍රණය කර අවසන් කරන්න. (උපදෙස් දර්ශකය NE දිශාවට දිවෙන අතර නැගෙනහිර කෙළවරේ සිට නිරිතදිග කෙළවරට ලූප වේ. තවද command එය ඊළඟ විධානය නොසලකා හැරීමට වග බලා ගනී)

   . . . .
  . . . @ .
 . . . ! . .
. . . < . . )
 . . $ . . <
  . . . . .
   . . . .

නඩුව% n = 0:

0 මුද්‍රණය කර අවසන් කරන්න (උපදෙස් දර්ශකය SW ධාවනය වන අතර ඉහළට ops දක්වා ලූප කරයි

   . . . .
  . . @ . .
 . . . . . >
. . . . . ! .
 . . . . . .
  . . . . .
   . . . .
— එටොප්ලේ
source
61
ශුද්ධ වූ කපටිය, එය සිත් ඇදගන්නා පළමු පෝස්ට් එකකි. :) මම මේ මොහොතේම ත්‍යාගය ලබා දෙන්නෙමි (ඔබගේ පිළිතුර කෙරෙහි තවත් අවධානයක් යොමු කිරීම සඳහා මම එය දින 7 කින් ප්‍රදානය කරමි). PPCG වෙත සාදරයෙන් පිළිගනිමු!
— මාටින් එන්ඩර්
35
නියම පිළිතුර! සඳහා +1 " මෙම කේතය ඇති කියවිය හැකි අනුවාදය වේ: <...> " :-)
— agtoever
69

ෂඩාස්රාකාර , 218 92 58 55 බයිට්

දැනුම්දීම: මෙම පිළිතුර එටොප්ලේ විසින් පැති දිග 4 විසඳුමකින් තදින් පහර දී ඇත .

)}?}.=(..]=}='.}.}~./%*..&.=&{.<......=|>(<..}!=...&@\[

ප්‍රථම වරට සුළු නොවන (එනම් රේඛීය නොවන) ෂඩාස්රාකාර වැඩසටහන! එය පදනම් වී ඇත්තේ Sp3000 හි Labyrinth පිළිතුරට සමාන වර්ග-සාධකීය ප්‍රවේශය මත ය . 10 වන ප්‍රමාණයේ ෂඩාස්රාකාරයකින් ආරම්භ කිරීමෙන් පසුව, එය 5 වන ප්‍රමාණය දක්වා සම්පීඩනය කිරීමට මට හැකි විය. කෙසේ වෙතත්, මට අනුපිටපත් කේත කිහිපයක් නැවත භාවිතා කිරීමට හැකි වූ අතර කේතයේ කිසිසේත් නො-ඕප් සමූහයක් ඇත, එබැවින් 4 වන ප්‍රමාණය පමණක් විය හැකිය හැකි විය හැකිය.

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

කේතය පිළිබඳ අවබෝධයක් ලබා ගැනීම සඳහා, අපි පළමුව එය දිග හැරිය යුතුය. ෂඩාස්රාකාර ඕනෑම මූලාශ්‍ර කේතයක් ඊළඟ කේන්ද්‍රීය ෂඩාස්රාකාර අංකයට ඕප්ස් ( .) නොමැති පෑඩ් කරයි , එනම් 61. ඉන්පසු එය කේතය අනුරූප ප්‍රමාණයේ සාමාන්‍ය ෂඩාස්රයකට නැවත සකස් කරයි:

     ) } ? } .
    = ( . . ] =
   } = ' . } . }
  ~ . / % * . . &
 . = & { . < . . .
  . . . = | > ( <
   . . } ! = . .
    . & @ \ [ .
     . . . . .

මෙය තරයේම ගොල්ෆ් කර ඇත්තේ හරස් මාර්ග සහ අතිච්ඡාදනය වන ක්‍රියාත්මක කිරීමේ මාර්ග සහ බහු උපදෙස් දර්ශක (අයිපී) ය. එය ක්‍රියාත්මක වන ආකාරය පැහැදිලි කිරීම සඳහා, පළමුවෙන් බලමු පාලක ප්‍රවාහය දාර හරහා නොයන, නොගැලපෙන අනුවාදයක් දෙස බලමු, එක් අයිපී එකක් පමණක් භාවිතා කරන අතර ක්‍රියාත්මක කිරීමේ මාර්ග හැකි තරම් සරල ය:

             . . . . . . . . . . . . .
            . . . . . . . . . . . . . .
           . . . . . . . . . . . . . . .
          . . . . . . . . . . @ . . . . .
         . . . . . . . . . . ! . . . . . .
        . . . . . . . . . . % . . . . . . .
       . . . . . . . . . . ' . . . . . . . .
      . . . . . . . . . . & . . . . . . . . .
     . . . . . . . . . . { . . . . . . . . . .
    . . . . . . . . . . * . . . . . . . . . . .
   . . . . . . . . . . = . . . . . . . . . . . .
  . . . . . . . . . . } . . . . . . . . . . . . .
 ) } ? } = & { < . . & . . . . . . . . . . . . . .
  . . . . . . . > ( < . . . . . . . . . . . . . .
   . . . . . . = . . } . . . . . . . . . . . . .
    . . . . . } . . . = . . . . . . . . . . . .
     . . . . | . . . . | . . . . . . . . . . .
      . . . . * . . . ) . . . . . . . . . . .
       . . . . = . . & . . . . . . . . . . .
        . . . . > } < . . . . . . . . . . .
         . . . . . . . . . . . . . . . . .
          . . . . . . . . . . . . . . . .
           . . . . . . . . . . . . . . .
            . . . . . . . . . . . . . .
             . . . . . . . . . . . . .

පැති සටහන: ඉහත කේතය ආරම්භ වන්නේ පළමු පේළිය ක්‍රියාත්මක කිරීමෙනි. IP, ඊසානදිග මායිමට පහර දුන් විට, එය )සත්‍ය කේතය ආරම්භ වන වම් කෙළවරට (the ) ඔතා ඇත.

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

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

අපි A දාරයේ ඇති සාධකය ගණනය කර , C දාරයේ ඇති අපගේ ආදානය ගණනය කර ආදානයේ තවත් පිටපතක් (මොඩියුලය සඳහා) D අද්දර ගබඩා කරමු . B ගණනය කිරීම් සඳහා තාවකාලික දාරයක් ලෙස භාවිතා කරයි.

මතක දර්ශකය (MP) A අද්දරින් ආරම්භ වී උතුරට යොමු කරයි (මන්ත්‍රීවරයා වටා ගමන් කිරීම සඳහා මෙය වැදගත් වේ). දැන් මෙන්න කේතයේ පළමු කොටස:

)}?}=&{

)වර්ධක දාරය A සිට 1සාධකීය පදනම ලෙස. }මන්ත්‍රීවරයා දකුණට හැරවීමට සලස්වයි, එනම් සී දාරයට (ඊසාන දෙසින්) ගමන් කරයි. මෙන්න අපි ආදානය සමඟ පූර්ණ සංඛ්‍යාවක් ලෙස කියවමු ?. ඉන්පසු අපි ඩී සමඟ තවත් දකුණට හැරෙමු }. =මන්ත්‍රීවරයා ආපසු හරවන අතර එය සී සමඟ බෙදාගත් සිරස් තලයට යොමු කරයි . &වෙතින් පිටපත් වටිනාකම සී බවට (ආදාන) ඩී වත්මන් වටිනාකම නොවන ධනාත්මක නිසා වටිනාකම වමේ සිට පිටපත් කිරීම (ශුන්ය) -. අවසාන වශයෙන්, අපි මන්ත්‍රීවරයා වමට හැරී සී සමඟ ආපසු යන්නෙමු {.

ඊළඟට, <තාක්ෂණික වශයෙන් ශාඛාවකි, නමුත් වර්තමාන අගය ධනාත්මක බව අපි දනිමු, එබැවින් IP සෑම විටම දකුණ දෙසට හැරෙනු ඇත >. පැත්තෙන් පහර දෙන ශාඛාවක් කැඩපතක් ලෙස ක්‍රියා කරයි, එනම් IP නැවතත් තිරස් අතට චලනය (වන අතර එය C හි අගය අඩු කරයි .

ඊළඟ ශාඛා, <වන ඇත්තටම දැන් ශාඛා. අපි n-1පහළ සිට පහළට ලූප් කරන ආකාරය මෙයයි 1. C හි වත්මන් අගය ධනාත්මක වන අතර, IP නිවැරදි හැරීමක් ගනී (ලූපය ක්‍රියාත්මක කිරීමට). අපි බිංදුවට පහර දුන් පසු, එය ඒ වෙනුවට වමට හැරෙනු ඇත.

ලූප් "බොඩි" දෙස බලමු. මෙම |වන, සරල දර්පණ >හා <ද නැවත දර්පණ ලෙස භාවිතා වේ. ඒ කියන්නේ නියම ලූප ශරීරය පහළට තම්බා

}=)&}=*}=

}පියවරයන් පාර්ලිමේන්තු මන්ත්රී අද්දරට බී , =ද ශීර්ෂයක් මුහුණ එහි දිශාව අන්තිම පුරුක් ABC . )අගය වැඩි කරයි: මෙය අදාළ වන්නේ B හි අගය තවමත් ශුන්‍ය වන පළමු පුනරාවර්තනය සඳහා පමණි : එය ධනාත්මක බව සහතික කිරීමට අපට අවශ්‍යය , එනම් ඊළඟ උපදෙස් නිවැරදි අසල්වැසියා &පිටපත් කරයි , එනම් A , එනම් සාධකයේ වත්මන් අගය ගණනය කිරීම, බී බවට .

}ඉන් පසු මන්ත්රීවරයා පෙලඹෙන්නේ ඒ , =එය නැවත පොදු ශීර්ෂයක් මුහුණ අන්තිම පුරුක්. *අසල්වැසියන් දෙදෙනාම ගුණ කරයි, එනම් B සහ C දාර සහ ප්‍රති result ලය A හි ගබඩා කරයි . අවසාන වශයෙන්, සී}= වෙත ආපසු යාමට අපට තවත් එකක් ඇත , තවමත් ඒබීසී ශීර්ෂයට මුහුණ ලා සිටී .

මෙය An-1 හි සාධකය ගණනය කරන්නේ කෙසේදැයි ඔබට දැක ගත හැකි යැයි මම බලාපොරොත්තු වෙමි .

දැන් අපි එය සිදු කර ඇත්තෙමු, C හි ලූප් කවුන්ටරය ශුන්‍ය වේ. අපට අවශ්‍ය වන්නේ සාධකය වර්ග කර ආදානය සමඟ මොඩියුලය ගැනීමයි. මෙම කේතය කරන්නේ එයයි:

&}=*{&'%!@

සිට සී ශුන්ය වේ, &පිටපත් වම් අසල්වැසියා, එනම් දී ක්රමාරෝපිත ඒ . }=*කිරීමට පියවර බී දී (එනම්, වර්ග) ක්රමාරෝපිත පිටපත් දෙකක්, නිෂ්පාදන හා ගබඩා බී . {නැවත සී වෙත ගමන් කරයි , නමුත් මන්ත්‍රීවරයා ආපසු හරවන්නේ නැත. වත්මන් අගය දැන් ධනාත්මක බව අපි දනිමු, එබැවින් D සිට C වෙත &ආදානය පිටපත් කරයි . මන්ත්‍රීවරයා පසුපසට දකුණට, එනම් ඒ . මතක තබා ගන්න, සාධකයේ වර්ග B හි ඇති අතර ආදානය C වේ. ඉතින් ගණනය කරන්නේ හරියටම අපි සොයන දේ.'%(n-1)!^2 % n!ප්‍රති result ලය පූර්ණ සංඛ්‍යාවක් ලෙස මුද්‍රණය කර (0 හෝ 1) @වැඩසටහන අවසන් කරයි.

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

  1. දාර වටා එති. IP ෂඩාස්රයේ දාරයකට වැදුනහොත් එය ප්රතිවිරුද්ධ දාරයට පනිනවා. අයිපී කෙළවරකට කෙළින්ම පහර දෙන විට මෙය අපැහැදිලි ය, එබැවින් කොනකට පහර දීම ද ශාඛාවක් ලෙස ක්‍රියා කරයි: වත්මන් අගය ධනාත්මක නම්, අයිපී ග්‍රිඩ් අද්දරට දකුණට පනින්න, එසේ නොමැතිනම් වමට වමට.
  2. ඇත්ත වශයෙන්ම IP 6 ක් ඇත. ඒ සෑම එකක්ම වෙනස් කොනකින් ආරම්භ වන අතර, දාරය දිගේ දක්ෂිණාවර්තව ගමන් කරයි. වරකට ඒවායින් එකක් පමණක් ක්‍රියාත්මක වන අතර එයින් අදහස් කරන්නේ ඔබට අවශ්‍ය නැතිනම් අනෙක් අයිපී 5 නොසලකා හැරිය හැකි බවයි. ඔබට ඊළඟ අයිපී වෙත (ඔරලෝසුව අනුව) ]පෙර සහ සමඟ මාරු විය හැකිය [. (ඔබට විශේෂිත එකක් තෝරා ගත හැකිය #, නමුත් එය තවත් කාලයක් සඳහා වේ.)

එය නව විධාන කිහිපයක් ඇත: \හා /සමාන දර්පණ |, සහ ~විසින් වත්මන් වටිනාකම වැරැදිය -1.

ඉතින් ගොල්ෆ් කළ අනුවාදය ගොල්ෆ් කළ ක්‍රීඩාවට පරිවර්තනය කරන්නේ කෙසේද? රේඛීය සැකසුම් කේතය )}?}=&{සහ මූලික ලූප ව්‍යුහය මෙහි සොයාගත හැකිය:

        ) } ? } .  ->
       . . . . . .
      . . . . . . .
     . . . . . . . .
->  . = & { . < . . .
     . . . . . > ( <
      . . . . . . .
       . . . . . .
        . . . . .

දැන් ලූප් බොඩි කිහිප වතාවක් දාර තරණය කරයි, නමුත් වඩාත්ම වැදගත් දෙය නම් සත්‍ය ගණනය කිරීම පෙර අයිපී වෙත භාර දීමයි (එය වම් කෙළවරේ ආරම්භ වී ඊසාන දෙසින් ගමන් කරයි):

        ) . . . .
       = . . . ] .
      } = . . } . .
     ~ . / . * . . .
    . . . . . . . . .
     . . . = . > ( <
      . . } . = . .
       . & . \ [ .
        . . . . .

අත්තෙන් ගිනිකොන දෙසට පිම්බීමෙන් පසු, අයිපී =ඉහළ වම් කෙළවරේ ඇති දෙපැත්තට දාරය වටා ඔතා (ඒවා එකට නොගැලපෙන) පසුව ඉවතට පැනේ /. මෙම ~පසු අනුකරණ සඳහා වැදගත් වන වත්මන් වටිනාකම, ලකුණ inverts. අයිපී යළිත් එකම දාරය වටා ඔතා අවසානයේ [අනෙක් අයිපී වෙත පාලනය භාර දෙන ස්ථානයට පහර දෙයි .

මෙය දැන් ක්‍රියාත්මක ~}=)&}=*}කරන්නේ නිෂේධනය අහෝසි කර පසුව නොගැලපෙන ලූප් බොඩි ධාවනය කරයි (us ණ =). අවසාන වශයෙන් එය ]මුල් අයිපී වෙත නැවත පාලනය කරන්නේ කුමන දෑතින්ද යන්න. (ඊළඟ වතාවේ, අපි එය මෙම අයිපී ක්‍රියාත්මක කරන විට, එය ආරම්භ වූ ස්ථානයේ සිට ආරම්භ වන බැවින් එය මුලින් කෙළවරට වැටෙනු ඇත. අයිපී නැවත වයඹ දිගට පනින්න නම් අපට වර්තමාන අගය negative ණ විය යුතුය. ගිනිකොන දෙසින් එකක් වෙනුවට.)

මුල් IP පාලනය යලි ඇරඹෙන විට, එය පන්දු රැකීමේ \, ඉතිරි ඉටු =පසුව තත්වය >ඉදිරි රදාපැවතීමයි බවට පෝෂණය කිරීම සඳහා.

දැන් ඇත්තෙන්ම පිස්සු කොටස: ලූපය අවසන් වූ විට කුමක් සිදුවේද?

        ) . . . .
       . ( . . ] =
      . . ' . } . }
     . . . % * . . &
    . . . . . . . . .
     . . . = | . . <
      . . } ! . . .
       . & @ . . .
        . . . . .

අයිපී ඊසාන දෙසින් චලනය වන <අතර ඊසාන දිග විකර්ණයට ඔතා ඇත. එබැවින් එය අවසන් වන්නේ ලූප් බොඩි ( &}=*}]) ලෙස ක්‍රියාත්මක වන මාවතේ ය . ඇත්තෙන්ම එය සිසිල් ය, මන්ද යත්, මේ අවස්ථාවේ දී අපට ක්‍රියාත්මක කිරීමට අවශ්‍ය කේතය එයයි, අවම වශයෙන් අපි තවත් එකක් එකතු කළහොත් =}(එයට }=}සමාන බැවින් {). නමුත් මෙය නැවත පෙර ලූපයට නැවත ඇතුල් නොවන්නේ කෙසේද? මක්නිසාද යත්, ]දැන් දකුණු පසින් දකුණු දකුණු දෙසට ගමන් කරන (මෙතෙක් භාවිතයට නොගත්) අයිපී ඊලඟ අයිපී වෙත වෙනස් වීමයි. එතැන් සිට, අයිපී දාරය දිගේ ඉදිරියට ගමන් කරයි, ඉහළ වම් කෙළවරට ඔතා, විකර්ණයෙන් පහළට ගමන් කරයි, ඉවතට පැන, |අවසන් @රේඛීය කේත ක්‍රියාත්මක කරන අතරතුර අවසන් වේ:

=}&)('%!@

( )(ඇත්ත වශයෙන්ම මෙය විවෘත විකල්පයක් නොවේ - ඒ වන විටත් එහි තිබූ (නිසා මට එය එකතු කිරීමට සිදුවිය ).)

පියු ... මොන අවුලක්ද ...

— මාටින් එන්ඩර්
source
හොඳයි! මෙය කෙතරම් අලුත්ද? ඔබට ස්ථාවර නිකුතුවක් ලැබෙන සෑම විටම esolangs පිටුවක් සෑදීමට ඔබට අවශ්‍ය විය හැකිය
— mbomb007
19
two mbomb007 මම දින දෙකකට පෙර භාෂාව ක්‍රියාත්මක කළෙමි (ඊට පෙර දින දෙක තුනකට වඩා එය නිර්මාණය කළෙමි). ඔව්, මම අනිවාර්යයෙන්ම esolangs පිටුවක් එක් කරන්නෙමි, නමුත් මම සිතන්නේ පිරිවිතර තවමත් 100% ස්ථායී නොවන බවයි (නිදසුනක් ලෙස තවමත් නියම නොකළ විධාන 3 ක් ඇත). එය වඩාත් ස්ථායී යැයි මට හැඟුණු පසු, මම එය esolangs සහ අපගේ මෙටා පෝස්ට් යන දෙකටම එකතු කරමි.
— මාටින් එන්ඩර්
පුළුල් කරන ලද හෙක්ස් යටතේ එය වම් කෙළවරට (ද 1) ඔතා ඇත . 1ඔබ එහි කුමක් ගැනද කතා කරන්නේ?
— mbomb007
@ mbomb007 ස්ථාවරයි. මෙම )ඉතා විය කිරීම සඳහා භාවිතා 1.
— මාටින් එන්ඩර්
5
+1 එය ක්‍රියාත්මක වන ආකාරය පිළිබඳ ඔබේ පැහැදිලි කිරීමේ විස්තර මට්ටම සඳහා පමණි. සවිස්තරාත්මකව වැඩි පිරිසකට ඒවා භාවිතා කළ හැකි උදාහරණයක් සමඟ තවත් භාෂා පැමිණියේ නම්: D
— jdarling
67

පයිත්, බයිට් 4 යි

}QPQ

මුද්රණ Trueහෝ False.

— orlp
source
12
මෙය පැරණි බව මම දනිමි, නමුත් දැන් ඔබටත් මේ ආකාරයට කළ හැකිය: P_Q සහ බයිට් 1 ක් ඉතිරි කරන්න.
— drobilc
14
දැන් එය කළ හැක්කේP_
— නිල්
3
rodrobilc ශ්‍රිතය තර්කයක් අපේක්ෂා කරන විට ඔබට EOF ලෙස Q කපා ගත හැකිය, එය ආදානය භාවිතා කරයි
— ස්ටැන් ස්ට්‍රම්
අපි දැන් ක්‍රියාත්මක වන විසඳුම් එකතු කරන්නේ /Pනම්, විකල්ප 2 බයිට් විකල්පයකි.
— isaacg
58

රෙටිනා , බයිට් 16 යි

^(?!(..+)\1+$)..

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

අපි සම්භාව්‍යයකින් ආරම්භ කරමු: රීජෙක්ස් සමඟ ප්‍රාථමික හඳුනා ගැනීම . නැවත නැවත මුද්‍රණය කළ හැකි අක්ෂර භාවිතා කරමින් ආදානය ඒකාකාරව ලබා දිය යුතුය . පරීක්ෂණ කට්ටලයට පහසුව සඳහා දශමයේ සිට ඒකීය බවට පරිවර්තනය කිරීම ඇතුළත් වේ.

තනි පේළියකින් සමන්විත රෙටිනා වැඩසටහනක් එම රේඛාව රීජෙක්ස් ලෙස සලකන අතර ආදානයේ ඇති ගැලපුම් ගණන මුද්‍රණය කරයි. 0 සංයුක්ත සංඛ්‍යා සහ 1ප්‍රාථමික සඳහා වේ.

බැලූ බැල්ම මඟින් ආදානය සංයුක්ත නොවන බව සහතික කරයි: පසුපසට යාම මඟින් හැකි සෑම උපස්ථරයක්ම (අවම වශයෙන් අක්ෂර 2 ක්) (..+)උත්සාහ කරනු ඇත, එවිට බැලූ බැල්මට මෙහි ග්‍රහණය කර ඇති දේ පුනරාවර්තනය කිරීමෙන් ඉතිරි ආදානයට ගැලපීමට උත්සාහ කරයි. මෙය කළ හැකි නම්, එයින් අදහස් වන්නේ ආදානයට 1 ට වඩා වැඩි බෙදීමක් ඇති නමුත් එය තමාට වඩා අඩු බවයි. එය එසේ නම් the ණාත්මක පෙනුම නිසා තරගය අසාර්ථක වේ. ප්‍රාථමිකයන් සඳහා එවැනි හැකියාවක් නොමැති අතර තරගය දිගටම පවතී.

එකම ගැටළුව වන්නේ මෙම බැල්ම හෙඩ් එක ද පිළිගැනීමයි 1, එබැවින් අවම වශයෙන් අක්ෂර දෙකක් වත් ගැලපීමෙන් අපි එය ප්‍රතික්ෂේප කරමු ...

— මාටින් එන්ඩර්
source
ප්‍රාථමිකයන් සාමාන්‍ය භාෂාවක් නොවන බැවින් එය ඇත්ත වශයෙන්ම අක්‍රමවත් ප්‍රකාශනයකි.
— PyRulez
YPyRulez බොහෝ තාත්වික රීජෙක්ස් රස සාමාන්‍ය ප්‍රකාශනවල න්‍යායාත්මක සංකල්පයට වඩා බොහෝ බලවත් ය. මම වචන වැඩි දියුණු කළත්.
— මාටින් එන්ඩර්
1
විවෘතව පවතින වඩාත්ම බලගතු “රීජෙක්ස්” එන්ජින්වලට දැන් රේඛීය මායිම් සහිත ස්වයංක්‍රීය යන්ත්‍රයකට සමාන හඳුනාගැනීමේ බලය ඇත. සන්දර්භය-සංවේදී විග්‍රහ කිරීම සඳහා ඔබට අවශ්‍ය වන්නේ සම්මත නිකුතුව රීජෙක්ස්, රටා පුනරාවර්තනය, අසීමිත බැල්ම හෙඩ් සහ අසීමිත පෙනුමකි (පසු විපරම් සහ සාමාන්‍යයෙන් කාර්යක්ෂම විග්‍රහ කිරීම සංකීර්ණ කිරීමට උපකාරී වේ), සහ සමහර ඒවා සියල්ලම ඇත. රීජෙක්ස් තුළට කේතය කාවැද්දීමට ඉඩ දෙන එන්ජින් වලින් මාව ආරම්භ කිරීමටවත් එපා.
— eaglgenes101
52

සී ජෑම්, බයිට් 4 යි

qimp

CJam හි ප්‍රාථමිකභාවය පරීක්ෂා කිරීම සඳහා සාදන ලද ක්‍රියාකරු සිටී.

— පීටර් ටේලර්
source
18
විකල්පයක් ලෙස:limp
— Sp3000
43
pimpමගේ cjam.
— දෝෂය
12
pimpවෛෂයිකව වඩා
— pimp
1
ඔබට ද කළ හැකියl~mp
— user41805
12
Ycyoce, qආදාන රේඛාවක් කියවීම, iඑය පූර්ණ සංඛ්‍යාවක් ලෙස විග්‍රහ කිරීම සහ mpඑය ගොඩනංවන ලද්දකි. CJam හි වර්‍ග දෙකකින් යුත් කණ්ඩායම් දෙකක් ඇත: “දීර් extended” ආරම්භ වන eඅතර “ගණිතමය” ආරම්භ වේm
— පීටර් ටේලර්
51

HTML + CSS, 254 + n උපරිම * බයිට් 28

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

@document [ <url> | url-prefix(<string>) | domain(<string>) | regexp(<string>) ]# {
  <group-rule-body>
}

වත්මන් URL එක මත පදනම්ව CSS හරහා මූලද්‍රව්‍ය පෙරීමට. මෙය තනි සාමාර්ථයකි, එබැවින් අපට පියවර දෙකක් කළ යුතුය:

  1. පරිශීලකයාගෙන් ආදානය ලබා ගන්න. මෙම ආදානය කෙසේ හෝ වත්මන් URL තුළ පිළිබිඹු විය යුතුය.
  2. පරිශීලකයාට හැකි තරම් කුඩා කේතයකින් පිළිතුරු දෙන්න.

1. ආදානය ලබා ගැනීම

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

එබැවින් අපි මෙය ආරම්භ කරමු (බයිට් 61):

<div id=q><p id=r>1<p id=s>0</div><form method=GET action=#q>

<p>ඇතුළත් කළ අංකය ප්‍රාථමික (1) ද නැතිනම් (0) ද යන්න දැක්වීමට අපට අද්විතීය s දෙකක් තිබේ. අපි පෝරමය ද අර්ථ දක්වන අතර එය ක්‍රියාවකි.

ඉන්පසු එකම නම සහිත n උපරිම පිරික්සුම් කොටු (n උපරිම * බයිට් 28):

<input type=checkbox name=i>

ඉදිරිපත් කිරීමේ අංගයෙන් පසුව (බයිට් 34):

<input name=d value=d type=submit>

2. පිළිතුර පෙන්වන්න

<p>පෙන්වීමට (1 හෝ 0) තේරීමට අපට CSS (බයිට් 159) අවශ්‍ය වේ :

#q,#s,#q:target{display:none}#q:target{display:block}@-moz-document regexp(".*\\?((i=on&)?|(((i=on&)(i=on&)+?)\\4+))d=d#q$"){#s{display:block}#r{display:none}}

Codpen.io (ෆයර්ෆොක්ස් පමණි) හි එය උත්සාහ කරන්න

— mınxomaτ
source
13
+1: මෙය මගේ සෑම විටම කැමතිම HTML අපයෝජනය වන අතර කෝඩ්ගොල්ෆ් ක්‍රීඩාවට මා ප්‍රිය කරන ආකාරයේ දේවල් වේ.
— පූසා
මෙය නිසැකවම සිත්ගන්නා සුළුය, නමුත් එය මෙම අභියෝගයේ නීති රීති සපුරාලන්නේ දැයි මට විශ්වාස නැත. විශේෂයෙන්, එය ඔබගේ ඇල්ගොරිතමයට අනුකූල වේ යැයි මම නොසිතමි [...] න්‍යායිකව අත්තනෝමතික ලෙස විශාල සංඛ්‍යා සඳහා වැඩ කළ යුතුය. ආදාන ක්ෂේත්‍රයක වටිනාකම පිළිබඳව ඔබට රීජෙක්ස් භාවිතා කළ නොහැකිද?
— ඩෙනිස්
Enn ඩෙනිස් සමහර විට. බොහෝ විට පවා. නමුත් එය ඔබ සඳහන් කළ ගැටලුව විසඳන්නේ නැත. මම එය මෙහි තරඟකාරී නොවන ප්‍රවේශයක් ලෙස තබමි, මන්ද ඒ සඳහා වඩාත්ම මාතෘකා අභියෝගය මෙයයි.
— mınxomaτ
ඇයි නැත්තේ? ආදාන ක්ෂේත්‍රයක ඔබට අංකයක් තිබේ නම්, ඔබේ කේතය තවදුරටත් උපරිම අංකය මත රඳා නොපවතී.
— ඩෙනිස්
6
හ්ම්, මම මේ ගැන තව ටිකක් සිතුවෙමි, ඇත්ත වශයෙන්ම x පිරික්සුම් කොටු පමණක් තිබීම සහ y-bit සංඛ්‍යා පමණක් ඇති පරිවර්තකයෙකු අතර වෙනසක් නැත. මගේ පෙර අදහස නොසලකා හරින්න.
— ඩෙනිස්
43

ෂඩාස්රාකාරය , බයිට් 28 යි

සිට Etoplay පරම මට වැදුනේ මෙම ප්රශ්නය , මා ඔහුගේ එකම outgolf තිබුණා කියලා මට හිතුණා පිළිතුර .

?\.">"!*+{&'=<\%(><.*.'(@>'/

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

මාටින් විල්සන්ගේ ප්‍රමේයය භාවිතා කරයි, මාටින් ඔහුගේ පිළිතුරට අනුව :n මම ප්රතිදානය(n-1!)² mod n

මෙන්න එය වැඩසටහන දිග හැරුනේ:

   ? \ . "
  > " ! * +
 { & ' = < \
% ( > < . * .
 ' ( @ > ' /
  . . . . .
   . . . .

කියවිය හැකි අනුවාදය මෙන්න :

ඉතා කියවිය හැකි ය

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

වැඩසටහනට ප්‍රධාන පියවර තුනක් ඇත: ආරම්භ කිරීම , සාධක හා ප්‍රතිදානය .

ෂඩාස්රාකාරයේ මතක ආකෘතිය අසීමිත ෂඩාස්රාකාර ජාලයකි. මෙම රූප සටහනේ පෙන්වා ඇති පරිදි මම මතක ස්ථාන 5 ක් භාවිතා කරමි:

මතකය

එම රූපසටහනේ ඇති ලේබල මගින් මම මෙම ස්ථාන (සහ ඒවායේ ගබඩා කර ඇති පූර්ණ සංඛ්‍යා) වෙත යොමු කරමි.

ආරම්භ කිරීම:

ආරම්භ කිරීම

උපදෙස් දර්ශකය ( IP ) ආරම්භ වන්නේ ඉහළ වම් කෙළවරේ සිට නැගෙනහිර දෙසට ය. මතක දර්ශකය ( MP ) ආරම්භ වන්නේ IN .

පළමුව, ?ආදානයෙන් අංකය කියවා එය IN හි ගබඩා කරයි . මෙම IP විසින් පිළිබිඹු නිල් මාර්ගය මත නවාතැන් පහසුකම් \. වූ අනුපිළිවෙල හා "&(ප්ළියක් පාර්ලිමේන්තු මන්ත්රී (නැවත සහ වම් කිරීමට ඒ ) , අගය IN සිට පිටපත් කරයි ඒ ඒ decrements.

මෙම IP පසුව ෂඩාස්රයේ එක් පැත්තක යෙදුම ඉවත්වීමේදී සහ අනෙක් පැත්තේ (හරිත මාර්ගය මතට) නැවත ඇතුල්. මන්ත්‍රීවරයා බී වෙත '+ගෙන යන අතර එය A හි ඇති දේ පිටපත් කරයි කරයි. <යළි හරවා යවයිIP බටහිර දෙසට .

සාධක:

මම සාධකය නිශ්චිත ආකාරයකින් ගණනය කරමි, එවිට එය වර්ග කිරීම පහසුය. මම පහත පරිදි බී සහ සීn-1! යන දෙකෙහිම ගබඩා කරමි .

සාධක

උපදෙස් දර්ශකය නැගෙනහිර දෙසට ගමන් කරමින් නිල් මාවතේ ආරම්භ වේ.

='මන්ත්‍රීවරයාගේ දිශාව ආපසු හරවා එය සී වෙත පසුපසට ගෙන යයි . මෙය සමාන {=නමුත් පසුව =එය ප්‍රයෝජනවත් වූ ස්ථානය තිබීම .

&{පිටපත් සිට වටිනාකම ඒ සඳහා සී , පසුව පෙලඹෙන්නේ පාර්ලිමේන්තු මන්ත්රී ආපසු ඒ . මෙම IP පසුව කොළ මාර්ගය, කිසිවක් නොකර, රතු මාර්ගය ඇතිවීමට පෙර, පහර පහත\ සහ තැඹිලි මාර්ගය මතට යනවා.

සමඟ (>, අපි A අඩු කර IP නැගෙනහිර නැවත හරවා යවමු . මෙන්න එය ශාඛාවකට පහර දෙයි : <. ධනාත්මක A සඳහා , අපි තැඹිලි මාවත ඔස්සේ ඉදිරියට යමු. එසේ නොමැති නම් අයි.පී. උතුරු-නැගෙනහිර දෙසට යොමු වේ.

'*පියවරයන් පාර්ලිමේන්තු මන්ත්රී කිරීමට බී හා ගබඩා කළ * සී දී බී . මේ (n-1)*(n-2)මූලික ආදාන සිටි n. මෙම IP පසුව මූලික පුඩුවක් බවට නැවත ඇතුල් decrementing හා තෙක් ගුණ දිගටම ඒ මට්ටම්වල 0. (පරිගණකකරණය n-1!)

සැ.යු : පහත දැක්වෙන ලූපවල, සී හි ධනාත්මක අගයක් දැන් ගබඩා කර ඇති බැවින් , බී හි &අගය සී හි ගබඩා කරයි. සාධක සාධක ගණනය කිරීම සඳහා මෙය ඉතා වැදගත් වේ.

ප්‍රතිදානය:

ප්‍රතිදානය

විට ඒ මට්ටම්වල 0. ශාඛාව ඒ වෙනුවට නිල් මාවත දිගේ IP යොමු කරයි .

=*මන්ත්‍රීවරයා ආපසු හරවා B * C හි අගය A හි ගබඩා කරයි . එවිට IP ෂඩාස්රයෙන් පිටවී හරිත මාවතට නැවත ඇතුල් වේ; ක්‍රියාත්මක කිරීම "%. මෙය ගමන් කරයි පාර්ලිමේන්තු මන්ත්රී කිරීමට පිටත හා ගණනය කළ , mod IN , හෝ (n-1!)² mod n.

පහත දැක්වෙන්නේ {"එකිනෙකා අවලංගු වන බැවින් ඒවා විවෘත කිරීමක් නොවේ. !අවසාන ප්‍රතිදානය මුද්‍රණය කර අවසන් *+'(කිරීමට පෙර ක්‍රියාත්මක කරනු ලැබේ:@ .

ක්‍රියාත්මක කිරීමෙන් පසු, (ආදානයකින් 5) මතකය මේ ආකාරයෙන් පෙනේ:

මතකය 2

පාලක ප්‍රවාහයේ සුන්දර රූප නිපදවා ඇත්තේ ටිම්විගේ ෂඩාස්රාකාර වර්ණකයෙනි .

මගේ පරිගණකයේ එය කළ නොහැකි බැවින් සියලු රූප ජනනය කිරීම ගැන මාටින් එන්ඩර්ට ස්තූතියි .

— එච්.පී.විස්
source
මෙම මතක රූප සටහන් සඳහා ඔබ භාවිතා කරන්නේ කුමක්ද? මම එසෝටරික් IDE දැක ඇති නමුත් මට එය ක්‍රියාත්මක කිරීමට නොහැකි විය ...
— NieDzejkob
IeNieDzejkob ඔබ කෙසේ හෝ මාටින් ඒවා මා වෙනුවෙන් සාදා ඇති බැවින් ඔබ චැට් කිරීමේදී මාටින්ගෙන් විමසීමට වඩා හොඳයි.
— H.PWiz
@NieDzejkob ඔව්, මතක රූප සටහන EsoIDE වෙතින් අපනයනය කළ හැකිය. chat.stackexchange.com/rooms/27364/… ඔබට මේ ගැන තවත් කතාබස් කිරීමට අවශ්‍ය නම්.
— මාටින් Ender
36

මෝනිංටන් ක්‍රෙසන්ට් , බයිට් 2448

අපි ආපහු ලන්ඩනයට ආවා!

Take Northern Line to Bank
Take Circle Line to Bank
Take District Line to Parsons Green
Take District Line to Bank
Take Circle Line to Hammersmith
Take District Line to Upney
Take District Line to Hammersmith
Take Circle Line to Victoria
Take Victoria Line to Seven Sisters
Take Victoria Line to Victoria
Take Circle Line to Victoria
Take Circle Line to Bank
Take Circle Line to Hammersmith
Take Circle Line to Cannon Street
Take Circle Line to Hammersmith
Take Circle Line to Cannon Street
Take Circle Line to Bank
Take Circle Line to Hammersmith
Take Circle Line to Aldgate
Take Circle Line to Aldgate
Take Metropolitan Line to Chalfont & Latimer
Take Metropolitan Line to Aldgate
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Hammersmith
Take Circle Line to Notting Hill Gate
Take Circle Line to Hammersmith
Take Circle Line to Notting Hill Gate
Take District Line to Upminster
Take District Line to Bank
Take Circle Line to Victoria
Take Circle Line to Temple
Take Circle Line to Aldgate
Take Circle Line to Aldgate
Take Metropolitan Line to Chalfont & Latimer
Take Metropolitan Line to Pinner
Take Metropolitan Line to Chalfont & Latimer
Take Metropolitan Line to Pinner
Take Metropolitan Line to Chalfont & Latimer
Take Metropolitan Line to Pinner
Take Metropolitan Line to Aldgate
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Victoria
Take Circle Line to Aldgate
Take Circle Line to Victoria
Take Circle Line to Victoria
Take District Line to Upminster
Take District Line to Embankment
Take Circle Line to Embankment
Take Northern Line to Angel
Take Northern Line to Moorgate
Take Metropolitan Line to Chalfont & Latimer
Take Metropolitan Line to Aldgate
Take Circle Line to Aldgate
Take Circle Line to Cannon Street
Take District Line to Upney
Take District Line to Cannon Street
Take District Line to Acton Town
Take District Line to Acton Town
Take Piccadilly Line to Russell Square
Take Piccadilly Line to Hammersmith
Take Piccadilly Line to Russell Square
Take Piccadilly Line to Ruislip
Take Piccadilly Line to Ruislip
Take Metropolitan Line to Preston Road
Take Metropolitan Line to Aldgate
Take Circle Line to Aldgate
Take Circle Line to Cannon Street
Take Circle Line to Aldgate
Take Circle Line to Aldgate
Take Metropolitan Line to Preston Road
Take Metropolitan Line to Moorgate
Take Circle Line to Moorgate
Take Northern Line to Mornington Crescent

Timwi පාලනය ගලා ස්ථාන ක්රියාත්මක කිරීමට කාරුණික විය Templeහා Angelතුළ විරල IDE එකතු ආදාන ලෙස හා භාෂා පිරිවිතර කිරීම මාණකරනය ක්රියාත්මක පූර්ණ සංඛ්යාමය මෙන්ම.

මෙය "හලෝ, වර්ල්ඩ්!" ට වඩා හොඳ ගොල්ෆ් ක්‍රීඩාවක් විය හැකිය, මන්ද මේ වතාවේ මම සීජෑම් පිටපතක් ලිවූයේ ඕනෑම දුම්රිය ස්ථාන දෙකක් අතර ඇති කෙටිම මාර්ගය සොයා ගැනීමට මට උපකාර කිරීමටය. ඔබට එය භාවිතා කිරීමට අවශ්‍ය නම් (කිසිවෙකුට අවශ්‍ය වන්නේ මන්දැයි මම නොදනිමි ...), ඔබට සබැඳි පරිවර්තකය භාවිතා කළ හැකිය . මෙම කේතය අලවන්න:

"Mornington Crescent"
"Cannon Street"
]qN/{'[/0=,}$:Q;{Q{1$#!}=\;_oNo'[/1>{']/0="[]"\*}%}%:R;NoQ{R\f{f{\#)}:+}:*},N*

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

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

සත්‍ය MC කේතය සම්බන්ධයෙන් ගත් කල, එය පදනම් වී ඇත්තේ වෙනත් බොහෝ පිළිතුරු ලෙස වර්ග-සාධකීය ප්‍රවේශය මත වන බැවින් MC හට ගුණ කිරීම, බෙදීම සහ මොඩියුලෝ ඇත. එසේම, එක් ලූපයක් පහසු වනු ඇතැයි මම සිතුවෙමි.

එක් ගැටළුවක් නම්, ලූපයන් කළ යුතු ලූප වන අතර, අඩු කිරීම සහ වැඩි කිරීම මිල අධික බැවින් මට පහසුවෙන් ගණනය කළ නොහැක (n-1)!(සඳහා n > 0). ඒ වෙනුවට, මම ගණනය n!කර පසුව බෙදමිn කර අවසානයේ . මට විශ්වාසයි මේ සඳහා වඩා හොඳ විසඳුමක් ඇති බව.

මම මෙය ලිවීමට පටන් ගත් විට, -1හැමර්ස්මිත් හි ගබඩා කිරීම හොඳ අදහසක් වනු ඇතැයි මට වැටහුණි, එබැවින් මට වඩා ලාභදායී ලෙස අඩු කළ හැකිය, නමුත් අවසානයේදී මෙය ඉතිරි කිරීමට වඩා වැඩි පිරිවැයක් දැරීමට සිදුවනු ඇත. මෙය නැවත සිදුකිරීමට මට ඉවසීමක් ඇත්නම්, -1ඒ වෙනුවට මම උපමින්ස්ටර් හි රැඳී සිටීමට උත්සාහ කරමි, එවිට මට වඩාත් ප්‍රයෝජනවත් යමක් සඳහා හැමර්ස්මිත් භාවිතා කළ හැකිය.

— මාටින් එන්ඩර්
source
11
ලන්ඩන් ටියුරින් කිරීම සම්පූර්ණද?
— රොහාන් ජුන්ජුන්වල
1
O රොහාන් ජුන්ජුන්වල බොහෝ විට
— මාටින් එන්ඩර්
1
වාව්! හොඳින් සිතා බැලූ ප්‍රශ්න දැකීමට මා කැමතිය. වැඩසටහනක් ලිවීමට ඔබට වැඩසටහනක් ලිවිය යුතු ප්‍රශ්න දැකීමට මම විශේෂයෙන් කැමතියි.
— රොහාන් ජුන්ජුන්වල
සුළු ප්රශ්නය - ආකාරය කළේ ඔබ ගබඩා -1හැමර්ස්මිත්හි? මම ලියන වැඩසටහනක් සඳහා ද එසේ කිරීමට සිතමි. මම හිතන්නේ එය නොටින් හිල් ගේට් විසින් කළ නමුත් මම වැරදියි.
— වලාකුළු 7
@ Cloudy7 ඔව් ඒ වගේ දෙයක්. මම එසෝටරික් අයිඩීඊ හි වැඩසටහන හරහා පියවරක් තැබූ අතර, පෙනෙන විදිහට මම සෙවන් සොහොයුරියන් 7 දෙනාගෙන් 1 ක් ලබා ගැනීම සඳහා චල්ෆොන්ට් සහ ලැටිමර් හි බෙදී, නොටින් හිල් ගේට් එකෙන් -2 ලබා ගැනීම සඳහා නොසලකා හැර -2 ක් ලබා ගැනීමට උපින්ස්ටර්හි එක් කළෙමි. -1 සඳහා. බැලූ බැල්මට මෙය ටිකක් අනවශ්‍ය ලෙස සංකීර්ණ බවක් පෙනේ. මම හිතන්නේ මට ආදානයේ අවසාන පියවර දෙක කළ හැකිය (7 තෝරා නොගෙන හෝ තනිවම බෙදීමෙන් තොරව).
— මාටින් එන්ඩර්
28

බ්‍රැචයිලොග් (වී 2), බයිට් 1 යි

ṗ

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

බ්‍රැචයිලොග් (වී 1), බයිට් 2 යි

#p

මෙය ගොඩනංවන ලද පුරෝකථනය භාවිතා කරයි #p - Prime , එමඟින් එහි ආදානය ප්‍රමුඛ අංකයක් ලෙස සීමා කරයි.

බ්‍රැචයිලොග් යනු ප්‍රොලොග් හි කේත ගොල්ෆ් අනුවාදයක් සෑදීමට මා දැරූ උත්සාහයයි. එය ප්‍රකාශිත කේත ගොල්ෆ් භාෂාවකි.

සාදන ලද විකල්ප විසඳුමක්: බයිට් 14 ක්

ybbrb'(e:?r%0)

ඉහත කේතයේ බිඳවැටීමක් මෙන්න:

y            The list [0, …, Input]
bbrb         The list [2, …, Input - 1]
'(           True if what's in the parentheses cannot be proven; else false
     e           Take an element from the list [2, …, Input - 1]
     :?r%0       The remainder of the division of the Input but that element is 0
)
— මාරාන්තික කරන්න
source
1
ඔබට මෙම බ්‍රැචයිලොග් 2 අනුවාදය පෝස්ටයට සංස්කරණය කිරීමට අවශ්‍ය විය හැකිය, දැන් වාක්‍ය ඛණ්ඩය බයිට් කෙටි වේ.
1
is ais523 ඇත්ත, කර ඇත.
— මාරාන්තික වන්න
බ්‍රැචයිලොග් 2 පිළිතුර අභියෝගය පසු දිනද?
— ස්කොට් මිල්නර්
1
C ස්කොට්මිල්නර් ඔව්, නමුත් මෙම අභියෝගයේදී මෙය පැහැදිලිවම අවසර දී ඇත: "අපගේ සුපුරුදු නීති මෙන් නොව, මෙම අභියෝගයට වඩා අළුත් වුවත් භාෂාවක් (හෝ භාෂා අනුවාදයක්) භාවිතා කිරීමට නිදහස් වන්න"
— මාරාන්තික කරන්න
26

හස්කල්, බයිට් 49 යි

විල්සන්ගේ ප්‍රමේයයට xnor's Corollary භාවිතා කිරීම :

main=do n<-readLn;print$mod(product[1..n-1]^2)n>0
— ලින්
source
එය කිරීමට කෙටි නොවේ ද main=interact$\n-> ...?
— ජෝන් ඩ්වොරක්
2
ප්‍රතිවිරුද්ධ ලෙස, නැත! ඔබට interact...readකොහේ හෝ තැනක අවශ්‍ය බව සලකන්න , එය නිකම්ම වඩා දිගු වේ readLn. බොහෝ විට doඅංකනය ඔබ බලාපොරොත්තු වනවාට වඩා සංක්ෂිප්ත විය හැකිය, විශේෂයෙන් විකල්පය ලැම්බඩා වන විට.
— ලින්
24

ලැබ්රින්ත් , බයිට් 29 යි

1
?
:
}  +{%!@
(:'(
 } {
 :**

STDIN සහ නිමැවුම් වලින් පූර්ණ සංඛ්‍යාවක් කියවයි ((n-1)!)^2 mod n. විල්සන්ගේ ප්‍රමේයය මෙම අභියෝගයට බෙහෙවින් ප්‍රයෝජනවත් වේ.

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

?ඉන්පසු nSTDIN වෙතින් කියවා :එය අනුපිටපත් කරයි. }මොඩියුලය nසඳහා අවසානයේ භාවිතා කිරීම සඳහා සහායක තොගයට මාරුවීම . (පසුව අඩු වේn , වර්ග සාධක සාධකය ගණනය කිරීම ආරම්භ කිරීමට අපි සූදානම්.

අපේ දෙවැන්න : (අනුපිටපත) හන්දියක පිහිටා ඇති අතර, මෙහි ලැබ්රින්ත්ගේ පාලන ප්‍රවාහ ලක්ෂණ ක්‍රියාත්මක වේ. උපදෙස් ක්‍රියාත්මක කිරීමෙන් පසු හන්දියක, තොගයේ ඉහළ කොටස ධනාත්මක නම් අපි දකුණට හැරෙමු, negative ණ සඳහා අපි වමට හැරී ශුන්‍යයට කෙලින්ම ඉදිරියට යන්නෙමු. ඔබ හැරී බිත්තියට පහර දීමට උත්සාහ කරන්නේ නම්, ඒ වෙනුවට ඔබ අනෙක් දිශාවට හැරවීමට ලැබ්රින්ත් හේතු වේ.

මක්නිසාද යත් n = 1, තොගයේ ඉහළ කොටස nඅඩු වී ඇති නිසා හෝ 0අපි කෙළින්ම ඉදිරියට යමු. ඉන්පසුව අපි නො-ඔප් එකකට පහර දුන් අතර 'තවත් අඩුවීමක් (අප වෙත ගෙන එයි -1. මෙය negative ණාත්මක වන අතර, අපි වමට හැරී, +ප්ලස් ( -1 + 0 = -1) ක්‍රියාත්මක කරමින්, සහායක තොගයේ සිට ප්‍රධාන හා මොඩියුලෝ ( ) {වෙත nආපසු %හැරෙමු -1 % 1 = 0. එවිට අපි ප්‍රතිදානය කර !අවසන් කරමු@ .

මක්නිසාද යත් n > 1, තත්පරයට :අපි දකුණට හැරෙමු. කවුන්ටරය ආපසු මාරු කර අඩු කිරීමට පෙර }අපි පිටපත් කළ ලූප් කවුන්ටරය සහායක තොගයට අනුපිටපත් :කර දෙවරක් ගුණ කරන්නෙමු . අපි තවමත් ධනාත්මක නම් අපි දකුණට හැරවීමට උත්සාහ කළත් එය කළ නොහැකි ය, එබැවින් ලැබ්රින්ත් අපව වමට හැරවීමට සලස්වයි. එසේ නොමැතිනම්, තොගයේ මුදුන අපගේ ලූප කවුන්ටරය වන අතර එය 0 දක්වා අඩු කර ඇති අතර එය අප ගණනය කළ අගය එකතු කරයි . අවසාන වශයෙන්, අපි පසුව මොඩියුලෝ , ප්‍රතිදානය සහ අවසන් කිරීම සමඟ ආපසු යමු .**{(+((n-1)!)^2n{%!@

මම කිව්වේ 'එය විකල්පයක් නොවන නමුත් එය නිදොස්කරණය සඳහා ද භාවිතා කළ හැකි බවයි. සම්මත වූ -dසෑම අවස්ථාවකම තොගයේ තත්වය බැලීමට ධජය සමඟ ධාවනය කරන්න '!

— Sp3000
source
2
සාධකය වර්ග කිරීම ඇත්තෙන්ම සිසිල් උපක්‍රමයකි :)
— ලින්
A මෞරිස් ස්තූතියි! Xnor විසින් භාවිතා කරන උපක්රමය මුලින්ම දකින්නෙ මම - මම එය වුවත් නියමිත තැන ණය ලබා දිය යුතුය මෙහි
— Sp3000
5
ඔව්, මා විසින් ලියන ලද පළමු ලැබ්රින්ත් පිළිතුර! :)
— මාටින් එන්ඩර්
24

Bash + GNU උපයෝගිතා, 16

  • බයිට් 4 ක් ඉතිරි කළේ en ඩෙනිස්ට ස්තූතියි

  • බයිට් 2 ක් ඉතිරි කළේ @ ලෙකන්ස්ටයින්ට ස්තූතියි

factor|awk NF==2

ආදානය යනු STDIN වෙතින් ලබාගත් එක් පේළියකි. ප්‍රතිදානය යනු ව්‍යාජ සඳහා හිස් නූලක් වන අතර සත්‍යය සඳහා හිස් නොවන නූල් වේ. උදා:

$ ./pr.sh <<< 1
$ ./pr.sh <<< 2
2: 2
$ ./pr.sh <<< 3
3: 3
$ ./pr.sh <<< 4
$
— ඩිජිටල් කම්පනය
source
2
කූල්, තවත් කෝරුටිල් ගැන ඉගෙන ගත්තා. ක්ෂේත්‍ර ගණන ගණනය කිරීමෙන් ඔබට අක්ෂර දෙකක් ඉවත් කළ හැකිය:factor|awk NF==2
— ලෙකන්ස්ටයින්
E ලෙකන්ස්ටයින් - ස්තූතියි - කිසියම් හේතුවක් නිසා මට මීට පෙර ඔබේ අදහස මග හැරුණි :)
— ඩිජිටල් කම්පනය
මම තරමක් සමාන දෙයක් පළ කිරීමට යන්නේ, දිගු හා AWK නොමැතිව පමණි. හොඳට කලා.
— ඩේවිඩ් කොන්රාඩ්
21

ජාවා, බයිට් 126 121

මම හිතන්නේ අපට ලකුණු පුවරුව සඳහා ජාවා පිළිතුරක් අවශ්‍යයි ... ඉතින් මෙන්න සරල අත්හදා බැලීමේ අංශ ලූපයක්:

class P{public static void main(String[]a){int i=2,n=Short.valueOf(a[0]);for(;i<n;)n=n%i++<1?0:n;System.out.print(n>1);}}

ජාවා සඳහා සුපුරුදු පරිදි, "සම්පූර්ණ වැඩසටහන" අවශ්‍යතාවය මෙය බොහෝ විට mainඅත්සන නිසා එය ශ්‍රිතයක් වූවාට වඩා විශාල වේ .

පුළුල් ස්වරූපයෙන්:

class P{
    public static void main(String[]a){
        int i=2,n=Short.valueOf(a[0]);
        for(;i<n;)
            n=n%i++<1?0:n;
        System.out.print(n>1);
    }
}

සංස්කරණය කරන්න: අදහස් දැක්වීමේදී පීටර් විසින් ස්ථාවර සහ නැවත සකස් කරන ලදි. ස්තූතියි!

— Geobits
source
දෝෂය: එය 1ප්‍රමුඛ බව වාර්තා කරයි . එසේ නොමැතිනම් ඉවත් pකර පැවසීමෙන් 4-char ඉතිරියක් ලැබෙනු ඇතfor(;i<n;)n=n%i++<1?0:n;System.out.print(n>0);
— පීටර් ටේලර්
2
OTOH class P{public static void main(String[]a){int i=2,n=Short.valueOf(a[0]);for(;i<n;)n=n%i++<1?0:n;System.out.print(n>1);}}වැඩ කරයි
— පීටර් ටේලර්
6
3 වන පේළිය 'දිගු i = 2, n = Long.valueOf (a [0]); `ප්‍රති results ලය වන්නේ දිගෙහි වෙනසක් නොව පුළුල් පරාසයක වලංගු යෙදවුම් ය.
— ජනාධිපති ජේම්ස් මූවියන් පොල්ක්
4
ඒ වෙනුවට .valueOfඔබට භාවිතා කළ හැකිය new, මෙන් new Short(a[0]), හෝ new Long(a[0]), එය ටිකක් කෙටි වේ.
— ECS
3
අතුරු මුහුණතක් භාවිතා කිරීමෙන් සහ publicවිකරණකාරකය අතහැර දැමීමෙන් ඔබට බයිට් 4 ක් ඉතිරි කර ගත හැකිය .
— රාමන්චෙෆ්
19

මොළය-ෆ්ලැක් , බයිට් 112 108

({}[()]){((({})())<>){{}<>(({}<(({}[()])()<>)>)<>)<>{({}[()]<({}[()]<({}())>)>{(<()>)}{})}{}{}}}<>{{}}([]{})

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

එය ක්‍රියාත්මක වන ආකාරය

මුලදී, පළමු කොටුවේ ධනාත්මක පූර්ණ සංඛ්‍යාවක් අඩංගු වේ n වන අතර දෙවන තොගය හිස් වනු ඇත.

අපි පහත පරිදි n අඩු කිරීමෙන් ආරම්භ කරමු .

(
  {}      Pop n.
  [()]    Yield -1.
)       Push n - 1.

n = 1

නම් n = 1 , බිංදුවයි අතර ලූප වේ

{
  ((({})())<>)
  {
    {}<>(({}<(({}[()])()<>)>)<>)<>{({}[()]<({}[()]<({}())>)>{(<()>)}{})}{}{}
  }
}

සම්පූර්ණයෙන්ම මඟ හැරී ඇත. අවසාන වශයෙන්, ඉතිරි කේතය ක්රියාත්මක වේ.

<>    Switch to the second stack (empty).
{}    Pop one of the infinite zeroes at the bottom.
{<>}  Switch stacks while the top on the active stack is non-zero. Does nothing.
(
  []    Get the length of the active stack (0).
  {}    Pop another zero.
)     Push 0 + 0 = 0.

n> 1

නම් n - 1 නොවන ශුන්ය වේ, අප කරන ලූප ඇතුළු n = 1 මඟහරියි. එය “සැබෑ” පුඩුවක් නොවේ; කේතය ක්‍රියාත්මක වන්නේ එක් වරක් පමණි. එය පහත සඳහන් දෑ සාක්ෂාත් කරගනී.

{                   While the top of the active stack is non-zero:
  (
    (
      ({})                Pop and push n - 1.
      ()                  Yield 1.
    )                   Push n - 1 + 1 = n.
    <>                  Switch to the second stack. Yields 0.
  )                   Push n + 0 = n.
                      We now have n and k = n - 1 on the first stack, and n on
                      the second one. The setup stage is complete and we start
                      employing trial division to determine n's primality.
  {                   While the top of the second stack is non-zero:
    {}                  Pop n (first run) or the last modulus (subsequent runs),
                        leaving the second stack empty.
    <>                  Switch to the first stack.
    (
      (
        {}                  Pop n from the first stack.
        <
          (
            (
              {}              Pop k (initially n - 1) from the first stack.
              [()]            Yield -1.
            )               Push k - 1 to the first stack.
            ()              Yield 1.
            <>              Switch to the second stack.
          )               Push k - 1 + 1 = k on the second stack.
        >               Yield 0.
      )               Push n + 0 = n on the second stack.
      <>              Switch to the first stack.
    )               Push n on the first stack.
    <>              Switch to the second stack, which contains n and k.
                    The first stack contains n and k - 1, so it is ready for
                    the next iteration.
    {({}[()]<({}[()]<({}())>)>{(<()>)}{})}{}{}  Compute and push n % k.
  }               Stop if n % k = 0.
}               Ditto.

මගේ බෙදීම් පරීක්ෂණ පිළිතුරෙන් බයිට් 42 මොඩියුලස් ඇල්ගොරිතම භාවිතා කරමින් n% k ගණනය කෙරේ .

අවසාන වශයෙන්, n හි ප්‍රාථමිකභාවය තීරණය කිරීම සඳහා අපි ප්‍රති results ල අර්ථ නිරූපණය කරමු .

<>    Switch to the first stack, which contains n and k - 1, where k is the
      largest integer that is smaller than n and divides n evenly.
      If (and only if) n > 1 is prime, k = 1 and (thus) k - 1 = 0.
{     While the top of the first stack is non-zero:
  {}    Pop it.
}     This pops n if n is prime, n and k - 1 if n is composite.
(
  []    Yield the height h of the stack. h = 1 iff n is prime).
  {}    Pop 0.
)     Push h + 0 = h.
— ඩෙනිස්
source
2
ඉහළින් ඇති සත්‍ය 1 ප්‍රමාණවත් බැවින් ඔබට අන්තිම 0 තොගය පොප් කිරීමට අවශ්‍ය නැත; අන්තිම ඉවත් කිරීමෙන් ඔබට ඒ ආකාරයෙන් බයිට් දෙකක් ඉතිරි කළ හැකිය {}.
— ස්ටීවන් එච්.
1
හ්ම්, මම ඉරී ඇත. එක් අතකින්, ප්රශ්නය පවසන්නේ ප්රතිදානය තනිකරම සත්ය හෝ අසත්ය අගයකින් සමන්විත විය යුතු අතර 1 0එය අගයන් දෙකකි . අනෙක් අතට, භාෂාව ඒවා සත්‍ය හෝ ව්‍යාජ යැයි සලකන තාක් කල් අපි අරා පිළිගනිමු. බහුවිධ සිරස් අයිතම යනු මොළ-ෆ්ලැක් අරා කිරීමට ඇති ආසන්නතම දෙයයි. මෙය මෙටා වෙත ගෙන යාම වටී.
— ඩෙනිස්
බ්‍රේන්- 1 0ෆ්ලැක්හි නිර්මාතෘ සමඟ මම සත්‍යාපනය කර ඇත්තෙමි. chat.stackexchange.com/transcript/message/32746241#32746241
— ස්ටීවන් එච්.
3
— ඩෙනිස්
18

ආර්, 37 29 බයිට්

n=scan();cat(sum(!n%%1:n)==2)

අත්හදා බැලීමේ අංශය භාවිතා කරයි. scan()STDIN වෙතින් පූර්ණ සංඛ්‍යාවක් කියවා STDOUT cat()වෙත ලියයි.

අපි n1 සිට nමොඩියුලෝ දක්වා පූර්ණ සංඛ්‍යා වලින් සමන්විත දිග දෛශිකයක් ජනනය කරමු n. ( !) නිෂේධනය කිරීමෙන් සෑම එකක්ම 0 ද යන්න අපි පරික්ෂා කරමු , එමඟින් තාර්කික අගයක් 0 වන විට සත්‍ය වන අතර එය 0 ට වඩා වැඩි නම් අසත්‍ය වේ. තාර්කික දෛශිකයක එකතුව සත්‍ය මූලද්‍රව්‍ය ගණන වන අතර ප්‍රාථමික සංඛ්‍යා සඳහා අපි අපේක්ෂා කරමු එකම nonzero moduli 1 විය යුතු අතර n, එම නිසා එකතුව 2 ක් වනු ඇතැයි අපි අපේක්ෂා කරමු.

ෆ්ලෝඩෙල්ට ස්තූතියි බයිට් 8 ක් ඉතිරි කර ඇත!

— ඇලෙක්ස් ඒ.
source
සමග f=function(x)sum(!x%%1:x)==2ඔබ බයිට් 28 ක ඒක කරන්න පුළුවන්.
— මුටඩෝර්
2
@ AndréMuta මෙම අභියෝගය සඳහා, සියලු ඉදිරිපත් කිරීම් හුදෙක් කාර්යයන් වෙනුවට සම්පූර්ණ වැඩසටහන් විය යුතුය. යෝජනාවට ස්තූතියි.
— ඇලෙක්ස් ඒ.
17

TI-BASIC, බයිට් 12 යි

2=sum(not(fPart(Ans/randIntNoRep(1,Ans

හරිම සරලයි. randIntNoRep(1 සිට සියලු සංඛ්‍යා දක්වා අහඹු ලෙස ප්‍රේරණය ලබා දෙයි Ans.

මෙය නීති ටිකක් නැමෙයි; TI-BASIC හි ලැයිස්තු මා අර්ථ නිරූපණය කළ මූලද්‍රව්‍ය 999 කට සීමා වී ඇති බැවිනි

ආදානය ඔබේ දත්ත වර්ගය තුළ ගබඩා කළ හැකි යැයි උපකල්පනය කරන්න

සියලු දත්ත සමුදායන් ආදානයට අනුගත විය හැකි යැයි උපකල්පනය කළ හැකිය. OP මෙම අර්ථ නිරූපණයට එකඟ වේ.

ඒ 17-බයිට විසඳුමක් ඇත්තටම 10 ^ 12 හෝ එසේ දක්වා වැඩ කරන:

2=Σ(not(fPart(Ans/A)),A,1,Ans
— lirtosiast
source
@toothbrush සහා TI-මූලික වන්නේ tokenized එසේ නම් මෙන්න සෑම සංකේත හැර, එක් බයිටය වේ, භාෂාව randIntNoRep(දෙකක් වේ.
— lirtosiast
+1 අහ්, මම මීට පෙර TL-BASIC දැක නැත. මට දැනුම් දීම ගැන ස්තූතියි
— දත් බුරුසුව
1
නමුත්, එය වේ ටිකක් අසාධාරණ, එය එසේ නොවේ ...? මම ලිවිය යුත්තේ බයිට් 1-4 ක් (ප්‍රශ්න හැඳුනුම්පත) පමණක් අවශ්‍ය වන ගොල්ෆ් භාෂාවක් වන අතර පසුව පරාමිතීන්. එය තේරුම් ගන්නා භාෂාවකින් ඉහළම පිළිතුර තෝරා ගනු ඇත, එය ක්‍රියාත්මක කරයි (ඕනෑම පරාමිතියක් පසුකර) සහ ප්‍රති result ලය ලබා දෙනු ඇත ... එය නීති කඩ කරන්නේ දැයි මට සිතේ. :-)
— දත් බුරුසුව
othtoothbrush TI-BASIC හි ආරක්ෂාව සඳහා: පරිවර්තකයාට එය පයිත් සහ සීජෑම්ගේ එක් අක්‍ෂර විධානයන්ට වඩා අසාධාරණ නොවන අතර TI-BASIC වඩා කියවිය හැකිය.
— lirtosiast
1
සැබෑ. අනෙක් සෑම භාෂාවකම විසඳුම් දිගු බැවින් මම ඒ ආකාරයේ භාෂාවන්ට අකමැතියි ... මම මෑතකදී VJ6 සමඟ CJam පරාජය කළද ! : -]
— දත් බුරුසුව
16

TI-BASIC, බයිට් 24 යි

TI-Basic වැඩසටහන් ටෝකන පද්ධතියක් භාවිතා කරන බව සලකන්න, එබැවින් අක්ෂර ගණන් කිරීමෙන් වැඩසටහනේ සත්‍ය බයිට් අගය නොලැබේ.

තෝමස් ක්වාගේ පිළිතුර ඉහළට , එය උසස් ය.

:Prompt N
:2
:While N≠1 and fPart(N/Ans
:Ans+1
:End
:N=Ans

නියැදිය:

N=?1009
                         1
N=?17
                         1
N=?1008
                         0
N=?16
                         0

දැන් ආපසු 0එන්නේ ප්‍රයිම් එකක් නොවේ නම් හෝ 1එසේ නම්.

— ශෙනෝම්
source
4
වර්ග මූලය ඔබට වැඩසටහන නිවැරදි වීමට අවශ්‍ය නොවන ප්‍රශස්තිකරණයක් නොවේද?
— මාටින් එන්ඩර්
ඔබට දෙකට බෙදීමට අවශ්‍ය ඇයි?
— Geobits
මම සෑම විටම TI-BASIC පිළිතුරු වලට කැමතියි.
— ග්‍රාන්ට් මිලර්
ආදානය හරහා විමසුම තෝරා ගන්නේ ඇයි? ඒවා එකම බයිට් ගණනක් වන අතර, එය තනි විචල්‍යයක් වන විට ආදානය වඩාත් රූපමය වනු ඇත ...
— ආයුබෝවන් ආයුබෝවන්
@HelloGoodbye මගේ තර්කය නිවැරදිව සිහිපත් කළහොත් UI නොමිලේ වඩා හොඳය.
— සෙනෝහම්
16

ජාවාස්ක්‍රිප්ට්, බයිට් 39 36

ETHproductions වලට ස්තූතියි බයිට් 3 ක් ඉතිරි කර ඇත:

for(i=n=prompt();n%--i;);alert(1==i)

අග්‍රයක් සඳහා සත්‍යය, වෙනත් ආකාරයකින් අසත්‍යය පෙන්වයි.

මෙම සඳහා පුඩුවක් සෑම අංකය පරීක්ෂා i සිට n-1 දක්වා මම එය භාජකය වේ. සොයාගත් පළමු බෙදුම්කරු 1 නම් එය ප්‍රාථමික අංකයකි.

පෙර විසඳුම (බයිට් 39):

for(i=n=prompt();n%--i&&i;);alert(1==i)

අනවශ්‍ය පරීක්ෂණයක් ඉතිරි කළේ කෙසේද:

for(i=2,n=prompt();n%i>0&&i*i<n;i++);alert(n%i>0) //49: Simple implementation: loop from 2 to sqrt(n) to test the modulo.
for(i=2,n=prompt();n%i>0&&i<n;i++);alert(n==i)    //46: Replace i*i<n by i<n (loop from 2 to n) and replace n%i>0 by n==i
for(i=2,n=prompt();n%i&&i<n;i++);alert(n==i)      //44: Replace n%i>0 by n%i
for(i=2,n=prompt();n%i&&i++<n;);alert(n==i)       //43: Shorten loop increment
for(i=n=prompt();n%--i&&i>0;);alert(1==i)         //41: Loop from n to 1. Better variable initialization.
for(i=n=prompt();n%--i&&i;);alert(1==i)           //39: \o/ Replace i>0 by i

හොඳම ජාවාස්ක්‍රිප්ට් පිළිතුර දැනටමත් බයිට් 40 ක් තිබූ නිසා මම බයිට් 39 විසඳුම පමණක් පළ කළෙමි.

— හෙඩි
source
2
ක්‍රමලේඛන ප්‍රහේලිකා සහ කේත ගොල්ෆ් වෙත සාදරයෙන් පිළිගනිමු!
— ඩෙනිස්
2
නියම පිළිතුර! මෙම &&iඇත්තටම මෙම වැඩසටහන සඳහා ඕනෑම දෙයක් නැහැ, ඒ නිසා ඔබ එය ඉවත් කළ හැක.
— ETH නිෂ්පාදන
n>1ඔබට 1ප්‍රාථමික වීමට අවශ්‍ය නැතිනම් අවසාන කොන්දේසියට එකතු කළ යුතුය .
— ටයිටස්
1
It ටයිටස් යනු ආදානය 1සඳහා ලූපය n%--iඑක් වරක් කරයි: 1%0නැවත පැමිණ NaNලූපය නතර කරයි. විට alertහැඳින්වේ iදැනටමත් සමාන වේ 0ඒ නිසා 1==iප්රතිලාභ false.
— හෙඩි
2
i <2 (සහ සමහර පෙළ)
— ෂයින්ටෝඩ්
15

රූබි, 15 + 8 = බයිට් 23 යි

p$_.to_i.prime?

නියැදි ධාවනය:

bash-4.3$ ruby -rprime -ne 'p$_.to_i.prime?' <<< 2015
false
— manatwork
source
හෙහෙහ්, මම දැනගෙන හිටියා රූබී වල කොහේ හරි තැනක් තියෙයි කියලා, නමුත් මට ඒ ගැන හොයන්න බැහැ, ඒ නිසා මම සී +1 හි පිළිතුරු දුන්නා.
— මට්ටමේ ගංගාව ශාන්ත
@steveverrill, මම එය දැන සිටියේ ප්‍රොජෙක්ට් අයිලර් සඳහා විශාල උපකාරයක් වූ බැවිනි.
— manatwork
15

PARI / GP, බයිට් 21 යි

print(isprime(input))

හාස්‍යජනක ලෙස විශාල යෙදවුම් සඳහා ක්‍රියා කරයි, මන්ද මේ ආකාරයේ දෙයක් PARI / GP සඳහා සාදා ඇත.

— ලින්
source
6
isprimeඒපීආර්-සීඑල් ප්‍රාථමිකභාවය සනාථ කරන අතර, යෙදවුම් ඉතා විශාල වන බැවින් එය ටිකක් මන්දගාමී වේ. ispseudoprime(input)AES BPSW සම්භාව්‍ය ප්‍රයිම් ටෙස්ට් එකක් කරයි, එය ඉලක්කම් 100 ට වඩා වේගවත් වනු ඇත. අවුරුදු 35 කට පසුව තවමත් දන්නා ප්‍රති-සාම්පල නොමැත. පැරී හි 2.1 සහ ඊට පෙර අනුවාදය, 2002 ට පෙර සිට, වැරදි ප්‍රති results ල පහසුවෙන් ලබා දිය හැකි වෙනස් ක්‍රමයක් භාවිතා කරයි, නමුත් කිසිවෙකු එය භාවිතා නොකළ යුතුය.
— DanaJ
15

බළලුන් , 62 + 4 = බයිට් 66 ක්

*(>:^]*(*>{<-!<:^>[:((-<)<(<!-)>>-_)_<<]>:]<]]}*<)]*(:)*=<*)>]

-lnවිධාන රේඛා ධජ සමඟ ධාවනය කළ යුතුය (එබැවින් +4 බයිට්). 0සංයුක්ත අංක සහ 1ප්‍රාථමික සඳහා මුද්‍රණ .

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

මම හිතන්නේ මෙය සුළුපටු නොවන පළමු බළලුන් වැඩසටහනයි.

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

ඉක්මන් ස්ටැක් බළලුන් හැඳින්වීම:

  • ස්ටැක් බළලුන් ක්‍රියාත්මක වන්නේ අසීමිත තොගයක් මත වන අතර, ටේප් හෙඩ් එකක් වර්තමාන තොගයක් වෙත යොමු කරයි. සෑම තොගයක්ම මුලින් අසීමිත ශුන්‍යයන්ගෙන් පිරී ඇත. මම සාමාන්‍යයෙන් මගේ වචන වල මෙම ශුන්‍යයන් නොසලකා හරිනු ඇත, එබැවින් මම "තොගයේ පතුල" යැයි කියන විට මම අදහස් කරන්නේ අඩුම ශුන්‍ය නොවන අගය වන අතර මම "තොගය හිස්" යැයි පැවසුවහොත් එයින් අදහස් කරන්නේ එහි ඇත්තේ ශුන්‍යයන් පමණි.
  • වැඩසටහන ආරම්භ වීමට පෙර, a -1ආරම්භක තොගයට තල්ලු කරනු ලැබේ, පසුව සම්පූර්ණ ආදානය ඒ මතට තල්ලු කරනු ලැබේ. මෙම අවස්ථාවේ දී, හේතුවෙන්-n ධජය හේතුවෙන් ආදානය දශම සංඛ්‍යාවක් ලෙස කියවනු ලැබේ.
  • වැඩසටහන අවසානයේ, වත්මන් තොගය ප්‍රතිදානය සඳහා භාවිතා කරයි. එය තියෙනවා නම් -1පතුලේ, එය නොසලකා හරිනු ලැබේ. නැවතත්, -nධජය හේතුවෙන් , තොගයේ අගයන් සරලවම රේඛීය-වෙන් කළ දශම සංඛ්‍යා ලෙස මුද්‍රණය කෙරේ.
  • ස්ටැක් බළලුන් යනු ආපසු හැරවිය හැකි වැඩසටහන් භාෂාවකි: සෑම කේත කැබැල්ලක්ම අහෝසි කළ හැකිය (ස්ටැක් බළලුන් පැහැදිලි ඉතිහාසයක් නොමැතිව). වඩාත් විශේෂිතව, කේතය ඕනෑම කෑල්ලක් ආපසු හැරවීම සඳහා, ඔබ හුදෙක් එය පිළිබිඹු, උදා: <<(\-_)බවට පත් (_-/)>>. මෙම සැලසුම් ඉලක්කය භාෂාවේ පවතින්නේ කුමන ආකාරයේ ක්‍රියාකරුවන් සහ පාලන ප්‍රවාහ ඉදිකිරීම් සහ ගෝලීය මතක තත්වය මත ඔබට ගණනය කළ හැකි කාර්යයන් මොනවාද යන්න පිළිබඳව තරමක් දැඩි සීමාවන් පනවා ඇත.

  • ඒ සියල්ලටම ඉහළින්, සෑම ස්ටැක් කැට්ස් වැඩසටහනක්ම ස්වයං-සමමිතික විය යුතුය. ඉහත මූලාශ්‍ර කේතය සඳහා මෙය එසේ නොවන බව ඔබට පෙනෙනු ඇත. මෙය කුමක් ද -lඑම මධ්යස්ථානය සඳහා පළමු අක්ෂරය භාවිතා වමට කේතය එය නිසැකයෙන්ම කැඩපත්: ධජය සඳහා වේ. එබැවින් සත්‍ය වැඩසටහන:

    [<(*>=*(:)*[(>*{[[>[:<[>>_(_-<<(-!>)>(>-)):]<^:>!->}<*)*[^:<)*(>:^]*(*>{<-!<:^>[:((-<)<(<!-)>>-_)_<<]>:]<]]}*<)]*(:)*=<*)>]

සමස්ත කේතය සමඟ effectively ලදායී ලෙස ක්‍රමලේඛනය කිරීම ඉතා සුළු හා නොදැනුවත්ව සිදු කරන අතර මිනිසෙකුට එය කළ හැක්කේ කෙසේදැයි තවමත් සොයාගෙන නැත. අපි තිරිසන් එවැනි වැඩකටයුතු සරල කාර්යයන් සඳහා බල කර ඇත, නමුත් අතින් ඒ අසල කොතැනකටවත් යාමට නොහැකි වනු ඇත. වාසනාවකට මෙන්, වැඩසටහනේ අඩක් නොසලකා හැරීමට ඔබට ඉඩ සලසන මූලික රටාවක් අප සොයාගෙන ඇත. මෙය නිසැකවම උප ප්‍රශස්ත වුවත්, දැනට ස්ටැක් බළලුන් තුළ program ලදායී ලෙස වැඩසටහන්ගත කළ හැකි එකම ක්‍රමය එයයි.

එබැවින් මෙම පිළිතුරෙහි, එම රටාවේ අච්චුව මෙයයි (එය ක්‍රියාත්මක කරන ආකාරයෙහි යම් විචල්‍යතාවයක් ඇත):

[<(...)*(...)>]

වැඩසටහන ආරම්භ වූ විට, තොග පටිය මේ ආකාරයට පෙනේ (ආදානය සඳහා 4, කියන්න):

     4    
... -1 ...
     0
     ^

මෙම [වම් (සහ ටේප් හිස දිගේ) වෙත පියවරයන් සිරස් එකතුවේ ඉහල - අපි "තල්ලු" මෙම කතා කරන්න. හා <ටේප් හිස පමණක් ගමන් කරයි. එබැවින් පළමු විධාන දෙකෙන් පසුව, අපට මෙම තත්වය තිබේ:

...   4 -1 ...
    0 0  0
    ^

දැන් (...)එය ලූපයක් වන අතර එය කොන්දේසි සහිතව ඉතා පහසුවෙන් භාවිතා කළ හැකිය: ලූපය ඇතුල් කර ඉතිරි වන්නේ වත්මන් තොගයේ ඉහළට ධනාත්මක වූ විට පමණි. එය දැනට ශුන්‍ය බැවින්, අපි වැඩසටහනේ පළමු භාගය මඟ හැරෙමු. දැන් කේන්ද්‍රීය විධානය වේ *. මෙය සරලවම XOR 1, එනම් එය තොගයේ ඉහළ සිට අවම වශයෙන් සැලකිය යුතු ප්‍රමාණයක් ටොගල් කරයි, මේ අවස්ථාවේ දී 0එය a 1:

... 1 4 -1 ...
    0 0  0
    ^

දැන් අපට දර්පණ රූපය හමු වේ (...). මෙම කාලය සිරස් එකතුවේ ඉහල ධනාත්මක සහ අපි කරන්න කේතය ඇතුලත් කරන්න. වරහන් තුළ සිදුවන්නේ කුමක්ද යන්න සොයා බැලීමට පෙර, අපි අවසානයේ දී ඔතා ගන්නේ කෙසේද යන්න පැහැදිලි කිරීමට මට ඉඩ දෙන්න: මෙම කොටස අවසානයේ අපට ධනාත්මක අගයක් මත ටේප් හිස නැවත ඇති බව සහතික කිරීමට අපට අවශ්‍යය (එවිට තනි ප්රතිඵලයක්ම හා සරලව රේඛීය කොන්දේසි ලෙස භාවිතා පසු ලූපය අවසන් කිරීමක්), දකුණට අඩුක්කුව නිමැවුමේ අඩුක්කුව අයිතිය හිමි බවත් ඒ බව රොක්ව -1. එය එසේ නම්, අපි ලූපයෙන් ඉවත්ව, >ප්‍රතිදාන අගය වෙතට ගමන් කර ]එය මතට තල්ලු කරන්නෙමු, -1එවිට අපට ප්‍රතිදානය සඳහා පිරිසිදු තොගයක් ඇත.

ඒක තමයි. දැන් වරහන් තුළ අපට පෙර ඡේදයෙහි විස්තර කර ඇති පරිදි දේවල් සකස් කර ඇති බව සහතික කරන තාක් කල් අපට ප්‍රාථමිකත්වය පරීක්ෂා කිරීමට අවශ්‍ය ඕනෑම දෙයක් කළ හැකිය (සමහර තල්ලු කිරීම සහ ටේප් හිස චලනය කිරීමෙන් පහසුවෙන් කළ හැකිය). මම මුලින්ම විල්සන්ගේ ප්‍රමේයයේ ගැටලුව විසඳීමට උත්සාහ කළ නමුත් බයිට් 100 කට වඩා වැඩි ප්‍රමාණයක් අවසන් කළෙමි , මන්ද වර්ග වර්ග සාධක සාධක ගණනය කිරීම ඇත්ත වශයෙන්ම ස්ටැක් බළලුන් තුළ බෙහෙවින් මිල අධිකය (අවම වශයෙන් මට කෙටි මාර්ගයක් හමු වී නැත). ඒ නිසා මම ඒ වෙනුවට අත්හදා බැලීම් අංශය සමඟ ගිය අතර එය වඩාත් සරල විය. පළමු රේඛීය බිට් දෙස බලමු:

>:^]

ඔබ දැනටමත් එම විධාන දෙකක් දැක ඇත. ඊට අමතරව, :වත්මන් තොගයේ ඉහළම අගයන් දෙක ^මාරු කරන අතර XOR දෙවන අගය ඉහළ අගයට මාරු කරයි. මෙය සිදු කරයි:^ හිස් සිරස් තලයක අගය අනුපිටපත් කිරීමට පොදු රටාවක් කරයි (අපි අගයට ඉහළින් ශුන්‍යයක් ඇදගෙන පසුව ශුන්‍යය බවට පත් කරමු 0 XOR x = x). ඉතින් මෙයින් පසු, අපගේ ටේප් කොටස මේ ආකාරයට පෙනේ:

         4    
... 1 4 -1 ...
    0 0  0
         ^

මා විසින් ක්‍රියාවට නංවා ඇති අත්හදා බැලීමේ ඇල්ගොරිතම ආදානය සඳහා ක්‍රියා නොකරයි 1, එබැවින් අපි එම අවස්ථාවෙහිදී කේතය මඟ හැරිය යුතුය. අප ඉතා පහසුවෙන් සිතියම්ගත හැකි 1කිරීමට 0හා සමග ධනාත්මක වටිනාකම් අන් සියල්ල* , ඒ නිසා මෙහි අපි ඒක කරන්න ආකාරය මෙසේය:

*(*...)

බව අපි හැරී යනු 1බවට 0, අපි නියත වශයෙන්ම ලබා නම් කේතය එක ලොකු දෙයක් මඟ 0, නමුත් අපි වහාම නැති ඇතුළත *අපේ ආදාන අගය ආපසු ලබා එසේ බව. වරහන් වර්‍ගවල ධනාත්මක අගයකින් අවසන් වන බවට අපි නැවත සහතික කර ගත යුතුය. කොන්දේසි සහිතව, අපි එක් තොගයක් දකුණට ගෙන >ගොස් ප්‍රධාන අත්හදා බැලීමේ අංශය ආරම්භ කරමු:

{<-!<:^>[:((-<)<(<!-)>>-_)_<<]>:]<]]}

වරහන් (වරහන් වලට ප්‍රතිවිරුද්ධව) වෙනස් ආකාරයේ ලූපයක් අර්ථ දක්වයි: එය කළ යුතු වේලාවකි, එයින් අදහස් වන්නේ එය සෑම විටම අවම වශයෙන් එක් පුනරාවර්තනයක් සඳහා ක්‍රියාත්මක වන බවයි. අනෙක් වෙනස වන්නේ අවසන් කිරීමේ කොන්දේසියයි: ලූපයට ඇතුළු වන විට ස්ටැක් කැට් වත්මන් තොගයේ ඉහළ අගය සිහිපත් කරයි (0 අපගේ නඩුවේදී). පුනරාවර්තනයක් අවසානයේ මෙම අගයම නැවත දකින තුරු ලූපය ක්‍රියාත්මක වේ. මෙය අපට පහසු ය: එක් එක් පුනරාවර්තනයේ දී අපි ඊළඟ විභව බෙදුම්කරුගේ ඉතිරි කොටස ගණනය කර එය අපි ආරම්භ කරන ලූපය වෙත ගෙන යන්නෙමු. අපි බෙදුම්කරුවෙකු සොයාගත් විට, ඉතිරි කොටස වන 0අතර ලූපය නතර වේ. අපි ආරම්භයේ සිට බෙදුම්කරුවන් උත්සාහ කර n-1ඒවා නවතම හා පහළට අඩු කරන්නෙමු. ආ) පසුව අප උත්සාහ කළ අවසන් බෙදුම්කරු පරීක්ෂා කිරීමෙන් අංකය ප්‍රමුඛද නැද්ද යන්න තීරණය කළ හැකිය (එය නම්1 . ඒ කියන්නේ අ) අප ළඟා වන විට මෙය අවසන් වන බව අපි දනිමු11, එය ප්‍රාථමිකයකි, එසේ නොවේ නම්).

අපි ඒකට යමු. ආරම්භයේ දී කෙටි රේඛීය අංශයක් ඇත:

<-!<:^>[:

ඔබ දන්නවා මේ වන විට ඒවායින් බොහොමයක් කරන්නේ කුමක්ද කියා. නව විධානයන් -සහ !. ස්ටැක් බළලුන්ට වර්ධක හෝ අඩු කිරීමේ ක්‍රියාකරුවන් නොමැත. කෙසේ වෙතත් එයට -(නිෂේධනය, එනම් ගුණ කිරීමෙන් -1) සහ !(බිට්වේස් නොවේ, එනම් ගුණ කිරීමෙන් -1හා අඩුවීමෙන්) ඇත. මේවා වර්ධකයක් !-හෝ අඩුවීමක් ලෙස ඒකාබද්ධ කළ හැකිය -!. ඒ නිසා අපි nඉහළින් ඇති පිටපත අඩු කර , පසුව වම් පසින් තොගයේ -1තවත් පිටපතක් සාදා n, පසුව නව අත්හදා බැලීමේ බෙදුම්කරු ගෙන එය යටින් තබමු n. එබැවින් පළමු පුනරාවර්තනයේදී අපට මෙය ලැබේ:

      4       
      3       
... 1 4 -1 ...
    0 0  0
      ^

වැඩිදුර පුනරාවර්තන වලදී, 3කැමැත්ත ඊළඟ පරීක්ෂණ බෙදුම්කරු සමඟ ප්‍රතිස්ථාපනය වේ. (පිටපත් දෙක nසැමවිටම මෙම අවස්ථාවේදී එකම අගයක් වනු ඇත).

((-<)<(<!-)>>-_)

මෙය මොඩියුලෝ ගණනය කිරීමකි. ධනාත්මක අගයන් මත ලූප අවසන් වන හෙයින්, අදහස වන්නේ අපට ධනාත්මක අගයක් ලැබෙන තෙක් -nඅත්හදා බැලීමේ බෙදුම්කරුගෙන් නැවත නැවත එකතු කිරීමයි d. අප එසේ කළ පසු, අපි එහි ප්‍රති result ලය අඩු කරන dඅතර මෙය අපට ඉතිරි කොටස ලබා දෙයි. මෙහි ඇති උපක්‍රමශීලී දෙය නම් අපට -nතොගයේ මුදුනේ තබා එකතු කරන ලූපයක් ආරම්භ කළ නොහැකි වීමයි d: තොගයේ ඉහළ කොටස negative ණ නම්, ලූපය ඇතුළත් නොවේ. ආපසු හැරවිය හැකි ක්‍රමලේඛන භාෂාවක සීමාවන් එවැනි ය.

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

(-<)

තොගයේ මුදුන ධනාත්මක වන විට (එනම් පළමු පුනරාවර්තනය මත පමණක්), අපි එය ප්‍රතික්ෂේප කරමු -. කෙසේ වෙතත්, අපට එය කළ නොහැක්කේ දෙවරක් යොදන තුරු (-)අපි ලූපයෙන් ඉවත් නොවන බැවිනි -. එබැවින් අපි එක් කොටුවක් ඉතිරි <කරන්නේ එහි ධනාත්මක අගයක් ඇති බව අප දන්නා බැවිනි 1. හරි, ඉතින් දැන් අපි nපළමු පුනරාවර්තනය විශ්වාසදායක ලෙස ප්‍රතික්ෂේප කර ඇත්තෙමු . නමුත් අපට නව ගැටළුවක් ඇත: ටේප් හෙඩ් දැන් අනෙක් සෑම දෙයකටම වඩා පළමු නැවතීමේ වෙනස් ස්ථානයක සිටී. අප ඉදිරියට යාමට පෙර මෙය තහවුරු කර ගත යුතුය. ඊළඟට <ටේප් හිස වමට ගෙන යයි. පළමු පුනරාවර්තනයේ තත්වය:

        -4       
         3       
...   1  4 -1 ...
    0 0  0  0
    ^

දෙවන පුනරාවර්තනයේදී (මතක තබා ගන්න අපි දැන් එක් dවරක් එකතු කළෙමු -n):

      -1       
       3       
... 1  4 -1 ...
    0  0  0
    ^

ඊළඟ කොන්දේසිය මෙම මාර්ග නැවත ඒකාබද්ධ කරයි:

(<!-)

පළමු පුනරාවර්තනයේදී ටේප් හිස ශුන්‍යයට යොමු කරයි, එබැවින් මෙය සම්පූර්ණයෙන්ම මඟ හැරේ. තව දුරටත් පුනරාවර්තනය වන විට, ටේප් හෙඩ් එකකට යොමු කරයි, එබැවින් අපි මෙය ක්‍රියාත්මක කර, වමට ගමන් කර එහි කොටුව වැඩි කරන්නෙමු. සෛලය ශුන්‍යයෙන් ආරම්භ වන බව අප දන්නා බැවින්, එය දැන් සෑම විටම ධනාත්මක වනු ඇත, එවිට අපට ලූපයෙන් ඉවත් විය හැකිය. මෙමඟින් අප සැමවිටම ප්‍රධාන තොගයේ වම්පස දෙකක් අවසන් වන අතර දැන් ආපසු යා හැකිය >>. එවිට මොඩියුලෝ ලූපය අවසානයේ අපි කරන්නෙමු -_. ඔබ දැනටමත් දන්නවා -. XOR ට ඇති _දේ අඩු ^කිරීම ය: තොගයේ මුදුන aසහ යටින් ඇති අගය bඑය ප්‍රතිස්ථාපනය කරයි aනම් b-a. අපි මුලින්ම බොහෝ දුරට නිශේධනය සිට aවුවත්, -_විස්ථාපනය aසමග අපගේ ධාවනය මුළු බවට.b+a එකතු කරයිd

ලූපය අවසන් වූ පසු (අපි ධනාත්මක අගයක් කරා), ටේප් එක මේ ආකාරයෙන් පෙනේ:

        2       
        3       
... 1 1 4 -1 ...
    0 0 0  0
        ^

වමේ වැඩිම අගය ඕනෑම ධනාත්මක සංඛ්‍යාවක් විය හැකිය. ඇත්ත වශයෙන්ම, එය පුනරාවර්තන ගණන us ණ එකක් වේ. දැන් තවත් කෙටි රේඛීය බිට් එකක් තිබේ:

_<<]>:]<]]

මා කලින් කීවාක් මෙන් dසත්‍ය ඉතිරි ( 3-2 = 1 = 4 % 3) ලබා ගැනීම සඳහා ප්‍රති result ලය අඩු කළ යුතුය , එබැවින් අපි _නැවත වරක් කරන්නෙමු . ඊළඟට, අපි වම් පසින් වැඩි කර ඇති තොගය පිරිසිදු කළ යුතුය: අපි ඊළඟ බෙදුම්කරු උත්සාහ කරන විට, එය නැවත ශුන්‍ය විය යුතුය, පළමු නැවත ක්‍රියා කිරීම සඳහා. ඒ නිසා අපි එතැනට ගොස් එම ධනාත්මක අගය අනෙක් සහායක තොගයට තල්ලු කර <<]නැවත අපගේ මෙහෙයුම් තොගය වෙත ගෙන යන්නෙමු >. අපි ඔසවන්න dසමග :සහ මතට එය නැවත තල්ලු -1සමග ]හා අප සමග අපගේ කොන්දේසි අඩුක්කුව මතට ඉතිරි ගමන් <]]. අත්හදා බැලීමේ අංශයේ ලූපයේ අවසානය එයයි: අපට ශුන්‍ය ඉතිරියක් ලැබෙන තෙක් මෙය දිගටම පවතී, එම අවස්ථාවේ දී වම් පස ඇති තොගය අඩංගු වේnශ්‍රේෂ් greatest තම බෙදුම්කරු (හැර n).

ලූපය අවසන් වූ පසු, *<අපි 1නැවත ආදානය සමඟ මාර්ගවලට සම්බන්ධ වීමට පෙර ඇත. මෙම *හුදෙක් බවට ශුන්ය පැහැයට 1අපි ටිකක් අවශ්ය කරන්නම්, ඉන් පසුව අපි සමග භාජකය ගමන් කරන, <(ඒ නිසා අපි ආදානය සඳහා මෙන් ම අඩුක්කුව මත කියලා 1).

මෙම අවස්ථාවෙහිදී එය විවිධ ආකාරයේ යෙදවුම් තුනක් සංසන්දනය කිරීමට උපකාරී වේ. පළමුව, n = 1අපි එම අත්හදා බැලීම් අංශ කිසිවක් සිදු නොකළ විශේෂ අවස්ථාව :

         0    
... 1 1 -1 ...
    0 0  0
         ^

එවිට, අපගේ පෙර උදාහරණය n = 4, සංයුක්ත අංකයක්:

    2           
    1    2 1    
... 1 4 -1 1 ...
    0 0  0 0
         ^

අවසාන වශයෙන්, n = 3ප්‍රාථමික අංකයක්:

    3           
    1    1 1    
... 1 3 -1 1 ...
    0 0  0 0
         ^

එබැවින් ප්‍රාථමික සංඛ්‍යා සඳහා, අපට 1මෙම තොගයේ ඇති අතර සංයුක්ත සංඛ්‍යා සඳහා අපට 0වඩා වැඩි හෝ ධනාත්මක සංඛ්‍යාවක් 2ඇත. අපි මෙම තත්වය පහත දැක්වෙන අවසාන කේතය සමඟ 0හෝ 1අපට අවශ්‍ය බවට හරවන්නෙමු

]*(:)*=<*

]මෙම අගය දකුණට තල්ලු කරයි. එවිට *අවම වශයෙන් සැලකිය යුතු ටිකක් මාරුවීමට විසින්, අපි හැරී: මෙම කොන්දේසි තත්ත්වය බොහෝ සෙයින් සරල කිරීම සඳහා භාවිතා කරයි 1බවට (අගමැති) 0, 0ධනාත්මක වටිනාකමින් (සංයුක්ත) 1, සහ අනෙකුත් සියලු ම ධන අගයන් තවමත් ධනාත්මක පවතිනු ඇත. දැන් අපට අවශ්‍ය වන්නේ 0ධනාත්මක හා වෙනස හඳුනා ගැනීමයි . එතන තමයි අපි තවත් එකක් පාවිච්චි කරන්නේ (:). තොගයේ මුදුන නම් 0(සහ ආදානය ප්‍රමුඛ විය), මෙය සරලව මඟ හැරේ. නමුත් තොගයේ ඉහළ කොටස ධනාත්මක නම් (සහ ආදානය සංයුක්ත අංකයක් විය) මෙය එය සමඟ හුවමාරු කරයි 1, එවිට අපට දැන් 0සංයුක්ත සහ1ප්‍රාථමික සඳහා - වෙනස් අගයන් දෙකක් පමණි. ඇත්ත වශයෙන්ම, ඒවා අපට ප්‍රතිදානය කිරීමට අවශ්‍ය දෙයට ප්‍රතිවිරුද්ධ දෙයකි, නමුත් එය වෙනත් එකක් සමඟ පහසුවෙන් සවි කර *ඇත.

ධනාත්මක අගය මත ටේප්, හිස, දකුණට අඩුක්කුව මත ප්රතිඵලයක්, හා තනි: දැන් සියලු වම් අට්ටි රටාව නැවත බව අපේ අවට රාමුව අපේක්ෂා -1ගොඩට අයිතිය මත බව . මෙය =<*සඳහා ය. =යාබද කොටස් දෙකේ මුදුන් මාරු කරයි, එමඟින් ප්‍රති -1result ලයේ දකුණට ගමන් කරයි , උදා 4: නැවත ආදානය සඳහා :

    2     0       
    1     3       
... 1 4   1 -1 ...
    0 0 0 0  0
          ^

එවිට අපි වමට <හැරී එම ශුන්‍යය සමඟ එකක් බවට පත් කරමු *. ඒක තමයි.

වැඩසටහන ක්‍රියාත්මක වන ආකාරය පිළිබඳව ගැඹුරින් හාරා බැලීමට ඔබට අවශ්‍ය නම්, ඔබට නිදොස් කිරීමේ විකල්ප භාවිතා කළ හැකිය. එක්කෝ -dධජය එකතු කර "වත්මන් මතක තත්වය බැලීමට අවශ්‍ය ඕනෑම තැනකට ඇතුළු කරන්න , උදා: මේ වගේ , නැතහොත් -Dධජය භාවිතා කර සමස්ත වැඩසටහනේ සම්පූර්ණ හෝඩුවාවක් ලබා ගන්න . විකල්පයක් ලෙස, ඔබට පියවරෙන් පියවර නිදොස් කිරීමක් සහිත ස්ටැක් කැට්ස් පරිවර්තකය ඇතුළත් ටිම්විගේ එසෝටෙරිකයිඩ් භාවිතා කළ හැකිය .

— මාටින් එන්ඩර්
source
3
>:^]නිල ස්ටැක් බළලුන්ගේ ලාංඡනය විය යුතුය
— ඇලෙක්ස් ඒ.
14

හස්කල්, බයිට් 54 යි

import Data.Numbers.Primes
main=readLn>>=print.isPrime

පැහැදිලි කිරීමට වැඩි යමක් නැත.

— නිමි
source
1
විල්සන්ගේ ප්‍රමේයය භාවිතා කරමින් බාහිර පුස්තකාල නොමැතිව එකම ලකුණු ලබා ගත හැකිය (ඉතා අකාර්යක්ෂම වුවද):main=do n<-readLn;print$n>1&&mod(product[1..n-1]+1)n<1
— ලින්
9
අපට ඊටත් වඩා කෙටි කළ හැකිය: main=do n<-readLn;print$mod(product[1..n-1]^2)n>0බයිට් 49 කි.
— ලින්
4
A මෞරිස්: හොඳයි. කරුණාකර එය වෙනම පිළිතුරක් ලෙස පළ කරන්න.
— nimi
14

සී ++ අච්චු මෙටප්‍රෝග්‍රැමිං. 166 131 119 බයිට්.

නියතය ප්‍රමුඛයක් නම් කේතය සම්පාදනය වන අතර සංයුක්ත හෝ 1 නම් සම්පාදනය නොකරයි.

template<int a,int b=a>struct t{enum{x=t<a,~-b>::x+!(a%b)};};
template<int b>struct t<b,0>{enum{x};};
int _[t<1>::x==2];

(අවසාන එක හැර අනෙක් සියලුම නව රේඛා "තාත්වික" අනුවාදයෙන් ඉවත් කරනු ලැබේ).

"සම්පාදනය කිරීමට අපොහොසත් වීම" යනු පරිවෘත්තීය භාෂාවක් සඳහා වැරදි ප්‍රතිලාභයක් බව මම සිතමි. එය සම්පූර්ණ C ++ වැඩසටහනක් ලෙස සම්බන්ධ නොවන බව සලකන්න (එබැවින් ඔබ එය ප්‍රාථමිකයක් පෝෂණය කරන්නේ නම්, සම්බන්ධක දෝෂ ලැබෙනු ඇත).

පරීක්ෂා කිරීමේ අගය අවසාන "රේඛාවේ" නිඛිලය වේ.

සජීවී උදාහරණය .

— යක්
source
13

ගොළුබෙල්ලන්, 122

ආදානය ඒකාකාරව ලබා දිය යුතුය. ඉලක්කම් නව රේඛා හැර ඕනෑම අක්ෂර එකතුවක් විය හැකිය.

^
..~|!(.2+~).!~!{{t.l=.r=.}+!{t.!.!~!{{r!~u~`+(d!~!.r~)+d~,.r.=.(l!~u~)+(d!~l~)+d~,.l.},l=(.!.)(r!~u~)+(d!~!.r~)+d~,.r.!.

මෙම 2D රටා ගැලපෙන භාෂාවෙන්, වැඩසටහන් තත්වය සමන්විත වන්නේ වර්තමාන ජාලක පිහිටීම, ගැලපෙන සෛල සමූහය සහ රටා කේතයේ පිහිටීම පමණි. ගැලපෙන චතුරස්රයකට ගමන් කිරීම ද නීති විරෝධී ය. එය උපක්‍රමශීලී නමුත් තොරතුරු ගබඩා කිරීමට සහ ලබා ගැනීමට හැකි ය. ගැලපෙන කොටුවකට ගමන් කිරීමට ඇති සීමාව පසුබැසීම, ටෙලිපෝර්ට් කිරීම ( t) සහ ප්‍රකාශයන් ( =, !) මගින් ජය ගත හැකිය .

25 ක සාධකකරණය

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

විවරණ කේතය:

^                         Match only at the first character
..~ |                     Special case to return true for n=2
!(.2 + ~)                 Fail for even numbers
. !~                      Match 1st character and fail for n=1
!{                        If the bracketed pattern matches, it's composite.
  (t. l=. r=. =(.,~) )+   Teleport to 1 or more chars and match them (blue in graphic)
                          Only teleport to ones that have an unmatched char on each side.
                          The =(.,~) is removed in the golfed code. It forces the
                          teleports to proceed from left to right, reducing the
                          time from factorial to exponential.
  !{                      If bracketed pattern matches, factorization has failed.
    t . !. !~             Teleport to a square to the left of a blue square (yellow in diagram)
    !{                    Bracketed pattern verifies equal number of spaces to
                          the left or right of a blue square.
      {              
        (r!~ u~)+         Up...
        (d!~!. r~)+       Right...
        d~,               Down...
        . r . =.          Move 1 to the right, and check that we are not on the edge;
                          otherwise d~, can fall off next iteration and create and infinite loop
        (l!~ u~)+         Up...
        (d!~ l~)+         Left...
        d ~,              Down...
        . l .             Left 1
      } ,                 Repeat 0 or more times
      l  =(. !.)          Check for exactly 1 unused char to the left
      (r!~ u~)+           Up...
      (d!~!. r~)+         Right...
      d ~,                Down...
      . r . !.
    }
  }
}
— feersum
source
13

පයිතන් 3, බයිට් 59 යි

දැන් input()විධාන රේඛා තර්ක වෙනුවට භාවිතා කරයි . Et බීටා ක්ෂය වීමට ස්තූතියි

n=int(input())
print([i for i in range(1,n)if n%i==0]==[1])
— uno20001
source
ආදානය භාවිතා input()කිරීම වඩා කෙටි වනු ඇත
— බීටා ක්ෂය වීම
ස්තූතියි, මම දැනටමත් ආදාන () භාවිතා කරමින් ලියා ඇත, නමුත් මගේ පිළිතුර නැවුම් කිරීමට මට අමතක විය. නැවත ස්තූතියි!
— uno20001
6
52 බයිට්: n=m=int(input()),print(all(n%m for m in range(2,n)))
— ජෝන් රයන්
3
ඔයා බැරැරුම් ද. කොර වූ චතුරස්රාකාර වේගවත් කිරීම සඳහා අමතර අක්ෂර 25 ක් වියදම් කරන්න? මෙන්න අපි බයිට් වලට වෛර කරනවා . අපගේ ජීවිතයේ සෑම පැයක්ම, මිනිත්තුවක්ම සහ තත්පරයක්ම දහනව වන බයිටයෙන් මිදීමට අපි වැය කරමු. (විහිළුවක් පමණි. නමුත් අපි වැඩසටහන් දිග වැඩි කරන කාල ප්‍රශස්තිකරණයන් නොකරමු.)
— කැල්කියුලේටර්
2
n%i<1ඒ වෙනුවට භාවිතා කරන්න .
— එරික් ද අවුට්ගොල්ෆර්
13

සී, බයිට් 67 යි

i,n;main(p){for(scanf("%d",&i),n=i;--i;p=p*i*i%n);putchar(48+p%n);}

මුද්‍රණ !1( පීටර් ටේලර්ගේ අර්ථ දැක්වීම අනුව ව්‍යාජ අගයක් ) 0 නම් (n-1)!^2 == 0 (mod n)සහ 1වෙනත් ආකාරයකින්.

සංස්කරණය කරන්න : කතාබස් වල යම් සාකච්ඡාවකින් පසුව, puts("!1"+p%n)එය ටිකක් වංචනික යැයි පෙනේ, එබැවින් මම එය ප්‍රතිස්ථාපනය කර ඇත්තෙමි. ප්‍රති result ලය එක් බයිට් එකකි.

සංස්කරණය කරන්න : විශාල යෙදවුම් සඳහා ස්ථාවරයි.

කෙටි විසඳුම්

බයිට් 56 : pawel.boczarski විසින් කරන ලද අදහස් දැක්වීම්වල නිර්දේශ කර ඇති පරිදි, විධාන රේඛා තර්ක ගණන කියවීමෙන් මට ඒකීය ලෙස ආදානය කළ හැකිය:

p=1,n;main(i){for(n=--i;--i;p=p*i*i%n);putchar(48+p%n);}

වැනි වැඩසටහනට ආයාචනා කිරීම

$ ./a.out 1 1 1 1 1
1                        <-- as 5 is prime

බයිට් 51 : ආපසු කේත මගින් ඔබ "ප්‍රතිදානය" කිරීමට ඉඩ දෙන්නේ නම්:

p=1,n;main(i){for(n=--i;--i;p=p*i*i%n);return p%n;}
— ලින්
source
මගේ විසඳුමෙහි පළ කර ඇති පරිදි, ඒකීය නිරූපණය (විධාන රේඛා තර්ක ගණන) භාවිතයෙන් ඔබේ විසඳුම කෙටි කළ හැකිය. ස්කෑන්ෆ් ඇමතුමෙන් ඔබට බයිට් කිහිපයක් කපා දැමිය හැකිය.
— pawel.boczarski
puts("!1"+p%n)සාරධර්ම a+bසඳහා ඔබට කවදා හෝ කළ හැක්කේ කෙසේද char*?
— එරික් ද අවුට්ගොල්ෆර්
"!1"නූල ලිපිනයෙන් ආරම්භ වන්නේ නම් a, එවිට a+1ඔබට නූල හමුවනු "1"ඇත.
— ලින්
@Lynn ඔහ්, මම (ඔව්, වඩා හොඳ නිවාඩු එය අකාර සඳහා කියලා ඒ සඳහා strcat(const char*,const char*).)
— එරික් මෙම Outgolfer
ඔබ වෙනස් විය හැකි p=p*i*i%nකිරීමටp*=i*i%n
— ඇල්බට් Renshaw
13

පයිතන් 2, 44

P=n=1
exec"P*=n*n;n+=1;"*~-input()
print P%n

Sp3000 හි පයිතන් පිළිතුර මෙන් , නමුත් විචල්‍යය ආදාන අගය nදක්වා ගණනය කිරීමෙන් ආදානය ගබඩා කිරීමෙන් වළකින්න 1.

— xnor
source
12

ඒපීඑල්, බයිට් 40 13

2=+/0=x|⍨⍳x←⎕

මගේ R පිළිතුරට සමාන ඇල්ගොරිතමයක් සහිත පරීක්ෂණ බෙදීම . අපි xSTDIN ( ⎕) වෙතින් ආදානය වෙත පවරා ඇති අතර ඉතිරිය xඑක් එක් නිඛිලයෙන් 1 සිට බෙදීම සඳහා ලබා ගනිමු x. සෑම ඉතිරියක්ම 0 හා සැසඳෙන අතර, එමඟින් අපට සංඛ්‍යා හා ශුන්‍ය දෛශිකයක් ලබා දෙයි x. +/බෙදුම්කරුවන්ගේ සංඛ්‍යාව ලබා ගැනීම සඳහා මෙය සාරාංශගත කරයි . මෙම සංඛ්‍යාව හරියටම 2 නම්, මෙයින් අදහස් කරන්නේ එකම බෙදුම්කරුවන් 1 ක් xවන අතර එමඟින් xප්‍රමුඛ වේ.

— ඇලෙක්ස් ඒ.
source
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.