लुटेरे: रेक्स को क्रैक करें - एक सांप बनाएं


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और एक ऐसी मैट्रिक्स बनाता है, उसी भाषा में एक पुलिस पोस्ट के रूप में, और एक कोड के साथ जो पुलिस के regex से मेल खाता है। आपके कोड का आउटपुट फॉर्मेट पुलिस के कोड के आउटपुट फॉर्मेट से मेल खाना चाहिए।

कृपया यह बताने के लिए कि आपने इसे क्रैक किया है, कॉप की पोस्ट के नीचे एक टिप्पणी छोड़ दें।

जीत की कसौटी:

विजेता वह उपयोगकर्ता होगा जिसने सबसे अधिक प्रस्तुतियाँ क्रैक की हैं। एक टाई के मामले में, फिर कई विजेता होंगे।

जवाबों:


10

जेली , 9 बाइट्स, दरार @Dennis का जवाब

²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एक महान विचार था,
ETHproductions

मेरा मूल कोड इसके बहुत समान है। मैं सिर्फ के Jबजाय इस्तेमाल किया F
डेनिस

@ डेनिस ओह, J... मैंने कोशिश की थी LRलेकिन 11 बाइट्स के तहत नहीं मिल सका
ETHproductions

9

05AB1E, एमिगा

यह मेरा पहली बार 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
@StewieGriffin जब जीवन आपको नींबू देता है लेकिन पानी या चीनी नहीं देता है, तो आपको बस उन्हें कच्चा खाना होगा। : D
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

मेरा पहला प्रयास है कि एक सरणी और एक int जोड़ने के रूप में काम नहीं किया है संभव नहीं है:

@┼MDR┼+;W

मेरा दूसरा प्रयास जो रेगेक्स से मेल नहीं खाता:

²@┼σ▓_^MR

तुमने ठीक वैसा ही किया जैसा मैंने किया! अच्छा काम!
निक क्लिफोर्ड

5

05AB1E, एमिग्ना (दूसरा सबमिशन)

पहली बार 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

अच्छी नौकरी! आपको अभीष्ट समाधान मिला है
21

@Emigna धन्यवाद! मैं इसे प्राप्त नहीं होता अगर यह अन्य समाधानों के लिए यहाँ पर नहीं था (आपका शामिल) जो मुझे एहसास दिलाता है कि अगर स्टैक खाली है तो वैश्विक सरणी प्रिंट करेगी! अगर ऐसा नहीं होता तो मैं कभी भी इसका पता नहीं लगाता; मैं ऐसी कोशिशें करता रहा, जो )यह सोचकर खत्म हुईं कि यह स्टैक पर सही परिणाम लाने का एकमात्र तरीका होगा।
मूल्य इंक

हाँ, )जब आप केवल 2 गैर-अल्फ़ान्यूमेरिक वर्णों का उपयोग कर सकते हैं, तो ऐसा करना बहुत असंभव है । यहाँ मुश्किल हिस्सा केवल 2 वाइल्डकार्ड का उपयोग करने और उन्हें अनुक्रमिक करने के लिए कार्यक्रम को संरचित करने के लिए था। संभवत: अन्य समाधानों के बिना थोड़ा कठिन रहा होगा, लेकिन इसमें कुछ
गड़बड़ी भी

@Emigna मैं जानना चाहता हूं कि क्या ^\w*..$संभव है।
mbomb007

@ mbomb007: मुझे ऐसा नहीं लगता। इस रणनीति के साथ आपको अगले पुनरावृत्ति के अतिरिक्त परिणाम को बचाने की आवश्यकता होगी और आप इस अर्थ के लिए स्टैक का उपयोग नहीं कर सकते हैं कि एक के 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जो वर्तमान टाइमस्टैम्प को धक्का देता है। जब से मैं अपने वास्तविक मूल्य के बारे में कोई अनुमान नहीं करना चाहता था, मैं के साथ अपने primality परीक्षण mp(जो देता है 0और 1और) परीक्षण है कि मूल्य के primality फिर से सुनिश्चित करने के लिए मैं एक मिल गया है 0ढेर पर। ए 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( ])। हम ~एक स्ट्रिंग में अन्य सभी को लपेटने के साथ उसको निकालते हैं , और फिर हम उस स्ट्रिंग को एक साथ जोड़ते हैं ~

