गैर-संख्या कितनी मजबूत है?

Question

आपको हमेशा की तरह 8 के माध्यम से अंक 0 से मिलकर एक गैर-नकारात्मक (आधार 9) गैर-नकारात्मक पूर्णांक दिया जाता है। हालाँकि इस संख्या में अंकों की संख्या (अग्रणी शून्य के साथ) एक प्रीफेक्ट वर्ग है।

इस वजह से, संख्या को एक वर्ग ग्रिड में व्यवस्थित किया जा सकता है (अभी भी संरक्षित आदेश पढ़ने के साथ)।

1480 (1125 आधार 10) के साथ उदाहरण:

14
80

अब इस तरह के गैर-ग्रिड ग्रिड में प्रत्येक अंक को किसी अन्य ग्रिड स्थान ( आवधिक सीमा शर्तों के साथ ) का संकेत मिलता है :

432
501
678

यह वह कह रहा है

0 = stay still
1 = move right
2 = move right and up
3 = move up
...
8 = move right and down

इसलिए, यदि आप 1480 ग्रिड में 4 पर शुरू करते हैं, तो आप ऊपर जाते हैं (पीबीसी को याद रखें) और 8 पर छोड़ दिया, जिसका मतलब है कि आप दाईं ओर नीचे और 4 पर वापस जाते हैं, जिसमें 2 अवधि के साथ एक चक्र शुरू होता है।

सामान्य तौर पर यह प्रक्रिया तब तक जारी रहती है जब तक कि आप 0 पर नहीं पहुंच जाते हैं या एक चक्र नजर नहीं आता है। (ए 0 को अवधि 1. के साथ एक चक्र माना जाता है)

1480 के मामले में, यह अवधि 2 2 2 1क्रमशः 4 शुरुआती अंकों में से प्रत्येक पर पहुंच गई।

एक बड़ी ग्रिड के लिए ये संख्या 8 से बड़ी हो सकती है, लेकिन हम अभी भी उन्हें एक नए गैर-संख्या में "अंकों" के रूप में उपयोग कर सकते हैं (बस 9 ^ n के गुणांक जैसे कि वे अंक थे):

2*9^3 + 2*9^2 + 2*9 + 1 = 1639 (base 10) = 2221 (base 9)

हम इसे मूल गैर-संख्या की ताकत कहेंगे। तो 1480 की ताकत 1639 (बेस 10) या, समकक्ष, 2221 (बेस 9) है।

चुनौती

सबसे छोटा कार्यक्रम लिखें जो बताता है कि क्या एक गैर संख्या की ताकत, गैर से कम या उससे अधिक है, जो गैर संख्या के बराबर है। (आपको ताकत की गणना करने की आवश्यकता नहीं है।)

इनपुट एक नॉन-नेगेटिव नॉनरी नंबर होगा जिसमें एक वर्ग संख्या का अंक (और 0 के विशेष मामले के अलावा कोई अग्रणी शून्य) नहीं होगा। इसे कमांड लाइन या स्टड से आना चाहिए।

आउटपुट को stdout में जाना चाहिए:

G if the strength is larger than the original number (example: 1480 -> strength = 2221)
E if the strength is equal to the original number (example: 1 -> strength = 1)
L if the strength is less than the original number (example: 5 -> strength = 1)

फन बोनस चैलेंज:
व्हाट्सएप सबसे ज्यादा इनपुट जो आप पा सकते हैं, जो इसकी ताकत के बराबर है? (क्या कोई सीमा है?)

Comments

इनपुट के लिए, क्या इसे दशमलव संख्या के रूप में दिया गया है, जिसके अंक गैर-संख्या के समान हैं या गैर-संख्या के दशमलव (या बाइनरी) प्रतिनिधित्व के रूप में हैं? यानी: 1480 (गैर) के लिए इनपुट 1480 या 1125 होगा?

— overactor

@overactor गैर-प्रारूप में।

मैं काफी विश्वास है कि कोई एक उच्च इनपुट है कि तुलना में 10 ^ 71-1 (गैर) अपनी ताकत के बराबर होती है यह है कि, एक 64 अंकों की संख्या कि केवल 8 के होते हैं मिलेगा हूँ

— overactor

मुझे लगता है कि यह 8 से अधिक की अवधि के चक्र के साथ संभव हो सकता है।

— मार्टिन एंडर

@ मार्टिनबटनर मैं अच्छी तरह से प्रभावित होऊंगा यदि आप उनमें से किसी को भी ढूंढते हैं।

— ओवरएक्टर 17

Answer 1

अजगर 2, 213 209 202

संपादित करें: शॉर्टक्रिटिंग को हटा दिया गया, जो कभी-कभी गलत होता है। निचे देखो।

(बड़े पैमाने पर) @ के रूप में एक ही एल्गोरिथ्म, लेकिन बहुत भारी गोल्फ।

n=`input()`
s=int(len(n)**.5)
c=0
for i in range(s*s):
 a=[]
 while(i in a)<1:a+=[i];x='432501678'.find(n[i]);i=(i+x%3-1)%s+((i/s+x/3-1)%s)*s
 c=c*9+len(a)-a.index(i)
d=long(n,9)
print'EGL'[(c>d)-(c<d)]

golfs:

• 213: लघु-परिच्छेद, त्रुटिपूर्ण समाधान।

• 209: पहला काम समाधान।

• 202: दो स्ट्रिंग लुकअप को एक में संयोजित करें।

संपादित करें: मुझे सिर्फ यह महसूस हुआ कि यह कार्यक्रम, और इस प्रकार केसाब की भी खामियां थीं, जिसमें वे बहु-चक्र की लंबाई को नजरअंदाज करते हैं। उदाहरण विफलता:

