ডাকাতরা: রেজেক্সকে ক্র্যাক করুন - একটি সাপ তৈরি করুন


20

এটি ডাকাতদের সুতো। পুলিস এর থ্রেড এখানে


একটি সাপ ম্যাট্রিক্স একটি বর্গ ম্যাট্রিক্স যা এই ধরণটি অনুসরণ করে:

3-বাই-3:

1  2  3
6  5  4
7  8  9

এবং 4-বাই -4:

1  2  3  4
8  7  6  5
9  10 11 12
16 15 14 13

আপনার কাজটি এমন একটি কোড লিখুন যা একটি ইনপুট নেয় nএবং একটি পুলিশ পোস্টের মতো একই ভাষায় এবং এমন একটি কোড সহ একটি মেট্রিক্স তৈরি করে যা কোনও পুলিশকে রেজিজেসের সাথে মেলে। আপনার কোডের আউটপুট ফর্ম্যাটটি অবশ্যই পুলিশের কোডের আউটপুট ফর্ম্যাটের সাথে মেলে।

আপনি এটি ক্র্যাক করেছেন তা বোঝাতে দয়া করে কপির পোস্টের নীচে একটি মন্তব্য দিন।

বিজয়ী মানদণ্ড:

বিজয়ী এমন ব্যবহারকারী হবেন যা সর্বাধিক জমা দেওয়ার ক্র্যাক করেছে। টাই করার ক্ষেত্রে একাধিক বিজয়ী থাকবে।

উত্তর:


10

জেলি , 9 বাইট, ক্র্যাক @ ডেনিসের উত্তর

²sµUFḤ$¦G

এটি অনলাইন চেষ্টা করুন!

এখনই সঠিক হওয়া উচিত; আমি বরং আমি যা করছি তা নিয়ে নতুন করে চিন্তা করতে হয়েছিল।

ব্যাখ্যা

এই সমস্যার সবচেয়ে শক্ত অংশটি এর ভিতরে থাকা সূচকগুলির ¦(যা নির্দিষ্ট সূচকগুলিতে কোনও ক্রিয়াকলাপ প্রয়োগ করে) তালিকা পাচ্ছে । বেশিরভাগ অপারেশনের বিপরীতে, যা পুরো অপারেণ্ডের জন্য ডিফল্ট হিসাবে পুরো প্রোগ্রামটির ইনপুট ¦ব্যবহার করে, সর্বাধিক দেখা মানটি একটি ডিফল্ট হিসাবে ব্যবহার করে (কারণ এটি ধারণাগতভাবে দুটি বাম অপারেন্ডের চেয়ে বেশিরভাগ জিনিসের মতো বাম এবং ডান অপারেন্ড থাকে যা দুটি মান গ্রহণ)।

তবে আমরা লক্ষ করতে পারি যে ইতিমধ্যে বর্তমান মানটিতে 1 থেকে অর্ধ ইনপুট পর্যন্ত সমস্ত পূর্ণসংখ্যাসহ আমাদের সংখ্যার একটি তালিকা রয়েছে। যেমন চ্যাপ্টা এবং দ্বিগুণ করা আমাদের সমান সূচকগুলি সহ আরও সংখ্যার একটি তালিকা দেয় (এছাড়াও কিছু অন্যান্য এমনকি সংখ্যাগুলিও আমরা সেগুলির বিষয়ে যত্ন করি না)। µপার্সিং অস্পষ্টতা এড়ানোর জন্য একমাত্র ব্যয় করা এমনকি 9 টি অক্ষরের মধ্যে আসা এমনকি সম্ভব ।

²sµUFḤ$¦G
 s         Split
²          {the list of numbers from 1 to} the square of {the input}
  µ        into a number of pieces equal to {the input};
   U       then reverse
       ¦   the elements at indexes
    F      obtained by flattening the split list
      $    and
     Ḥ     doubling each element in the flattened list;
        G  finally, format it into a grid.         

উহ, যেভাবে ¦প্রতিবার কাজগুলি আমাকে হত্যা করে, গতকাল আমি এটি চেষ্টা করেছিলাম এবং বরং Uসিদ্ধান্ত নিয়েছিলাম যে এটি কার্যকর হচ্ছে না।
জোনাথন অ্যালান

ভাল, আমি প্রায় এটি ছিল কিন্তু পাশাপাশি অন্যান্য উপাদান নির্বাচন করতে আটকে গিয়েছিলাম। Fএকটি দুর্দান্ত ধারণা ছিল
ETH প্রোডাকশনগুলি 9:37

আমার আসল কোডটি এর থেকে অনেকটা অভিন্ন। আমি শুধু Jপরিবর্তে ব্যবহার F
ডেনিস

@ ডেনিস ওহ, J... আমি চেষ্টা করেছি LRকিন্তু 11 বাইটের আওতায় পাচ্ছি না
ইটিএইচ প্রডাকশনস

9

05 এ বি 1 ই, এমিগনা

05AB1E ব্যবহার করে এটি আমার প্রথমবার। কিছুটা সাহায্য নিয়ে পেয়েছি। ঐটা মজা ছিল. :)

UXFXLNX*+N2BSR1k_iR}ˆ

এটি অনলাইনে চেষ্টা করুন

ব্যাখ্যা:

U                       Assign input to X
 XF                     For N in range(0,X):
   XL                   Push list [1 .. X]
     NX*+               Add N*X to each element of the list
         N2BSR1k_       Super clever way to get N%2:
                            not bool(reversed(str(bin(N))).index('1')) (N%2 is odd)
                 iR}    if N%2 is odd, then reverse the list
                    ˆ   Add row to global array
                        Implicit print

আমি আসলে এই জাতীয় প্রোগ্রামটি নিজে থেকেই পেয়েছি তবে আউটপুট ফর্ম্যাটটি আলাদা:

UXFXLNX*+N2BSR1k_iR}=

এটি অনলাইনে চেষ্টা করুন

[1, 2, 3, 4]
[8, 7, 6, 5]
[9, 10, 11, 12]
[16, 15, 14, 13]

আমার আগের দুটি চেষ্টার জন্য সম্পাদনা ইতিহাস দেখুন।


সুন্দর কাজ! মূল সমাধানের সাথে বেশ মিল।
এমিগিনা

5
not bool(reversed(str(bin(N))).index('1'))... আমি মনে করি এটিই সবচেয়ে অযৌক্তিক উপায়ে আমি কাউকে N%2অপারেশন করতে দেখেছি ।
স্টিভি গ্রিফিন

3
@ স্টেভি গ্রিফিন যখন জীবন আপনাকে লেবু দেয় কিন্তু জল বা চিনি না দেয়, আপনাকে কেবল তাদের কাঁচা খেতে হবে। : ডি
mbomb007


5

ওহম, নিক ক্লিফোর্ড

আমার প্রথমবার ওহমের চেষ্টা করা।
সত্যিই খুব সুন্দর ভাষা যা আমি আবার ব্যবহার করার জন্য প্রত্যাশা করি :)

²@┼σ▓_^è?R

ব্যাখ্যা

²             # square input
 @            # range [1 ... input^2]
  ┼σ          # split in input sized chunks
    ▓         # perform the following block on each element of the array
     _        # current element
      ^è?     # if index is odd
         R    # reverse

আমার প্রথম প্রচেষ্টা যা অ্যারের যোগ হিসাবে কাজ করে নি এবং কোনও ইন্টি সম্ভব নয়:

@┼MDR┼+;W

আমার দ্বিতীয় প্রচেষ্টা যা রেজেক্সের সাথে মেলে না:

²@┼σ▓_^MR

আমি ঠিক কীভাবে করেছিলে! দারূন কাজ!
নিক ক্লিফোর্ড

5

05 এ বি 1 ই, এমিগনা (২ য় জমা)

05AB1E এর সাথে প্রথমবার কাজ করা।

VYLUYFYXDˆ+RU

এটি অনলাইন চেষ্টা করুন! | রেজেক্স যাচাইকরণ

ব্যাখ্যা

VYLUYFYXDˆ+RU  # Implicit input
V              # Save input to Y
 YL            # Push [1 .. Y]
   U           # Save list to X
    YF         # Repeat Y times:
      YX       # Push Y, then X
        Dˆ     # Add X into the global array (could've used X here instead)
          +    # Push X + Y
           R   # Reverse top of stack
            U  # Save updated list to X
               # Implicit loop end
               # Implicit global array print if stack is empty

