अमिदाकुजी (阿 弥陀 ak) सरलीकरण

Question

यदि आपके पास कभी भी जापानी या पूर्वी एशियाई संस्कृति के लिए कोई जोखिम था, तो आप निश्चित रूप से अमिदाकुजी खेल का सामना करेंगे:

जैसा कि विकिपीडिया बताते हैं , यह एक प्रकार की लॉटरी है जिसे कागज पर खींचा जाता है और इसका उपयोग बेतरतीब ढंग से एन वस्तुओं के क्रमांकन का चयन करने के लिए किया जाता है।

उदाहरण के लिए, इसका उपयोग बेतरतीब ढंग से एन लोगों को शुरुआती अनुक्रम सौंपने के लिए किया जा सकता है, या एन लोगों को एन पुरस्कार, और इसी तरह।

यह समझने की चाल कि खेल एक क्रमचय का प्रतिनिधित्व क्यों करता है, यह महसूस करने के लिए कि प्रत्येक क्षैतिज स्ट्रोक (जिसे "पैर" कहा जाता है) अपनी दो वस्तुओं को जगह पर स्वैप कर देता है।

वही विकिपीडिया पृष्ठ यह भी बताता है कि N वस्तुओं के प्रत्येक क्रमपरिवर्तन P, अमिदाकुजी आरेखों की अनंत संख्या से मेल खाते हैं। क्षैतिज स्ट्रोक (पैरों) की कम से कम संख्या वाले एक को उस विशेष क्रमपरिवर्तन पी के "प्राइम्स" कहा जाता है।

आपका कार्य इस प्रारूप में 2 या अधिक ऊर्ध्वाधर लाइनों (इस उदाहरण में वे 6 हैं) के साथ एक Amidakuji आरेख प्राप्त करना है:

A B C D E F
| | | | | |
|-| |-| |-|
| |-| |-| |
| | | | |-|
| |-| |-| |
| | |-| |-|
| | |-| | |
|-| | |-| |
|-| |-| | |
| |-| | |-|
| | | | | |
B C A D F E

और इसके एक प्राइम का निर्माण करें (फिर से, अक्षरों को घटाएं):

A B C D E F
| | | | | |
|-| | | |-|
| |-| | | |
| | | | | |
B C A D F E

अक्षरों के साथ पहली और आखिरी लाइनें प्रारूप का हिस्सा नहीं हैं । मैंने उन्हें क्रमोन्नति दिखाने के लिए यहाँ जोड़ा है। यह भी आवश्यक नहीं है कि पहली या अंतिम पंक्तियों में कोई पैर न हो |-|, न ही यह कि आउटपुट जितना संभव हो उतना कॉम्पैक्ट हो।

यह विशेष इनपुट उदाहरण विकिपीडिया पृष्ठ के शीर्ष पर Amidakuji आरेख के (अनंत) ASCII अभ्यावेदन में से एक है।

इन ASCII आरेखों के बारे में एक गैर-स्पष्ट नियम है: आसन्न पैर निषिद्ध हैं।

|-|-|  <-  NO, this does not represent a single swap!

विकिपीडिया एक आरेख से प्राइम प्राप्त करने के लिए एक मानक प्रक्रिया की व्याख्या करता है, जिसे "बब्बलाइजेशन" कहा जाता है, जिसमें निम्नलिखित सरलीकरणों को लागू करना शामिल है:

1) दाएं कांटे को बाएं कांटा:

| |-|      |-| |
|-| |  ->  | |-|
| |-|      |-| |

2) डबल्स को खत्म करना:

|-|        | |
|-|   ->   | |

मुझे यकीन नहीं है कि यह स्पष्टीकरण स्पष्ट नहीं है। आपका कोड उस तकनीक या किसी अन्य एल्गोरिथ्म का उपयोग कर सकता है जो आवश्यक primes उत्पन्न करता है।

सबसे छोटा कोड जीतता है।

