पुलिस: एक रेगीक्स बनाओ - एक साँप बनाओ

40

यह पुलिस का धागा है। डाकू का धागा यहाँ है ।

एक कोड लिखें जो एक इनपुट लेता है nऔर एक n-by-n "स्नेक मैट्रिक्स" बनाता है।

साँप मैट्रिक्स एक मैट्रिक्स है जो इस पैटर्न का अनुसरण करता है:

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

सटीक आउटपुट स्वरूप वैकल्पिक है। आप उदाहरण के लिए आउटपुट [[1 2 3],[6 5 4],[7 8 9]], या कुछ इसी तरह का हो सकता है।

आपको भाषा का नाम और एक regex प्रदान करना होगा जो आपके कोड से पूरी तरह मेल खाता हो। आप चुन सकते हैं कि आपका रेगेक्स कितना विस्तृत होना चाहिए। चरम में, आप प्रत्येक संभावित स्ट्रिंग से मेल खाने वाले रेगेक्स लिख सकते हैं, इस स्थिति में आपके कोड को क्रैक करना बहुत आसान होगा। आपको इसके लिए आउटपुट भी देना होगा n=4, ताकि लुटेरों को आपके द्वारा चुने गए सटीक प्रारूप का पता चल सके।

आप regex101.com , या रूबी स्वाद पर उपलब्ध रेगेक्स-फ्लेवर में से एक का उपयोग कर सकते हैं ।

  • PCRE (PHP)
  • जावास्क्रिप्ट
  • अजगर
  • Golang
  • माणिक

आपको यह निर्दिष्ट करना होगा कि आप किसका उपयोग कर रहे हैं।

टिप्पणियाँ:

  • आपको किसी भी बड़े का समर्थन करना चाहिए n। आप मान सकते हैं कि यह डेटाटाइप या मेमोरी को ओवरफ्लो नहीं करेगा। यदि डिफ़ॉल्ट डेटाटाइप 8-बिट हस्ताक्षरित पूर्णांक है, तो आप मान सकते हैं n<=11, यदि यह 8-बिट पूर्णांक से रहित है, तो आप मान सकते हैं n<=15।
  • लुटेरों को प्रमुख / अनुगामी स्थानों और न्यूलाइन्स को छोड़कर सबमिशन के आउटपुट फॉर्मेट का मिलान करना होता है, क्योंकि एसई फॉर्मेटिंग द्वारा छीन लिया गया हो सकता है।

जीत की कसौटी:

विजेता कम से कम रेगेक्स के साथ अनियोजित सबमिशन होगा, जिसे वर्णों की संख्या में मापा जाता है।

यदि आपकी पोस्ट 7 दिनों के लिए अनियंत्रित रह गई है, तो आप इच्छित समाधान पोस्ट कर सकते हैं और अपने सबमिशन को सुरक्षित मान सकते हैं।

regular-expression  cops-and-robbers  matrix 
— स्टीवी ग्रिफिन
स्रोत
5
बीज, लंबाई १ .।
— क्रिति लिथोस
1
क्या मैं यहाँ प्रलेखित भाषाओं में से किसी एक का उपयोग कर सकता हूँ? codegolf.stackexchange.com/questions/61804/…
2
@KritiiLithos को छोड़कर आपको सुरक्षित बनने के लिए अपना मूल कार्यक्रम जारी करना होगा ;-)
— ETHproductions
3
@DeepakAgarwal - एक सांप उत्पन्न करने के लिए अपना कोड लिखें, फिर एक रेग्क्स प्रदान करें जो इसे मेल खाता है। डाकू का समाधान उसी भाषा में होना चाहिए और रेगेक्स से भी मेल खाना चाहिए। तो एक रणनीति यह है कि लुटेरा बनाने के लिए एक प्रतिबंधात्मक रेगेक्स प्रदान किया जाए, लेकिन इतना प्रतिबंध नहीं कि आप समाधान दें!
2
क्या यह मेटा सर्वसम्मति, यूनि I / O को sed के लिए अनुमति देता है, जिसके पास कोई डेटा प्रकार नहीं है, इस चुनौती के लिए मान्य है?
— शीशमारा

जवाबों:

9

05AB1E , mbomb007 द्वारा क्रैक किया गया

उम्मीद है कि दरार करने के लिए मजेदार है और बहुत स्पष्ट नहीं है।

रेगेक्स (पीसीआरई):

^\w*[+\-*\/%]*\w*.{0,2}$

आउटपुट n = 4:

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

मूल समाधान

UXFXLNX*+NFR}ˆ
— Emigna
स्रोत
oooooomg - यार वह डोप है (तारीफ जरूर करें)
— तिलक मैडी
@ mbomb007: लहजे वाले अक्षर नहीं से मेल नहीं खाते \w। आप खुद को regex101
— Emigna
1
आप बदल कर अपनी regex कम कर सकता है .{0,2}के लिए.?.?
— हारून
1
आप -ब्रैकेटेड चार्ट ( [+*\/%-]) की अंतिम स्थिति में रख सकते हैं ताकि आपको उससे बचना न पड़े।
— दादा
@ दादा: यह वास्तव में पीसीआरई में काम करता है। मैं अभी इसे छोटा करने से बहुत चिंतित नहीं हूं क्योंकि मैं बहुत निश्चित हूं कि यह फटा होगा। अगर इसे पकड़ना चाहिए, तो मैं आपके और आरोन दोनों के सुझावों को शामिल करूँगा। धन्यवाद :)
— एमिग्ना
7

जेली , लंबाई 6, फटा

रेगेक्स (पीसीआरई)

^.{9}$

नमूना उत्पादन

 1  2  3  4
 8  7  6  5
 9 10 11 12
16 15 14 13
— डेनिस
स्रोत
3
यह जेली में डी वास्तव में अच्छी तरह से गोल्फ के लिए मजबूर कर रहा है: D
— Yytsi
1
कोई नौ अक्षर? आप उदार महसूस कर रहे हैं! : D
— AdmBorkBork
1
'कोई नौ' जेली में कितने कार्य थे?
— मैथ्यू रो
मैं 99% निश्चित हूं कि अंतिम चार को Gआउटपुट को ठीक से प्रारूपित करना है। मैं बाकी को हल करने के करीब हूं, लेकिन मैं सिर्फ यह नहीं पता लगा सकता हूं कि जेली के साथ एक सरणी में हर दूसरे आइटम को कैसे रिवर्स किया जाए ...
— ETHproductions
@ETHproductions: मुझे पूरा यकीन था कि मैं इसे लगभग हल कर चुका हूँ और मेरे पास हर दूसरी वस्तु को उलटने का एक तरीका है। मेरी समस्या यह है कि मैं यह पता नहीं लगा सकता कि सब कुछ एक साथ कैसे बांधें (मैंने ट्यूटोरियल की कोशिश नहीं की है)। मैं हालांकि अब तक इसे हल देखने की उम्मीद कर रहा था। शायद यह मेरे विचार से कठिन है।
— एमिग्ना
6

आर, लंबाई 14 प्लेनैपस द्वारा क्रैक किया गया

मुझे उम्मीद है कि मुझे यह रेगेक्स सही लगा। मैं क्या कहने की कोशिश कर रहा 77 को छोड़कर वर्ण है <space>, #, ;और [। मैंने यहां इसका परीक्षण किया

regex