সুন্দর কাজ! আপনি উদ্দিষ্ট সমাধানটি পেয়েছেন :)
এমিগিনা

@ এমিগনা ধন্যবাদ! আমি যদি এখানে অন্য সমাধানগুলির জন্য না থাকি তবে এটি অর্জন করতে পারতাম না (আপনার অন্তর্ভুক্ত) যা আমাকে বুঝতে দেয় যে স্ট্যাকটি ফাঁকা থাকলে বিশ্বব্যাপী অ্যারেটি মুদ্রণ করবে! যদি এটি না হয় তবে আমি কখনই এটি বের করতে পারতাম না; )স্ট্যাকের সঠিক ফলাফল পাওয়ার একমাত্র উপায় হতে পারে এই ভেবেই আমি সেই কৌশলগুলি চেষ্টা করে যাচ্ছি।
মান কালি

হ্যাঁ )আপনি যখন কেবলমাত্র 2 অ-বর্ণমালা অক্ষর ব্যবহার করতে পারেন তখন এটি করা বেশ অসম্ভব । এখানে জটিল অংশটি কেবলমাত্র 2 টি ওয়াইল্ডকার্ড ব্যবহার এবং সেগুলিকে ক্রমযুক্ত করার জন্য প্রোগ্রামটি কাঠামোগত করা হয়েছিল। অন্য সমাধানগুলি না থাকলে সম্ভবত কিছুটা শক্ত হতে পারত তবে কিছুটা
হতবাক

@ এমিগনা আমি যা জানতে চাই তা যদি ^\w*..$সম্ভব হয়।
mbomb007

@ এমবম্ব ২০০7: আমি তা মনে করি না। এই কৌশলটির সাথে আপনার পরবর্তী পুনরাবৃত্তির জন্য সংযোজনটির ফলাফল সংরক্ষণ করতে হবে এবং আপনি এই অর্থটির জন্য স্ট্যাকটি ব্যবহার করতে পারবেন না যে এর পরে একটি UVপ্রয়োজন । আমি শেষের দিকে কেবল 2 টি ওয়াইল্ডকার্ড দিয়ে এটি করার অন্য কোনও উপায় সম্পর্কে ভাবতে পারি না। এটি 3 টি ওয়াইল্ডকার্ডের সাথে করা যেতে পারে যদিও।
এমিগিনা

5

সিজেম , লিন

esmpmpmeimtmemqmememqicelic
esmpmpmeimememqmlmtmemoc
esmpmpmeimememqmtmtmtmtmeic
esmpmpmeimememqmtmtmtmtmeic
esmpmpmeimeiscic
esmpmpmeimemeimfsic
esmpmpmeisciscimqmtmemeic
esmpmpmeiscimlmqmqmemeic
esmpmpmeimemomqmqmemeic
esmpmpmeisciscimfsimqic
esmpmpmeimeiscic
esmpmpmeisciscimfsimqic
esmpmpmeimemomqmemqmemtmemoc
esmpmpmeiscic
esmpmpmeimemomeimqmeic
esmpmpmeimemeimqmlmtmeic
esmpmpmeimtmtmqmemtmtmeic
esmpmpmeimemomqmqmtmeic
esmpmpmeimemqmqmemeic
esmpmpmeiscimlmqmqmemeic
esmpmpmeiscimqmtmtmtmqmemeic
esmpmpmeimeimemtmqmemeic
esmpmpmeimeiscimlmlmtmlmtic
esmpmpmeimemeimqmlmtmeic
~~

সমস্ত লাইনফিডগুলি কসমেটিক উদ্দেশ্যে হয় এবং প্রোগ্রামকে প্রভাবিত না করেই সরানো যেতে পারে।

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

লিন {|}অনুমতিপ্রাপ্ত অক্ষরের তালিকা থেকে সরানোর পরে , আমাকে নতুন কিছু চেষ্টা করতে হয়েছিল। দেখা যাচ্ছে যে আমরা এখনও নির্বিচারে স্ট্রিংগুলি তৈরি করতে পারি এবং কোড হিসাবে তাদের মূল্যায়ন করতে পারি।

প্রথমত, আমাদের স্ট্যাকের উপর কিছু মূল্য অর্জন করতে হবে। শুধুমাত্র উপলব্ধ বিল্ট-ইনগুলিকে অন্য কিছু পপিং প্রথম ছাড়া (এবং ইনপুট পড়া ছাড়া) কিছু ধাক্কা হয় es, eaএবং et। আমি নিশ্চিত যে আপনি এই সমস্ত এক বা অন্য কোনও উপায়ে থেকে শুরু করতে পারেন তবে আমি esযা করেছি বর্তমান টাইমস্ট্যাম্পকে ধাক্কা দিয়ে। যেহেতু আমি এর আসল মান সম্পর্কে কোনও ধারনা তৈরি করতে চাইনি, তাই আমি এর প্রাথমিকতাটি mp(যা দেয় 0এবং 1) দিয়ে পরীক্ষা করে এবং সেই মানটির আধিপত্যটি আবারও পরীক্ষা করে দেখি যে আমি 0স্ট্যাকটি পেয়েছি a এ 1আরও কার্যকর হবে, সুতরাং আমরা এটির exp(0)সাথে গণনা করব meএবং এটিটিকে একটি পূর্ণসংখ্যার সাথে পরিণত করব i। সুতরাং সমস্ত নম্বর দিয়ে শুরু:

esmpmpmei

এখন কাজ করার জন্য আমাদের কাছে পুরো ইউনিট অ্যালারি ম্যাথস অপারেটর রয়েছে:

i    int(x) (floor for positive numbers, ceiling for negative)
me   exp(x)
ml   ln(x)
mq   sqrt(x)
mo   round(x)
mt   tan(x)

এর আরও বিস্তৃত ফাংশনগুলির জন্য আমরা কয়েকটি বিল্ট-ইনগুলিও একত্রিত করতে পারি x:

sci     Extract first digit of x and add 48 (convert to string, convert
        to character, convert to integer).
ceui    Convert to character, convert to upper case, convert to integer.
celi    Convert to character, convert to lower case, convert to integer.
mfsi    Get a sorted list of prime factors of x and concatenate them into 
        a new number.
mfseei  Get a sorted list of prime factors, interleave it with 1,2,3,..., and
        concatenate the result into a new number.

এগুলি ব্যবহার করে আমরা 0 <= x < 12810 টিরও কম পদক্ষেপে কোনও সংখ্যক (এবং আরও অনেক) পেতে পারি 1। আমি নিশ্চিত যে এই কমান্ডগুলির একটি আরও ছোট উপসেটটিও যথেষ্ট। এই সমস্ত স্নিপেটগুলি নির্ধারণ করার জন্য আমি একটি ছোট ম্যাথমেটিকা ​​প্রোগ্রাম লিখেছি (এটি খুব পাঠযোগ্য নয়, দুঃখিত):