मानक नियम और मानक भत्ते लागू होते हैं। (यदि इनपुट मान्य नहीं है, तो आपका प्रोग्राम आग पकड़ सकता है। इनपुट / आउटपुट प्रारूप स्टड / स्टडआउट, स्ट्रिंग तर्क, लाइनों की सूची, वर्णों की मैट्रिक्स, जो भी आपके लिए सबसे अच्छा काम करता है, आदि हो सकते हैं)

Comments

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

— जोशियान्वेन

क्या आउटपुट को यथासंभव कॉम्पैक्ट होने की आवश्यकता है या जब तक पैरों की संख्या कम से कम हो, ऊर्ध्वाधर स्थान की कितनी मात्रा की अनुमति है?

— लैकोनी

@ लैकोनी किसी भी ऊर्ध्वाधर स्थान की अनुमति है।

— टोबिया

क्या बुब्ब्लाइज़ेशन और उलटा बुब्ब्लाइज़ेशन हर परिणाम अमिदाकुजी तक पहुंचता है?

— l4m2

@ l4m2 प्रतिलोम बब्लीकरण क्या है?

— टोबिया

Answer 1

पायथन 2 , 322 240 बाइट्स

def f(X):
 X=[[c>' 'for c in s.split('|')]for s in X.split('\n')];h=L=len(X[0])-1;p=range(L)
 for x in X:p=[a-x[a]+x[a+1]for a in p]
 while h:h=i=0;exec"if p[i]>p[i+1]:print'|'+i*' |'+'-|'+(L-i-2)*' |';h=p[i],p[i+1]=p[i+1],p[i]\ni+=1\n"*~-L

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

एक फ़ंक्शन जो स्ट्रिंग को निर्दिष्ट रूप में लेता है, और कम अमिदाकुजी को उस रूप में भी प्रिंट करता है।

यहां मूल विचार इनपुट को पहले क्रमपरिवर्तन ( for x in Xलूप में) में बदलना है ; और फिर whileलूप में, उस क्रमचय का एक बुलबुला प्रकार प्रदर्शन करते हैं, क्योंकि विकिपीडिया लेख नोट्स के रूप में, यह एक 'प्राइम' अमिदाकुजी में परिणाम करता है।

Comments

वाह। मैंने सिर्फ एक लंबा समय पायथन 3 संस्करण बनाने में बिताया, लेकिन यह 526 बाइट्स है, हेह।

— जोशियाहैन

मैंने आपके कोड में सैकड़ों यादृच्छिक चित्र दिए हैं और मैं पुष्टि कर सकता हूं कि यह सही primes आउटपुट करता है!

— तोबिया

Answer 2

हास्केल , 288 बाइट्स