कार्यक्रम के अंत में चलाया गया वास्तविक कोड फिर से है:

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

स्पष्टीकरण के लिए मेरा पिछला समाधान देखें ।


4

पायथन 3, टुक्का

क्षमा करें, आपके द्वारा उपयोग किया गया रेगेक्स तुच्छ बनाना बहुत आसान था। नहीं 0, #या ? कोई दिक्कत नहीं है!

मैं उदाहरण आउटपुट का गलत अर्थ लगा सकता हूं, लेकिन अभी भी यह बहुत आसान है क्योंकि मेरे पास 45 अतिरिक्त अक्षर बचे हैं

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"

अच्छा! : D FYI करें: यदि आप इसे हल करना चाहते हैं, तो मैं पायथन में एक और बनाऊंगा;
यति

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")))

जो एक ही आउटपुट देता है और एक ही regex से मेल खाता है


6
lets_make_a_snake... मुझे आश्चर्य होगा कि अगर इसका इच्छित समाधान था: P
Stewie Griffin

@plannapus महान नौकरी। पहले वाला मूल रूप से मैं ` for` और ` if` का उपयोग करने का इरादा रखता था , लेकिन मेरी तुलना में बहुत बेहतर गोल्फ है।
मिकी


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), पर जा रहा है तो हम सिर्फ यह सुनिश्चित करने की जरूरत है "..."प्रिंट j-वीं पंक्ति।

यह for i in range(j,स्ट्रिंग के अंत के बहुत करीब है, बिना किसी सूची समझ के संकेत देना if। इसलिए हम उन का उपयोग कर आई-वें स्तंभ का निर्माण करने की जरूरत है i%n, 2*nसामान।

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

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

मेरा कोड एन 2 के साथ एक लूप का उपयोग करता है पुनरावृत्तियों के , एक शून्य आधारित काउंटर (1 डी) रखते हुए, और गणना करता है कि संबंधित मैट्रिक्स पंक्ति और स्तंभ (आर, सी) निर्देशांक के आधार पर किस संख्या को मुद्रित करने की आवश्यकता है।

उदाहरण का क्या मतलब है, अगर N = 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.

@MitchellSpector यहाँ मेरा स्पष्टीकरण है। जैसा कि आप देखते हैं, हम दोनों का शाब्दिक रूप से एक ही एल्गोरिथ्म है, केवल मैं ~एक बार में पंक्ति और स्तंभ अनुक्रमित की गणना करने के लिए कमांड का उपयोग करता हूं । लेकिन मेरे पिछले प्रयासों में से एक ने आपको अलग-अलग गणना की थी। बड़े मन वाले ऐसा सोचते हैं? :)
seshoumara

1
हां, यह वास्तव में एक ही एल्गोरिदम है। मुझे ~कोड को छोटा करने का आपका उपयोग पसंद है ।
मिशेल स्पेक्टर

मुझे लगता है कि आप इसे एक बाइट से छोटा कर सकते हैं यदि आप मैक्रो के अंत में लूप टेस्ट में स्क्वायर-रूट ट्रिक का उपयोग करते हैं: ?sN0[AP]sP[ddlN~_2*lN+1-r2%*+1+n32P1+dlN%0=PdvlN>L]dsLx tio.run/nexus/…
मिशेल स्पेक्टर

@MitchellSpector आप सही हैं, और मैंने आपका स्पष्टीकरण पढ़ते समय इसे नोट किया, लेकिन इसके बजाय चैट रूम में टिप्पणी की ।
शेषमारा

हां, अब मैं देख रहा हूं - मैंने आज सुबह चेटरूम को नहीं देखा था।
मिशेल स्पेक्टर

3

पॉवरशेल , कॉनरॉल्सडब्ल्यू

दरार

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

मैंने इस मुद्दे के एक छोटे से समाधान के साथ शुरुआत की और अपने वैरिएबल नामों को मिलान करने के लिए regex प्राप्त किया। मुझे लगता है कि बृहदान्त्र के लिए एक उपयोग खोजने की कोशिश कर रहा था मेरे सिर को लपेटने के लिए सबसे कठिन हिस्सा था।

