लगातार अंकों के सबसे लंबे रन का पता लगाएं

Question

सरल चुनौती: सकारात्मक पूर्णांक संख्याओं की एक श्रृंखला को देखते हुए, वह संख्या ज्ञात करें जो इसके अंकों में शामिल है जो लगातार अंकों का सबसे लंबा रन है। चाल? यह संभव मानों ( 0123456789) के चारों ओर लपेटने और पीछे की ओर चलाने के लिए अंकों में अंकों के लिए अनुमति दी गई है । तो दोनों 2345, 89012और 5432109लगातार अंकों के वैध रन हैं (लेकिन नहीं 3456765और न ही के 321090123रूप में रन हमेशा एक ही दिशा में होना चाहिए, हालांकि 3456765दो रन के रूप में माना जा सकता है: 34567और 765)। संबंधों के मामले में, पहले वाले को लौटाएं।

परीक्षण के मामलों:

Input:  [3274569283, 387652323, 23987654323648, 2345687913624]
Output: 23987654323648 
        (The run is 98765432; run length: 8)

Input:  [123012363672023, 098761766325432, 15890123456765]
Output: 15890123456765
        (The run is 8901234567; run length: 10)

Input:  [43, 19, 456]
Output: 456

Input:  [5, 9, 0]
Output: 5

Input:  [71232107, 7012347]
Output: 7012347

Input:  [1234, 32109876]
Output: 32109876

Input:  [9090, 123]
Output: 123

टिप्पणियाँ:

• इनपुट में कम से कम एक नंबर होगा।
• इनपुट संख्या में अग्रणी शून्य हो सकते हैं।
• इनपुट और आउटपुट किसी भी उचित प्रारूप में हो सकते हैं । इसलिए इनपुट नंबरों को स्ट्रिंग्स, अंकों / पात्रों की सूची के रूप में लिया जा सकता है ...
• जब तक संख्या मुद्रित होती है तब तक आउटपुट में अनुगामी और / या प्रमुख व्हाट्सएप और न्यूलाइन्स शामिल हो सकते हैं।
• यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा की जीत के लिए सबसे छोटा कार्यक्रम / कार्य हो सकता है!

Comments

संबंधित ।

— चार्ली

बस सुनिश्चित करने के लिए, सूची ही नहीं लपेट सकती है, है ना? (मुझे सूची रैपिंग के रूप में रैपिंग डिजिटली गलत समझा गया) इसलिए हाँ, [7,8,1,6]के [7,8]बजाय अधिकतम रन है [6,7,8]?

— जोनाथन एलन

@JonathanAllan हाँ, 78उस मामले में अधिकतम रन है ।

— चार्ली

Answer 1

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

I9,-;N¤yŒgỊS€ṀµÐṀḢ

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

प्रमुख शून्य को संरक्षित करने के लिए अंकों की सूची के रूप में लेता है और लौटता है।

Comments

मेरा करने के लिए इसी तरह की समस्या - कोशिश यह आकार के लिए बाहर (मेरा मानना है कि यह गलत परिणाम देता है - मैं इसे का सुझाव दिया है के रूप में एक परीक्षण मामला बस सुनिश्चित करने के लिए)।

— जोनाथन एलन

@JonathanAllan मुझे लगता है कि यह सही आउटपुट है? ( 3210पहले नंबर btw में है)

— एर्ग आउटफोलर

आह, यह , माफ करना!

— जोनाथन एलन

@JonathanAllan ओह मैं देख रहा हूं कि आपका क्या मतलब है ... यह शायद Aवहां के कारण है।

— आउटगॉल्फ

@JonathanAllan फिक्स्ड।

— आउटगोल्फर ऑग

Answer 2

जावास्क्रिप्ट (ईएस 6), 104 102 98 बाइट्स

अंकों की सूची की सूची के रूप में इनपुट लेता है। सबसे अच्छा लौटाता है।

a=>a.map(s=>s.map(n=>(i=(d=(x-(x=n)+11)%10)&&d-2?0:d-p?(p=d,1):i+1)>j&&(r=s,j=i),p=x=-10),j=-1)&&r

परीक्षण के मामलों

let f =

a=>a.map(s=>s.map(n=>(i=(d=(x-(x=n)+11)%10)&&d-2?0:d-p?(p=d,1):i+1)>j&&(r=s,j=i),p=x=-10),j=-1)&&r

console.log(JSON.stringify(f([[3,2,7,4,5,6,9,2,8,3], [3,8,7,6,5,2,3,2,3], [2,3,9,8,7,6,5,4,3,2,3,6,4,8], [2,3,4,5,6,8,7,9,1,3,6,2,4]])))
console.log(JSON.stringify(f([[1,2,3,0,1,2,3,6,3,6,7,2,0,2,3], [0,9,8,7,6,1,7,6,6,3,2,5,4,3,2], [1,5,8,9,0,1,2,3,4,5,6,7,6,5]])))
console.log(JSON.stringify(f([[4,3], [1,9], [4,5,6]])))
console.log(JSON.stringify(f([[5], [9], [0]])))

