सबसे लंबे समय तक बढ़ते पदार्थ

Question

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

उदाहरण के लिए यदि इनपुट था:

$[1,1,2,1,1,4,5,3,2,1,1]$

सबसे लंबी बढ़ती उप-सूची , इसलिए आप 4 का उत्पादन करेंगे ।$[1,1,4,5]$$4$

आपके उत्तर को उसके स्रोत को बाइट्स की सूची के रूप में लिया जाएगा और फिर उस सूची की सबसे लंबी बढ़ती उप-सूची की लंबाई का पता लगाया जाएगा। एक कम स्कोर लक्ष्य है। कम समग्र बाइट्स वाले कार्यक्रमों के पक्ष में संबंध टूट जाते हैं।

Comments

क्या 1 के बजाय सही लौटना ठीक है? और क्या हमें एक खाली सूची को संभालना है?

— जो किंग

आपके पहले एक के लिए, जो भी मेटा आम सहमति है, आप जो कर सकते हैं, वह है, मुझे याद नहीं है कि यह Trueएक विकल्प है, 1लेकिन यह हो सकता है। आपको रिक्त सूची को संभालने में सक्षम होना चाहिए (आउटपुट निश्चित रूप से 0 है)।

— तदर्थ गार्फ हंटर

सुझाए गए परीक्षण मामलों: [] => 0, [0] => 1, [3,2,1] => 1,[1,2,1,2] => 2

— सोक

क्या आप 'स्कोर' पर थोड़ा और विस्तार से विचार करेंगे?

— 9

@ouflak मुझे यकीन नहीं है कि स्कोर पर क्या कहना है। अपनी प्रविष्टि को बाइट की सूची में परिवर्तित करें और इसे अपने स्वयं के प्रोग्राम के माध्यम से पास करें और यह आपका स्कोर है। स्कोर बराबर हैं, टाई ब्रेकर bytecount है

— जो राजा

Answer 1

पायथ , स्कोर 2 (8 बाइट)

lefSIT.:

यहाँ यह कोशिश करो!

कोड अंक [108, 101, 102, 83, 73, 84, 46, 58]। एक और छोटा समाधान, leSI#.:स्कोर 3, लेकिन इसके कोड बिंदु हैं [108, 101, 83, 73, 35, 46, 58], जो वास्तव में 1 के स्कोर के बहुत करीब हैं। थोड़ा सा भी पुनर्व्यवस्थित करने से नेवरमाइंड को मदद मिल सकती है , इसमें निर्मित सबस्ट्रिंग .:को पुनर्व्यवस्थित नहीं किया जा सकता है, इसलिए यदि प्रोग्राम इसका उपयोग करता है तो सबसे कम स्कोर 2 होना चाहिए।

कैसे?

lefSIT.:     Full program. Accepts either a list or a string from STDIN.
      .:     Substrings.
  f  T       Only keep those that are...
   SI        Sorting-Invariant.
le           Length of the last item.

Answer 2

हास्केल , स्कोर 2, 66 64 61 60 65 बाइट्स

• मैक्स बायकलाकोव को -2 बाइट्स धन्यवाद
• -1 बाइट थैंक्स टू निम्मी
• खाली सूची को संभालने के लिए +5 बाइट्स

foldr1 max.g
g[]=[0]
g(x:y:z)|x>y=1: g(y:z)
g(_:y)|a:b<-g y=1+a:b

इसे ऑनलाइन आज़माएं! (स्वयं सत्यापित करता है)।

मैंने कभी नहीं सोचा था कि मैं हास्केल के साथ 2 का स्कोर प्राप्त कर सकता हूं, और फिर भी मैं यहां हूं!

फ़ंक्शन gपुनरावर्ती रूप से सभी बढ़ते पदार्थों की लंबाई की गणना करता है। foldr1 max.gउन लंबाई की अधिकतम लेता है ( foldr1 maxएक बराबर maximumस्कोर के साथ, लेकिन कम स्कोर के साथ)।

Comments