$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चर और कुछ गन्दे लूपिंग का इस्तेमाल किया , ताकि [array]::Reverse()यह सही हो सके, हालांकि, बधाई - मुझे लगता है कि आप इसकी लंबाई $iऔर $MySnakeIndexहालाँकि बाहर भी चाहते होंगे ।
colsw

@ConnorLSW मुझे पता है कि आप रात को सो नहीं पाएंगे, यह जानते हुए कि मेरे लुटेरे में गलतियाँ थीं। मैंने इसे ठीक कर लिया है।
मैट

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

सभी व्हाट्सएप ... "पठनीयता" के लिए है ... और लिन के रेगेक्स के अनुपालन के लिए छोड़ा जा सकता है।

इसे ऑनलाइन आज़माएं!

व्याख्या

रेगेक्स के लिए आवश्यक है कि हम केवल समस्या का समाधान करें:

  • छोटे अक्षर।
  • {}, जिसका उपयोग ब्लॉक बनाने के लिए किया जा सकता है।
  • |, ज्यादातर बिटवाइस या के लिए उपयोग किया जाता है।
  • ~, "eval" और बिटवाइज़ नहीं ("डंप सरणी" भी, लेकिन मैं इसका उपयोग नहीं करने जा रहा हूं)।

चूंकि हमारे पास है, ~अगर हम मनमाने तार का निर्माण कर सकते हैं, तो हम मनमाने कोड चला सकते हैं। हालाँकि, पहले यह स्पष्ट नहीं है कि ऐसा कैसे किया जाए।

पहेली का पहला टुकड़ा यह है कि ब्लॉक कोड के अविकसित बिट्स हैं, जो इसके साथ तार में बदल सकते हैं s। तो {abc}sहमें देता है "{abc}"। अगला, हम euइन स्ट्रिंग्स को ऊपरी मामले में बदलने के लिए उपयोग कर सकते हैं ।

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

इसका लाभ यह है कि अपर-केस लेटर्स प्री-इनिशियल वेरिएबल्स हैं, इसलिए हम इस तरह के एक स्ट्रिंग को बनाकर कई निरंतर मान प्राप्त कर सकते हैं, और इसे दो बार eval'ing कर सकते हैं (एक बार स्ट्रिंग को ब्लॉक में और एक बार वापस करने के लिए) उस ब्लॉक को निष्पादित करें)। हम सभी पत्र प्राप्त नहीं कर सकते हैं, क्योंकि कुछ, जैसे xकि मान्य कमांड नहीं हैं (इसलिए सीजेएम युक्त ब्लॉक को पार्स करने से इनकार कर देगा)। हम इसका उपयोग नहीं कर सकते f, क्योंकि इसे किसी अन्य कमांड द्वारा पालन करने की आवश्यकता है, लेकिन हम fbएक साथ दो मानों का उपयोग कर सकते हैं। इसी तरह, हम के eeबजाय का उपयोग कर सकते हैं e। कि के साथ, हम नंबर प्राप्त कर सकते हैं 0, -1, 3, और 10करने के लिए 19-1सुविधाजनक है, क्योंकि अगर हम इसे एक स्ट्रिंग (में बदल जाते हैं "-1") (फिर एक चरित्र में'-) और फिर इसे बाहर निकालना, हम या तो घटाव या सेट अंतर प्राप्त कर सकते हैं। जैसा कि मैंने कहा, हम नहीं मिल सकता है X(के लिए ।1), लेकिन हम का निरपेक्ष मान ले जा सकते हैं -1के साथz

हम sएक स्पेस युक्त स्ट्रिंग प्राप्त करने के लिए भी उपयोग कर सकते हैं , और cइसे स्पेस कैरेक्टर में बदलने के लिए उपयोग कर सकते हैं :

{s}seu~~c

यह सुविधाजनक है, क्योंकि वहां से हम विभिन्न नंबरों के साथ अंतरिक्ष की ओर से कम एएससीआईआई रेंज में बहुत सारे उपयोगी कमांड प्राप्त कर सकते हैं। कोड बिंदु से ऊपर के कुछ वर्ण प्राप्त करने के लिए 48, हम चरित्र '0को आधार के रूप में उपयोग करते हैं :

{t}seu~~si

यह पहले से ही मनमाने तारों का निर्माण करने के लिए पर्याप्त है, क्योंकि हम '+निम्नलिखित स्निपेट से (जोड़ और स्ट्रिंग संयोजन) प्राप्त कर सकते हैं :

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