Answer 3

जेली ,  18 16  15 बाइट्स

I%⁵Œg%8ċ€1ṀµÐṀḢ

अंकों की सूचियों की सूची लेने वाला एक विवादास्पद लिंक, और वर्णित के रूप में एक अधिकतम रन वाले बाएं को वापस करना।

इसे ऑनलाइन आज़माएं! या एक परीक्षण सूट देखें(I / O जैसा दिखने के लिए प्रसंस्करण के साथ यह प्रश्न में है)।

कैसे?

I%⁵Œg%8ċ€1ṀµÐṀḢ - Link: list of lists of integers (digits) from [0-9]
           µÐṀ  - keep elements for which the link to the left is maximal:
I               -   incremental differences (i.e. [a2-a1, a3-a2, ...])
  ⁵             -   literal 10
 %              -   modulo by (i.e. [(a2-a1)%10, (a3-a2)%10, ...])
                -     this equates deltas of -9 and -1 with 1 and 9 respectively
   Œg           -   group runs of equal elements
     %8         -   modulo by 8; vectorised (9s become 1s, others unaffected)
       ċ€1      -   count number of 1s in €ach group
          Ṁ     -   maximum
              Ḣ - head (get the first one of those that were maximal)

Comments

V€इस बारे में निश्चित नहीं है, आपको अग्रणी शून्य गिनना पड़ सकता है।

— आउटगॉल्फ

यह स्टिंग इनपुट के अग्रणी शून्य की गिनती करता है, हालांकि मैं देखता हूं कि हम अंकों की सूची ले सकते हैं ...

— जोनाथन एलन

मुझे लगता है कि आप अग्रणी शून्य का समर्थन करने वाले हैं।

— आउटगॉल्फ

मैं प्रमुख शून्य का समर्थन करता हूं

— जोनाथन एलन

मैंने पढ़ा है कि "दैट काउंट ..." के रूप में नहीं

— एरिक आउटगोल्फर

Answer 4

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

अंकों की सूची की एक सूची लेता है a; इसकी एक सूची लौटाता है।

lambda a:max(a,key=lambda l:len(max(re.findall('1+|9*',`[(x-y)%10for x,y in zip(l,l[1:])]`[1::3]),key=len)))
import re

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

Comments

इनपुट पर विफल रहता है [[9,0,9,0],[1,2,3]]।

— जर्गर्ब

@Zgarb उफ़, आप सही कह रहे हैं। एक पुराने संस्करण पर वापस जाता हूं।

— लिन

Answer 5

भूसी , 20 बाइट्स

←Ö¤<(→Of€1†%8gẊo%10-

अंकों की सूची की सूची बनाता है और लौटाता है। इसे ऑनलाइन आज़माएं!

व्याख्या

←Ö¤<(→Of€1†%8gẊo%10-  Implicit input.
←                     Return first element of
 Ö                    the input sorted in a stable manner
   <                  in descending order
  ¤ (                 with respect to the following function:
                       Argument is list of digits, say [5,2,1,0,9,1,0].
                   -   Differences
               o%10    mod 10
              Ẋ        of all adjacent pairs: [7,9,9,9,2,1]
             g         Group adjacent equal elements: [[7],[9,9,9],[2],[1]]
          †%8          Vectorized mod 8: [[7],[1,1,1],[2],[1]]
       f€1             Keep those runs where 1 occurs: [[1,1,1],[1]]
      O                Sort in ascending order: [[1],[1,1,1]]
     →                 Take last element (gives [] on empty list): [1,1,1]
                       This is a list of 1s with length one less than
                       the longest run of consecutive digits.

Answer 6

MATLAB, 130 बाइट्स

कॉलम अंतर, कॉलम अंतरों के सरणी [X (2) -X (1), ..., X (n) -X (n-1)] को ले लो, सरणी में सबसे लगातार मूल्य (1 आरोही क्रम) की जांच करें 1 अन्यथा), या तो सबसे लगातार मूल्य या -9 के लिए सूचकांक प्राप्त करें, जो कि सबसे लगातार मूल्य से गुणा किया जाता है (-9 आरोही क्रम में होता है, 9 अन्यथा), लगातार सूचकांकों को खोजें (जिसका अंतर 1 के बराबर है) और इसे योग करें। कृपया, क्योंकि यह देर हो चुकी है। सबसे बड़ा आउटपुट।

a=input('')
t=[]
for i=1:numel(a)
b=diff(num2str(a(i))-'0')
c=mode(b)
t=[t sum(diff(find(b==c|b==-9*c))==1)]
end
[t,I]=max(t),a(I)

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