आईडी जनरेटर जिसके साथ कोई मेल नहीं खाता है

16

दिए गए 2 इनपुट (m = न्यूनतम आरंभिक आईडी , n = आईडी की संख्या ), आईडी की क्रमिक सूची उत्पन्न, = = m से शुरू, अंकों से बना 0-9 जहां कोई 2 सन्निहित संख्याएँ समान नहीं हैं, जैसे 1232 है ठीक है, 1233 नहीं है (2 '3 एक दूसरे के बगल में है)।

उदाहरण

m = 985, n = 6 के लिए, नीचे दिए गए आइडी से पता चलता है कि आइडी जनरेट / स्किप किया जाएगा

...
985 - ok, 1st
986 - ok, 2nd
987 - ok, 3rd
# skip 0988 (contains '88')
989 - ok, 4th
# Skip 099x (contains '99')
# Skip 100x (contains '00')
1010 - ok, 5th
# Skip 1011 (contains '11')
1012 - ok, 6th
...

उत्पादन

उपरोक्त क्रम के अनुसार प्रत्येक आईडी को एक नई लाइन पर मुद्रित किया जाना चाहिए:

985
986
987
989
1010
1012

नियम

मानक कोड-गोल्फ नियम, सबसे कम बाइट गिनती जीतता है

code-golf  subsequence 
— beirtipol
स्रोत
14
PPCG में आपका स्वागत है! प्रत्येक आईडी को एक नई लाइन पर मुद्रित किया जाना चाहिए I अत्यधिक आउटपुट को एक विशेष प्रारूप में स्पष्ट रूप से प्रतिबंधित करता है।
— एग्रीग्राफर का एरिक
3
क्या आईडी की सूची (यानी पूर्णांक की एक डी-डी सरणी) को वापस करने के बजाय, स्टडआउट के लिए वापस करना ठीक है?
— जुन्गवां मिन
4
@ user202729 इस मामले में जवाब अमान्य नहीं होंगे।
— एग्रीग्राफर एरिक
2
@ user202729 जो उत्तर को अमान्य नहीं बनाता है ... यदि कुछ भी हो, तो उत्तर निश्चित हो जाएंगे या वे पुराने नियमों का पालन कर रहे हैं।
— पूरी तरह से
3
गोल्फिंग में लिखी जाने वाली भाषाओं के लिए नियम बदलने से अधिक आउटपुट फॉर्मेट की अनुमति नहीं होती है। बाकी के लिए आप केवल एक टिप्पणी यह ​​कहकर छोड़ सकते हैं कि आउटपुट स्वरूप अब प्रतिबंधित नहीं है।
— ब्रैड गिल्बर्ट

जवाबों:

3

जेली , 6 बाइट्स

DIẠµ#Y

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

यह काम किस प्रकार करता है?

DI # Y - पूर्ण कार्यक्रम। तर्क: दो पूर्णांक, X और Y।

   µ # - पहले Y पूर्णांकों को संतुष्ट करने वाले X से अधिक या उसके बराबर लौटें:
 मैं - वेतन वृद्धि ...
डी - ... उनके आधार -10 अंकों के ...
  All - ... सभी गैर 0 हैं। 
     Y - newlines द्वारा परिणाम में शामिल हों।
— श्री एक्सकोडर
स्रोत
8

ब्रेकीलॉग , 11 10 बाइट्स

{≤ṫẹ~ḅẉ}ᶠ⁾

इनपुट दो नंबरों की एक सूची है। इसे ऑनलाइन आज़माएं!

व्याख्या

बिल्ट-इन ḅएक सूची या स्ट्रिंग लेता है, जैसे "1000220", और इसे समान आसन्न तत्वों के ब्लॉक में विभाजित करता है, जैसे ["1","000","22","0"]। इस कार्यक्रम में, मैं लागू होते हैं~ ऑपरेटर को उस पर , इसलिए यह रिवर्स में काम करता है: यह स्ट्रिंग्स की एक सूची लेता है, जांचता है कि प्रत्येक स्ट्रिंग में एक एकल वर्ण की पुनरावृत्ति होती है और पड़ोसी के स्ट्रिंग में अलग-अलग वर्ण होते हैं, और सूची को संक्षिप्त करता है। विधेय की ≤संख्या बढ़ते क्रम में पहले इनपुट से शुरू होने वाली संख्याओं की गणना करती है, और मैं उन पर एक स्थिति की जांच करता हूं, जो उन्हें संतुष्ट करते हैं और जब मैंने पर्याप्त पाया तो रोक दिया।

{≤ṫẹ~ḅẉ}ᶠ⁾  Input is a pair, say [M=988,N=3].
{      }ᶠ⁾  Apply this predicate to M and compute the first N results.
 ≤          Take a number that is greater than or equal to M (first up is 988).
  ṫ         Convert it to string: "988"
   ẹ        Split it into substrings of length 1: ["9","8","8"]
     ~ḅ     Apply ḅ in reverse: fails, try next number.
       ẉ    If ḅ succeeds, print the resulting string and a newline.
            This counts as a result of the predicate.
— Zgarb
स्रोत
6

05AB1E , 9 बाइट्स

µÐÔQi=¼}>

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