3117
2755
3117
7455

जबकि 3 में एक चक्र की लंबाई 2 है, और इस प्रकार उपरोक्त एल्गोरिथ्म शॉर्ट सर्किट 'एल' के लिए है, यह वास्तव में 'जी' पर लौटना चाहिए, क्योंकि दूसरे अंक पर 14 की चक्र लंबाई अधिक होने से अधिक है। इसलिए मैंने कार्यक्रम को बदल दिया है। यह भी छोटा, मजेदार रूप से पर्याप्त हो गया। अपने कार्यक्रम का परीक्षण करने के लिए, का उपयोग करें 3117275531177455। इसे वापस लौटना चाहिए G।

Comments

वाह मुझे लगा कि मैंने इसे थोड़ा सा नीचे कर दिया है, लेकिन आपने वहां कुछ बहुत ही चतुर चीजें कीं।

— केएसएबी

@ शक धन्यवाद - आपका एल्गोरिथ्म शुरू करने के लिए बहुत ही चतुर था - मुझे ऐसा करने का कोई बेहतर तरीका नहीं मिला।

— isaacg

Answer 2

पायथन 296

वास्तव में बहुत अक्षम नहीं है, यह केवल उतने ही अंकों की जाँच करता है, जितने की आवश्यकता होती है।

n=raw_input();s=int(len(n)**.5);t=0
for i in range(s**2):
    l=[]
    while i not in l:l.append(i);c=n[i];i=(i%s+(-1 if c in'456'else 1 if c in'218'else 0))%s+((i/s+(-1 if c in'432'else 1 if c in'678'else 0))%s)*s
    t=t*9+len(l)-l.index(i)
print'EGL'[cmp(t,long(n,9))]

उनकी ताकत के बराबर संख्या के लिए, मुझे लगता है कि एकमात्र समाधान हैं, प्रत्येक N x N वर्ग के लिए N = 8 प्रत्येक वर्ग में N युक्त एक वर्ग। मेरी सोच यह है कि चूंकि लूप में प्रत्येक संख्या समान संख्या (लूप की लंबाई) होनी चाहिए, इसलिए प्रत्येक लूप को एक ही दिशा में होना चाहिए। यह निश्चित रूप से इसका मतलब है कि लूप का आकार एन (और प्रत्येक तत्व एन होना चाहिए) होना चाहिए। मुझे पूरा यकीन है कि यह तर्क किसी भी आकार के वर्गों और छोरों पर लागू किया जा सकता है, जिसका अर्थ है कि पहले 8 के अलावा उनकी ताकत के बराबर कोई वर्ग नहीं हैं।

Comments

हालांकि संभावना नहीं है, यह 8 से बड़ा छोरों के लिए संभव हो सकता है

— ओवरएक्टर

मुझे लगता है कि यह गलत परिणाम देता है 3117275531177455, क्योंकि लूप का आकार 8. से अधिक है। मेरी पोस्ट देखें।

— isaacg

@isaacg ओह, मैंने यह नहीं देखा, मैंने इसे काम करने के लिए बदल दिया है, लेकिन मैं इसे आगे बढ़ाने की कोशिश नहीं कर रहा हूं क्योंकि यह बहुत ही आपके उत्तर को कॉपी-पेस्ट करने वाला होगा। ओह और मुझे लगता है कि आप उपयोग करके अपनी पिछली दो पंक्तियों को सुधार सकते हैं cmp।

— केएसएबी

Answer 3

CJam - 81

q:X,:L,{[L2*{_[_Lmqi:Smd@X=432501678s#3md]2/z{~+(S+S%}%Sb}*]L>_&,\X=~-}%9bg"EGL"=

इसे http://cjam.aditsu.net/ पर आज़माएं

यह शायद कुछ और गोल्फ हो सकता है।

Answer 4

लुआ - अभी तक गोल्फ नहीं हुआ

बस यहाँ सुरक्षित रखने के लिए डाल दिया। मैं इसे गोल्फ करूँगा ("बड़े ग्रिड के लिए लागू करूँगा ये संख्या 8 से अधिक हो सकती है, लेकिन हम बाद में भी इन्हें" अंक "" के रूप में उपयोग कर सकते हैं)। हालांकि काम करता है।

d={{1,0},{1,-1},{0,-1},{-1,-1},{-1,0},{-1,1},{0,1},{1,1}}
d[0]={0,0}ssd=''
n=arg[1]
q=math.sqrt(#n)t={}

    for y=1,q do
    table.insert(t,y,{})
    for x =1,q do
        v=(y-1)*q+x
        table.insert(t[y],x,n:sub(v,v)+0)
        io.write(t[y][x])
    end
end
for y=1,q do
    for x=1,q do
        cx=x cy=y pxy=''sd=0
        while pxy:match(cx..':%d*:'..cy..' ')==nil do
            pxy=pxy..cx..':'..sd..':'..cy.." "
            ccx=cx+d[t[cx][cy]][2]
            ccy=cy+d[t[cx][cy]][1]
            cx=ccx cy=ccy
            if cx<1 then cx=q elseif cx>q then cx=1 end
            if cy<1 then cy=q elseif cy>q then cy=1 end
            sd=sd+1
        end
        dds=(pxy:sub(pxy:find(cx..':%d+:'..cy)):match(':%d*'))
        ssd=ssd..(sd-dds:sub(2))
    end
end
print(ssd)
nn=tonumber(n,9) tn=tonumber(ssd,9)
if tn>nn then print("G") elseif tn==nn then print("E") else print("L") end