ऐसा लगता है कि व्हॉट्सएप 1+a : bजरूरी नहीं है, इसलिए यह 62 बाइट्स है।

— मैक्स येखलाकोव

@MaxYekhlakov तुम सही हो, मुझे नहीं पता कि मैं कैसे चूक गया।

— Delfad0r

आपका कोड 1खाली सूची के लिए लौटता है , जहां इसे वापस आना चाहिए0

— जो किंग

@ जो राजा वास्तव में, मैं टिप्पणियों में चर्चा से चूक गया था। जिसे अभी ठीक कर रहे हैं।

— Delfad0r

Answer 3

जावास्क्रिप्ट (Node.js) , स्कोर 3, 53 46 बाइट्स स्कोर 2, 51 50 बाइट्स

-7 बाइट्स थैंक्स @Arnauld

-1 स्कोर के बदले में +5 +4 स्थान

a=> a.map($= p=n=>$=(p<=(p=n)?++ x:x=1)<$?$: x)&&$

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

गैर-रिक्त इनपुट मानता है। 61 बाइट्स अगर खाली सूची को संभाला जाना चाहिए। स्कोर अभी भी 2।

a=> a.map($= p=n=>$=(p<=(p=n)?++ x:x=1)<$?$: x)&& a.length&&$

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

... या 58 अगर लौटने falseकी अनुमति है। स्कोर अभी भी 2।

a=> a.map($= p=n=>$=(p<=(p=n)?++ x:x=1)<$?$: x)&& a>[ ]&&$

Comments

यह 46 बाइट्स और उसी स्कोर के लिए काम करना चाहिए।

— अरनुलद

@Arnauld ने आपके सुझाव में 5 स्थान जोड़े ताकि यह अब स्कोर 2 हो जाए

— शायरु असाकोतो

Answer 4

भूसी , 5 बाइट्स , स्कोर = 2

00000000: bc6d 4cdc 14                   ▲mLġ≥

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

यह हस्क के साथ 2 से कम अंक प्राप्त करने की संभावना नहीं है क्योंकि ġ¹ में वास्तव में उच्च कोडपॉइंट है और अधिकतम और लंबाई प्राप्त करने के लिए इससे पहले कुछ होने की आवश्यकता है। कई कार्यों का उपयोग करने की कोशिश के साथ एक प्रयास किया जा सकता है, लेकिन \nकिसी भी सहायक कार्यों से पहले होगा जो वास्तव में कम कोडपॉइंट है इसलिए कुछ भी कम से कम लंबाई 2 के बढ़ते बाइट-क्रम का निर्माण करेगा।

_{1: ऐसा लगता है कि तुलनात्मक ऑपरेटरों के लिए उपयोग करने का सबसे अच्छा तरीका विभिन्न विभाजन कार्यों ↕( जैसे span) का पालन करना होगा ।}

व्याख्या

▲mLġ≥  -- example input: [1,1,2,1,1,4,5,3,2,1,1]
   ġ≥  -- group elements by geq: [[1,1,2],[1,1,4,5],[3],[2],[1,1]]
 mL    -- map length: [3,4,1,1,2]
▲      -- maximum: 4

Answer 5

रेटिना 0.8.2 , 40 बाइट्स, स्कोर 3

\d+
$*
(?<=(1+)),(?!\1)
¶
T`1`_
^O`
\G,?

इसे ऑनलाइन आज़माएं! लिंक में इनपुट के रूप में स्वयं बाइट कोड शामिल हैं। स्पष्टीकरण:

\d+
$*

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

(?<=(1+)),(?!\1)
¶

घटते जोड़े पर विभाजन।

T`1`_

अंक हटाएं।

^O`

अल्पविराम को उल्टे क्रम में क्रमबद्ध करें। (मैं सामान्य रूप से इसे लिखूंगा O^लेकिन स्पष्ट कारणों के लिए यहां ऐसा नहीं कर सकता।)

\G,?

सबसे लंबे समय तक अल्पविराम चलाने की गणना करें, और अंतिम संख्या को शामिल करने के लिए एक जोड़ें।