^[^ #;\[]{77}$

नमूना आउटपुट n = 4

1 2 3 4 
8 7 6 5 
9 10 11 12 
16 15 14 13
— MickyT
स्रोत
मुझे लगा कि यह आसान होगा, लेकिन मुझे बड़ी परेशानी हो रही है कि मैं उन नंबरों को इस तरह आउटपुट करूं (जैसे किसी प्रकार की एक सरणी)। अच्छा कार्य।
— बीएलटी
1
@BLT धन्यवाद, कोशिश करना और मुश्किल करना एक दिलचस्प समस्या थी।
— मिकी
फटा , हालांकि शायद तुम्हारा जैसा कोड नहीं है।
— प्लेनैपस
6

> <> , लंबाई 49, हारून द्वारा क्रैक की गई

रेगेक्स (जावास्क्रिप्ट)

^.{7}\n.{12}\n\?.{6};[^v^]{27}(\n.{13}:&.{2}){2}$

नमूना उत्पादन (n = 4)

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

स्वरूपण थोड़ा अजीब है, लेकिन संख्या की लंबाई के लिए जाँच ने इसे बहुत लंबा बना दिया है। शायद यकीन नहीं हो रहा है, regex पर थोड़ा अधिक सवार हो गया है!

संपादित करें: इसके अलावा मैं उल्लेख करना भूल गया, मैं इनपुट के लिए प्रारंभिक स्टैक (-v ध्वज) का उपयोग करता हूं, न कि सामान्य मछली इनपुट के लिए। माफ़ कीजिये!

मूल कोड:

<v1*2&:
 >:{:}=?v:1+
?^{r0}v;>&:&[r]{&:&2*+}::&:::&*@+@(
+:}=?v>n" "o&:&{1
0~{oa<^v?)*&::&:}

हारून बहुत सरल है! मेरे मूल कोड की जटिलता n[r]उस खंड (पंक्ति) को फ्लिप करने के लिए प्रत्येक n-वें नंबर का उपयोग करने के विचार के आसपास आधारित है , फिर सभी नंबरों को एक साथ अंत में प्रिंट करना

— torcado
स्रोत
1
..से छोटा है .{2};)
— हारून
कोई बात नहीं, यह फटा ! मैंने स्पष्ट रूप से आपके कोड का बहुत अधिक पालन नहीं किया है, लेकिन यह वैसे भी एक दिलचस्प चुनौती थी। कृपया अपना मूल कोड साझा करें! यदि आप चाहें, तो आप एहसान वापस कर सकते हैं ;)
— हारून
@ अच्छा काम! हाँ, मुझे यकीन नहीं है कि मैंने कैसे ध्यान नहीं दिया कि रेगेक्स में। ओह अच्छा :) मैं देखूंगा कि क्या मैं तुम्हारा
— पीछा
5

ओम , फटा

इसके अलावा मेरे पहले पुलिस और लुटेरे चुनौती देते हैं, इसलिए मुझे बताएं कि क्या इस पैटर्न के साथ समस्याएं हैं (विशेषकर चूंकि यह एक काफी अज्ञात भाषा है)।

रेगेक्स (पीसीआरई)

^\S{6}\W{0,3}\w$

आउटपुट (n = 4)

[[1, 2, 3, 4], [8, 7, 6, 5], [9, 10, 11, 12], [16, 15, 14, 13]]
— निक क्लिफोर्ड
स्रोत
1
अगर कुछ भी यह बहुत आसान हो सकता है। यदि आप .*अपने regex में हैं, तो यह कुछ भी हो सकता है। इसलिए अगर भाषा में टिप्पणियां हैं, तो वे किसी भी कार्यक्रम को लिख सकते हैं और उसके बाद टिप्पणी कर सकते हैं।
— mbomb007
@ mbomb007 अच्छी बात है।
— निक क्लिफर्ड
1
— एमिग्ना
@Emigna शाबाश!
— निक क्लिफर्ड
5

PHP, 221 बाइट्स ( फटा )

मुझे उम्मीद है कि यह काफी मुश्किल है।

रेगेक्स (पीसीआरई): 16 बाइट्स

