विलक्षण रूप से हानिपूर्ण पूर्णांक: एक एकल तत्व को समाप्‍त करने वाले अनुक्रम

Question

मैं अनुक्रम के संयोजन की विधि को परिभाषित करता हूं, जिसका अर्थ है कि अनुक्रम में प्रत्येक संख्या को स्ट्रिंग के रूप में संक्षिप्त किया जाता है, फिर उस परिणाम को पूर्णांक बनाया जाता है।

[1, 2, 3] -> 123

कम से कम 3 लगातार पूर्णांक के प्रत्येक परिमित अनुक्रम के लिए, अनुक्रम में ठीक एक तत्व गायब है, और यह लापता तत्व अनुक्रम में पहला या अंतिम तत्व नहीं हो सकता है, पूर्णांक को संयुक्त अनुक्रम से उत्पन्न आउटपुट करता है। मैं इसे "एकांत रूप से दोषपूर्ण पूर्णांक" के रूप में संदर्भित कर रहा हूं।

[1, 2, 3] -> {1, 3} (missing an element) -> 13

विलक्षण रूप से घटिया पूर्णांक का यह क्रम निम्नलिखित क्रमों (विभाजनों?) का मिलन है:

पहले परिणाम को {n, n+2}है A032607 ।

{n, n+2}            -> 13, 24, 35, 46, 57, 68, 79, 810, 911, 1012, ...
{n, n+1, n+3}       -> 124, 235, 346, ...
{n, n+2, n+3}       -> 134, 245, 356, ...
{n, n+1, n+2, n+4}  -> 1235, 2346, 3457, ...
{n, n+1, n+3, n+4}  -> 1245, 2356, 3467, ...
{n, n+2, n+3, n+4}  -> 1345, 2456, 3567, ...
... 
for n ∈ ℕ (integers >= 1)

इन पूर्णांकों को आरोही क्रम में मुद्रित किया जाना चाहिए। पहले 25 एकल हानिपूर्ण पूर्णांक निम्न हैं :

13, 24, 35, 46, 57, 68, 79, 124, 134, 235, 245, 346, 356, 457, 467, 568, 578, 679, 689, 810, 911, 1012, 1113, 1214, 1235, ...

पहले 7597 सिंगली लस्सी इंटेगर

अनपेक्षित संदर्भ कार्यान्वयन। मैंने इसे छोटा होने के बजाय और तेज बना दिया।

• Ideone
• TIO (सबसे तेज़, उच्च सीमा)

नियम:

• सबसे छोटा कोड जीतता है
• आप या तो कह सकते हैं (जो एक):
  • हमेशा के लिए एकल हानिपूर्ण पूर्णांक प्रिंट करें
  • एक सकारात्मक पूर्णांक n को देखते हुए , पहले n तत्वों को एक सूची, या अल्पविराम या व्हाट्सएप- सीमांकित स्ट्रिंग के रूप में प्रिंट या वापस करें ।
• यदि आपकी भाषा इसे अनुमति देती है, तो आपको मनमाने ढंग से बड़े पूर्णांक का समर्थन करना चाहिए, खासकर यदि आप हमेशा के लिए प्रिंट कर रहे हों।

से प्रेरित / संबंधित

नोट: इस अनुक्रम के लिए OEIS में अभी तक कोई प्रविष्टि नहीं है।

एक और नोट: मैंने उन्हें "सिंगली लॉसी इंटेगर्स" नाम दिया ताकि बदले में "डाउली लॉसी इंटीगर्स", "एन-लाइ लॉससी इंटीगर्स", "(एन + 1) -ली लॉसली इंटीजर्स", और "लॉसी इंटीजर्स" हो सकें। ”(इन सभी का मिलन)।

Comments

मैंने पहले ~ 7600 तत्वों की एक सूची जोड़ी, साथ ही एक संदर्भ कार्यान्वयन मैंने अभी-अभी पायथन में पूरा किया।

— mbomb007

यह एक मजेदार fastest-codeचुनौती होगी।

— माइकल क्लिन

यह होगा कि क्या यह एक चुनौती को फिर से स्वीकार करने के लिए स्वीकार्य है लेकिन एक अलग जीत मानदंड के साथ? यदि हां, तो मैं वैसे भी एक सप्ताह या उससे अधिक समय तक प्रतीक्षा करूंगा।

— mbomb007