Answer 6

जाप -h, 6 बाइट, स्कोर 2

मत सोचो कि 1 का स्कोर संभव है। तार और चरित्र सरणियों के साथ भी काम करना चाहिए।

ò>¹mÊn

इसे आज़माएं - शामिल किया गया परीक्षण मामला समाधान का चारकोड है।

---

व्याख्या

ò          :Partition after each integer
 >         :  That's greater than the integer that follows it
  ¹        :End partition
   m       :Map
    Ê      :  Length
     n     :Sort
           :Implicitly output last element

Answer 7

MATL , स्कोर 2, 13 बाइट्स

d0< ~Y'w)X>sQ

इनपुट हो सकता है:

• संख्या की एक सरणी।
• एकल उद्धरण के साथ संलग्न एक स्ट्रिंग। स्ट्रिंग के भीतर एकल उद्धरण डुप्लिकेट करके बच जाते हैं।

MATL ASCII एन्कोडिंग का उपयोग करता है। उपरोक्त कोड के कोडपॉइंट हैं

100, 48, 60, 32, 126, 89, 39, 119, 41, 88, 62, 115, 81

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

व्याख्या

d     % Implicit input. Consecutive differences (of code points) 
0<    % Less than 0? Element-wise. Gives true or false
      % Space. This does nothing; but it breaks an increasing substring
~     % Negate
Y'    % Run-length encoding. Gives array of true/false and array of lengths
w     % Swap
)     % Index. This keeps only lenghts of runs of true values
X>    % Maximum. Gives empty array if input is empty
s     % Sum. This turns empty array into 0
Q     % Add 1. Implicit display

Answer 8

पास्कल (एफपीसी) , स्कोर 2

111 बाइट्स

var a,b,c,t:bYte;bEgIn repeat read(a); iNc(c); if a<b then c:=1; if c>t then t:= c;b:= a;until eOf;write(t)eNd.

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

गैर-रिक्त इनपुट मानता है। स्पेस से अलग किए गए स्टैंडर्ड इनपुट से नंबर लिए जाते हैं।

Answer 9

जेली , 8 बाइट्स , स्कोर 2

^{संभवत: किसी तरह एक अंक 1 समाधान है ...}

IṠµṣ-ZL‘

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

बाइट मूल्यों की सूची के रूप में स्रोत कोड:

[73, 205, 9, 223, 45, 90, 76, 252]

कैसे?

IṠµṣ-ZL‘ - Link: list of integers  e.g. [ 1, 1, 2, 1, 1, 4, 5, 3, 2, 1, 1]
I        - increments                    [ 0, 1,-1, 0, 3, 1,-2,-1,-1, 0]
 Ṡ       - sign                          [ 0, 1,-1, 0, 1, 1,-1,-1,-1, 0]
  µ      - start a new monadic chain (a low byte to stop score being 3)
    -    - literal minus one             -1
   ṣ     - split at                      [[0, 1], [0, 1, 1], [], [], [0]]
     Z   - transpose                     [[0, 0, 0], [1, 1], 1]
      L  - length                        3
       ‘ - increment                     4

Answer 10

पर्ल 6 , स्कोर 2, 46 बाइट्स

{my&g=1+*×*;+max 0,|[\[&g]] [ |@_] Z>=0,|@_ }

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

खाली सूची को संभालता है। मूल कोड था:

{my&g=1+*×*;+max 0,|[\[&g]] @_ Z>=0,|@_}

तो 2 को स्कोर कम करने के लिए केवल 5 अतिरिक्त बाइट्स।

संपादित करें: आह, मुझे पता चला कि असाइनमेंट को कैसे निकालना है , लेकिन तब मैं 3 के नीचे उस स्कोर को प्राप्त नहीं कर सकता )]]...

स्पष्टीकरण:

{                                  }  # Anonymous code block
 my&g=     ;  # Assign to &g an anonymous Whatever lambda
      1+*×*   # That multiplies the two inputs together and adds 1
                            @_ Z  0,|@_   # Zip the list with itself off-set by one
                                >=        # And check if each is equal or larger than the previous
                                         # e.g. [5,7,7,1] => [1,1,1,0]
                    [\[&g]]  # Triangular reduce it by the function declared earlier
                          # This results in a list of the longest substring at each index
                          # e.g. [5,7,7,1] => [1,2,3,1]
            +max 0,|      # And return the max value from this list, returning 0 if empty

Comments

तो [[&(*+*)]]काम करता है [+]? कमाल ...

— nwellnhof

@nwellnhof हाँ, कुछ कैविएट हैं जैसे आपके पास कोई व्हाट्सएप ( बिल्कुल भी नहीं ) हो सकता है, लेकिन आप इसे Zऔर के साथ भी उपयोग कर सकते हैं X। इसे ऑनलाइन आज़माएं!

— जो किंग

मैं कुछ इस तरह की कोशिश करने जा रहा था:{max 0,|.[[X..] ^$_ xx 2].map({+$_ if [<=] $_})}

— ब्रैड गिल्बर्ट b2gills

Answer 11

05AB1E , स्कोर 3 (9 बाइट्स )

Œʒ¥dP}éθg

सबसे अधिक संभावना किसी भी तरह 2 का स्कोर हो सकता है।

कार्यक्रम के कोड अंक बाइट्स: [140,1,90,100,80,125,233,9,103](लंबाई 3 के दो उपविजेता: [1,90,100]और [80,125,233])

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

स्पष्टीकरण:

Π           # Sublists
 ʒ   }       # Filter by:
  ¥          #  Take the deltas
   d         #  Check for each whether the number is >= 0
    P        #  And check if it was truthy for all deltas
      é      # Then sort by length
       θ     # Take the last element
        g    # And take its length as result

Answer 12

जावा (JDK) , स्कोर 3, 94 बाइट्स

a->{int m=0,p=0,x=0,i=0,n;while(i<a.length){n=a[i++];m=(p<=(p=n)?++x:(x=1)) <m?m:x;}return m;}

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

पोर्ट ऑफ माई (अरनौल्ड के सुझावों के साथ) जेएस जवाब। etuमें returnऔर hilमें whileबना यह असंभव स्कोर करने के लिए गोल्फ के लिए 2।

for यहाँ इस्तेमाल नहीं किया जा सकता क्योंकि:

• ;for आरोही है
• forलैम्ब्डा बॉडी (गुंजाइश प्रतिबंध) की शुरुआत में इस्तेमाल नहीं किया जा सकता है। इसे लपेटना संभव है {}लेकिन स्पष्ट रूप whileसे बाइट्स का उपयोग करके ।

Comments

मैं \uकुछ स्थानों पर संभवतः उपयोग करने का सुझाव देने जा रहा था , लेकिन फिर आपको 00एक अंक का पालन करना होगा जो कि वैसे भी 3 है ...

— ETHproductions

Answer 13

पॉवर्सशेल, स्कोर 3, 44 बाइट्स

($args|%{$i*=$_-ge$p;$p=$_;(++$i)}|sort)[-1]

टेस्ट स्क्रिप्ट:

$f = {

(
    $args|%{        # for each integer from argument list
        $i*=$_-ge$p # -ge means >=.
                    # This statement multiplies the $i by the comparison result.
                    # A result of a logical operator is 0 or 1.
                    # So, we continue to count a current sequence or start to count a new sequence
        $p=$_       # let $p stores a 'previous integer'
        (++$i)      # increment and return incremented as length of a current sequence
    }|sort          # sort lengthes 
)[-1]               # take last one (maximum)

}

@(
    ,(4, 1,1,2,1,1,4,5,3,2,1,1)
) | % {
    $e,$a = $_
    $r = &$f @a
    "$($r-eq$e): $r"
}

आउटपुट:

True: 4

स्पष्टीकरण:

• स्क्रिप्ट पूर्णांक को तर्क सूची ( स्पैलेटिंग ) के रूप में लेती है ।
• प्रत्येक पूर्णांक नक्शे के आधार पर कार्य करता है contiguous sub-list that is increasing (not strictly)। फिर स्क्रिप्ट की लंबाई लंबी हो जाती है और एक अंतिम (अधिकतम) लेती है (...|sort)[-1]।

---

पॉवर्सशेल 6, स्कोर 3, 43 बाइट्स

$args|%{$i*=$_-ge$p;$p=$_;(++$i)}|sort -b 1

ऊपर की तरह। एक अंतर: सॉर्ट किए गए सरणी के अंत से 1 तत्व केsort -b 1 लिए शॉर्टकट sort -Bottom 1का मतलब है । इसलिए हमें सूचकांक की आवश्यकता नहीं है ।[-1]

Answer 14

स्टैक्स , स्कोर 3 (15 बाइट्स)

Z|[F|]F:^!C_%|M

इसे चलाएं और डीबग करें

Answer 15

पायथन 2 , स्कोर 5, 87 बाइट्स स्कोर 2, 101 93 92 101 बाइट्स

lambda a,m=1,o=[1]:max(reduce(lambda B,c:[B[:-m]+[B[-m]+m],B+o][c[0]>c[m]],zip(a,a[m:]), o)) *(a>[ ])

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

ओह! सोचा था कि यह पहली बार कोड-गोल्फ था ...

Comments

5 का स्कोर ऑनलाइन यह कोशिश करो!

— मैपेटेलियन

4 के स्कोर प्राप्त करने के लिए टैब के साथ इंडेंट करें

— mypetlion

@ चेतावनी: D'oh! सोचा कि यह कोड गोल्फ था ... मेरे जवाब का संपादन अब।

— चेस ब्राउन

अजीब बात है कि को हटाने m=1,o=[1]हिस्सा किसी भी बाइट्स बचत अंत नहीं है एक बार हम स्कोर को कम

— जो राजा

@ राजा: चकले! मैं उम्मीद करता रहा कि उस तरह से स्क्वरिंग करके, मैं एक और बाइट को चीप कर सकता हूं; लेकिन ऐसी कोई किस्मत नहीं!

— चास ब्राउन

Answer 16

डायलॉग एपीएल , स्कोर 2, 20 बाइट्स

{⍵≡⍬:0⋄⌈/≢¨⍵⊂⍨1,2>/⍵}

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

Answer 17

वोल्फ्राम लैंग्वेज (गणितज्ञ) , स्कोर 3, 45 बाइट्स

