এককভাবে ক্ষতিকারক পূর্ণসংখ্যা: সংঘবদ্ধ ক্রমগুলি একটি একক উপাদান অনুপস্থিত

Question

আমি অনুক্রমের সংমিশ্রনের পদ্ধতিটি সংজ্ঞায়িত করি যে অনুক্রমের প্রতিটি সংখ্যা একটি স্ট্রিং হিসাবে সংমিশ্রিত হয়, তারপরে ফলাফলটি একটি পূর্ণসংখ্যা হয়।

[1, 2, 3] -> 123

কমপক্ষে তিনটি পরপর পূর্ণসংখ্যার প্রতিটি সীমাবদ্ধতার জন্য, ক্রমের ঠিক এক উপাদান অনুপস্থিত এবং এই অনুপস্থিত উপাদানটি ক্রমের প্রথম বা শেষ উপাদান নাও হতে পারে, সংযুক্ত ক্রমের ফলে পূর্ণসংখ্যাকে আউটপুট দেয়। আমি এটি "এককভাবে ক্ষতিগ্রস্থ পূর্ণসংখ্যার" হিসাবে উল্লেখ করছি।

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

এককভাবে ক্ষতিকারক পূর্ণসংখ্যার এই ক্রমটি হ'ল নিম্নোক্ত অনুচ্ছেদের (পার্টিশন?) মিলন:

প্রথম subsequence {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
• টিআইও (দ্রুত, উচ্চতর সীমা)

নিয়মাবলী:

• সংক্ষিপ্ততম কোড জিতেছে
• আপনি হয় (যা বলতে পারেন):
  • এককভাবে ক্ষতিকারক পূর্ণসংখ্যা চিরকালের জন্য মুদ্রণ করুন
  • একটি ধনাত্মক পূর্ণসংখ্যা এন দেওয়া হয়েছে , তালিকা হিসাবে প্রথম এন উপাদানগুলি মুদ্রণ করুন বা ফিরে আসুন, বা কমা- বা হোয়াইটস্পেস-সীমাবদ্ধ স্ট্রিং।
• আপনার ভাষা যদি এটিকে অনুমতি দেয় তবে নির্বিচারে বড় পূর্ণসংখ্যার সমর্থন করা উচিত, বিশেষত আপনি যদি চিরকালের জন্য মুদ্রণ করেন।

দ্বারা অনুপ্রাণিত / সম্পর্কিত

দ্রষ্টব্য: এই সিকোয়েন্সের জন্য এখনও ওইআইএস-তে কোনও প্রবেশ নেই is

অন্য দ্রষ্টব্য: আমি তাদের নাম "এককভাবে লসী পূর্ণসংখ্যার" রেখেছি যাতে ফলস্বরূপ "ডবলি লসী ইন্টিজার্স", "এন-ল্য লসী ইন্টিজার্স", "(এন + 1) -লস লসী ইন্টিজার্স" এবং "লসী ইন্টিজার" থাকতে পারে I "(এই সকলের মিলন)।

Comments

আমি প্রথম ~ 7600 উপাদানগুলির একটি তালিকা যুক্ত করেছি, পাশাপাশি একটি সুনির্দিষ্ট বাস্তবায়ন আমি পাইথনে সবেমাত্র সম্পন্ন করেছি।

— mbomb007

এটি একটি মজার fastest-codeচ্যালেঞ্জ হবে।

— মাইকেল ক্লেইন

এটা যে। চ্যালেঞ্জটি আবার পোস্ট করার পক্ষে কি ভিন্ন গ্রহণযোগ্য মানদণ্ড সহ গ্রহণযোগ্য? যদি তা হয় তবে আমি এক সপ্তাহ বা আরও আগে অপেক্ষা করতাম

— mbomb007

আমি যতদূর জানি, এটা ঠিক করা উচিত। একটি মোড জিজ্ঞাসা করতে আড্ডায় পপ করতে পারে, কেবল ক্ষেত্রে / পরামর্শের জন্য want

— মাইকেল ক্লেইন

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

আসলেই কি এটি অন্তর্নির্মিত গণিত? আমি অবাক হই না। : ডি

— mbomb007

না, তবে এটি দিয়ে সংশোধন করা যায় Party[_]:=While[True,Print["PARTY!!!"]]। যুক্তি উপেক্ষা করা হয়েছে কারণ সমস্ত পার্টি অংশ নিচ্ছে।

— ক্যালকুলেটরফলাইন

পছন্দ করুন Party[Where]মুদ্রণ করা উচিত Here!, এবং Party[When]মুদ্রণ করা উচিত Now!, ইত্যাদি। পার্টি করার বিষয়ে হালকা চিন্তা করবেন না।

— সানচাইজস

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 বাইট @ নিমিমি দ্বারা গল্ফ করেছে।

Comments

এটি কি অসীম, নাকি লাগে n?

— mbomb007

@ mbomb007 এর সাথে Integer, যতক্ষণ না আপনি স্মৃতি থেকে সরিয়ে চলেছেন (বা ধৈর্য) it এটি অবিরত Intথাকবে, তবে একবারে এটি ভেসে উঠলে ভুল উত্তর দেওয়া শুরু করবে ( > 2^29-1)।

— মাইকেল ক্লেইন

আপনি কি এমন একজন দোভাষীর সাথে লিঙ্ক করতে পারেন যেখানে আমি এটি চালাতে পারি? আমি এটিকে ট্রিহাস্কেল.আর.আর্গ.তে পেস্ট করেছি এবং এটি কার্যকর হয়নি।

— mbomb007

@ mbomb007 শ্রেষ্ঠ আমি এতদূর পেয়েছি কোনদিন এই যদিও এটা প্রয়োজন, main=print$যে GHCi না। জিএইচসি.ইও মেমরির বাইরে চলে গেছে এবং ট্রাইহ্যাস্কেল.অর্গ.এর বৈশিষ্ট্য সেটটি খুব সীমিত।

— মাইকেল ক্লিন

বাহ, সময় নির্ধারণের আগে এটি খুব বেশি দূর হয় না। : ডি

— mbomb007

Answer 3

পাইথন 3, 136 127 126 122 বাইট

প্রাণবন্ত সমাধান সমাধান, আমি এমনকি এন = 7000 চেষ্টাও করি না (এটি ইতিমধ্যে এন = 100 এর জন্য 10 সেকেন্ড সময় নিয়েছে)

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 এবং @ ফ্রিভেটিভমেলনকে ধন্যবাদ

Comments

আপনার একটি )এবং নিম্নলিখিত বর্ণের মধ্যে কোনও স্থানের প্রয়োজন নেই এবং আপনি t=rangeপ্রোগ্রামের শুরুতে যুক্ত করতে পারেন এবং rangeকল সহ সমস্ত ফাংশন কলগুলি প্রতিস্থাপন করতে পারেন t। এটি বাইট গণনা অনেক কমাতে হবে।

— কাল্পনিক মেলুন

@ ফ্রিক্যটিভমেলন ঠিক আছে, আমি অকেজো জায়গা সরিয়ে ফেলব

— এরওয়ান

i!=l+kএছাড়াও প্রতিস্থাপন করা যেতে পারে l+k-i, যা একটি বাইট সংরক্ষণ করে।

— কাল্পনিক মেলুন

@ ফ্রিক্যটিভেলন আমি একটি ছোট বিবরণ যুক্ত করেছি :)

— এরওয়ান

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

hSTDIN থেকে ইনপুট হিসাবে নেয় এবং প্রথম 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আমরা প্রক্রিয়া করতে চলেছি, আমরা থামাতে পারি, যেহেতু আমরা সেই বহু বা কম সংখ্যার সাথে আর একটি নম্বর পেতে পারি না, যেহেতু আমাদের গ্যারান্টির দ্বারা আমাদের তখনই এটি প্রক্রিয়া করা উচিত ছিল, এবং তাই আমরা কোন সংখ্যারই বিষয়টি বিবেচনা করি না matter কম্পিউটিং শেষ হবে, প্রথম 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, যা আমরা কি এমন সমস্ত পূর্ণসংখ্যার enumerating দ্বারা 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