जहां तक ​​मुझे पता है, यह ठीक होना चाहिए। एक मॉड पूछने के लिए चैट में पॉप करना चाहते हैं, बस मामले में / सुझावों के लिए।

— माइकल क्लिन

Answer 1

गणितज्ञ, 101 बाइट्स

Sort@Flatten@Table[FromDigits[""<>ToString/@(z~Range~x~Delete~y)],{x,3,#},{z,1,x-1},{y,2,x-z}][[1;;#]]&

वाह! एक बार के लिए मेरे पास सबसे छोटा जवाब है!Party[Hard]

Comments

क्या यह एक वास्तविक गणितज्ञ बिल्ट-इन है? मुझे आश्चर्य नहीं होगा। : D

— mbomb007

नहीं, लेकिन इसे ठीक किया जा सकता है Party[_]:=While[True,Print["PARTY!!!"]]। तर्क को नजरअंदाज कर दिया जाता है क्योंकि सभी पार्टीबाजी कर रहे हैं।

— कैलकुलेटर

@CatsAreFluffy मैं असहमत हूं। Party[Where]प्रिंट करना चाहिए Here!, और Party[When]प्रिंट करना चाहिए Now!, आदि पार्टी करने के बारे में हल्के में मत सोचो।

— 15:24 बजे

Party[x_]:=Switch[x,Where,"Here!",When,"Now!",How,Pause[1];"...Really?",_,While [True,Print["PARTY!!!"]]]

— कैलकुलेटर

Answer 2

हास्केल, 131 , 114 , 106 बाइट्स

iterate(\n->minimum[x|x<-[read(show=<<filter(/=k)[i..j])::Int|i<-[1..n],j<-[i+2..n],k<-[i+1..j-1]],x>n])13

इस के आकार के द्वारा सीमित है Int, लेकिन यह आसानी से बदल कर बढ़ाया जा सकता है Intके साथInteger ।

कम गोल्फ वाला:

concatInt x = read (concatMap show x) ::Int
allUpToN n = [concatInt $ filter (/=k) [i..j] | i <- [1..n], j <- [i+2..n], k <- [i+1..j-1]]
f n = minimum[x | x <- allUpToN, x > n ]
iterate f 13

8 बाइट्स गोल्फ @nimi द्वारा।

Comments

क्या यह अनंत है, या यह लेता है n?

— mbomb007

@ mbomb007 इसके साथ Integer, यह तब तक जारी रहेगा जब तक आप मेमोरी (या धैर्य) से बाहर नहीं निकल जाते। यह जारी रहेगा Int, लेकिन जब यह ओवरफ्लो ( > 2^29-1) होगा तो गलत उत्तर देना शुरू कर देगा ।

— माइकल क्लेन

क्या आप एक दुभाषिया से जुड़ सकते हैं जहां मैं इसे चला सकता हूं? मैंने इसे TryHaskell.org में चिपकाया और यह काम नहीं किया।

— mbomb007

@ mbomb007 बेस्ट मैं अब तक मिल गया है है इस हालांकि यह की जरूरत है, main=print$कि GHCi नहीं करता है। GHC.io मेमोरी से बाहर है और TryHaskell.org की सुविधा सेट बहुत सीमित है।

— माइकल क्लेन

वाह, यह समय से पहले बहुत दूर नहीं मिलता है। : D

— mbomb007

Answer 3

पायथन 3, 136 127 126 122 बाइट्स

जानवर बल समाधान, मैं भी n = 7000 की कोशिश नहीं करता (यह पहले से ही n = 100 के लिए 10s लेता है)

r=range
f=lambda n:sorted(int(''.join(str(i+k)for i in r(1,j)if l-i))for k in r(n)for j in r(4,n)for l in r(2,j-1))[:n]

व्याख्या

# f=lambda n:sorted( int(''.join(str(i+k) for i in r(1,j)   if l-i)) for k in r(n) for j in r(4,n) for l in r(2,j-1))[:n]
#            ──┬──                        ───────┬───────    ───┬──  ──────┬──────  ──────┬──────  ────────┬──────── ─┬─
#              │                                 │              │          │              │                │          └── selection of the n first numbers
#              │                                 │              │          │              │                └── loop to remove missing element
#              │                                 │              │          │              └── loop for the dimension of the list n to be sure we miss nothing xD
#              │                                 │              │          └── loop on the n in op description 
#              │                                 │              └── Test to remove missing element
#              │                                 └── loop on {n, n+1 ...} in the op description
#              └──── sort the list

परिणाम

>>> f(25)
[13, 24, 35, 46, 57, 68, 79, 124, 134, 235, 245, 346, 356, 457, 467, 568, 578, 679, 689, 810, 911, 1012, 1113, 1214, 1235]

>>> f(100)
[13, 24, 35, 46, 57, 68, 79, 124, 134, 235, 245, 346, 356, 457, 467, 568, 578, 679, 689, 810, 911, 1012, 1113, 1214, 1235, 1245, 1315, 1345, 1416, 1517, 1618, 1719, 1820, 1921, 2022, 2123, 2224, 2325, 2346, 2356, 2426, 2456, 2527, 2628, 2729, 2830, 2931, 3032, 3133, 3234, 3335, 3436, 3457, 3467, 3537, 3567, 3638, 3739, 3840, 3941, 4042, 4143, 4244, 4345, 4446, 4547, 4568, 4578, 4648, 4678, 4749, 4850, 4951, 5052, 5153, 5254, 5355, 5456, 5557, 5658, 5679, 5689, 5759, 5789, 5860, 5961, 6062, 6163, 6264, 6365, 6466, 6567, 6668, 6769, 6870, 6971, 7072, 7173, 7274, 7375]

उनकी मदद के लिए @ mbomb007 और @FricativeMelon को धन्यवाद

Comments

आपको )निम्न और निम्न वर्ण के बीच स्थान की आवश्यकता नहीं है , और आप t=rangeप्रोग्राम की शुरुआत में जोड़ सकते हैं और rangeकॉल के साथ सभी फ़ंक्शन कॉल को बदल सकते tहैं। कि बाइट गिनती को कम करना चाहिए।

— फ्रिकेटिव मेलन

@FricativeMelon सही, मैं बेकार जगह निकाल दूंगा

— Erwan

i!=l+kके साथ भी प्रतिस्थापित किया जा सकता है l+k-i, जो बाइट बचाता है।

— सन 1947

@FricativeMelon मैं एक छोटा सा वर्णन :) जोड़ा