codes = SortBy[
  Select[Nest[Select[DeleteDuplicatesBy[SortBy[Join @@ (Through[{
               List,
               If[1 <= # < 50, {Exp@#, #2 <> "me"}, Nothing] &,
               If[# >= 1, {Log@#, #2 <> "ml"}, Nothing] &,
               If[# > 1, {Sqrt@#, #2 <> "mq"}, Nothing] &,
               {If[# > 0, Floor@#, Ceiling@#], #2 <> "i"} &,
               {Floor[# + 1/2], #2 <> "mo"} &,
               {Tan@#, #2 <> "mt"} &,               
               If[NumberQ@# && # >= 0, {First@
                   ToCharacterCode@ToString@#, #2 <> "sci"}, 
                 Nothing] &,
               If[IntegerQ@# && 
                  32 < # < 65536, {First@
                   ToCharacterCode@
                    ToUpperCase@FromCharacterCode@#, #2 <> "ceui"}, 
                 Nothing] &,
               If[IntegerQ@# && 
                  32 < # < 65536, {First@
                   ToCharacterCode@
                    ToLowerCase@FromCharacterCode@#, #2 <> "celi"}, 
                 Nothing] &,
               If[IntegerQ@# && # > 0, ## & @@ {
                   {FromDigits[
                    "" <> (ToString /@ (f = 
                    Join @@ Table @@@ FactorInteger@#))], #2 <> 
                    "mfsi"},
                   {FromDigits[
                    "" <> (ToString /@ 
                    MapIndexed[## & @@ {#2[[1]] - 1, #} &, f])], #2 <>
                     "mfeesi"}
                   }, Nothing] &
               }@##] &) @@@ #, StringLength@*Last], 
       First], #[[1]] < 1000000 &] &, {{1, "esmpmpmei"}}, 9], 
   IntegerQ@# && 0 <= # < 128 &@*First], First]

এটির সাহায্যে আমরা কেবল অক্ষর কোডগুলির একটি স্বেচ্ছাসেবী তালিকায় চাপ দিতে পারি, সেগুলির প্রত্যেককে cপরবর্তীকালে একটি চরিত্রে রূপান্তরিত করতে পারি । একবার আমরা পুরো কোডটি কার্যকর করতে চাইলে আমরা পুশ করে ফেলি 95( ])। আমরা যে এক Eval ~একটি স্ট্রিং অন্যান্যদের মোড়ানো এবং তারপর আমরা যে স্ট্রিং Eval ~

প্রোগ্রামের শেষে চালিত আসল কোডটি আবার:

ri__2#,:)/2/[1W]f.%:~<p

একটি ব্যাখ্যা জন্য আমার আগের সমাধান দেখুন ।


4

পাইথন 3, টুকুএক্সএক্স

দুঃখিত, আপনি যে রেজেক্সটি ব্যবহার করেছিলেন তা তুচ্ছ করা খুব সহজ ছিল। না 0, #নাকি ? সমস্যা নেই!

আমি উদাহরণের আউটপুটটির ভুল ব্যাখ্যা করতে পারি তবে আমার কাছে ৪৫ টি অতিরিক্ত অক্ষর বাকী থাকার কারণে এটি টুইঙ্ক করা এখনও সহজ

n=int(input())
print(str(n)+":")
x=1-1
exec("print([*range(1+x*n,1+n*-~x)][::(1,-1)[x%2]]);x+=1;"*n)
"no-op:a_string_that_doesnt_actually_matter"

নিস! : ডি এফওয়াইআই: পাইথনে আমি আরও একটি তৈরি করব, যদি আপনি এটি সমাধান করতে আগ্রহী হন;) এটি আরও দীর্ঘ হবে তবে সৌন্দর্যটি অবাস্তবতার মধ্যে রয়েছে।
ইয়াতসি

4

আর, মিকিটি

lets_make_a_snake<-function(n)`for`(i,1:n,cat(i*n+1-`if`(i%%2,n:1,1:n),"\n"))

পরীক্ষার ক্ষেত্রে:

> lets_make_a_snake(4)
1 2 3 4 
8 7 6 5 
9 10 11 12 
16 15 14 13 
> lets_make_a_snake(7)
1 2 3 4 5 6 7 
14 13 12 11 10 9 8 
15 16 17 18 19 20 21 
28 27 26 25 24 23 22 
29 30 31 32 33 34 35 
42 41 40 39 38 37 36 
43 44 45 46 47 48 49 

এবং রিজেক্সের নিশ্চয়তা: https://regex101.com/r/OB8ZIM/1

আমারও ছিল:

invisible(sapply(1:(n=scan()),function(i)cat(i*n+1-`if`(i%%2,n:1,1:n),"\n")))

যা একই আউটপুট দেয় এবং একই রেজেসের সাথে মেলে


6
lets_make_a_snake... আমি যদি অবাক হয়ে থাকি তবে এটিই যদি উদ্দেশ্যযুক্ত সমাধান হত: পি
স্টিভি গ্রিফিন

@ প্ল্যানাপাস গ্রেট জব প্রথমটি হ'ল আমি ` for` এবং ` using ব্যবহার করতে চেয়েছিলাম if, তবে আমার চেয়ে অনেক ভাল olf
মিকিটি


4

বাশ, @ মারকোস এম

sort -n <(seq 1 $((n * n)) | xargs -n$n | sed -n 'p;n'; seq $((n * n)) 1 | xargs -n$n | sort -n | sed -n 'n;p')

Prettified:

sort -n <(               # feed the stdout of this subshell into stdin for `sort -n`
    seq 1 $((n * n)) |   #   generate 1 2 3 ... n²
        xargs -n$n |     #     add line break every n numbers
        sed -n 'p;n';    #     print only odd lines
    seq $((n * n)) 1 |   #   generate n² ... 3 2 1
        xargs -n$n |     #     add line break every n numbers
        sort -n |        #     reverse all lines (keeping each row decreasing)
        sed -n 'n;p'     #     print only even lines
)

Subcommand প্রথম অংশ উত্পন্ন করবে 1 2 3 4, 9 10 11 12এবং দ্বিতীয় অংশ উত্পন্ন করবে8 7 6 5 , 16 15 14 13। বাইরের sort -nসঠিকভাবে তাদের একসঙ্গে মিশ্রিত করা সাপ প্যাটার্ন গঠন করতে হবে।

বিজোড় এবং এমনকি লাইনগুলি মুদ্রণের জন্য আমি /superuser//a/101760 এ কৌশলটি ব্যবহার করেছি । আপনাকে ধন্যবাদ মার্কোস, সত্যিই মজাদার একটি।


খুব সুন্দর সমাধান
মিচেল স্পেক্টর


3

পাইথন 3, @ টুক্কাএক্স

n=int(input());j=0;exec("print([(j-+i%n-n++2*n-0,j+i%n+1)[1&int(i/n)//1^(0x1)//1]*(2*(i%n)*0+2222222//2222222)for i in range(j,j+n)]);j+=n;"*n)

কপিসের রেজেক্সকে সামান্য বিশ্লেষণ করা একটি নির্দিষ্ট টেম্পলেট দেখায়:

________________________"___________i%n____2*n-____i%n__________i/n)//1_____)//1___2*(i%n)____^^^^^^^^^^^^^^^^for i in range(j,____])______"*n)

যেখানে _ছাড়া [ '"#]আর কোনও চরিত্র নেই^ কোন হয় [int()2/]

"*n)শেষে স্পষ্টভাবে দেখায় একটি eval("..."*n)বাexec("..."*n) , চলছে তাই আমরা ঠিক নিশ্চিত করার জন্য প্রয়োজন "..."কপি করে প্রিন্ট ঞ তম সারি।

for i in range(j,খুব স্ট্রিংয়ের শেষ প্রান্ত কাছাকাছি থাকে, কোনো ছাড়া তালিকা ধী ইঙ্গিত if। সুতরাং আমরা সেইগুলি i%n, 2*nস্টাফ ব্যবহার করে i-th কলামটি তৈরি করা দরকার ।

n = int(input())
j=0
exec("""print([
    (
        j - +i%n - n ++ 2*n - 0,    # equivalent to (n + j - i%n) for the decreasing rows
        j + i%n + 1                 # equivalent to (j + i%n + 1 == i + 1) for the increasing rows
    )[1 & int(i/n)//1 ^ (0x1)//1]   # int(i/n)   ->    get row number 0, 1, 2, 3, ...; 
                                    # 1 & int(i/n)//1    ->    0 for increasing rows, 1 for decreasing rows, 
                                    # 1 & int(i/n)//1 ^ (0x1)//1    ->   flip 0 and 1
    * (2*(i%n)*0+2222222//2222222)  # multiply by the constant 1.
    for i in range(j,j+n)
]); j+=n; "*n)

নিস! ঠিক আছে, প্রায় এক সপ্তাহ বেঁচে গিয়েছি: ডি আমি আমার মূল কোডটি পোস্ট করব।
ইয়াতসি

3

ডিসি , মিশেল স্পেক্টর

এটি একটি পুলিশ এবং ডাকাতদের চ্যালেঞ্জের মধ্যে আমার প্রথম প্রবেশ ছিল এবং আমি খুব মজা পেয়েছিলাম। রিজেক্সটি মিলে যাওয়ার দরকার ছিল সহজ, ^[^# !]{59}$যা মূলত আমার 3 টি চরিত্রটি ব্যবহার না করে আমার কাজটিকে গল্ফ করে তোলে। প্রথমদিকে আমার 60 বাইটের নিচে যেতে অসুবিধা হয়েছিল, তবে শেষ পর্যন্ত আমি এটি ক্র্যাক করেছিলাম।

?sN0[AP]sP[ddlN~_2*lN+1-r2%*+1+n32P1+dlN%0=PdlNd*>L]dsLxqqq

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা:

আমার কোড এন এর সাথে একটি লুপ ব্যবহার করে শূন্য ভিত্তিক কাউন্টার (1 ডি) রেখে 2 পুনরাবৃত্তির করে এবং সম্পর্কিত ম্যাট্রিক্স সারি এবং কলাম (r, c) স্থানাঙ্কের উপর ভিত্তি করে কোন সংখ্যাটি মুদ্রণ করা দরকার তা গণনা করে।

আমি কী বলতে চাইছি তার উদাহরণ, যদি এন = 4:

 0  1  2  3            (0,0) (0,1) (0,2) (0,3)             1  2  3  4
 4  5  6  7     ->     (1,0) (1,1) (1,2) (1,3)     ->      8  7  6  5
 8  9 10 11            (2,0) (2,1) (2,2) (2,3)             9 10 11 12
12 13 14 15            (3,0) (3,1) (3,2) (3,3)            16 15 14 13

এটি জটিল দেখাচ্ছে তবে মধ্যস্থতাকারী পদক্ষেপটি সহায়ক। এছাড়াও, আমি শুরু থেকে 2 টি লুপ ব্যবহার করার চেষ্টা করেছি, তবে আমি রেজেক্স অক্ষরের সীমা ছাড়িয়ে এসেছি। প্রতিটি পুনরাবৃত্তিতে সংখ্যা উত্পন্ন (শূন্য ভিত্তিক):

  • যদি r % 2 = 0(সাধারণ সারি),n = (r * N) + c = counter
  • যদি r % 2 = 1(বিপরীত সারি),n = ((r + 1) * N) - c - 1 = counter + N - (2 * c) - 1

বা সমস্ত একবারে, এক ভিত্তিক নম্বর হিসাবে: n = counter + ((N - (2 * c) - 1) * (r % 2)); n++

?sN0             # read input, save as N, initialize iteration counter
[AP]sP           # macro 'P' that prints a newline (ASCII code 10 = A)
[                # start loop
    ddlN~        # push N, calculate row and column coordinates:
                 #r = int(counter / N), c = counter % N, '~' calculates both
    _2*lN+1-     # c is on top, so this does: N - (2 * c) - 1
    r2%*+        # now r is on top, do: (r % 2) * (previous result) + counter
    1+n32P       # do: n++, print space (ASCII code 32)
    1+           # increment counter
    dlN%0=P      # call macro 'P' every Nth printed number
    dlNd*>L      # if: N * N > counter, repeat loop
]dsLx            # this saves the loop to macro 'L', then executes it
qqq              # my script was shorter, so I added a bunch of quit commands to
                 #fit the regex limit. Use of comments ('#') was prohibited.

@ মিচেলস্পেক্টর এখানে আমার ব্যাখ্যা। যেমন আপনি দেখতে পাচ্ছেন, আমাদের উভয়েরই আক্ষরিক অর্থেই একই অ্যালগরিদম রয়েছে, কেবলমাত্র আমি ~একবারে সারি এবং কলামের সূচীগুলি গণনা করতে কমান্ডটি ব্যবহার করি । তবে আমার আগের একটি চেষ্টা তাদের হিসাবে আলাদাভাবে গণনা করেছিল। বিখ্যাত মন সর্বদাই অন্যরকম চিন্তা করে? :)
শৈশুমারা

1
হ্যাঁ, এটি আসলে একই অ্যালগরিদম। ~কোডটি ছোট করার জন্য আপনার ব্যবহারটি আমি পছন্দ করি ।
মিচেল স্পেক্টর

আমি মনে করি আপনি ম্যাক্রোর শেষে লুপ পরীক্ষায় স্কোয়ার-রুট ট্রিকটি ব্যবহার করলে আপনি এটি একটি বাইট দ্বারা সংক্ষিপ্ত করতে পারবেন: ?sN0[AP]sP[ddlN~_2*lN+1-r2%*+1+n32P1+dlN%0=PdvlN>L]dsLx tio.run/nexus/…
মিচেল স্পেক্টর

@ মিচেলস্পেক্টর আপনি ঠিক বলেছেন এবং আপনার ব্যাখ্যা পড়ার সময় আমি এটি লক্ষ্য করেছি, তবে পরিবর্তে চ্যাট রুমে মন্তব্য করেছে ।
শৈশুমারা

হ্যাঁ, আমি এখন এটি দেখতে পাচ্ছি - আমি আজ সকালে চ্যাটরুমের দিকে তাকাইনি।
মিচেল স্পেক্টর

3

পাওয়ারশেল, কনরএলএসডাব্লু

ফাটল

$mySnakeIndex=1;$seq=1..$args[0];$seq|%{$rowNum=$seq|%{($mySnakeIndex++)};if(!($_%2)){[array]::Reverse($rowNum)};$rowNum-join" "}

আমি ইস্যুটির একটি ছোট সমাধান দিয়ে শুরু করেছি এবং আমার পরিবর্তনশীল নামগুলিকে প্যাড করেছি রেগেক্সটি ম্যাচ করার জন্য। আমি মনে করি যে কোলনের জন্য আমার মাথাটি চারপাশে জড়ানোর পক্ষে সবচেয়ে শক্ত অংশ ছিল তার জন্য কোনও ব্যবহারের সন্ধান করার চেষ্টা করা।

$a=1..$args[0];$i=1;$a|%{$r=$a|%{($i++)};if(!($_%2)){[array]::Reverse($r)};$r-join" "}

ব্যাখ্যা

# Initialize a counter that starts at one.
$mySnakeIndex=1
# Save the integer array from 1 to the input value. 
$seq=1..$args[0]
# For each row of the output...
$seq|%{
    # Build the integer array for this row sequentially
    $rowNum=$seq|%{
        # Increase the integer index while sending it down the pipeline
        ($mySnakeIndex++)}
        # Check if this is and odd row. If so reverse the integer array.
        if(!($_%2)){[array]::Reverse($rowNum)}
        # Take this row and join all the numbers with spaces.
        $rowNum-join" "

নাইস, আমি একটি ব্যবহৃত $scriptপরিবর্তনশীল এবং এটি প্যাড আউট, এর কিছু সত্যিই নোংরা looping [array]::Reverse()সঠিক যদিও ছিল, অভিনন্দন - আমার মনে হয় আপনি এমনকি আউট দৈর্ঘ্য করতে চাইতে পারেন $iএবং $MySnakeIndexযদিও।
কলস ডাব্লু

@ কননরএলএসডাব্লু আমি জানি আমার ডাকাতটিতে আমার ত্রুটি রয়েছে তা জেনে আপনি রাতে ঘুমাতে পারবেন না। আমি এটি স্থির করেছি।
ম্যাট

3

সিজেম, লিন

এটার মতো কিছু:

ri
{s}seu~~ci{zs}seu~~c{a}seu~~|~{w}seu~~z{w}seu~~sc~c{z}seu~~{w}seu~~sc~c{w}seu~~z{w}seu~~sc~c~

{s}seu~~ci{z}seu~~{s}seu~~c{a}seu~~|~{w}seu~~z{w}seu~~sc~c
{s}seu~~ci{z}seu~~{s}seu~~c{a}seu~~|~{w}seu~~z{w}seu~~sc~c
{s}seu~~ci{z}seu~~{s}seu~~c{a}seu~~|~{w}seu~~z{w}seu~~sc~c
{s}seu~~c{a}seu~~|
{s}seu~~c{c}seu~~|
{t}seu~~sc{a}seu~~|
{s}seu~~c{a}seu~~|{w}seu~~z{w}seu~~sc~c
{s}seu~~sc{fb}seu~~||
{s}seu~~sc{i}seu~~|
{s}seu~~sc{fb}seu~~||
{s}seu~~ci{z}seu~~{s}seu~~c{a}seu~~|~{w}seu~~z{w}seu~~sc~c{z}seu~~{w}seu~~sc~c{w}seu~~z{w}seu~~sc~c
{a}seu~~scs
{w}seu~~
{s}seu~~ci{z}seu~~{s}seu~~c{a}seu~~|~{z}seu~~{w}seu~~sc~c
{fb}s{b}s{w}seu~~sc~
{s}seu~~sc{ee}seu~~||
{s}seu~~sc{z}seu~~|{w}seu~~{w}seu~~sc~{w}seu~~{w}seu~~sc~
{t}seu~~sc{a}seu~~|
{~}s{}s{w}seu~~sc~
{t}seu~~sc{c}seu~~|

{s}seu~~ci{z}seu~~{s}seu~~c{a}seu~~|~{z}seu~~{w}seu~~sc~c~
s~
p

সমস্ত শ্বেত স্পেস ... "পঠনযোগ্যতা" এর জন্য ... এবং লিনের রেজেক্স মেনে চলতে বাদ দেওয়া যেতে পারে।

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

রেজেক্সের প্রয়োজন কেবলমাত্র আমরা ব্যবহার করে সমস্যাটি সমাধান করি:

  • ছোট হাতের অক্ষর.
  • {}, যা ব্লক তৈরি করতে ব্যবহার করা যেতে পারে।
  • |, বেশিরভাগ বিটওয়াইস OR এর জন্য ব্যবহৃত হয়।
  • ~, "ইভাল" এবং বিটওয়াইজ নট (এছাড়াও "ডাম্প অ্যারে", তবে আমি এটি ব্যবহার করব না)।

যেহেতু আমাদের রয়েছে, ~আমরা যদি স্বেচ্ছাচারী স্ট্রিংগুলি তৈরি করতে পারি, আমরা স্বেচ্ছাসেবক কোড চালাতে পারি। তবে এটি কীভাবে করবেন তা প্রথমে স্পষ্ট নয়।

ধাঁধাটির প্রথম অংশটি হ'ল ব্লকগুলি কোডের অমূল্য বিট, যা স্ট্রিংগুলিতে স্ট্রিংয়ে রূপান্তর করতে পারে s। সুতরাং {abc}sআমাদের দেয় "{abc}"। এরপরে, আমরা euএই স্ট্রিংগুলি আপার কেসে রূপান্তর করতে ব্যবহার করতে পারি ।

{abc}seu  e# gives "{ABC}"

এর সুবিধাটি হ'ল আপার-অক্ষরের অক্ষরগুলি পূর্ব-প্রারম্ভিক চলক হয়, সুতরাং আমরা এরকম স্ট্রিং তৈরি করে এবং এর দ্বিগুণ করে বহুবার ধ্রুবক মান পেতে পারি (একবারে স্ট্রিংটিকে একটি ব্লকে পরিণত করতে এবং একবারে ব্লক কার্যকর করুন)। আমরা সমস্ত অক্ষর পেতে পারি না, কারণ কিছু, পছন্দ মতো xবৈধ কমান্ড নয় (সুতরাং সিজেম সেগুলি সহ একটি ব্লককে বিশ্লেষণ করতে অস্বীকার করবে)। আমরা fযেমনটি ব্যবহার করতে পারি না কারণ এটি অন্য কমান্ড অনুসরণ করা দরকার তবে আমরা fbএবং তারপরে বা দুটি মান একসাথে ব্যবহার করতে পারি । তেমনি, আমরা eeপরিবর্তে ব্যবহার করতে পারেন e। যে সঙ্গে, আমরা সংখ্যার পেতে পারেন 0, -1, 3, এবং 10করতে 19-1সুবিধাজনক, কারণ আমরা যদি (ক স্ট্রিং মধ্যে এটি চালু"-1" ) (তারপর একটি অক্ষর মধ্যে'-) এবং তারপরে এটি সাফ করুন, আমরা বিয়োগ বা সেট পার্থক্য পেতে পারি। আমি বলেন, আমরা পেতে পারে না X(জন্য 1), কিন্তু আমরা পরম মান গ্রহণ করতে পারেন -1সঙ্গে z

আমরা sএকটি স্থান যুক্ত স্ট্রিং পেতে এবং এটিকে cএকটি স্থানের অক্ষরে রূপান্তর করতেও ব্যবহার করতে পারি :

{s}seu~~c

এটি সুবিধাজনক, কারণ সেখান থেকে আমরা বিভিন্ন সংখ্যার সাথে স্পেসটি ORing করে নিম্ন ASCII পরিসরে প্রচুর দরকারী কমান্ড পেতে পারি। কোড পয়েন্টের উপরের কিছু অক্ষর পেতে 48, আমরা '0পরিবর্তে ভিত্তি হিসাবে অক্ষরটি ব্যবহার করি :

{t}seu~~si

এটি ইচ্ছামত স্ট্রিংগুলি নির্মাণের জন্য যথেষ্ট, কারণ আমরা '+নিম্নলিখিত স্নিপেট থেকে (সংযোজন এবং স্ট্রিং উপসংহার) পেতে পারি :

{s}seu~~c{b}seu~~|

এবং আমাদের একটি আক্ষরিক রয়েছে 1যাতে আমরা কেবল স্থানের অক্ষরগুলিকে ধাক্কা দিতে পারি, তাদের প্রয়োজনীয় মূল্যগুলিতে তাদের বাড়িয়ে তুলি এবং তারপরে তাদের সকলকে একত্রে সংমিশ্রণ করতে পারি তবে এটি কিছুটা বিরক্তিকর এবং কোডটি বিশাল আকার ধারণ করবে।

পরিবর্তে, আমি উত্পন্ন করে থাকেন [এবং ]তাদের evalled, যাতে সমস্ত অক্ষর আমি মাঝে ধাক্কা একটি স্ট্রিং স্বয়ংক্রিয়ভাবে আবৃত করা হয়। এই দুটি লাইন:

{s}seu~~ci{zs}seu~~c{a}seu~~|~{w}seu~~z{w}seu~~sc~c{z}seu~~{w}seu~~sc~c{w}seu~~z{w}seu~~sc~c~

...

{s}seu~~ci{z}seu~~{s}seu~~c{a}seu~~|~{z}seu~~{w}seu~~sc~c~

এবং পরিশেষে, আমাদের প্রয়োজন fএবং ~স্ট্রিংয়ে আমরা জেনারেট করছি। যদিও এটি ইতিমধ্যে বৈধ অক্ষর, আমাদের স্ট্রিং লিটারেল বা অক্ষর অক্ষর নেই, তাই আমাদের এগুলিও উত্পন্ন করতে হবে এবং স্থান থেকে বৃহত্তর কোড পয়েন্টগুলি তৈরি করা কিছুটা বিরক্তিকর। পরিবর্তে, আমি এখানে সেট বিয়োগটি ব্যবহার করেছি, তবে দুটি ব্লক বিয়োগ করে (এর থেকে মুক্তি পেতে {}):

{fb}s{b}s{w}seu~~sc~
...
{~}s{}s{w}seu~~sc~

এটি প্রায় অনেক কিছুই আছে। আমরা স্পষ্ট [। আমরা সমস্ত অক্ষরকে পুশ করি, আমাদের হাতে থাকা কয়েকটি বিল্ট-ইন কনস্ট্যান্ট |, -(ইওলালের মাধ্যমে) এবং +(ইওল এর মাধ্যমে ) বিভিন্ন গণনা দ্বারা প্রাপ্ত । আমরা স্পষ্ট ]। আমরা পুরো জিনিসটিকে স্ট্রিংয়ে ফ্ল্যাট করি, কারণ এক পর্যায়ে আমি তালিকায় কিছু স্ট্রিং বা সংখ্যা যুক্ত করেছি। আমরা আমাদের স্বেচ্ছাসেবী স্ট্রিং এর সাথে বিভক্ত ~

ri...pপ্রকৃত চূড়ান্ত কর্মসূচির অংশ আছে, কিন্তু আমি তাদের নিষ্কাশিত থাকেন, কারণ তারা এনকোডিং প্রয়োজন হবে না।

অবশেষে, এটি সেই প্রোগ্রাম যা আমরা আসলে চালাচ্ছি:

ri___*,:)/2/[1-1]f.%:~<p

ri      e# Read input and convert to integer.
__      e# Make two copies.
_*      e# Square the last copy.
,       e# Turn into range [0 1 ... n^2-1].
:)      e# Increment each to get [1 2 ... n^2].
/       e# Split into chunks of length n, creating a square.
2/      e# Split into pairs of lines.
[1-1]   e# Push [1 -1].
f.%     e# Use this to reverse the second line in each pair. If n was odd,
        e# this will pair a -1 with the last line.
:~      e# Flatten the pairs back into the square.
<       e# Truncate to n lines to get rid of that extraneous -1 for odd inputs.
p       e# Pretty-print.

3

tinylisp , @DLosc

(v(c(h(q(d)))(c(h(q(f)))(q((c(q(n))(q((g(v(h(q(n))))(s(v(h(q(n))))(v(h(q(1)))))())))))))))(v(c(h(q(d)))(c(h(q(mod)))(q((c(c(h(q(x)))(q(y)))(q((i(l(v(h(q(x))))(v(h(q(y)))))x(mod(s(v(h(q(x))))(v(h(q(y)))))y))))))))))(v(c(h(q(d)))(c(h(q(range)))(q((c(c(h(q(x)))(c(h(q(y)))(c(h(q(z)))(q(w)))))(q((i(l(times(v(h(q(z))))(v(h(q(x))))(v(h(q(0)))))(times(v(h(q(z))))(v(h(q(y))))(v(h(q(0))))))(range(v(h(q(x))))(s(v(h(q(y))))(v(h(q(z)))))z(c(s(v(h(q(y))))(v(h(q(z)))))w))w)))))))))(v(c(h(q(d)))(c(h(q(times)))(q((c(c(h(q(x)))(c(h(q(y)))(q(acc))))(q((i(l(v(h(q(x))))(v(h(q(0)))))(times(s(v(h(q(0))))(v(h(q(x)))))(s(v(h(q(0))))(v(h(q(y)))))acc)(i(e(v(h(q(x))))(v(h(q(0)))))acc(times(s(v(h(q(x))))(v(h(q(1)))))y(a(v(h(q(y))))(v(h(q(acc))))))))))))))))(v(c(h(q(d)))(c(h(q(g)))(q((c(c(h(q(n)))(c(h(q(w)))(q(r))))(q((i(l(v(h(q(w))))(v(h(q(0)))))r(g(v(h(q(n))))(s(v(h(q(w))))(v(h(q(1)))))(c(i(e(v(h(q(0))))(mod(v(h(q(w))))(v(h(q(2))))))(range(a(v(h(q(1))))(times(v(h(q(w))))(v(h(q(n))))(v(h(q(0))))))(a(a(v(h(q(1))))(times(v(h(q(w))))(v(h(q(n))))(v(h(q(0))))))n)1())(range(a(times(v(h(q(w))))(v(h(q(n))))(v(h(q(0)))))n)(times(v(h(q(w))))(v(h(q(n))))(v(h(q(0)))))(s(v(h(q(0))))(v(h(q(1)))))()))r)))))))))))

এটি অনলাইন চেষ্টা করুন!

এটি একটি ফাংশন সংজ্ঞায়িত করে fযা উত্তর দেয় returns এটি স্টাডাউটকে আমি যে ফাংশনগুলি সংজ্ঞায়িত করেছি তার নামগুলিও প্রিন্ট করে, তবে আমি ধরে নিই যে কোড গল্ফের জন্য [আমাদের আমাদের আউটপুট প্রবাহটি বেছে নেওয়ার অনুমতি দেওয়া হয়েছে), কমপক্ষে। এটি যদি বড় কথা হয় তবে আমি মনে করি যে এগুলি মুদ্রণ না করার জন্য আমি এটি টুইট করতে পারি। কীভাবে করলাম? আমি মোটামুটি মানক কিছু দিয়ে শুরু করেছি:

(d f (q ((n)
  (g n (s n 1) ()))))

(d mod (q((x y)
  (i (l x y) x
    (mod (s x y) y)))))

(d range (q((x y z w)
  (i (l (times z x 0) (times z y 0))
    (range x (s y z) z (c (s y z) w))
    w))))

(d times (q ((x y acc)
  (i (l x 0) (times (s 0 x) (s 0 y) acc)
  (i (e x 0) acc
    (times (s x 1) y (a y acc)))))))

(d g (q ((n w r)
  (i (l w 0) r
    (g n (s w 1)
       (c (i (e 0 (mod w 2))
             (range (a 1 (times w n 0)) (a (a 1 (times w n 0)) n) 1 ())
             (range (a (times w n 0) n) (times w n 0) (s 0 1) ()))
          r))))))

তারপরে, আমি লক্ষ্য করেছি যে কেউ এই জাতীয় ফাংশন সংজ্ঞা রূপান্তর করতে পারে:

(d mod (q ((x y) (body))))

হয়ে

(v(c(h(q(d)))(c(h(q(mod)))(q((c(c(h(q(x)))(q(y)))(q((body)))))))))

এবং ফাংশন কল এর মত:

(a x y)

হয়ে

(a(v(h(q(x))))y)

আমি এই পুনরাবৃত্তকারী ভিম ম্যাক্রো ব্যবহার করেছি, যা রেজিস্টারে সঞ্চিত আছে q, দ্বিতীয়টি করার জন্য (আমি এতে jkম্যাপ করেছি <Esc>) : f s(v(h(q(jkea))))jk@q.

এই দুটি রূপান্তর সমস্ত স্থান খালি করার জন্য যথেষ্ট ছিল।


সুন্দরভাবে সম্পন্ন! আমার মূল কোডটি বেশ অনুরূপ, যদিও আমি এটি লেখার জন্য কিছুটা কম কষ্টদায়ক করতে একটি সহায়ক ম্যাক্রো লিখেছিলাম। সংজ্ঞায়িত প্রতীকগুলি কীভাবে মুদ্রণ এড়ানো যায় সে সম্পর্কে আপনার চিন্তায় আমি আগ্রহী - আপনি যদি সেগুলি ভাগ করে নিতে আগ্রহী হন তবে আমি টিনালিস্প চ্যাট রুমে থাকব
DLosc

@ ডিএলকাস সম্পন্ন, আমি সেখানে পোস্ট করেছি।
ব্রায়ান ম্যাকচ্যাচন

2

সুইফ্ট, জেমস ওয়েবস্টার

{n in for j in 0..<n{print((1...n).map{j%2==0 ?$0+j*n:j*n+n+1-$0})}} as(CShort)->()

যাচাইকরণ: https://regex101.com/r/7ukrM0/1


আমি এটির সাথে "এক্সপ্রেশন একটি অব্যবহৃত ফাংশনটির সমাধান করে" পাই তবে এটি গ্রহণযোগ্য উত্তর দেয় এমন সমস্ত কিছুর সাথে আমি অপরিচিত। উদাহরণস্বরূপ `লেট এ = <কোড>; একটি (CShort (4)); এটি চালানো প্রয়োজনীয় নয়?
জেমস ওয়েবস্টার

@ জামেস ওয়েবেস্টার আমি সঠিক নিয়ম সম্পর্কে নিশ্চিত নই যেহেতু "একটি কোড" বেশ অস্পষ্ট। জন্য কোড-গলফ জমা একটি প্রোগ্রাম বা ফাংশন হতে পারে , তাই আমি শুধু এখানে একটি বেনামী ফাংশন প্রদান। আর কীভাবে আমরা ইনপুট আর্গুমেন্ট গ্রহণ করব?
কেনেটিএম

আমার আসলটি একটি ফাংশনের মূল অংশ ছিল, সুতরাং আমারও বৈধ কিনা তা নিশ্চিত হন না! সুতরাং আমি কেবল "শিওর, এটি ভাল" এর সাথে যাচ্ছি এবং এটিকে উজ্জীবিত করব। :)
জেমস ওয়েবস্টার

@ জেমস ওয়েস্টার আপনি পুরো বিষয়টিকে কল করতে পারেন (…)(4), সিএসএর্টে পূর্ণসংখ্যাটি আক্ষরিক কাস্ট করার দরকার নেই।
কেনেটিএম

ওহ হ্যাঁ! আমি এটা কখনই ভাবতাম না।
জেমস ওয়েবস্টার

2

পিএইচপি, @ জার্গহেলার্সম্যান

<?=(function($n,$snake){foreach(array_chunk(range(1,$n*$n),$n)as$i=>$a){if($i%2)$a=array_reverse($a);echo"\n",join('',array_map(function($e){return(sprintf("%3d",$e));},$a));}})($argv[1],'-=-=-=-=-=-=-=-=-=-=-=-=-=-o~')?>

221 বাইট খুব দীর্ঘ (এইভাবে সাপ), এবং সাদা স্থানের অভাব সহজেই কাজ করা যায়।

Prettified:

<?=
(
    function($n, $snake) {
        foreach (array_chunk(range(1, $n*$n), $n) as $i => $a) {
            if($i % 2)
                $a = array_reverse($a);
            echo "\n", join('', array_map(function($e) {
                return (sprintf("%3d", $e));
            }, $a));
        }
    }
)($argv[1], '-=-=-=-=-=-=-=-=-=-=-=-=-=-o~')
?>

সুন্দর রূপ। আমার
দোষটি

2

জেলি, দৈর্ঘ্য 12, @ জনাথন অ্যালান

Ḷ-*m@"s@²$G

এটি অনলাইন চেষ্টা করুন!

কিভাবে এটা কাজ করে

Ḷ-*m@"s@²$G  Main link. Argument: n

Ḷ            Unlength; yield [0, ..., n-1].
 -*          Yield [(-1)**0, ..., (-1)**(n-1)].
         $   Combine the two links to the left into a chain.
        ²    Yield n².
      s@     Split [1, ..., n²] into chunks of length n.
   m@"       Take the lists to the right modulo the units to the left, 1 being
             normal order and -1 being reversed.

2

জেলি , 12 বাইট, জোনাথন অ্যালান এর দ্বিতীয় উত্তর ক্র্যাক করেছে

²sµ;@/€FḤ$¦G

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

এটি আমার অন্যান্য উত্তর হিসাবে প্রায় একই । আমি সবেমাত্র দুটি পরিবর্তন করেছি:

প্রথমত, আমি U("প্রতিটি উপাদানকে বিপরীত করুন") Ṛ€("প্রতিটি উপাদানকে" বিপরীত "") এ পরিবর্তন করেছি। এটি নিজে থেকে সহায়তা করে না, কারণ এটি নিষিদ্ধও is

তারপরে, আমি ("বিপরীত") ;@/( /" তালিকায় বিপরীত ক্রমে ;" @"তালিকার দ্বারা" মূল তালিকায় ") পরিবর্তন করেছি। এটি নিষিদ্ধ সমস্ত অক্ষরগুলি এড়ায়, একটি বৈধ সমাধান দেয়।

আমি ধরে নিলাম পরের পদক্ষেপটি হবে পরমাণু ছাড়াও অ্যারে-ম্যানিপুলেশন কুইকস নিষিদ্ধ করা ।


আহ, আমি জানতাম আমার নিষিদ্ধ করা উচিত ...
জোনাথন অ্যালান

আপনি খুব শর্তে লিখতে পারেন /। এই সমাধানের চেয়ে এটি বরং আরও ভার্বোজ।

হ্যাঁ এবং একজন পারে ;@\ṫ0, রেজেক্স দীর্ঘ হচ্ছে।
জোনাথন অ্যালান

2

জেলি, দৈর্ঘ্য 13, @ জনাথন অ্যালান

1r-*Nm@"s@²$G

এটি অনলাইন চেষ্টা করুন!

কিভাবে এটা কাজ করে

1r-*Nm@"s@²$G  Main link. Argument: n

1r             Range 1; yield [1, ..., n].
 -*            Yield [(-1)**1, ..., (-1)**n].
   N           Negate each unit.
           $   Combine the two links to the left into a chain.
          ²    Yield n².
        s@     Split [1, ..., n²] into chunks of length n.
     m@"       Take the lists to the right modulo the units to the left, 1 being
               normal order and -1 being reversed.

ওহ অপেক্ষা কর, কী মিস করলাম m?!
জোনাথন অ্যালান

2

এটি চিত্তাকর্ষক: ডি
জোনাথন অ্যালান

ধন্যবাদ! :) কোনও কারণে, আমি নিশ্চিত ছিলাম যে আমার কোডটিতে কোনও নতুন লাইন থাকতে পারে না, যা আমাকে কিছু চেইন ট্রিক্রি আবিষ্কার করতে বাধ্য করেছিল।
ডেনিস

2

স্কালা, @ সোপি

def g(n:Int) = {
    var vec = Vector.fill(0)(Vector.fill(0)(1))
    for (p <- 1 to n) {
        var vec2 = Vector.fill(0)(1)
        for (q <- (p-1)*n+1 to p*n) {
            vec2 = vec2 ++ Vector(q)
        }
        if (p%2==1) vec = vec ++ Vector(vec2)
        else vec = vec ++ Vector(vec2.reverse)

    }
    println(vec)
}

কিছুক্ষণের মধ্যে স্কালাকে স্পর্শ করেনি, এটি পুনরায় দেখার মজা পেয়েছিল was দুর্ভাগ্যক্রমে, এই সমাধানটি স্কালার দুর্দান্ত বৈশিষ্ট্যগুলিকে খুব মিস করে।

এখানে চেষ্টা করে দেখুন

রেজেক্স কনফার্মেশন


2

কিউব্যাসিক ( কিউবি 64 ), @ ডিএলকাস

নোট করুন যেহেতু .\n (U + 000A, LF) এর সাথে মেলে না , তাই এখানে নতুন \rলাইনটি একটি (U + 000D, CR)।

INPUT N:ZERO=N-N:ONE=N/N:FOR I=ZERO TO N-ONE:FOR J=ONE TO N:IF ZERO=I MOD(ONE+ONE)THEN PRINT I*N+J;ELSE PRINT I*N+N-J+ONE;REM
NEXT:PRINT:NEXT

যাচাই করুন:

>>> re.match('^([A-Z]+.)+$', 'INPUT N:ZERO=N-N:ONE=N/N:FOR I=ZERO TO N-ONE:FOR J=ONE TO N:IF ZERO=I MOD(ONE+ONE)THEN PRINT I*N+J;ELSE PRINT I*N+N-J+ONE;REM\rNEXT:PRINT:NEXT')
<_sre.SRE_Match object; span=(0, 141), match='INPUT N:ZERO=N-N:ONE=N/N:FOR I=ZERO TO N-ONE:FOR >

মূল অসুবিধাটি হল এর পরে কোনও শব্দ কীভাবে সন্নিবেশ করা যায় ;। ধন্যবাদ, কিউবি 64 সিআরটিকে একটি নতুন লাইন হিসাবে বিবেচনা করে অথচ পাইথনের রেজেক্স না করে, তাই আমরা REM\rএখানে একটি স্লিপ করতে পারি। অনুমোদিত পাঁচটি রেগেক্স স্বাদগুলির মধ্যে,

সুতরাং এই ক্র্যাকটি যতক্ষণ না আমরা জাভাস্ক্রিপ্ট ... mention উল্লেখ না করি ঠিক আছে 🤐


আমি এটি গ্রহণ করব, যেহেতু এটি QB64 এ কাজ করে। তবে, আমি এও বলব যে আর্কাইভ.অর্গের কিউবাসিক (যা আমি মনে করি একটি অনুকরণের পরিবর্তে আসল কিউবাসিক বলে) REMতত্ক্ষণাত কোনও বিবৃতি বিভাজক না করে একটি বিবৃতি অনুসরণ করার বিষয়ে অভিযোগ করে । আমার মূল সমাধানটি মন্তব্য ব্যবহার করে নি। আমি আরও একটি ভিন্নতা পেয়েছি যা আমি শীঘ্রই পোস্ট করব। : D
DLosc



1

সি, @ ইয়ামিন রং

main(int c,char**p){int n=atoi(*++p),i=n-n,t,o=c;for(--o;i<n;++i)for(t=o;t<=n;++t)printf("%-*d%c",n-o,i%c?i*n+n+o-t:i*n+t,t%n?' ':'\n');}

প্রোগ্রামটিতে নম্বর থাকতে পারে না তবে আমরা এর মাধ্যমে নম্বর পেতে পারি:

  1. c, সাধারণত "আরজিসি" হিসাবে পরিচিত, যা সর্বদা 2।
  2. +এবং -উপলভ্য, তাই আমরা 0 দিয়ে তৈরি করতে পারি n-nএবং এর সাথে 1 তৈরি করতে পারি o=c;--o

মাইনর ইস্যু, কপ সংস্করণটি স্থান-ন্যায্যতার বিপরীতে ট্যাব-সীমিত করা হয়েছিল, তবে কোনও বড় বিষয় নয়।


1

tinylisp, @DLosc

একটি খুব সোজা সমাধান, এবং সম্পূর্ণ অপ্রয়োজনীয় :)

(d p(q((m n)(s m(s(s 1 1)n)))))(d j(q((f g)(i(l f g)(c f(j(p f 1) g))()))))(d r(q((f g)(i(l f g)(c(s g 1)(r f(s g 1)))()))))(d k(q((m o f g n)(i(l n g)()(c(m f(p f n))(k o m(p f n)(p g 1) n))))))(d f(q((n)(k j r 1 1 n))))

যেমন কল (disp (f 4))

  • (p m n)বিয়োগ s(m + n == মি - ((1 - 1) - এন)) ব্যবহার করে এম + এন গণনা করুন
  • (j f g) উত্পন্ন (f f+1 f+2 ... g-1)
  • (r f g) উত্পন্ন (g-1 g-2 g-3 ... f)
  • (k m o f g n)সাপ ম্যাট্রিক্সের একটি সারি তৈরি করুন এবং তারপরে পরবর্তী সারির জন্য পুনরুক্ত করুন, যতক্ষণ না এন সারি তৈরি হয়। যুক্তিগুলি m, ক্রমবর্ধমান বা হ্রাস করার জন্য / oদ্বারা প্রতিস্থাপিত হয় । যুক্তি ,jrfg আমরা কোন সারিতে রয়েছি তা জানতে সূচকগুলি চালাচ্ছে।
  • (f n)(k j r 1 1 n)প্রজন্ম শুরু করার আহ্বান জানায় ।

ভাল কাজ. (BTW, এটি আরো কথ্য শুধু কি কথা (f 4)--দী dispউহ্য হয়।)
DLosc

1

পিএইচপি, @ আইনিট বোটিজান

এই মুহুর্তে আমার কাছে আসল সমাধানটি ক্র্যাক করার আরও ভাল ধারণা নেই।

N <= 15 সমর্থন করে

আমি প্রথমবার ব্যবহার করি get ইনপুট হিসাবে বিকল্পগুলি ব্যবহার করার জন্য সেরা ধারণা নয়।

কমান্ড লাইন থেকে এইভাবে শুরু করুন

php hack.php -a=4

অরিজিনাল রেজেক্স

স্তর 1:

^<[^'"\d{vV;<$]+$

চিঠির খুব সুন্দর সমন্বয়। পুলিশ থ্রেডে বিনা দ্বিধায় ভোট দিন।

এটি আমাকে - স্ট্র্রেভ - অ্যারে_রেভারস - গেট_ডিফাইন্ড_ওয়ার্সের মতো ক্রিয়াকলাপগুলিকে অবরুদ্ধ করে

https://regex101.com/r/5rGTnw/2

স্তর 2:

^<[^'"\d{v;<$_~|&A-Z]+$

https://regex101.com/r/XtVl9G/1

সমাধান

 <?php
    error_reporting(~E_NOTICE)&
    define(A,a.chr(E_COMPILE_ERROR-E_NOTICE+E_WARNING))
    &define(B,getopt(A,[])[a])&print_r(array_chunk(
    array_slice(
    array_merge(
    range(E_ERROR,B)
    ,range(E_WARNING*B,E_ERROR+B)
    ,range(E_WARNING*B+E_ERROR,(E_WARNING+E_ERROR)*B)
    ,range(E_PARSE*B,+E_ERROR+(E_WARNING+E_ERROR)*B)
    ,range(E_PARSE*B+E_ERROR,(E_PARSE+E_ERROR)*B)
    ,range((E_PARSE+E_WARNING)*B,+E_ERROR+(E_PARSE+E_ERROR)*B)
    ,range((E_PARSE+E_WARNING)*B+E_ERROR,(E_NOTICE-E_ERROR)*B)
    ,range(E_NOTICE*B,+E_ERROR+(E_NOTICE-E_ERROR)*B)
    ,range(E_NOTICE*B+E_ERROR,(E_NOTICE+E_ERROR)*B)
    ,range((E_NOTICE+E_WARNING)*B,E_ERROR+(E_NOTICE+E_ERROR)*B)
    ,range((E_NOTICE+E_WARNING)*B+E_ERROR,(E_NOTICE+E_WARNING+E_ERROR)*B)
    ,range((E_NOTICE+E_PARSE)*B,E_ERROR+(E_NOTICE+E_WARNING+E_ERROR)*B)
    ,range((E_NOTICE+E_PARSE)*B+E_ERROR,(E_NOTICE+E_PARSE+E_ERROR)*B)
    ,range((E_CORE_ERROR-E_WARNING)*B,E_ERROR+(E_NOTICE+E_PARSE+E_ERROR)*B)
    ,range((E_CORE_ERROR-E_WARNING)*B+E_ERROR,(E_CORE_ERROR-E_ERROR)*B)
    )
    ,B-B,B*B
    ),B)
    )
    ?>

স্তর 2:

<?php
define(aa,a.chr(ord(strtoupper(a))-ord(h)+ord(a)))and
define(bb,getopt(aa,[])[a])and
define(us,chr(ord(a)-true-true))and
(prin.t.(us).r)(
(arra.y.(us).chunk)(
(arra.y.(us).slice)(
(arra.y.(us).merge)(
range((ord(b)-ord(a)),bb)
,range((ord(c)-ord(a))*bb,(ord(b)-ord(a))+bb)
,range((ord(c)-ord(a))*bb+(ord(b)-ord(a)),((ord(c)-ord(a))+(ord(b)-ord(a)))*bb)
,range((ord(e)-ord(a))*bb,+(ord(b)-ord(a))+((ord(c)-ord(a))+(ord(b)-ord(a)))*bb)
,range((ord(e)-ord(a))*bb+(ord(b)-ord(a)),((ord(e)-ord(a))+(ord(b)-ord(a)))*bb)
,range(((ord(e)-ord(a))+(ord(c)-ord(a)))*bb,+(ord(b)-ord(a))+((ord(e)-ord(a))+(ord(b)-ord(a)))*bb)
,range(((ord(e)-ord(a))+(ord(c)-ord(a)))*bb+(ord(b)-ord(a)),((ord(e)-ord(a))-(ord(b)-ord(a)))*bb)
,range((ord(e)-ord(a))*bb,+(ord(b)-ord(a))+((ord(e)-ord(a))-(ord(b)-ord(a)))*bb)
,range((ord(e)-ord(a))*bb+(ord(b)-ord(a)),((ord(e)-ord(a))+(ord(b)-ord(a)))*bb)
,range(((ord(e)-ord(a))+(ord(c)-ord(a)))*bb,(ord(b)-ord(a))+((ord(e)-ord(a))+(ord(b)-ord(a)))*bb)
,range(((ord(e)-ord(a))+(ord(c)-ord(a)))*bb+(ord(b)-ord(a)),((ord(e)-ord(a))+(ord(c)-ord(a))+(ord(b)-ord(a)))*bb)
,range(((ord(e)-ord(a))+(ord(e)-ord(a)))*bb,(ord(b)-ord(a))+((ord(e)-ord(a))+(ord(c)-ord(a))+(ord(b)-ord(a)))*bb)
,range(((ord(e)-ord(a))+(ord(e)-ord(a)))*bb+(ord(b)-ord(a)),((ord(e)-ord(a))+(ord(e)-ord(a))+(ord(b)-ord(a)))*bb)
,range(((ord(q)-ord(a))-(ord(c)-ord(a)))*bb,(ord(b)-ord(a))+((ord(e)-ord(a))+(ord(e)-ord(a))+(ord(b)-ord(a)))*bb)
,range(((ord(q)-ord(a))-(ord(c)-ord(a)))*bb+(ord(b)-ord(a)),((ord(q)-ord(a))-(ord(b)-ord(a)))*bb)
)
,bb-bb,bb*bb
),bb)
)
?>
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.