^[^\s/\#6]{221}$

कोई स्थान नहीं, कोई टिप्पणी नहीं, base64_decode का कोई उपयोग नहीं। मज़े करो।

उत्पादन

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

मूल कोड

$w=$argv[1];$s="";$r=range(1,$w**2);for($i=0;$i<$w;$i++)if($i%2)array_splice($r,$i*$w,$w,array_reverse(array_slice($r,$i*$w,$w)));foreach(($r)as$v)$s.=str_pad($v,$l=strlen(max($r))+1,"\x20",0);echo(chunk_split($s,$l*$w));
— जार्ग हुल्सरमन
स्रोत
कृपया ध्यान दें कि उत्तर का उपयोग कर सकते हैं base64_decodeक्योंकि आपका रेगेक्स इसे अस्वीकार नहीं करता है।
— कैलक्यूलेटरफैनलाइन
4
@ कैलाकुलरफलाइन: रेगेक्स ब्लॉक 6, जो ब्लॉक हो सकता है base64_decode।
— nnonneo
— 112405/
उफ़, चूक गए। लेकिन ^ इससे कोई फर्क नहीं पड़ता।
— कैलकुलेटरफ्लीन
5

C # net46 (क्रैक किया गया)

( http://ideone.com/ काम करता है)

Regex101 पर परीक्षण किया गया रेगेक्स पीसीआरई फ्लेवर लंबाई 58

^sta((?![\d%bh\/]|==|if|(\[.*){4}|(i.*){6}).){142}urn....$

केवल विधि regexed है। एक इनपुट n = 4 के लिए मेथड 2d int [,] एरे (int [4,4]) देता है। अगर प्रिंट इस तरह दिखता है:

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

यह इस तरह से किसी भी चीज में मेरी पहली प्रविष्टि है, मुझे बताएं कि क्या मैंने कुछ गलत किया है। सुनिश्चित करने के लिए रेगेक्स की लंबाई से जीतने की कोशिश नहीं कर रहा हूं, मुझे सिर्फ यह देखने में दिलचस्पी है कि मैंने दरार को रोकने में कितना अच्छा किया :)

मूल कोड:

static int[,]g(int n){int l,j,k=n-n,c,s;var _=new int[n,n];var d=n!=n;c=k;c++;s=k;for(l=k;l<n;l++){for(j=k;j<n;j++){_[l,d?n-j-c:j]=++s;}d=!d;}return _;}
— EklipZ
स्रोत
— kennytm
ठीक है, मुझे कोशिश करनी चाहिए कि लंबाई कम से कम चुनौतीपूर्ण हो ...
— एकलिप्ज़
5

QBasic, regex लंबाई 10 ( फटा )

regex

किसी भी regex स्वाद में काम करना चाहिए, लेकिन हम इसे पायथन स्वाद कहेंगे।

([A-Z]+.)+

नोट: मेरा समाधान अनवस्थित QBasic का उपयोग करता है; स्वरूपण के बाद, कोड जोड़ा रिक्त स्थान के कारण रेगेक्स से मेल नहीं खाता है। (लेकिन मैं आपको बता सकता हूं कि यह एकमात्र बदलाव है जो एक अंतर बनाता है। ([A-Z]+ ?. ?)+अभी भी स्वरूपित संस्करण पर काम करता है।)

परीक्षण के उद्देश्यों के लिए, मैंने QB64 का उपयोग कोड स्वरूपण बंद (विकल्प> कोड लेआउट के तहत) के साथ किया। आप डाउनलोड कुछ नहीं करना चाहते हैं, तो आप भी QBasic ऑनलाइन से चला सकते हैं archive.org (लेकिन आप वहाँ बंद स्वरूपण चालू नहीं कर सकता)।

नमूना उत्पादन

 1  2  3  4 
 8  7  6  5 
 9  10  11  12 
 16  15  14  13
— DLosc
स्रोत
इसलिए स्रोत के सभी प्रतीकों को एक पत्र से पहले होना चाहिए।
— कैलक्यूलेटरफेलीन
@ कैलाकेटरफेलिन एक या एक से अधिक अक्षर।
— mbomb007
ठीक है, मेरी आवश्यकता समतुल्य है क्योंकि इसमें \w+\Wविभाजित किया जा सकता है \w*और \w\W। ( \w*या तो है null(तुच्छ) या \w+(आसानी से एक प्रतीक के साथ में snuck))
— CalculatorFeline
@CalculatorFeline कुछ भी नहीं कह रहा है कि .एक शब्द चरित्र नहीं हो सकता है। यह एक लोअरकेस अक्षर या एक अंक हो सकता है। वास्तव में, यह एक पूंजी पत्र भी हो सकता है, इस घटना में कि कार्यक्रम का अंतिम चरित्र एक है।
— mbomb007
1
— 112653/
5

अजगर 3, 55 बाइट्स (फटा)

पीसीआरई / पायथन / गोलंग स्वाद।

def [triangles=(1,SNAKE)]{27}:print[]SNAKE(--:>or[]{48}

(याद रखें कि पूर्ण मिलान आवश्यक है । मान लें ^और $परीक्षण करते समय।)

नमूना उत्पादन:

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

मूल समाधान:

def r(N,S=1,A=1,K=range,E=list):print(E(K(S,S+N))[::A])or(S+N>N*N)or(r(N,S+N,-A,K,E))

4 बाइट्स छंटनी चाहिए: पी

— kennytm
स्रोत
मेरे लिए ऐसा लगता है कि आप )रेगेक्स के दूसरे भाग को याद करते हैं
— जॉर्ग ह्यूल्सरमैन
@ JörgHülsermann कुछ भी याद नहीं है, regex सही है।
— kennytm
1
@ JörgHülsermann अतिरिक्त (एक चरित्र वर्ग के अंदर शुरू printहोने से पहले और अंत के बाद है {48}। मुझे भी देखने के लिए कुछ समय लिया। ;) (उस मामले के लिए, कोष्ठक की पहले की जोड़ी भी एक चरित्र वर्ग के अंदर है।)
— डीएलोस्क
@DLosc अब यह स्पष्ट है। धन्यवाद
— Jörg Hülsermann
— xsot
5

dc , Regex की लंबाई 12   seshoumara द्वारा क्रैक की गई!

^[^# !]{59}$

यह नियमित अभिव्यक्ति काफी सरल है कि मुझे नहीं लगता कि रेगेक्स मामलों का स्वाद - यह बोर्ड भर में काम करना चाहिए। (Regex में # के बाद के स्थान पर ध्यान दें।)

मैंने regex101.com (PCRE / PHP, Javascript, Python, और Golang), और रूबी.कॉम पर Ruby संस्करण में सभी चार स्वादों का परीक्षण किया है। डीसी प्रोग्राम सभी पांच रेगेक्स संस्करणों में रेगेक्स से मेल खाता है।

डीसी प्रोग्राम स्टड पर अपना इनपुट लेता है और स्टडआउट पर अपना आउटपुट डालता है।

इनपुट 4 के लिए नमूना आउटपुट (प्रत्येक पंक्ति के अंत में एक अनुगामी स्थान है):

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

मूल कोड (टूटने के बाद जोड़ा गया)

इसे @seshoumara ने क्रैक किया है । यहाँ मेरा इच्छित कोड है:

?sd[AP]s+0[dddld/2%rld%2*1+ldr-*+1+n2CP1+dld%0=+dvld>l]dslx

स्पष्टीकरण:

?sd      Input number and store it in register d.
[AP]s+   Macro that prints a newline. The macro is stored in register '+'.
0        Push 0 on the stack, initializing a loop.  (The top of the stack is the index variable.  It will go up to d^2-1.)
[        Start a macro definition.  (The macro will be stored in register l.)
ddd      Push 3 copies of the loop index variable on the stack, so they'll be available later. I'll call this number i.
ld/      Divide the last copy of i by d (integer division); this computes the row of the square that we're in (starting with row 0).
2%       Replace the row number with 0 if the row number is even, with 1 if the row number is odd.
r        Swap the top two items on the stack, so the top item is now the next to last copy of i, and the second item on the stack is the row number mod 2.
ld%      Compute i mod d; this goes from 0 to d-1. It is the column in the square that the next number will be placed in.  (The leftmost column is column 0.)
2*1+     Top of the stack is replaced with 2*(column number)+1.
ldr      Inserts d as the second item on the stack.
-        Computes d-2*(column number)-1.
*        The second item on the stack is the row number mod 2, so multiplying yields 0 if the row number is even, and d-2*(column number)-1 if the row number is odd.
+        Add to the remaining copy of i. The sum is i itself in even-numbered rows, and it's i+d-2*(column number)-1 in odd-numbered rows.

स्टैक के शीर्ष पर अब वह अगला नंबर है जिसे हम प्रिंट करना चाहते हैं:

  • यह देखना आसान है कि यदि पंक्ति संख्या सम है तो सही है, तब से योग सिर्फ i है।

  • विषम संख्या वाली पंक्तियों के लिए, ध्यान दें कि i = d * (i / d) + (i% d) = d * (पंक्ति संख्या) + स्तंभ संख्या। यह इस प्रकार है कि योग i + d-2 * (स्तंभ संख्या) -1 d * (पंक्ति संख्या) + स्तंभ संख्या + d - 2 * (स्तंभ संख्या) - 1 = d * (पंक्ति संख्या + 1) - स्तंभ संख्या है - 1, वह संख्या जो हम संकेतित पंक्ति और कॉलम में रखना चाहते हैं यह सुनिश्चित करने के लिए कि हम विषम संख्या वाली पंक्तियों में पीछे की ओर गिन रहे हैं।

अब स्पष्टीकरण पर लौट रहे हैं:

n        Print the desired number for the current row and column.
2CP      Print a space.  (2C, which is computed by dc as 20 + 12, is 32, the ASCII code for a space.)
1+       The original copy of i is at the top of the stack; add 1 to it.
dld%0=+  If (the incremented value of) i is a multiple of d, call the macro at register '+', which prints a newline.
dvld>l   If d > sqrt(i) (in other words, if i < d^2), then go back to the top of the loop by calling macro l again.
]dslx    End the macro definition, store the macro in register l, and execute it.
— मिशेल स्पेक्टर
स्रोत
क्या #आकर्षण और `` छोड़े गए हैं ताकि एक छोटा समाधान 59 बाइट तक पहुंचने के लिए टिप्पणियों का उपयोग न कर सके? यदि हां, तो dc से कोई आवश्यकता नहीं है क्योंकि कमांड जोड़ने के बहुत सारे तरीके हैं जो कुछ भी नहीं बदलते हैं, पूर्व के लिए। qस्क्रिप्ट के अंत में दोहराए जाने वाले आदेश।
— शेषमारा
@ शीशमौरा इसका मतलब उस दिशा में एक संकेत होना है जबकि रेगेक्स को छोटा रखना। लेकिन आप सही कह रहे हैं, बिल्कुल। (यह मेरी पहली पुलिस और लुटेरों की प्रविष्टि है, इसलिए मुझे यकीन नहीं है कि यह कितना आसान है।)
— मिशेल स्पेक्टर
फटा! । 59 बाइट्स से थोड़ा अधिक प्राप्त करना आसान था, लेकिन आपकी सीमा से कम या उससे अधिक मिलान करना मेरी अपेक्षा से अधिक कठिन था। रेगेक्स के लिए, अंतरिक्ष को छोड़ना ठीक था, मेरा बुरा, क्योंकि एक को इसे मुद्रित करने की आवश्यकता है, इसलिए मुझे कुछ और उपयोग करना पड़ा।
— शेषमारा
@seshoumara अच्छा काम!
— मिशेल स्पेक्टर
@ शेशमौरा वैसे तो दो क्रमिक स्थिरांक को अलग करने के लिए dc में रिक्त स्थान भी उपयोगी होते हैं, इसलिए यदि आपको उस कार्यक्षमता की आवश्यकता होती है, तो रिक्त स्थान पर रोक लगाना आवश्यक है। हालाँकि, किसी स्पेस को प्रिंट करना कोई बड़ी बात नहीं है, क्योंकि वैसे भी 32Pकम है [ ]n।
— मिशेल स्पेक्टर
5

बैश, रेगेक्स लंबाई 38, फटा ( @kennytm )

^sort -n <[1adegnopqrstx$\-*()|'; ]+$

इनपुट:

n=4; <command>

आउटपुट:

1 2 3 4
8 7 6 5
9 10 11 12
16 15 14 13
— मार्कोस एम
स्रोत
क्रैक कोडगोल्फ.स्टैकएक्सचेंज . com/a/112656/32353 । यह एक अच्छा है: D
— kennytm
खुशी है कि आपने इसका आनंद लिया @kennytm ने मेरे मूल आदेश के रूप में सटीक समाधान पाया है!
— मार्कोस एम
5

पीएचपी

मुझे उम्मीद है कि यह एक मजेदार होगा! : डी

आउटपुट (n = 4)

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

लेवल 1: पीसीआरई (लंबाई = 17) ( जो हॉर्ग्समैन द्वारा क्रैक किया गया )

^<[^'"\d{vV;<$]+$
  • कोई एकल या दोहरा उद्धरण नहीं ... कोई तार नहीं!
  • कोई अंक नहीं!
  • नहीं {ऐसा नहीं है ... कोई अनाम फ़ंक्शन नहीं!
  • नहीं vतो ... नहीं eval()!
  • नहीं ;ऐसा नहीं है ... यह एक ही कथन होना चाहिए!
  • नहीं <तो ... नहीं Heredocऔर न ही कई PHP ब्लॉक!
  • बड़ा वाला! कोई $ नहीं ... अच्छा भाग्य परिभाषित चर! >: D

@ JörgHülsermann के पास एक दिलचस्प दृष्टिकोण था, लेकिन यह वह नहीं है जो मेरे मन में था :)। इसलिए, मैं कठिनाई के एक नए स्तर का परिचय दे रहा हूं (मैं वादा करता हूं कि मेरे पास वह कोड है जो इसे फिट करता है और मैं सिर्फ आपके साथ खिलवाड़ नहीं कर रहा हूं)

स्तर 2: पीसीआरई (लंबाई = 23) ( जोर्ज ह्यूल्सरमन द्वारा क्रैक किया गया )

^<[^'"\d{v;<$_~|&A-Z]+$
  • स्तर 1 के सभी प्रतिबंध
  • इस स्तर पर नया: इनमें से कोई नहीं _~|&A-Z! :)

मज़े करो!

मूल समाधान

इसलिए, $इसका मतलब है कि चर को नियमित रूप से एक्सेस नहीं किया जा सकता है, लेकिन इसका मतलब यह नहीं है कि उनका उपयोग नहीं किया जा सकता है! आप अभी भी extract()/compact()मौजूदा दायरे में चर आयात / निर्यात कर सकते हैं । :)

$i = 1;
// can be written as
extract(['i' => 1])

echo $i;
// can be written as
echo compact('i')['i'];

हालाँकि, एक गोचर है: compact('x')['x']++काम नहीं करेगा क्योंकि PHP में चर एक मान के साथ पारित किए जाते हैं ...! ऑब्जेक्ट्स।

$x = (object) ['i' => 1];
// is
extract(['x' => (object) ['i' => 1]]);

// and
compact('x')['x']->i++;
// works just fine!

बाकी काम आसान है।

  • नंबर 0और 1आसानी से परिवर्तित करके उत्पन्न कर रहे हैं falseऔर trueकरने के लिए intउन लोगों के साथ prepending द्वारा +हस्ताक्षर
  • उपयोग andऔर orबाद से &और |निषिद्ध हैं
  • निषिद्ध उद्धरणों के आसपास काम करने के लिए, बस अपरिभाषित स्थिरांक का उपयोग करें, जिन्हें स्ट्रिंग्स के रूप में माना जाता है
  • अपरिभाषित स्थिरांक का उपयोग करके उत्पन्न नोटिस को दबाने के लिए, बस का उपयोग करें @
  • निषिद्ध पत्र vका उपयोग करके उत्पन्न किया जा सकता है chr(ord('u') + 1), जो @chr(ord(u) + true)उपरोक्त वर्कअराउंड का उपयोग करने के लिए अनुवाद करता है
  • अंडरस्कोर उपरोक्त के समान है: chr(ord('a') - 2)जिसका अनुवाद हैchr(ord(a) - true - true)
  • जिन फ़ंक्शन में निषिद्ध वर्ण हैं उन्हें कॉल करना PHP के callableप्रकार का लाभ उठाकर किया जा सकता है , जो फ़ंक्शन के नाम से युक्त एक स्ट्रिंग हो सकता है। इसलिए, आप ord()फ़ंक्शन के नाम का निर्माण करने के लिए अपरिभाषित स्थिरांक और एकल वर्ण स्ट्रिंग्स को संक्षिप्त कर सकते हैं और इसे इस तरह से लागू कर सकते हैं: array_reverse()बन जाता है (a.rray.chr(ord(a)-true-true).re.chr(ord(u)+true).erse)()( arrayयह एक भाषा का निर्माण है, इसीलिए इसे अपरिभाषित स्थिरांक में विभाजित किया गया है ) aऔरrray
  • इस तथ्य का लाभ उठाएं कि, जब यह सशर्त और लूप निर्माण की बात आती है, तो घुंघराले कोष्ठक वैकल्पिक होते हैं यदि निर्माण तुरंत निम्नलिखित कथन पर लागू होता है। इसका मतलब है कि आप सामान की तरह कर सकते हैं: if ($n = $argv[1] and $i = 0) while ($n > $i++ and do_some and other_stuff or exit)

मानव पठनीय कोड में तर्क होगा:

if (
    $x = (object) [
        'result' => [],
        'i' => 0
    ]

    and

    define('n', $argv[1])

    and

    define('un', '_')

    and

    // create the initial set which we'll loop through
    define('segments', array_chunk(range(1, pow(n, 2)), n))
) while (
    // store each odd segment as-is and increment the "pointer"
    ($x->result[] = @segments[$x->i++])

    and

    // store each even segment reversed and increment the "pointer"
    ($x->result[] = @array_reverse(segments[$x->i++]))

    and

    // check if we need to break out of the loop
    n > $x->i

    or

    // exit and output the result if the above is false
    die(json_encode(
        // if n is odd, the above would have copied a NULL entry 
        // from the segments, so it needs to be filtered out
        array_filter($x->result)
    ))
)

और अनफ्रेंडली संस्करण जो रेगेक्स से मेल खाता है:

<?php if (@extract([x=>(object)[s=>[],i=>+false]])and@define(n,compact(arg.chr(ord(u)+true))[arg.chr(ord(u)+true)][+true]?:+true)and@define(un,chr(ord(a)-true-true))and@define(s,(a.rray.un.chunk)(range(+true,pow(n,true+true)),n)))while((@compact(x)[x]->s[]=s[@compact(x)[x]->i++])and(@compact(x)[x]->s[]=(a.rray.un.re.chr(ord(u)+true).erse)(s[@compact(x)[x]->i++]))and(n>@compact(x)[x]->i)or(@die((json.un.encode)((a.rray.un.filter)(@compact(x)[x]->s)))))?>

— Ionut Botizan
स्रोत
@ JörgHülsermann चूंकि मेरा रेगीक्स बहुत लंबा था, इसलिए मुझे उम्मीद नहीं थी कि इसे जीतने का कोई मौका मिलेगा, मैंने बस यह मान लिया था कि रेगेक्स इंजन की केस सेंसिटिविटी के रूप में लोग ऐसी तकनीकी पर नहीं टिकेंगे। वैसे भी, मैंने अपना उत्तर संपादित कर दिया है, इसलिए रेगेक्स में अब एक पूंजी शामिल है V। मज़े करो! :)
— आयनुत बोतिज़ान
2
— जॉर्ग ह्यूल्सरमैन
1
@ JörgHülsermann यह वास्तव में एक ही कोड है, लेकिन मैंने शुरू में एक शिथिल नियमित अभिव्यक्ति का उपयोग किया था क्योंकि मुझे इस बात की उत्सुकता थी कि अन्य समाधान क्या हो सकते हैं। मैं इसे एक और दिन दूंगा (हो सकता है कि कोई व्यक्ति सप्ताह के अंत में इस पर शॉट लेना चाहे) और मैं कल रात को अपना कोड और स्पष्टीकरण पोस्ट करूँगा। अभी मैं आपको जो बता सकता हूं वह यह है कि आप अपरिभाषित स्थिरांक को स्ट्रिंग्स के रूप में उपयोग करने के बारे में सही रास्ते पर थे। इसके अलावा, आप अपने समाधान में कुछ के बारे में गलत थे। आप कॉल कर सकते हैं (array_re.chr(ord(u)+true).erse)()! :) (... या कम से कम जब आपको _अनुमति दी गई थी)
— Ionut Botizan
3
@IonutBotizan आप स्तर 1 के समाधान को अभी के लिए गुप्त रख सकते हैं क्योंकि यह फटा है। लेवल 2 को नई पोस्ट के रूप में बनाना आपके लिए अभी भी बेहतर है, अन्य लोगों के लिए यह जांचना आसान है कि यह फटा है या नहीं।
— kennytm
1
स्तर 2 दरार regex101.com/r/XtVl9G/1 संकेत के लिए धन्यवाद। अब मैं लेवल 3 :-) का इंतजार कर रहा हूं
— Jörg Hülsermann
5

रूबी [फटा]

पहले पुलिस और लुटेरे चुनौती देते हैं। आशा है कि मैंने इसे बहुत आसान नहीं बनाया।

संपादित करें: प्रतिस्थापित \g<1>के साथ (?1)क्योंकि वे जाहिर PCRE में बराबर कर रहे हैं।

Regex (PCRE)

^(\W?\W\w){4}..(?1){2}[(-=Z-~]*(?1){5}\w*(?1)(.)\2$

आउटपुट (n = 4)

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

(सरणियों की एक सरणी लौटाता है। यह एक मेमना है, BTW है, लेकिन शायद यह बहुत दूर देता है?)

— मूल्य स्याही
स्रोत
— a/
4

जावास्क्रिप्ट (फटा)

पहली बार एक पुलिस और लुटेरे चुनौती देते हैं, उम्मीद है कि यह सही है।

रेगेक्स (जावास्क्रिप्ट)

^.*(\.\w+\(.*\)){4}$

उत्पादन

एक सरणी के बराबर:

[[1,2,3,4],[8,7,6,5],[9,10,11,12],[16,15,14,13]]
— टॉम
स्रोत
आप $रेगेक्स के अंत पर चाहते हैं यदि कोड खुद रेगेक्स के अंत में समाप्त हो जाए। अन्यथा मैं कर सकता था उदा x=>x.toString().toString().toString().toString()और उसके बाद जो भी मैं चाहता हूं।
— ETHproductions
@ETHproductions अच्छी बात है, टिप के लिए धन्यवाद!
— टॉम
— ovs
1
@ वाह वाह, यह तेजी से था। बहुत बढ़िया!
— टॉम
4
@ .*शुरुआत में यह वास्तव में आसान बना दिया है। यह एक टिप्पणी के बाद किसी भी कार्यक्रम हो सकता है। मूल रूप से, .*अपने रेगेक्स में शामिल न करें।
— mbomb007
4

स्विफ्ट, रेगेक्स 25 (क्रैक)

बेनाम: ठीक है, चलो देखते हैं अगर मैं इस का फांसी मिल गया है। यह मेरी पहली पुलिस और लुटेरे पोस्ट है, इसलिए मुझे पता है कि क्या मैंने गड़बड़ की है!

regex

मैंने regex101.com पर जावास्क्रिप्ट स्वाद का उपयोग किया

^.{21}print[^/]{49}o.{7}$

नमूना आउटपुट

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

मूल कोड

(0..<n).forEach{i in print((0..<n).map{i%2>0 ?(i+1)*n-$0 :i*n+$0+1},separator:",")}
— जेम्स वेबस्टर
स्रोत
— 112401/
ऐसा प्रतीत होता है कि यह सबमिशन nइनपुट के रूप में नहीं लिया जाता है, लेकिन इसके लिए हार्ड कोडेड वैरिएबल की आवश्यकता होती है । अगर यह सही है तो मुझे डर है कि यह मेटा सर्वसम्मति के अनुसार मान्य नहीं है।
— स्टीवी ग्रिफिन
नोट: आप पोस्ट रख सकते हैं, क्योंकि यह पहले से ही फटा हुआ है :)
— स्टीवी ग्रिफिन
@Stewie। जानकारी के लिए धन्यवाद, एक कारण है कि मैंने अतीत में इस प्रकार के प्रश्नों से बचा है! मुझे लगता है कि मैं इस उत्तर को क्रैक करने के बाद से "बस एक फ़ंक्शन" की अवधारणा को थोड़ा बेहतर समझता हूं। मैंने यह मान लिया था कि इसका मतलब किसी फ़ंक्शन का शरीर है, लेकिन मैं अब इकट्ठा करता हूं इसका मतलब फ़ंक्शन चर है?
— जेम्स वेबस्टर
4

C - 42 वर्णों का रेगेक्स लंबाई में - फटा

जावास्क्रिप्ट regex के रूप में regex101 में इस्तेमाल किया ।

^[-h<=*c+m?{printf("\/a: %d\\',o);}]{137}$

अंदाजा लगाना ये होगा तुच्छ ...

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

आउटपुट \nप्रत्येक पंक्ति के बाद टैब-सीमांकित है ।

मेरे समाधान, यहाँ integers 0 - 2 के माध्यम से प्राप्त किया गया t-t, t/tऔर t:

main(int t,char**a){int o=t-t,i=t/t,m,n,h=atoi(*(a+i));for(m=o;m<h;m++)for(n=o;n<h;n++)printf("%d%c",m*h+(m%t?h-n:n+i),n<h-i?'\t':'\n');}
— समुदाय
स्रोत
आप rअपने रेगेक्स में एक हटा सकते हैं ।
— kennytm
@kennytm - धन्यवाद - उस एक को याद किया
— 112447/
4

जेली , लंबाई 14 फटा

डेनिस द्वारा फटा

[^/P-`mvḊ-ṫ€]*

पायथन रेगेक्स।

mमैंने उसे फिर से खिसकने के बाद वापस जोड़ा ।

/(जल्दी कम करें);
से P(उत्पाद) से `(जल्दी से मोनाद);
m(modulo indexing);
v(eval dyad);
से Ḋकरने के लिए (विपंक्ति) ṫ(पूंछ); और
€(प्रत्येक त्वरित के लिए)

4मेरा आउटपुट के इनपुट के लिए :

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

... क्योंकि मैंने एक ग्रिड के रूप में सूचियों की एक सूची तैयार की है G।

— जोनाथन एलन
स्रोत
फटा। यह एक मजेदार था।
— डेनिस
4

पॉवरशेल, 23 ​​बाइट्स

मैट द्वारा फटा

^.+?%.{42}%.{11}:.{35}$

मूल समाधान:

$n="$args";$script:r=0;$a=1..$n|%{$t=++$script:r..($script:r+=$n-1);if(!($_%2)){[Array]::Reverse($t)};,$t};$a|%{$_-join" "}

इनपुट को तर्क के रूप में लेता है और स्टडआउट को आउटपुट देता है

उम्मीद है कि यह रेगेक्स ठीक है, मुझे उम्मीद नहीं है कि यह दरार करना बहुत मुश्किल है, क्योंकि मैंने इसके बारे में बहुत कुछ नहीं बताया है, और रेपेक्स अंतराल में भरने के लिए कुछ अच्छे शुरुआती बिंदु देता है, पहले सेगमेंट में एक बात है हालांकि कोड गोल्फ में यह बहुत ही असामान्य है, जो किसी को पकड़ सकता है, मुझे लगता है कि इसे थोड़ा कठिन बनाने के लिए एक गैर-लालची मैच की आवश्यकता है।

वैसे भी पहले पुलिस चुनौती।

1..4 | % { "----$_----" ; .\snake-cops.ps1 $_  }
----1----
1
----2----
1 2
4 3
----3----
1 2 3
6 5 4
7 8 9
----4----
1 2 3 4
8 7 6 5
9 10 11 12
16 15 14 13
— colsw
स्रोत
— मैट
आपका हल क्या था?
— मैट
@ मैट ने कहा, मुझे लगा कि यह विचार करना कठिन होगा कि मैंने कितने गैर-कोड-गोल्फ चीजों को जोड़ा, अर्थात [Array]::Reverse()इसके बजाय $array[9..0]और $script:rचर का उपयोग करके जो ज्यादातर अनावश्यक हैं।
— कोल्स
4

रोड़ा 0.12 , लंबाई 19 (क्रैक्सीलीथोस द्वारा क्रैक किया गया)

PCRE:

^{(\|[^\/#\s]*){8}$

नमूना उत्पादन (n = 4):

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

मूल कोड:

{|n|seq(0,n-1+n%2)|push([{|i|seq(n*i+1,n*i+n)}(_)],[{|j|seq(n*j+n,n*j+1,step=-1)}(_)])|head(n)}

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

— fergusq
स्रोत
1
यह तब तक उचित खेल है जब तक यह इस चुनौती से पहले है और इसमें उपलब्ध (मुक्त) दुभाषिया है। पहली बार मैंने MATL की कोशिश की थी जब मैं एक पुलिस चौकी को तोड़ने की कोशिश कर रहा था । अगर कोई इस सवाल का जवाब देने के लिए रोडा सीखे तो हैरान मत होना :)
— स्टीवी ग्रिफिन
मुझे उम्मीद है कि प्रलेखन अंग्रेजी में है, फिनिश नहीं है हालांकि :)
— स्टीवी ग्रिफिन
@StewieGriffin कुछ प्रलेखन उपलब्ध है। क्या मुझे अपने उत्तर के लिए एक लिंक जोड़ना चाहिए या गीथब पृष्ठ से खोजने के लिए पर्याप्त रूप से आसान है?
— फर्ग्यूसक
— क्रिति लिथोस
4

PHP 7 (सुरक्षित)

मूल कोड

for($z=0,$q="";$z<($x=$argv[1])**2;){$w=($d=intdiv($z,$x))%2?($d+1)*$x-$z%$x:($z+1);for($f=0;$f<(log10($x**2)^0)-(log10($w)^0);$f++)$q.="\x20";$q.=++$z%$x?"$w\x20":"$w\n";}print(rtrim($q));

दूसरा प्रयास

रेगेक्स (पीसीआरई): 29 बाइट्स

^[^A-Z#\/\s\>busy_heck]{189}$

कोई स्थान नहीं, कोई टिप्पणी नहीं, base64_decode का कोई उपयोग नहीं।

कई कार्यों की अनुमति नहीं है! अंडरस्कोर

आउटपुट n = 11

  1   2   3   4   5   6   7   8   9  10  11
 22  21  20  19  18  17  16  15  14  13  12
 23  24  25  26  27  28  29  30  31  32  33
 44  43  42  41  40  39  38  37  36  35  34
 45  46  47  48  49  50  51  52  53  54  55
 66  65  64  63  62  61  60  59  58  57  56
 67  68  69  70  71  72  73  74  75  76  77
 88  87  86  85  84  83  82  81  80  79  78
 89  90  91  92  93  94  95  96  97  98  99
110 109 108 107 106 105 104 103 102 101 100
111 112 113 114 115 116 117 118 119 120 121

आउटपुट n = 4

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

आउटपुट n = 3

1 2 3
6 5 4
7 8 9
— जार्ग हुल्सरमन
स्रोत
मेरा मानना ​​है कि आपका उत्तर अब सुरक्षित है :)
— हारून
@Aaron मुझे आश्चर्य है कि फटा नहीं था। मूल कोड जोड़ा गया है
— Jörg Hülsermann
4

MATL , लंबाई 12 (सुरक्षित)

regex

पायथन स्वाद का उपयोग करता है:

(\w{3}\W){5}

उदाहरण आउटपुट

के लिए n=4:

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

समाधान

txU:GeG:oEq*S5M*TTx!

यह देखने के लिए कि यह कैसे काम करता है, इनपुट पर विचार करें n=4।

tx   % Implicit input n, duplicate, delete. So this does nothing
     % STACK: 4
U    % Square
     % STACK: 16
:    % Range
     % STACK: [1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16]
Ge   % Reshape as an n-row array in column major order
     % STACK: [1  5  9 13;
               2  6 10 14;
               3  7 11 15;
               4  8 12 16]
G:   % Push range [1 2 ... n]
     % STACK: [1  5  9 13;
               2  6 10 14;
               3  7 11 15;
               4  8 12 16]
               [1 2 3 4]
o    % Modulo 2
     % STACK: [1  5  9 13;
               2  6 10 14;
               3  7 11 15;
               4  8 12 16]
              [1  0  1  0]
Eq   % Times 2, minus 1 (element-wise)
     % STACK: [1  5  9 13;
               2  6 10 14;
               3  7 11 15;
               4  8 12 16]
              [1 -1  1 -1]
*    % Multiply (element-wise with broadcast)
     % STACK: [1 -5  9 -13;
               2 -6 10 -14
               3 -7 11 -15
               4 -8 12 -16]
S    % Sort each column
     % STACK: [1 -8  9 -16;
               2 -7 10 -15;
               3 -6 11 -14;
               4 -5 12 -13]
5M   % Push [1 -1 1 -1] again
     % STACK: [1 -8  9 -16;
               2 -7 10 -15;
               3 -6 11 -14;
               4 -5 12 -13]
              [1 -1  1  -1]
*    % Multiply (element-wise with broadcast)
     % STACK: [1  8  9  16;
               2  7 10  15;
               3  6 11  14;
               4  5 12  13]
TTx  % Push [true true] and delete it. So this does nothing
!    % Transpose. Implicitly display
     % STACK: [ 1  2  3  4;
                8  7  6  5;
                9 10 11 12;
               16 15 14 13]
— लुइस मेंडो
स्रोत
4

जेली , लंबाई 17 (सुरक्षित)

[^/P-`mvÇ-ıḃ-ṫ€]*

पायथन रेगेक्स।

गाँठ को कसते हुए, यह कुछ और उपयोगी चीजों पर प्रतिबंध लगाता है, आपकी सहायता के लिए यहां प्रतिबंधित बाइट्स हैं:

/PQRSTUVWXYZ[\]^_`mvÇÐÑ×ØÞßæçðñ÷øþĊċĖėĠġİıḃḄḅḊḋḌḍḞḟḢḣḤḥḲḳḶḷṀṁṂṃṄṅṆṇṖṗṘṙṚṛṠṡṢṣṪṫ€

बस उनमें से एक तिहाई के तहत!

4मेरा आउटपुट के इनपुट के लिए :

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

... क्योंकि मैंने एक ग्रिड के रूप में सूचियों की एक सूची तैयार की है G।

एक तरकीब:

’:2o1
Ḃ¬aẋ@0
’r0;0ẋ$ẋ1Ŀ¬0¦;2ĿÆ¡œ?⁸²¤s⁸G

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

यहाँ मुख्य चाल n 2 तक प्राकृतिक संख्याओं के क्रमपरिवर्तन की क्रमबद्ध सूची में अनुक्रमित करने के लिए है ( œ?लंबाई n 2 की सूची के निर्माण से बचने के लिए उपयोग ! ), और परिणाम को लंबाई n के भाग में विभाजित करने के लिए । उपर्युक्त सूचकांक को फैक्टरियल संख्या प्रणाली में अपना प्रतिनिधित्व बनाने के द्वारा पाया जाता है जो कि "बिना लाइसेंस के" सांप है क्योंकि तत्वों को निर्धारित तरीके से अनुमति देकर बनाया गया है (इसे आसानी से एक संख्या के साथ परिवर्तित किया जा सकता है Æ¡)।

मैं जो समाधान प्रस्तुत करता हूं वह Ŀपिछले लिंक को भिक्षुओं (बदलने Ñऔर Ç) के रूप में संदर्भित करता है , लेकिन $इन सहायक कार्यों को "इनलाइन" करने के बजाय एक पंक्ति में एकाधिक को नियोजित किया जा सकता है। यह तब से भी उपयोग करता rहै Ḷऔर Rप्रतिबंधित है।

’:2o1 - Link 1, periodic repetitions in the factorial base representation: n
’     - decrement n
 :2   - integer divide by 2
   o1 - or 1 (keep one period in the cases n=1 and n=2)

Ḃ¬aẋ@0 - Link 2, n zeros if n is even, else an empty list: n
Ḃ      - mod 2
 ¬     - not
   ẋ@0 - 0 repeated n times
  a    - and

’r0;0ẋ$ẋ1Ŀ¬0¦;2ĿÆ¡œ?⁸²¤s⁸G - Main link: n                    e.g. 6
’r0                        - inclusive range(n-1, 0)              [5,4,3,2,1,0]
    0ẋ$                    - 0 repeated n times                   [0,0,0,0,0,0]
   ;                       - concatenate (makes one "period")     [5,4,3,2,1,0,0,0,0,0,0,0]
        1Ŀ                 - call link 1 as a monad               2
       ẋ                   - repeat list                          [5,4,3,2,1,0,0,0,0,0,0,0,5,4,3,2,1,0,0,0,0,0,0,0]
           0¦              - apply to index 0 (rightmost index):
          ¬                -     not (make the last 0 a 1)        [5,4,3,2,1,0,0,0,0,0,0,0,5,4,3,2,1,0,0,0,0,0,0,1]
              2Ŀ           - call link 2 as a monad               [0,0,0,0,0,0]
             ;             - concatenate                          [5,4,3,2,1,0,0,0,0,0,0,0,5,4,3,2,1,0,0,0,0,0,0,1,0,0,0,0,0,0]
                Æ¡         - convert from factorial base          45461852049628918679695458739920
                      ¤    - nilad followed by link(s) as a nilad
                    ⁸      -     left argument, n                 6
                     ²     -     square                           36
                  œ?       - lexicographical permutation lookup   [1,2,3,4,5,6,12,11,10,9,8,7,13,14,15,16,17,18,24,23,22,21,20,19,25,26,27,28,29,30,36,35,34,33,32,31]
                       s⁸  - split into chunks of length n        [[1,2,3,4,5,6],[12,11,10,9,8,7],[13,14,15,16,17,18],[24,23,22,21,20,19],[25,26,27,28,29,30],[36,35,34,33,32,31]]
                         G - format as a grid
— जोनाथन एलन
स्रोत
4

पिप , रेगेक्स लंबाई 3 (सुरक्षित)

समाधान एक पूर्ण कार्यक्रम है जो कमांड-लाइन तर्क के रूप में n लेता है। यह किसी भी कमांड-लाइन झंडे का उपयोग नहीं करता है।

रेगेक्स (किसी भी स्वाद)

\w+

नमूना उत्पादन

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

मेरा समाधान

YENsXaPBsPOyY_MUyFi_MUENsXaIiBA1PsPUPODQENsXiXaPBsX_PBsMRVyEI1PsPUPODQENsXiXaPBsX_PBsMy

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

रणनीति

यहाँ कोड हम करेंगे की तरह लिखने के लिए:

Y \,a
F i ,a
 I i%2
  P i*a+_.s M RVy
 E
  P i*a+_.s M y

अर्थात्:

  • स्टोर संख्या 1 के माध्यम से aमेंy
  • के iमाध्यम से 0 से मूल्यों पर लूपa-1
  • यदि iविषम है, तो रिवर्स वाई, i*aप्रत्येक तत्व में जोड़ें, प्रत्येक तत्व के लिए एक स्थान को संक्षिप्त करें, और प्रिंट करें
  • अन्यथा, एक ही काम करें, लेकिन पहले उलटा किए बिना

कठिनाइयाँ

पिप में बहुत सारे आदेश और चर अक्षरों का उपयोग करते हैं, लेकिन कुछ महत्वपूर्ण नहीं हैं:

  • रेंज और समावेशी रेंज ( ,और \,)
  • अधिकांश गणित आपरेशन ( +, -, *, %, ++)
  • असाइनमेंट ( :)
  • हमारे पास एक से अधिक स्टेटमेंट वाला लूप या फंक्शन बॉडी नहीं हो सकता (जिसकी आवश्यकता होगी {})
  • हम पूर्वता को लागू करने के लिए कोष्ठकों का उपयोग नहीं कर सकते हैं

हम उन सीमाओं के आसपास कैसे पहुँचें:

  • ENके स्थान पर umerate का उपयोग किया जा सकता है ,; हमें केवल उन पात्रों की संख्या के साथ एक स्ट्रिंग की आवश्यकता होती है जिन्हें हम चाहते हैं, और हमें प्रत्येक संरचना में प्रत्येक सबलिस्ट के पहले तत्व को निकालने की आवश्यकता है जैसे [[0 "H"] [1 "i"]]।
  • अगर हम समस्या को हल Fया छोरों के साथ बढ़ा सकते हैं तो हमें कुछ भी बढ़ाने की आवश्यकता नहीं है ।
  • हम ak ऑपरेटर के yसाथ वैरिएबल को असाइन कर सकते हैं Y।
  • हम स्ट्रिंग्स के साथ गणित कर सकते हैं: Xस्ट्रिंग गुणन है, और PUश (या PB"पुश-बैक") एक स्ट्रिंग को दूसरी स्ट्रिंग को इन-प्लेस कर देगा। एक स्ट्रिंग की लंबाई लेने के लिए, हम इसे ENumerate कर सकते हैं और परिणामी सूची से सही संख्या निकाल सकते हैं ।
  • जब तक उन्हें सिंगल-एक्सप्रेशन लैम्ब्डा फ़ंक्शन का उपयोग करके लिखा जा सकता है, तब तक हम फ़ंक्शन का उपयोग कर सकते हैं _।

विशिष्ट तथ्य

हमारे कार्यक्रम के भवन खंड:

रेंज

_MUENsXa

ऐसा इसलिए है map-unpack(_, enumerate(repeat(space, a)))स्यूडोकोड में। मैप-अनपैक पाइथन की तरह है itertools.starmap: सूचियों की एक सूची दी गई है, यह प्रत्येक सबलिस्ट की वस्तुओं पर एक फ़ंक्शन को कॉल करता है। _अपना पहला तर्क देता है, इसलिए _MUबस प्रत्येक सबलिस्ट का पहला आइटम मिलता है। उदाहरण के लिए, यदि a = 3:

     sXa  "   "
   EN     [[0 " "] [1 " "] [2 " "]]
_MU       [0 1 2]

... जो जैसा है वैसा ही है ,a।

समावेशी सीमा

मुझे यकीन नहीं है कि inclusive-range(1, a)एक एकल अभिव्यक्ति में करने का एक तरीका है , लेकिन सौभाग्य से हमें केवल एक बार इसकी आवश्यकता है, इसलिए हम इसे yतीन चरणों में चर में बना सकते हैं।

YENsXaPBs

छद्मकोड में yank(enumerate(repeat(space, a).push-back(space))):

   sXa     "   "
      PBs  "    "
 EN        [[0 " "] [1 " "] [2 " "] [3 " "]]
Y          Store that in y

अगला POy, पहले आइटम को पॉप करता है yऔर इसे छोड़ देता है [[1 " "] [2 " "] [3 " "]]।

आखिरकार,

Y_MUy

अर्थात् yank(map-unpack(_, y)): प्रत्येक सबलिस्ट का पहला तत्व निकालें और परिणामी सूची को वापस इसमें डालें y। yअब है [1 2 3]।

लंबाई

PODQENaPBs

स्यूडोकोड में, pop(dequeue(enumerate(a.push-back(space))))। यहाँ कठिनाई यह है कि गणना करने वाला हमें केवल संख्या तक देता है len(a)-1, लेकिन हम चाहते हैं len(a)। इसलिए हम पहले एक स्थान को धक्का देते हैं a, इसे एक वर्ण से लंबा करते हैं, और फिर len-1नए स्ट्रिंग को लेते हैं।

      a     "xyz"
       PBs  "xyz "
    EN      [[0 "x"] [1 "y"] [2 "z"] [3 " "]]
  DQ        [3 " "]
PO          3

गणित

अब हमारे पास स्ट्रिंग्स की लंबाई लेने का एक तरीका है, हम स्ट्रिंग्स का उपयोग गुणा और संख्याओं को जोड़ने के लिए कर सकते हैं:

PODQENsXaXbPBs
PODQENsXaPBsXbPBs

पहला रिक्त स्थान sXaXbबनाने के लिए एक स्ट्रिंग बनाता है a*bऔर फिर उसकी लंबाई लेता है; दूसरी करता है sXaPBsXbकी एक स्ट्रिंग को पुश करने bके एक सूत्र के रिक्त स्थान aरिक्त स्थान है और फिर इसे की लंबाई लेता है।

अच्छा हिस्सा है कि सभी ऑपरेटरों हम यहाँ का उपयोग कर रहे (है PU, PO, PB, DQ, EN, X) के साथ इस्तेमाल किया जा सकता _प्रपत्र लैम्ब्डा भाव है। इसलिए हम गणितीय परिवर्तनों को उस समावेशी रेंज में मैप कर सकते हैं जिसे हमने पहले बनाया था।

हमें i%2लूप के अंदर भी जांच करने की आवश्यकता है , लेकिन यह बिटवाइज़ और: के साथ आसानी से पूरा होता है iBA1।

उन्हें एक साथ रखें

पूर्ण कोड, कुछ जोड़े गए व्हाट्सएप के साथ:

YENsXaPBs POy Y_MUy              Get \,a into y
F i _MUENsXa                     For i in ,a
 I iBA1                           If i%2=1
  P sPUPODQENsXiXaPBsX_PBs M RVy   Print sPUi*a+_ M RVy
 EI1                              Elseif 1 (using E would cause a parsing problem)
  P sPUPODQENsXiXaPBsX_PBs M y     Print sPUi*a+_ M y
— DLosc
स्रोत
क्या हमें झंडे का उपयोग करने की अनुमति है -S?
— ब्रायन मैक्च्यूटन
@BrianMcCutchon अच्छा सवाल: जवाब नहीं है । (चूंकि वे regex के अधीन कोड विषय का हिस्सा नहीं हैं, इसलिए उनका उपयोग करने के लिए बहुत ही कम-ईश लग रहा था।) स्पष्ट करने के लिए संपादित किया गया।
— DLosc
अब तक मेरे पास वह a*bहै _V_VRVENCGaRLbPU1, ,aहै _MUENZGa, aJ" "है aJ_VRVk, और a@iकुछ ऐसा है _V_VRVaZCGi, हालांकि मैं अभी तक बिना कोष्ठक के पूर्ववर्ती कार्य को पूरा नहीं कर सकता। इसके अलावा, एक अस्पष्ट विचार है कि मैं एक सीमा के क्रमपरिवर्तन प्राप्त कर सकता हूं (ऊपर जैसा बनाया गया है, बराबर का उपयोग करके ,(a*a)) और प्रत्येक पंक्ति के लिए सही क्रमचय का चयन करने के लिए उपयोग कर सकता हूं ।
— ब्रायन मैक्च्यूटन
@BrianMcCutchon मैं निश्चित रूप से किसी भी बारीकियों पर टिप्पणी नहीं कर सकता, लेकिन मैं वास्तव में प्रगति का आनंद ले रहा हूं। ^ _ ^
— DLosc
मुझे लगता है कि यह अब सुरक्षित है। आप इसे कैसे करेंगे?
— ब्रायन मैककिनटन
3

CJam, PCRE, लंबाई 8, फटा

^[a-~]*$

4 के लिए उदाहरण आउटपुट:

[[1 2 3 4] [8 7 6 5] [9 10 11 12] [16 15 14 13]]
— लिन
स्रोत
फटा। अछा सुझाव। :) उस काम के लिए बहुत सारे दृष्टिकोण प्रतीत होते हैं, मुझे आश्चर्य है कि आपके मन में क्या था।
— मार्टिन एंडर
मेरा जवाब वास्तव में एक तंग regex को संतुष्ट करता है - मैं इसे दिखाता हूँ जब कोई टूट जाता है!
— लिन
3

CJam, PCRE, लंबाई 9, फटा

^[a-z~]*$

4 के लिए उदाहरण आउटपुट:

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

अब {|}प्रतिबंधित हैं, भी।

— लिन
स्रोत
— मार्टिन एंडर
बहुत बढ़िया! मेरा जवाब मूल रूप से एक ही था, सिवाय इसके कि यह केवल एक गुच्छा का उपयोग करता था meऔर mqसंख्या को अनुमानित करता था, इसलिए यह बहुत ही (~ 20k बाइट्स) लंबा था।
— लिन
3

गणितज्ञ, रेगेक्स की लंबाई 11, गैर-प्रतिस्पर्धात्मक , फटा

पीसीआरई स्वाद:

^[^]@]{49}$

सही समाधान एक फ़ंक्शन होगा जो पूर्णांक लेता है और आउटपुट को नेस्टेड सूची के रूप में लौटाता है:

{{1, 2, 3, 4}, {8, 7, 6, 5}, {9, 10, 11, 12}, {16, 15, 14, 13}}
— मार्टिन एंडर
स्रोत
— kennytm
@kennytm ओह, यह एक साफ समाधान है। मेरे पास जो कुछ था, उससे काफी अलग। मैं देखूंगा कि क्या मैं बाद में अपना पोस्ट करता हूं या यदि मैं एक अधिक प्रतिबंधात्मक रेगेक्स जोड़ता हूं।
— मार्टिन एंडर
3

टिनिस्प , रेगेक्स लंबाई 3 ( फटा )

आप कोशिश कर सकते हैं यह ऑनलाइन पर tinylisp कोड का परीक्षण !

रेगेक्स (किसी भी स्वाद)

\S+

कट्टर होने का समय।

उत्पादन

समाधान एक फ़ंक्शन को परिभाषित करता है जो एक पूर्णांक तर्क लेता है और इस तरह एक सूची देता है (n = 4 के लिए)

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

मेरा मूल कोड उसी मूल विचार का उपयोग करता है जो ब्रायन मैककचॉन के साथ आया था, सूचियों का निर्माण और उन्हें विकसित करना। यहाँ यह एक पंक्ति में है:

(v(c(h(q(d)))(c(h(q(d')))(c(c(h(q(q)))(c(c()(c(q(arglist))(c(c(h(q(v)))(c(c(h(q(c)))(c(c(h(q(q)))(q(d)))(q(arglist))))()))())))()))()))))(d'(seq-args(c(h(q(start)))(c(h(q(stop)))(c(h(q(step)))())))))(d'(seq(c(c(h(q(accum)))seq-args)(q((i(e(v(h(q(start))))stop)(c(v(h(q(start))))accum)(seq(c(v(h(q(stop))))accum)start(s(v(h(q(stop))))step)step)))))))(d'(f'(c(c(h(q(index)))(c(h(q(size)))seq-args))(q((i(e(v(h(q(index))))size)()(c(seq()start(v(h(q(stop))))step)(f'(a(h(q(1)))index)size(a(v(h(q(stop))))size)(a(v(h(q(start))))size)(s(h(q(0)))step)))))))))(d'(f(q((size)(f'(h(q(0)))size(h(q(1)))size(h(q(1))))))))

मैंने एक बार एक मैक्रो को परिभाषित करने के लिए पूर्ण निर्माण-और-विकसित विधि का उपयोग किया, d'जो परिभाषाओं को पसंद करता है d, लेकिन इसके तर्कों को एक सूची में लपेटता है: इसलिए इसके बजाय (d x 42), आप कर सकते हैं (d'(x 42))। तब यह परिभाषाओं में किसी भी सूची को फिर से लिखने की बात थी, जिसके लिए व्हाट्सएप की आवश्यकता हो सकती है: (q(a b))-> (c a(q(b)))->> (c(h(q(a)))(q(b)))।

— DLosc
स्रोत
1
फटा । यह आसान नहीं था।
— ब्रायन मैक्च्यूटन
2

पायथन 3, लंबाई 162 (क्रैक किया गया!)

regex: ^([^"' #]){24}"(?1){11}i%n(?1){4}2\*n-(?1){4}i%n(?1){10}i\/n(\)\/\/1)(?1){5}(?2)(?1){3}2\*\(i%n\)(?1){4}[int()2\/]{16}for i in range\(j,(?1){4}\]\)(?1){6}\"\*n\)$

ठीक है, मुझे पता है, यह काफी लंबा है। सौभाग्य से, यह एक सप्ताह से कम नहीं होगा ...: 'डी।

मुझे लगता है कि मैंने कहीं भी एक गलती नहीं की, जो कि कमियां-वाई जवाब देगा।

आउटपुट स्वरूप

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

मूल कोड:n=int(input());j=0;exec("print([int(i%n+1+(2*n-(2*(i%n)+1))*((((i/n)//1+1)/2)//1)+(2*(i%n)+1)*int(int(i/n)/2))for i in range(j,j+n)]);j+=n;"*n)

— Yytsi
स्रोत
— 21:21 बजे kennytm
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.