— एर्वान

str(i)for i in r(1+k,j+k)if l+k-istr(i+k)for i in r(1,j)if l-i4 बाइट की बचत के साथ प्रतिस्थापित किया जा सकता है ।

— mbomb007

Answer 4

पायथन 3, 319 , 270 , 251 बाइट्स

t,h,n,k,q*=range,input(),1,2,
while h>len(q)or n*k<=len(str(q[h])):
 q+=[int("".join([str(c+s)for c in t(k+1)if c-y]))for s in t(10**~-n,10**n)for y in t(1,k)]
 if~-n:n*=k;k+=1
 else:n,k=k+1,2
 while n//k*k-n:k+=1
 n//=k;q.sort()
print(q[:h])

hएसटीडीआईएन से इनपुट के रूप में लिया जाता है और पहले hएकल-दोषपूर्ण पूर्णांकों की एक सरणी प्रिंट करता है । यह बहुत तेज़ है, इसके लिए केवल कुछ सेकंड का समय लगता है h=7000।

स्पष्टीकरण: ध्यान दें, यदि हमारे पास अनंत समय था, तो हम बस सभी पर n,kऔर प्रत्येक जोड़ी के लिए n+1,n+2,...,n+k-1( k-1संभावनाओं) ड्रॉप कर सकते हैं , और उन सभी (असीम रूप से कई) मूल्यों को प्राप्त कर सकते हैं, तो बस आरोही क्रम में क्रम को क्रमबद्ध करें और काटें hतत्वों। बेशक, हम वास्तव में ऐसा नहीं कर सकते हैं, लेकिन अगर हम किसी ऐसे बिंदु पर पहुंच सकते हैं, जहां पहले छंटे हुए hतत्व अब किसी भी भविष्य के n,kजोड़े के मूल्यों को जोड़कर नहीं बदल सकते हैं, तो हम केवल समय में और फिर से किया जा सकता है। किसी भी n,kजोड़ी के लिए, इसमें कम से कम floor(log10(n)+1)*kअंक होते हैं, संभवतः अधिक। तो इन जोड़ियों को मान द्वारा समूह बनाते हैं c(n,k)=floor(log10(n)+1)*k, जहाँ हम गारंटी देते हैं कि यदि c(a,b)<c(n,k), हम संसाधित करते हैंa,b पहलेn,k । यदि हमारे पास सूची है, और उसका अंतिम तत्व हैdअंक, औरd<c(n,k) अगले के लिएn,kहम प्रक्रिया करने जा रहे हैं, हम रोक सकते हैं, क्योंकि हम अब उस संख्या को कई या कम अंकों के साथ नहीं प्राप्त कर सकते हैं, क्योंकि हमारी गारंटी से हमें पहले ही इसे संसाधित करना चाहिए था, और इसलिए कोई बात नहीं कि हम कौन सी संख्याओं की गणना करेंगे, पहले hतत्व नहीं बदल सकते हैं, इसलिए हम उन्हें वापस कर सकते हैं।