Exlpanation

µ           # loop until counter equals n
 Ð          # triplicate current value (initially m)
  Ô         # connected uniqueified on the copy at the top of the stack
   Q        # compare to unmodified for equality
    i  }    # if true
     =      # print current value while leaving it on the stack
      ¼     # increment the counter
        >   # increment current value
— Emigna
स्रोत
4

जावा 8, 83 बाइट्स

(m,n)->{for(;n>0;m++)if(!(m+"").matches(".*(.)\\1.*")){System.out.println(m);n--;}}

स्पष्टीकरण:

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

(m,n)->{                      // Method with two integer parameters and no return-type
  for(;n>0;                   //  Loop as long as `n` is larger than 0
      m++)                    //    After every iteration: increase `m` by 1
    if(!(m+"").matches(".*(.)\\1.*")){
                              //   If there are no repeated adjacent digits:
      System.out.println(m);  //    Print `m`
      n--;}}                  //    And decrease `n` by 1
— केविन क्रूज़सेन
स्रोत
बहुत अच्छा। जिज्ञासा से बाहर, इस सवाल के लिए उपयुक्त मंच कहां होगा जहां चुनौती "बाइट्स" नहीं बल्कि "दक्षता" थी?
— बर्टिपोल
1
@beirtipol सबसे कुशल आप सबसे तेजी से निष्पादन समय का मतलब है? उस स्थिति में भी शायद PPCG पर, टैग कोड-चुनौती और सबसे तेज़-कोड के साथ । हालांकि अब उसी चुनौती को पोस्ट करना और कोड-गोल्फ को सबसे तेज़-कोड में बदलना शायद अभी भी एक
— डुबकी के
3

पावरशेल , 59 बाइट्स

param($m,$n)for(;$n){if("$m"-notmatch"(.)\1"){$m;$n--}$m++}

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

मूल रूप से अन्य उत्तरों के समान। जब तक हमारे पास प्रिंट करने के लिए संख्या बची है तब तक लूप्स ( for(;$n)), परीक्षण करता है कि क्या हमारे पास एक डबल-अंक के खिलाफ एक रेगेक्स मैच है और यदि यह पाइप लाइन पर नहीं है और घटता है $n। फिर हम वृद्धि $mऔर लूप फिर से। तत्वों को पाइपलाइन से उठाया जाता है और निहित Write-Outputहमें मुफ्त में एक नया-अलग-अलग आउटपुट देता है।

— AdmBorkBork
स्रोत
3

आर , 111 92 71 बाइट्स