Max[Length/@SequenceCases[#,x_/;OrderedQ@x]]&

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

SequenceCasesऔर OrderedQखुद से 3 का स्कोर देते हैं, इसलिए दृष्टिकोण को महत्वपूर्ण रूप से बदले बिना स्कोर में सुधार नहीं किया जा सकता है।

Comments

पैटर्न का उपयोग करने का सही तरीका हमें करना होगा Max[Length/@SequenceCases[#,_?OrderedQ]]&, लेकिन _?Orलंबाई की बढ़ती संख्या है 4. (जैसा है _?AnyCamelCaseCommand)।

— मिशा लावरोव

Answer 18

जावा (JDK), 126 बाइट्स, स्कोर 6

golfed

private static int l(byte[] o){int m=0;int c=1;int p=0;for(byte i:o){if(m<c){m=c;}if(i>=p){p= i;c++;}else{c=1;p=0;}}return m;}

Ungolfed

private static int longest(byte[] input) {
    int maxc = 0;
    int consec = 1;
    int prev = 0;
    for (byte i : input) {
        if (maxc < consec) {
            maxc = consec;
        }
        if (i >= prev) {
            prev = i;
            consec++;
        }
        else {
            consec = 1;
            prev = 0;
        }
    }
    return maxc;
}

इनपुट

[112, 114, 105, 118, 97, 116, 101, 32, 115, 116, 97, 116, 105, 99, 32, 105, 110, 116, 32, 108, 40, 98, 121, 116, 101, 91, 93, 32, 111, 41, 123, 105, 110, 116, 32, 109, 61, 48, 59, 105, 110, 116, 32, 99, 61, 49, 59, 105, 110, 116, 32, 112, 61, 48, 59, 102, 111, 114, 40, 98, 121, 116, 101, 32, 105, 58, 111, 41, 123, 105, 102, 40, 109, 60, 99, 41, 123, 109, 61, 99, 59, 125, 105, 102, 40, 105, 62, 61, 112, 41, 123, 112, 61, 32, 105, 59, 99, 43, 43, 59, 125, 101, 108, 115, 101, 123, 99, 61, 49, 59, 112, 61, 48, 59, 125, 125, 114, 101, 116, 117, 114, 110, 32, 109, 59, 125]

Comments

नहीं byteहोना चाहिए int, क्योंकि byte8 बिट्स तक ही सीमित रहेगा?

— जो किंग

@JoKing मुझे बिल्कुल यकीन नहीं है कि आपका क्या मतलब है। क्या आपका मतलब है कि मुझे बाइट क्लास को इंट क्लास में बदलना चाहिए?

— जेडन ली

हां, चूंकि इनपुट पूर्णांक की एक सूची है

— जो किंग

Answer 19

कोटलिन, स्कोर 6, 119 बाइट्स

 fun x(a : IntArray){var m=1;var k=0;var d=1;while(k<a.size-1){if(a[k]<=a[k+1])m++;else{if(d<m)d=m;m=1};k++};println(d)}

ऑनलाइन प्रयास करें

व्याख्या

1. चरण 1: पिछले मान के लिए अगले मान की जाँच करें
2. चरण 2: यदि पिछला मान कम या बराबर है तो जोड़ 1 रखें जबकि स्थिति सत्य है
3. चरण 3: अगली गिनती के साथ पिछली गणना की जाँच करें, चर d में उच्चतम गिनती रखें।

Comments

ठीक है, मुझे मिल गया, मैं इसे शीघ्र ही संपादित करूंगा।

— सैयद हमजा हसन

कृपया जांचें, मैंने एक फ़ंक्शन बनाया है जिसमें इनपुट दिया जा सकता है। मेरे नमूने के अनुसार स्ट्रिंग का उत्तर होगा [2,4,5,6,7,7,7] स्कोर है 7.

— सैयद हमजा हसन

मैंने स्कोर और लिंक अपडेट किया है कृपया जाँच करें।

— सैयद हमजा हसन

ठीक है, मैंने अपडेट दिया।

— सैयद हमजा हसन

आइए हम इस चर्चा को चैट में जारी रखते हैं ।

— जो किंग

Answer 20

कोटलिन, स्कोर 4, 67 बाइट्स

{a:IntArray->var i=0;var p=0;a.map{if(it<p){i=0};p=it;(++i)}.max()}

मुख्य विचार है: सन्निहित उप-अनुक्रमों की लंबाई के लिए प्रत्येक पूर्णांक को ट्रांसफ़ॉर्म करना (जो सख्ती से नहीं) बढ़ रहा है। अधिकतम वापस लौटें।

• a.map{...} - सरणी में प्रत्येक पूर्णांक के लिए
• if(it<p){i=0} - यदि वर्तमान पूर्णांक कम है तो पिछला पूर्णांक, फिर काउंटर रीसेट करें
• p=it - पूर्व में वर्तमान पूर्णांक स्टोर करें
• (++i) - वृद्धि काउंटर और अभिव्यक्ति का वापसी मूल्य
• .max() - अधिकतम लंबाई प्राप्त करें

Answer 21

रूबी , 64 बाइट्स

->e{e.size.downto(1).find{|l|e.each_cons(l).find{|c|c==c.sort}}}

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

Comments

ध्यान दें कि यह कोड-गोल्फ नहीं है । आपके वर्तमान स्कोर है 6। इसके अलावा, आपका कोड खाली सूची (जहां आउटपुट होना चाहिए 0) को नहीं संभालता है

— जो किंग