तो अब हमें केवल उस फ़ंक्शन की आवश्यकता है जो उस पर दिए गए आदेश की गारंटी देता है c(n,k)। प्रत्येक yप्राप्य के लिए c(n,k), हमें (n,k)ऐसी सभी प्रक्रिया करनी चाहिए y=c(n,k)। चलो L=floor(log10(n)+1)कुछ के लिए कहते हैं n। इसलिए y=L*kधारण करना चाहिए। इसके साथ शुरू करें k=2,L=y/2, फिर k=3,L=y/3;k=4,L=y/4...k=y,L=1, गैर-पूर्णांक मानों को छोड़ दें L। पूरे उत्पन्न करने के लिए c(n,k)समारोह, के साथ शुरू (1,2)के साथ y=2, और वृद्धि y1 से और फिर से शुरू जब भी आप प्राप्त L==1। अब हमारे पास जोड़े की गणना है (L,k), और यह हमारी स्थिति को संतुष्ट करता है। हालांकि, हम सभी संभव पुनः प्राप्त करने की जरूरत nसे Lहै, जो हम करते हैं के साथ सभी पूर्णांकों गणना करके Lअंक। फिर उनमें से प्रत्येक (n,k)जोड़े के लिए, प्रत्येक के लिएk-1गिराए गए तत्वों को हमें परिणामस्वरूप प्राप्त होने वाली हानिपूर्ण संख्या को उत्पन्न करना चाहिए, और इसे हमारी सूची में जोड़ना चाहिए, जो खाली शुरू होता है। फिर हम सूची को सॉर्ट करते हैं और अगली (L,k)जोड़ी पर दोहराते हैं, जब हम d<c(n,k)पहले बता चुके होते हैं ।

कोड टूटना (थोड़ा पुराना):

t=range                     #shortens code
def f(r,n,k):               #helper function
 for s in t(10**~-n,10**n): #for the (L,k) pair, add value of (s,k,y)
  for y in t(1,k):r+=[(int("".join(map(str,[c+s for c in t(k+1)if c!=y]))))]
 if n>1:                    #case where L!=1
  n*=k;k+=1                 #multiply n (which is n'/k from prev iter), inc k
 else:n,k=k+1,2             #reset n and k
 while n//k*k-n:k+=1        #find next proper divisor of n
 return(r,n//k,k)           #divide by that divisor and return
def g(h):                   #main function
 q,a,b=[],1,2               #initial values
 while h>=len(q)or a*b<=len(str(q[h])):(q,a,b)=f(q,a,b);q.sort()
 return q[:h]               #continues until at least h numbers and surpassed current max

Comments

मुझे लगता है कि मनमाने ढंग से पूर्णांकों का समर्थन len(`q[h]`)करना चाहिए len(str(q[h]))? या यूँ कहें कि यह केवल एक निश्चित सीमा तक काम करता है, क्योंकि आप एक पैरामीटर ले रहे हैं, हमेशा के लिए नहीं।

— mbomb007

मैंने सोचा कि गैर-नकारात्मक पूर्णांकों के लिए `x` == repr (x) == str (x), और यह सच नहीं होने का कोई संदर्भ नहीं मिल सकता है। आपको क्यों लगता है कि यह सच नहीं है?

— फ्रिकटिव मेलन

मुझे पता है कि यह सच नहीं है, क्योंकि मैं अक्सर पायथन में गोल्फ करता हूं। उदाहरण है । पूर्णांक अधिकतम मान ( 2**63-1) से बड़ा कुछ भी Lउपयोग करने पर अंत में होगा repr। ध्यान दें कि यह प्रविष्टि संभवतः अनुक्रम में बहुत दूर है।

— mbomb007