function(m,n)while(F<n){if(!grepl("(.)\\1",m)){cat(m,'
');F=F+1}
m=m+1}

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

greplदोहराया अंकों के लिए खोज करने के लिए उपयोग करता है।

— ग्यूसेप
स्रोत
आप परिणाम को newlines द्वारा शामिल नहीं करते हैं, और यदि यह अभी तक अनुमति दी गई है, तो ओपी ने जवाब नहीं दिया (हालांकि मुझे आशा है कि यह ठीक होगा)
— श्री Xcoder
@ Mr.Xcoder आह, ठीक है, मैंने देखा कि और फिर कॉपी और गलत संस्करण चिपकाया :(
— Giuseppe
2

पर्ल 6 , 56 बाइट्स

{.put for grep({none .comb Zeq.comb.skip},$^a..*)[^$^b]}

कोशिश करो

विस्तारित:

{  # bare block lambda with placeholder params $a $b

  .put for

  grep(

    {
      none          # create a none junction (True if all are False)

        .comb       # the input split into digits
        Zeq         # Zip using &infix:«eq» operator
        .comb.skip  # the input split into digits starting at second one
    },

    $^a .. *        # a Range starting at the first argument

  )[ ^ $^b ]        # take the first $b values
}
— ब्रैड गिल्बर्ट b2gills
स्रोत
2

रेटिना , 34 बाइट्स

.0A`
"$+"{\/(.)\1/{`.+
*
)C`
.+
*

इसे ऑनलाइन आज़माएं! ले जाता है nऔर mअलग पंक्ति में इनपुट के रूप में। स्पष्टीकरण:

.0A`

स्वचालित आउटपुट बंद करें और nकार्य बफ़र से हटाएं ।

"$+"{

दोहराएँ nबार।

\

mनिम्नलिखित लूप वाले समूह के अंत में मूल्य प्रिंट करें ।

/(.)\1/{`

लूप जबकि सन्निहित अंक हैं।

.+
*

यूनीरी में बदलें।

)C`

खाली तारों की संख्या की गणना करें, जो वर्णों की संख्या से एक अधिक है, इस प्रकार 1 को जोड़ना और दशमलव में वापस परिवर्तित करना। इससे अंदर का लूप खत्म हो जाता है।

.+
*

छपा हुआ m , उसी तरह से फिर से 1 जोड़ें। (अंतिम पंक्ति की आवश्यकता नहीं है C`क्योंकि यह अंतिम पंक्ति के लिए डिफ़ॉल्ट चरण प्रकार है।) बाहरी लूप अंतर्निहित रूप से समाप्त हो गया है।

ध्यान दें कि एकात्मक और वापस दशमलव में परिवर्तित करना थोड़ा धीमा है; 39 बाइट्स के लिए, एक संस्करण जो कोई रूपांतरण नहीं करता है:

.0A`
"$+"{\/(.)\1/+`.+
$.(*__
.+
$.(*__

इसे ऑनलाइन आज़माएं! स्पष्टीकरण: $.(बाकी प्रतिस्थापन की लंबाई की गणना करता है, आसानी से वास्तव में इसे विस्तारित किए बिना; चूँकि लंबाई *_अनुमानित मिलान मूल्य की _है और पाठ्यक्रम की लंबाई 1 है और इससे मूल्य में वृद्धि होती है।

— नील
स्रोत
2

पर्ल 5.10.0 + -n, 40 39 बाइट्स

for(;$i;$_++){!/(.)\1/&&$i--&&say}$i=$_

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

-1 बाइट एक्सकली के लिए धन्यवाद

दो लाइनों पर इनपुट, पहले एन, फिर एम। सुनिश्चित करें कि मी के बाद कोई न्यूलाइन नहीं है:

(echo '6'; echo -n '985') | perl -nE 'for(;$i;$_++){!/(.)\1/&&$i--&&say}$i=$_'
— wastl
स्रोत
1
आप एक बाइट को बचाने के लिए 'एम' को खत्म कर सकते हैं।
— Xcali
@Xcali थैंक्स, पता नहीं मैं क्या सोच रहा था ...
— wastl
2

पर्ल 5 ,-ln 33 बाइट्स

STDIN पर 2 लाइनें दर्ज करें, पहले आईडी शुरू करें फिर गिनती करें

#!/usr/bin/perl -ln
$n-=!/(.)\1/&&say,$_++while$n.=<>

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

— टन हास्पेल
स्रोत
मुझे नहीं पता था कि उस $n.=<>तरह से काम किया, विशेष रूप से -=...
— डोम हेस्टिंग्स
@DomHastings दुर्भाग्य से मुझे इसे वापस लेना होगा क्योंकि ऐसा करने से दोनों एक साथ गलत कर $nसकते 0हैं
— टन हास्पेल
1

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

-19 बाइट्स निम्मी को धन्यवाद।

s#n=unlines$map show$take n$filter(and.(zipWith(/=)=<<tail).show)[s..]

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

17 बाइट्स को न्यूलाइन द्वारा अलग करने के लिए समर्पित।

— totallyhuman
स्रोत
1
— nimi
आप परिणाम को newlines द्वारा शामिल नहीं करते हैं, और अगर यह अभी तक अनुमति दी है, तो ओपी ने जवाब नहीं दिया (हालांकि मुझे आशा है कि यह ठीक होगा)
— श्री Xcoder
@ Mr.Xcoder आह, फिक्सिंग ...
— totallyhuman
1
आप उपयोग कर सकते हैं mapMऔर print। इसे ऑनलाइन आज़माएं!
— नमि
1

स्टैक्स , 9 8 बाइट्स सीपी ४३ by

ç@F6╕↔┤ú

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

अपने जेली जवाब में @ Mr.Xcoder के एल्गोरिथ्म के साथ मेल खाना।

-1 बाइट प्रति टिप्पणी @recursive द्वारा।

व्याख्या

समझाने के लिए अनपैक्ड प्रारूप का उपयोग करता है।

{$:-|A}gn
{     }gn    Generator, generate given number of values, using block as a filter
                 And implicit output, one element on a line.
             In Stax, only 0 and [] is falsy.

 $           Convert the number to string
  :-         Difference between contiguous digit
    |A       All of them are truthy (may use `:*` as well)
— वीजुन झोउ
स्रोत
staxlang.xyz/… 8 बाइट देता है। जब तक वे मानक इनपुट की पहली पंक्ति पर होते हैं, तब तक कई मूल्यों पर लागू होने वाला निष्कासन कार्य करता है।
— पुनरावर्ती
@recursive धन्यवाद, यह एक ऐसी चीज है जिसे मैंने नोटिस नहीं किया था हालांकि यह दस्तावेज है।
— वीजुन झोउ
1

हास्केल , 94 93 91 बाइट्स

-1 बाइट लाईकोनी की बदौलत
-2 बाइट्स जर्ब की बदौलत

import Data.List
a!0=[]
a!b|all(null.tail)$group$show a=show a++'\n':(a+1)!(b-1)|c<-a+1=c!b

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

पहला हास्केल गोल्फ।

— OVS
स्रोत
1
हास्केल गोल्फ में आपका स्वागत है! group(show a)हो सकता है group$show a।
— लाकोनी
2
(<2).lengthहो सकता हैnull.tail
— झगरब
0

AWK , 90 बाइट्स

{for(j=$1;k<$2;j++){for(a=b=d;++b<=(n=split(j,A,""))&&a!=c=A[b];a=c);if(n<b&&++k)print j}}

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

यह एक बहुत बदसूरत है जितना मैंने सोचा था कि यह होगा। मुझे पता चला कि AWKकेवल इसके में बैक-प्रतिस्थापन हैgensub फ़ंक्शन जो इस एप्लिकेशन के लिए उपयोग करने में बहुत कुशल नहीं होगा।

तो यह एक आईडी काउंटर को बढ़ाने का एक बहुत ही सीधा तरीका है, प्रत्येक वर्ण पर काउंटर को विभाजित करना, वर्णों के माध्यम से यह देखना कि क्या कोई चरित्र पिछले चरित्र के समान है। यदि कोई दोहराए गए वर्ण नहीं मिलते हैं, तो आईडी काउंटर प्रिंट करें और मुद्रित आईडी की संख्या बढ़ाएं।

मैं " AWKअधिक मजबूत नियमित अभिव्यक्ति करने की क्षमता होनी चाहिए " की तर्ज पर एक बयान देने से बचना चाहूंगा , लेकिन यह मुश्किल होगा।

— रॉबर्ट बेन्सन
स्रोत
0

पिप , 22 बाइट्स

--aLb{W`(.)\1`N++a0Pa}

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

व्याख्या

--aLb{W`(.)\1`N++a0Pa}
                        a,b are command-line arguments
--a                     Decrement a
   Lb{               }  Loop b times:
       `(.)\1`           Regex matching a character followed by itself
      W       N++a       While that regex matches in incremented a:
                  0       No-op
                   Pa    When the while loop exits, a is a valid ID; print it
— DLosc
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.