और हमारे पास एक शाब्दिक है 1 इसलिए हम केवल अंतरिक्ष वर्णों को धकेल सकते हैं, उन्हें उस मूल्य में वृद्धि कर सकते हैं जिसकी हमें आवश्यकता है और फिर उन सभी को एक साथ जोड़ दें, लेकिन यह थोड़ा उबाऊ है और कोड बड़े पैमाने पर हो जाएगा।

इसके बजाय, मैंने उन्हें उत्पन्न किया है [और ]उन्हें रोक दिया है, ताकि मेरे बीच में धकेलने वाले सभी वर्ण स्वचालित रूप से एक तार में लिपटे रहें। यही दो लाइनें हैं:

{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~

यह सब बहुत सुंदर है। हम स्पष्ट करते हैं [। हम सभी किरदारों से विभिन्न संगणना के द्वारा प्राप्त धक्का कुछ बिल्ट-इन स्थिरांक हमारे पास है, |, -(eval माध्यम से) और +(eval के माध्यम से)। हम स्पष्ट करते हैं ]। हम पूरी चीज को एक स्ट्रिंग में समतल करते हैं, क्योंकि कुछ बिंदु पर मैंने सूची में कुछ तार या संख्याएं जोड़ीं। हम अपनी मनमानी स्ट्रिंग के साथ विकसित करते हैं~

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

टिनिस्पिल , @ डल

(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जो उत्तर देता है। यह उन कार्यों के नाम भी छापता है जिन्हें मैंने stdout में परिभाषित किया था, लेकिन मुझे लगता है कि कोई फर्क नहीं पड़ता, क्योंकि कोड गोल्फ के लिए [हमें अपना आउटपुट स्ट्रीम चुनने की अनुमति है] कम से कम। अगर यह एक बड़ी बात है, तो मुझे लगता है कि मैं इसे प्रिंट कर सकता हूं उन लोगों को न छापने के लिए। मैंने इसे कैसे किया? मैंने कुछ मानक के साथ शुरुआत की:

(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)); यह आवश्यक नहीं है बनाने के लिए आवश्यक है?
जेम्स वेबस्टर

@JamesWebster मुझे सटीक नियमों के बारे में यकीन नहीं है क्योंकि "एक कोड" बहुत अस्पष्ट है। के लिए कोड गोल्फ प्रस्तुत करने के लिए एक कार्यक्रम या समारोह हो सकता है , तो मैं बस यहाँ एक गुमनाम समारोह प्रदान करते हैं। हम और कैसे इनपुट तर्कों को प्राप्त करते हैं?
kennytm

मेरा मूल एक समारोह का शरीर था, इसलिए यह सुनिश्चित नहीं था कि मेरा भी वैध है! तो मैं बस "श्योर, दिस इज़ फाइन" के साथ जाने वाला हूं और इसे बढ़ा दूंगा। :)
जेम्स वेबस्टर

@JamesWebster आप पूरे मामले को कॉल कर सकते हैं (…)(4), पूर्णांक शाब्दिक को CShort में डालने की आवश्यकता नहीं है।
kennytm

आह बिल्कुल! मैंने ऐसा कभी नहीं सोचा होगा।
जेम्स वेबस्टर

2

PHP, @ JörgHülsermann

<?=(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~')
?>

अच्छा संस्करण। मेरा दोष किसी फंक्शन के बारे में सोचना और केवल एक आउटपुट बनाना नहीं था
Jörg Hülsermann

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("प्रत्येक तत्व को उल्टा") ("प्रत्येक तत्व" को Ṛ€"उल्टा")। यह अपने आप से मदद नहीं करता है, क्योंकि यह भी प्रतिबंधित है।

फिर, मैंने मूल सूची के विपरीत क्रम में " (" रिवर्स ") को ;@/( /" ;"कॉन्सेटिविंग" @"से गुना ) में बदल दिया । जो सभी प्रतिबंधित चरित्रों से बचता है, एक वैध समाधान देता है।

मुझे लगता है कि अगला कदम परमाणुओं के अलावा सरणी-हेरफेर क्विक को प्रतिबंधित करना होगा ।


उह, मुझे पता था कि मुझे प्रतिबंध लगाना चाहिए था ...
जोनाथन एलन

आप के संदर्भ में /भी लिख सकते हैं। यह सिर्फ इस समाधान की तुलना में अधिक क्रिया है।

हां और एक ;@\ṫ0, regex लंबा हो रहा है।
जोनाथन एलन

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)
}