p x(_:[])=x
p(x:y:z)(_:b:c)|b=='-'=y:p(x:z)c|0<1=x:p(y:z)c
c 0='-'
c _=' '
_#1="|"
m#n='|':c m:(m-1)#(n-1)
p?q=(p:fst q,snd q)
f%b|b==f b=b|0<1=f%f b
f l=reverse$snd$(g 0)%(foldl p[1..n]l,[])where n=1+div(length$l!!0)2;g b((x:y:z),a)|x>y=y?g(b+1)(x:z,a++[b#n])|0<1=x?g(b+1)(y:z,a);g _ x=x

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

व्याख्या

-- the function p performs the permutation of a list
-- according to a single line from amidakuji board
p x (_:[]) = x
p (x:y:z) (_:b:c)
    | b == '-' = y : p (x : z) c
    | otherwise = x : p (y : z) c

-- helper to select either leg '-' or empty cell
c 0 = '-'
c _ = ' '

-- the # operator generates an amidakuji line containing one leg
-- which corresponds to one swap during bubble sort

-- terminal case, just one edge left
_ # 1 = "|"
-- each cell contains an edge '|' and either space or a '-' for the "active" cell
m # n = '|' : c m : (m - 1) # (n - 1)

-- helper to find the limit value of a function iteration
f % b
    | b == f b = b  -- return the value if it is unchanged by the function application 
    | otherwise = f % f b -- otherwise repeat

-- helper to appropriately combine q which is the result of invocation of 
-- the function g (see below), and a character p
p ? q = (p : fst q, snd q)

-- the function that does the work
f l = reverse $ snd $ (g 0) % (foldl p [1..n] l, []) where
    -- number of lines on the board
    n = 1 + div (length $ l !! 0) 2
    -- apply one iteration of bubble sort yielding (X, Y)
    -- where X is partially sorted list and Y is the output amidakuji
    g b ((x:y:z), a)
        -- if we need to swap two elements, do it and add a line to our board
        | x > y = y ? g (b + 1) (x:z, a ++ [b # n])
        -- if we don't need to, just proceed further
        | otherwise = x ? g (b + 1) (y:z, a)
    -- terminal case when there is only one element in the list
    g _ x = x

Comments

बहुत बढ़िया! मैंने आपके कोड के लिए अधिकतम यादृच्छिक आरेख दिए हैं और इसने उन सभी को हल किया है।

— टोबिया

(_:[])बस हो सकता है [_]और p?q=(p:fst q,snd q)हो सकता है p?(f,s)=(p:f,s)। परिभाषित करने c 0='-';c _=' ';और फिर उपयोग करने के बजाय c m, " -"!!(0^abs m)काम करना चाहिए।

— लकोनी

(g 0)कोष्ठक की आवश्यकता नहीं है और letएक गार्ड की तुलना में कम है where। सभी एक साथ 274 बाइट्स: इसे ऑनलाइन आज़माएं!

— लकोनी

आपके फ़िक्सपॉइंट फ़ंक्शन %को इनलाइन किया जा सकता है until(\x->g 0 x==x)(g 0)।

— लकोनी

Answer 3

रेटिना 0.8.2 , 105 बाइट्स

$
¶$%`
r`.?.\G
 1$.'$*
+r-1=`\|(-?.?[- 1]*¶.*)(1+)
$2$1
-
 
1G`
;{`\b(1+) \1
$1-$1
*`1+
|
(1+)-(1+)
$2 $1

इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

$
¶$%`

अंतिम पंक्ति को दोहराएं।

r`.?.\G
 1$.'$*

अंतिम पंक्ति में कॉलम की संख्या।

+r-1=`\|(-?.?[- 1]*¶.*)(1+)
$2$1

जब तक वे पहली पंक्ति में नहीं आते, तब तक संख्या को स्थानांतरित करें। प्रत्येक पुनरावृत्ति पर, केवल सबसे दाईं ओर -1=ले जाया जाता है। इसे |तब तक सबसे दाईं ओर ले जाया जाता है जब तक कि यह उस स्थिति से पहले न हो, जब इसे पिछले हिस्से -में ले जाया जाता है |। ( rइंगित करता है कि रेगेक्स को संसाधित किया जाता है जैसे कि यह एक खोज थी, जो इस मामले से मेल खाने के लिए थोड़ा आसान बनाता है।) यह उस क्रमांकन की गणना करता है जो अमिदाकुजी क्रमबद्ध क्रम में बदल जाता है।

-
 
1G`

केवल संख्याओं की सूची रखें, -पहली पंक्ति के बाद एस और कुछ भी हटाना ।

;{`

फिर कार्यक्रम के बाकी हिस्सों को फिर से क्रम में सूची में क्रमबद्ध किया जाता है, लेकिन अंतिम सूची मुद्रित नहीं की जाती है, हालांकि यह रेटिना 0.8.2 के लिए एक पुनरावृत्ति लेता है यह देखने के लिए कि सूची क्रम में है, बिना पैरों वाली एक पंक्ति है अंत में, जो मुझे लगता है कि स्वीकार्य है।

\b(1+) \1
$1-$1

-पैरों के लिए एस के साथ आसन्न अनसुलझी संख्या के सभी उपलब्ध जोड़े को चिह्नित करें ।

*`1+
|

पैरों को प्रिंट करें लेकिन एस के साथ प्रतिस्थापित संख्याओं के साथ |।

(1+)-(1+)
$2 $1

दरअसल स्वैप करते हैं।

Comments

क्या आपके पास Retina.exe के साथ अपने कोड को चलाने के बारे में कोई सलाह है ? मुझे लगता है कि मेरे पास सही स्रोत (105 बाइट्स) हैं, लेकिन यह कुछ भी नहीं करता है। मैंने रेटिना के उदाहरणों से हैलो वर्ल्ड की कोशिश की और यह काम करता है। क्या आप स्रोत को कहीं अपलोड कर सकते हैं, या Base64 ने इसे एनकोड किया है और इसे एक पास्टबिन में रखा है, अगर मुझे एन्कोडिंग गलत लगी है?

— टोबिया

@Tobia क्षमा करें, लेकिन मुझे याद नहीं है कि Retina.exe का उपयोग कैसे किया जाए; मुझे लगता है कि मैंने इसे एक या दो बार इस्तेमाल किया होगा, लेकिन इन दिनों मैं सिर्फ ट्राई ऑनलाइन का उपयोग करता हूं।

— नील

LOL मैं गूंगा हूँ! मैं 0.8.2 के बजाय कुछ अत्याधुनिक संस्करण का उपयोग कर रहा था। अब मुझे अपने कोड के सैकड़ों यादृच्छिक आरेखों को खिलाया जाने के लिए मेरी हार्नेस मिली और मैं पुष्टि कर सकता हूं कि यह हमेशा सही अपराधों का उत्पादन करता है। बहुत बढ़िया!

— टोबिया

@Tobia परीक्षण के लिए धन्यवाद! रेटिना 1 के लिए आवश्यक मोड़: $*→ *; -1=→ 0; 1→ _; ;→ .(लगभग); *→ *\।

— नील

Answer 4

पायथन 3 , 524 488 486 बाइट्स

-38 बाइट्स ओव्स के लिए धन्यवाद!

from numpy import*
A=array;E=array_equal
K=[0]
def r(a,m,n):
	X=len(m);Y=len(m[0]);W,H=a.shape
	for x in range(W-X+1):
		for y in range(H-Y+1):
			if E(a[x:x+X,y:y+Y],A(m)):a[x:x+X,y:y+Y]=A(n)
	return a
def p(a):
	b=A([[j>" "for j in i]for i in[i.split("|")for i in a.split("\n")]])
	while E(a,b)<1:a=b;Z=K*3;O=[0,1,0];T=[K+O,O+K]*2;D=[O,O],[Z,Z];P=[Z,O],[O,Z];*R,_=T;_,*L=T;b=r(r(r(r(r(r(a[any(a,1)],R,L),*D),*P),L,R),*D),*P)
	for i in a:print("",*[" -"[j]for j in i[1:-1]],"",sep="|")

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

यह Amidakuji को 2D बाइनरी सरणी में परिवर्तित करता है, और नियमों का उपयोग करके इसे सीधे कम कर देता है।

Comments

मैं आपके दृष्टिकोण के बारे में उत्सुक हूं; मैं एक नजर मार लूगां! इस बीच, आप कुछ बाइट्स के " "+i.replace("|","")+" "साथ बदलकर बचा सकते हैं i.split("|")। आपके pकार्य की पहली पंक्ति ...

— चास ब्राउन

कुछ और मानक पायथन गोल्फिंग इसे 479 बाइट्स के लिए लाती है ।

— चेस ब्राउन

ऐसा लगता है कि मेरा एल्गोरिथ्म सबऑप्टिमल है ...

— JosiahRyanW

याह, निश्चित नहीं कि ऐसा क्यों हो रहा है ...

— चास ब्राउन

हमेशा नहीं ... कभी-कभी दाएं से कांटा बाएं से दाएं तक का नहीं होता है, लेकिन बाएं से दाएं का कांटा होता है। उस विशिष्ट मामले में, यह वहाँ विपरीत करने की बात है। शायद मुझे दोनों करने की ज़रूरत है?

— जोशाइरनॉ

Answer 5

स्टैक्स , 45 बाइट्स

⌐φ²MC½↕uö∩┴║%≤Oo╧i╕ïô§ê{δ¿k>┴ê◘►╢lµ∙→Z↔8╨─(·£

इसे चलाएं और डीबग करें