थोड़ी देर में स्काला को नहीं छुआ, फिर से घूमने का मजा ही कुछ और था। दुर्भाग्य से, यह समाधान बहुत सारे स्काला की शांत विशेषताओं को याद करता है।

इसे यहाँ आज़माएँ

रेगेक्स कन्फर्मेशन


2

QBasic (QB64), @DLosc

ध्यान दें कि चूंकि .मिलान \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 >

मुख्य कठिनाई यह है कि कैसे के बाद एक शब्द सम्मिलित करें ;। शुक्र है कि QB64 CR को एक नई रेखा के रूप में मानता है जबकि पायथन का रेग्क्स नहीं है, इसलिए हम REM\rयहां पर्ची कर सकते हैं। पाँच अनुमत रेगेक्स फ्लेवर में से,

तो यह दरार तब तक ठीक है जब तक हम जावास्क्रिप्ट का उल्लेख नहीं करते ... as


मैं इसे स्वीकार करता हूँ, क्योंकि यह QB64 में काम करता है। हालाँकि, मैं यह भी कहूंगा कि आर्काइव.ऑर्ग क्यूबेसिक (जो मुझे लगता है कि एक अनुकरण के बजाय वास्तविक क्यूबेसिक है) REMबिना किसी स्टेटमेंट विभाजक के एक बयान के तुरंत बाद शिकायत करता है। मेरे मूल समाधान ने टिप्पणियों का उपयोग नहीं किया। मुझे एक और भिन्नता मिली है जिसे मैं शीघ्र ही पोस्ट करूंगा। : डी
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, आमतौर पर "argc" के रूप में जाना जाता है, जो हमेशा 2 होता है।
  2. +और -उपलब्ध हैं, इसलिए हम 0 बना सकते हैं n-n, और 1 बना सकते हैं o=c;--o

स्थान-औचित्य के विपरीत माइनर समस्या, पुलिस संस्करण टैब-सीमांकित किया गया था, लेकिन कोई बड़ी बात नहीं थी।

1

रूबी, @Value इंक

->n{(1..n).map{|r|x=(r*n-n+1..r*n).to_a;if(r.modulo(2)==1)then(x)else(x.reverse)end}}#1-2-3-4-5-6--

[(-=Z-~]* इसका मतलब है "मैं कुछ भी लिख सकता हूँ मुझे पसंद है :)"


आह, मैं गड़बड़ कर दिया कि मैं नहीं था
मूल्य इंक

1

टिनिस्पिल, @ डल

एक बहुत ही सीधा समाधान, और पूरी तरह से अडॉप्टेड :)

(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)घटाव का उपयोग कर m + n की गणना करता है s(m + n == m - ((1 - 1) - n):
  • (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द्वारा प्रतिस्थापित कर रहे हैं j/ rबढ़ रही है या पंक्तियों को कम उत्पन्न करने के लिए। तर्क f, gयह जानने के लिए संकेत दे रहे हैं कि हम किस पंक्ति पर हैं।
  • (f n)(k j r 1 1 n)पीढ़ी शुरू करने के लिए कॉल करता है।

अच्छा कार्य। (BTW, यह सिर्फ करने के लिए और अधिक मुहावरेदार है (f 4)- dispनिहित है।)
DLosc

1

PHP, @Ionut Botizan

मूल समाधान को क्रैक करने के लिए मेरे पास कोई बेहतर विचार नहीं है।

N <= 15 का समर्थन करता है

यह पहली बार है कि मैं getopt का उपयोग करता हूं। शायद इनपुट के रूप में विकल्पों का उपयोग करने के लिए सबसे अच्छा विचार नहीं है।

कमांड लाइन से इस तरह शुरू करें

php hack.php -a=4

मूल रेगेक्स

स्तर 1:

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

पत्रों का बहुत अच्छा संयोजन। सिपाही धागे को वोट करने के लिए स्वतंत्र महसूस करें।

यह मुझे कार्य करता है जैसे - strrev - array_reverse - get_defined_vars

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)
)
?>
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.