यह चुनौती स्टेन ली को श्रद्धांजलि के रूप में सेवा ( एक और ) है, जो 95 वर्ष की आयु में निधन हो गया।

स्टेन ली ने हमें एक अमूल्य विरासत और एक अजीबोगरीब शब्द: एक्सेलसियर छोड़ दिया है । तो यहाँ एक छोटी सी चुनौती है जो उन्होंने कहा कि यह इसके अर्थ पर आधारित है :

अंत में, "एक्सेलसियर" का क्या अर्थ है? "ऊपर और आगे की महिमा के लिए आगे!" जब भी मैं ट्वीट करना समाप्त करता हूं, मैं यही चाहता हूं! एक्सेलसियर!

चुनौती

गैर-नकारात्मक पूर्णांक की एक श्रृंखला को देखते हुए, Excelsior!हर बार जब पूर्णांक पिछले एक से अधिक होता है, तो एक पंक्ति का उत्पादन होता है।

नियम

इनपुट गैर-ऋणात्मक पूर्णांकों की एक सरणी होगी।
आउटपुट में शब्द Excelsior(केस से कोई फर्क नहीं पड़ता) के साथ लाइनों से मिलकर बनता है, जिसके बाद !वर्तमान में तेजी से बढ़ रही संख्याओं की लंबाई होती है। आप स्ट्रिंग्स की एक सरणी भी वापस कर सकते हैं।
इनपुट और आउटपुट प्रारूप साइट के नियमों के अनुसार लचीले होते हैं, इसलिए बेझिझक उन्हें अपने भाषा प्रारूपों में अनुकूलित करें। तुम भी लाइनों के अंत में रिक्त स्थान जोड़ सकते हैं, या यहां तक कि पाठ के पहले या बाद में यदि आवश्यक हो तो अतिरिक्त नई लाइनें।

उदाहरण

Input             Output
-----------------------------------
[3,2,1,0,5]       Excelsior!      // Excelsior because 5 > 0

[1,2,3,4,5]       Excelsior!      // Excelsior because 2 > 1
                  Excelsior!!     // Excelsior because 3 > 2 (run length: 2)
                  Excelsior!!!    // Excelsior because 4 > 3 (run length: 3)
                  Excelsior!!!!   // Excelsior because 5 > 4 (run length: 4)

[]                <Nothing>

[42]              <Nothing>

[1,2,1,3,4,1,5]   Excelsior!      // Excelsior because 2 > 1
                  Excelsior!      // Excelsior because 3 > 1
                  Excelsior!!     // Excelsior because 4 > 3 (run length: 2)
                  Excelsior!      // Excelsior because 5 > 1

[3,3,3,3,4,3]     Excelsior!      // Excelsior because 4 > 3

यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा की जीत के लिए सबसे छोटा कोड हो सकता है!

code-golf string number

— चार्ली
स्रोत

ouflak मानता है कि पूर्णांक 1 अंक लंबा है, यह ठीक है

— ASCII-only

1

@ ASCII- केवल वास्तव में नहीं। मुझे नहीं पता कि LUA के साथ कोई सीमा है, लेकिन अगर ऐसा नहीं है तो ouflak को किसी भी लम्बाई के पूर्णांक को पार्स करना चाहिए।

— चार्ली

@ चेर्ली मैं लूआ को नहीं जानता, लेकिन यद्यपि यह क्रिया है, उदाहरण के लिए एक अंतरिक्ष-सीमांकित इनपुट लेना और इस तरह विभाजित करना संभव है ।

— केविन क्रूज़सेन

मैं इसे देख रहा हूं। चाल दोनों परिदृश्यों को संभालने में सक्षम है।

— ouflak

सीडब्ल्यू या जावास्क्रिप्ट जैसी एफडब्ल्यूआईडब्ल्यू भाषाएँ वैसे भी पूर्णांक (9/16 अंक) के भीतर पूर्णांक संभालेंगी।

— user202729

9

जावास्क्रिप्ट (ईएस 6), 58 54 बाइट्स

a=>a.map(c=>a<(a=c)?`Excelsior${s+='!'}
`:s='').join``

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

टिप्पणी की गई

a =>                           // a[] = input array, also used to store the previous value
  a.map(c =>                   // for each value c in a[]:
    a <                        //   compare the previous value
    (a = c)                    //   with the current one; update a to c
                               //   this test is always falsy on the 1st iteration
    ?                          //   if a is less than c:
      `Excelsior${s += '!'}\n` //     add a '!' to s and yield 'Excelsior' + s + linefeed
    :                          //   else:
      s = ''                   //     reset s to an empty string and yield an empty string
  ).join``                     // end of map(); join everything

पिछले मान को संग्रहीत करने के लिए एक [] का फिर से उपयोग क्यों सुरक्षित है

तीन संभावित मामले हैं:

यदि $a[\text{ }]$ खाली है, तो कॉलबैक फ़ंक्शन .map()बिल्कुल भी लागू नहीं होता है और हमें एक खाली सरणी मिलती है, एक खाली स्ट्रिंग की उपज होती है।
यदि $a[\text{ }]$ में ठीक एक तत्व $x$ , तो यह पहले (और अद्वितीय) परीक्षण के दौरान उस तत्व के लिए बाध्य है a < (a = c)। तो, हम $x < x$ परीक्षण कर रहे हैं , जो मिथ्या है। हमें एक खाली स्ट्रिंग युक्त एक सरणी मिलती है, फिर से एक खाली स्ट्रिंग प्राप्त होती है।
अगर $a[\text{ }]$ में कई तत्व होते हैं, तो यह NaNपहले परीक्षण के दौरान किया जाता है a < (a = c)। इसलिए, परिणाम गलत है और जो निष्पादित किया जाता है वह एक स्ट्रिंग के लिए $s$ का आरंभीकरण है - जो हम चाहते हैं। पहली सार्थक तुलना 2 पुनरावृत्ति पर होती है।

— Arnauld
स्रोत

5

पायथन 2 , 84 83 81 70 68 बाइट्स

a=n=''
for b in input():
 n+='!';n*=a<b;a=b
 if n:print'Excelsior'+n

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

_{-2 बाइट्स, केवल ASCII के लिए धन्यवाद}

— TFeld
स्रोत

68?

— केवल

@

— ASCII-

कार्य बहुत लंबे होते हैं :(

— केवल

कम से कम, पुनरावर्ती दृष्टिकोण कम से कम

— ASCII-only

जिप के साथ भी ऐसा ही है

— ASCII-only

5

05AB1E , 26 24 23 बाइट्स

ü‹γvyOE.•1Š¥èò²•™N'!×«,

-2 बाइट्स @Kroppeb को धन्यवाद ।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

ü                        # Loop over the (implicit) input as pairs
 ‹                       #  And check for each pair [a,b] if a<b is truthy
                         #   i.e. [1,2,1,3,4,1,5,7,20,25,3,17]
                         #   → [1,0,1,1,0,1,1,1,1,0,1]
  γ                      # Split it into chunks of equal elements
                         #  i.e. [1,0,1,1,0,1,1,1,1,0,1]
                         #   → [[1],[0],[1,1],[0],[1,1,1,1],[0],[1]]
   vy                    # Foreach `y` over them
     O                   #  Take the sum of that inner list
                         #   i.e. [1,1,1,1] → 4
                         #   i.e. [0] → 0
      E                  #  Inner loop `N` in the range [1, length]:
       .•1Š¥èò²•         #   Push string "excelsior"
                ™        #   Titlecase it: "Excelsior"
                 N'!×«  '#   Append `N` amount of "!"
                         #    i.e. N=3 → "Excelsior!!!"
                      ,  #   Output with a trailing newline

मेरा यह 05AB1E टिप देखें (अनुभाग संपीड़ित तार शब्दकोश का हिस्सा नहीं कैसे? ) को समझने के लिए क्यों .•1Š¥èò²•है "excelsior"।

— केविन क्रूज़सेन
स्रोत

2

मैं वास्तव में 05AB1E नहीं जानता, लेकिन क्या आप इसके 0Kgसाथ आदान-प्रदान नहीं कर सकते हैं O?

— क्रॉपेब

@ क्रॉपेब आह, पूरी तरह से याद किया, लेकिन हां, मैं वास्तव में कर सकता हूं। धन्यवाद! :)

— केविन क्रूज़सेन

5

पर्ल 6 , 60 58 57 बाइट्स

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

{"Excelsior"X~("!"Xx grep +*,[\[&(-+^*×*)]] .skip Z>$_)}

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

बेनामी कोड ब्लॉक जो एक्सेलर्स की सूची देता है!

— मजाक कर रहा है
स्रोत

4

जावा -8 118 113 बाइट्स

n->{String e="";for(int i=0;i<n.length-1;)System.out.print(""==(n[i+1]>n[i++]?e+="!":(e=""))?e:"Excelsior"+e+"\n");}

पढ़ने में अासान :

private static void lee(int num[]) {
    String exclamation = "";
    for (int i = 0; i < num.length - 1;) {
        exclamation = num[i + 1] > num[i++] ? exclamation += "!" : "";
        System.out.print("".equals(exclamation) ? "" : "Excelsior" + exclamation + "\n");
    }
}

— CoderCroc
स्रोत

2

यहाँ कुछ बाइट्स 10 बाइट्स बचाने के लिए n->{var e="";for(int i=0;i<n.length-1;System.out.print(""==e?e:"Excelsior"+e+"\n"))e=n[i++]<n[i]?e+="!":"";}:। इसे ऑनलाइन प्रयास करें ( 108 बाइट्स )। (जावा 10+)

— केविन क्रूज़सेन

@KevinCruijssen धन्यवाद!

— कोडरकाक

2

n->{for(int e=0,i=0;i<n.length-1;)if(n[i++]<n[i])System.out.println("Excelsior"+"!".repeat(e++));else e=0;}(

— ओलिवियर ग्रेजायर

मेरा मुद्दा ठीक करना: ++eइसके बजाय e++कम से कम एक !मुद्रित होना चाहिए।

— ओलिवियर ग्रेजायर

1

@ केविनक्रूजसेन अपने गोल्फ में छोटे टाइपो आपको एक बाइट हासिल करने के लिए: के e=...?e+"!":बजाय e=...?e+="!":।

— ओलिवियर ग्राएगोइरे

4

आर , 86 बाइट्स

इस उत्तर का आधा @ Giuseppe है। आरआईपी स्टेन ली।

function(a)for(i in diff(a))"if"(i>0,cat("Excelsior",rep("!",F<-F+1),"
",sep=""),F<-0)

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

— J.Doe
स्रोत

4

05AB1E , 20 19 बाइट्स

ü‹0¡€ƶ˜ε'!×”¸Îsiorÿ

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

व्याख्या

ü‹                    # pair-wise comparison, less-than
  0¡                  # split at zeroes
    €ƶ                # lift each, multiplying by its 1-based index
      ˜               # flatten
       ε              # apply to each
        '!×           # repeat "!" that many times
                  ÿ   # and interpolate it at the end of
           ”¸Îsior    # the compressed word "Excel" followed by the string "sior"

— Emigna
स्रोत

4

C (gcc / clang), 106 99 97 बाइट्स

f(a,n)int*a;{int r=0,s[n];for(memset(s,33,n);n-->1;)r*=*a<*++a&&printf("Excelsior%.*s\n",++r,s);}

2 बाइट गोल्फिंग के लिए गैस्ट्रोपनर के लिए धन्यवाद ।

इसे यहाँ ऑनलाइन आज़माएँ ।

Ungolfed:

f(a, n) // function taking a pointer to the first integer and the length of the array
  int *a; { // a is of type pointer to int, n is of type int

    int r = 0, // length of the current run
        i = 0, // loop variable
        s[n];  // buffer for exclamation marks; we will never need more than n-1 of those (we are declaring an array of int, but really we will treat it as an array of char)

    for(memset(s, 33, n); // fill the buffer with n exclamation marks (ASCII code 33)
        n -- > 1; ) // loop over the array

        r *= *a < *(++ a) // if the current element is less than the next:
             && printf("Excelsior%.*s\n", // print (on their own line) "Excelsior", followed by ...
                       ++ r, // ... r (incremented) of the ...
                       s) // ... n exclamation marks in the buffer s
             ; // else r is reset to 0

}

— OOBalance
स्रोत

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

— गैस्ट्रोपनर

@gastropner अपने संस्करण को साझा करने के लिए धन्यवाद। मैंने आपके सुधारों को शामिल किया है और इसे 99 बाइट तक आगे बढ़ाया है। अगर केवल हमें खाली सरणी को संभालने की आवश्यकता नहीं थी - अन्यथा यह लूप की आपकी शैली का उपयोग करके 97 बाइट्स होगा ।

— OOBalance

4

जाप `-R`, 25 22 बाइट्स

ò¨ ËÅ£`ExlÐâ`ú'!Y+A
c

कोशिश करो

कामिल की बदौलत 3 बाइट बच गईं

ò¨                      :Partition at items that are greater than or equal to the previous item
   Ë                    :Map
    Å                   :  Slice off the first element
     £                  :  Map each element at 0-based index Y
      `ExlÐâ`           :    Compressed string "Excelsior"
             ú'!        :    Right pad with exclamation marks
                Y+A     :     To length Y+10
c                       :Flatten
                        :Implicitly join with newlines & output

— झबरा
स्रोत

एक और 25 बाइट्स

— लुइस फेलिप डी जीसस मुनोज़

-Rझंडा वास्तव में आवश्यक नहीं है, चुनौती कहते हैं आप उत्पादन तार की एक सरणी कर सकते हैं।

— कामिल दकरी

अच्छा लगा, धन्यवाद @KamilDrakari। मैंने sliceअपने पहले पास का उपयोग करके एक समाधान की कोशिश की, लेकिन जब यह बहुत लंबा हो गया तो इसे खारिज कर दिया। अब वापस आते हुए, आपके संकेत के साथ, मुझे लगता है कि मुझे इसके साथ अटक जाना चाहिए क्योंकि मैं इसे 22 तक भी नीचे ले आया था।

— झबरा

3

आम लिस्प, 111 बाइट्स

(setq i 0)(loop for(a b)on(read)do(incf i(if(and b(> b a))1(- i)))(format(> i 0)"Excelsior~v@{~a~:*~}~%"i #\!))

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

— रेंज़ो
स्रोत

3

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

n->{String s="",z=s;for(int i=0;i<n.length-1;)z+=n[i++]<n[i]?"Excelsior"+(s+="!")+"\n":(s="")+s;return z;}

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

^{(उन reassignments के s... yikes)}

— NotBaal
स्रोत

आप (s="")+s=>(s="")

— OOBalance

1

n->{String s="",z=s;for(int i=0;i<n.length-1;)z+=n[i++]>=n[i]?s="":"Excelsior"+(s+="!")+"\n";return z;}( १०३ बाइट्स ) बाइट्सs="" को छोड़ें।

— ओलिवियर ग्रेजायर

3

स्टैक्स , 17 बाइट्स

Θx7├╖&σ '@7g┼┘Ñ«═

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

— पुनरावर्ती
स्रोत

3

आर , 111 बाइट्स

function(a,r=rle(sign(diff(a))),v=r$l[r$v>0])write(paste0(rep("Excelsior",sum(v)),strrep("!",sequence(v))),1,1)

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

एक बेहतर आर श्रद्धांजलि यहां मिल सकती है - मुझे भी ठीक किया गया था sequenceऔर rle।

— ग्यूसेप
स्रोत

यह कुछ रिक्त लाइनें नहीं देता है, लेकिन 86 बाइट्स?

— जे। नोवे

2

@ जे। डांग, यह बेहतर तरीका है। अगर मैं तुम होते तो मैं खुद को पोस्ट करता।

— Giuseppe

3

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

<Ɲṣ0ÄẎ”!ẋ“Ø6ḥ»;Ɱ

पात्रों की सूचियों की एक सूची देने वाला एक अद्वैत लिंक।

इसे ऑनलाइन आज़माएं!(पाद लेख newlines के साथ मिलती है)

कैसे?

<Ɲṣ0ÄẎ”!ẋ“Ø6ḥ»;Ɱ - Link: list of integers     e.g. [1,1,4,2,1,1,3,4]
 Ɲ               - for each pair of integers:      [1,1] [1,4] [4,2] [2,1] [1,1] [1,3] [3,4]
<                -   less than?                    [  0,    1,    0,    0,    0,    1,    1]
  ṣ0             - split at zeros                  [[],    [1],     [],   [],      [1,    1]]
    Ä            - cumulative sums                 [[],    [1],     [],   [],      [1,    2]]
     Ẏ           - tighten                         [1,1,2]
      ”!         - literal '!' character           '!'
        ẋ        - repeat (vectorises)             [['!'],['!'],['!','!']]
         “Ø6ḥ»   - dictionary lookup               ['E','x','c','e','l','s','i','o','r']
               Ɱ - map with:
              ;  -   concatenate                   [['E','x','c','e','l','s','i','o','r','!'],['E','x','c','e','l','s','i','o','r','!'],['E','x','c','e','l','s','i','o','r','!','!']]

— जोनाथन एलन
स्रोत

3

पर्ल 5 `-n` , 41 बाइट्स

$_>$l&&$l?say$c.='!':($c=Excelsior);$l=$_

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

इसके इनपुट को अलग-अलग लाइनों पर ले जाता है।

— Xcali
स्रोत

3

जाप , 22 बाइट्स

ò¨ ®£`ExlÐâ`+'!pYÃÅÃc

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

स्पष्टीकरण, सरलीकृत उदाहरण के साथ:

ò¨                       :Split whenever the sequence does not increase
                           e.g. [2,1,1,3] -> [[2],[1],[1,3]]
   ®               Ã     :For each sub-array:
    £            Ã       :  For each item in that sub-array:
     `ExlÐâ`             :    Compressed "Excelsior"
            +            :    Concat with
             '!pY        :    a number of "!" equal to the index
                               e.g. [1,3] -> ["Excelsior","Excelsior!"]
                  Å      :  Remove the first item of each sub-array
                            e.g. [[Excelsior],[Excelsior],[Excelsior,Excelsior!]]->[[],[],[Excelsior!]]
                    c    :Flatten
                           e.g. [[],[],[Excelsior!]] -> [Excelsior!]

— कामिल दकरी
स्रोत

3

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

$args|%{if($o-ne$e-and$_-gt$o){'Excelsior'+'!'*++$c}else{$c=0}$o=$_}

कम गोल्फ परीक्षण स्क्रिप्ट:

$f = {

$args|%{
    if($old-ne$empty-and$_-gt$old){
        'Excelsior'+'!'*++$c
    }else{
        $c=0
    }
    $old=$_
}

}

@(
    ,( (3,2,1,0,5),  'Excelsior!')      # Excelsior because 5 > 0

    ,( (1,2,3,4,5),  'Excelsior!',      # Excelsior because 2 > 1
                    'Excelsior!!',     # Excelsior because 3 > 2 (run length: 2)
                    'Excelsior!!!',    # Excelsior because 4 > 3 (run length: 3)
                    'Excelsior!!!!')   # Excelsior because 5 > 4 (run length: 4)

    ,( $null,         '')                # <Nothing>

    ,( (42),          '')                # <Nothing>

    ,( (1,2,1,3,4,1,5), 'Excelsior!',      # Excelsior because 2 > 1
                        'Excelsior!',      # Excelsior because 3 > 1
                        'Excelsior!!',     # Excelsior because 4 > 3 (run length: 2)
                        'Excelsior!')      # Excelsior because 5 > 1

    ,( (3,3,3,3,4,3),   'Excelsior!')      # Excelsior because 4 > 3
) | % {
    $a,$expected = $_
    $result = &$f @a
    "$result"-eq"$expected"
    $result
}

आउटपुट:

True
Excelsior!
True
Excelsior!
Excelsior!!
Excelsior!!!
Excelsior!!!!
True
True
True
Excelsior!
Excelsior!
Excelsior!!
Excelsior!
True
Excelsior!

— Mazzy
स्रोत

1

यह वहाँ है, मैं काम करने के लिए एक लैग पॉइंटर प्राप्त करने की कोशिश कर रहा था, लेकिन यह नहीं सोच सकता कि कैसे।

— विस्कह

3

पॉवरशेल , 87 85 बाइट्स

param($n)for(;++$i-lt$n.count){if($n[$i]-gt$n[$i-1]){"Excelsior"+"!"*++$c}else{$c=0}}

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

वहाँ शायद एक पुनर्गठन में छिपा है, सबसे अधिक संभावना में अगर-और, लेकिन कुल मिलाकर बहुत ठीक है। सूचकांक और दोनों को बनाने के लिए ol '' '' अन-इंस्टेंटिअटेड वैरिएबल डिफॉल्ट्स टू 0 '' ट्रिक का उपयोग करता है !।

— Veskah
स्रोत

2

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

\d+
*
L$rv`(_*,(?<!(?(1)\1|\2,)))+(_+)\b
Excelsior$#1*!

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

\d+
*

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

rv`(_*,(?<!(?(1)\1|\2,)))+(_+)\b

मैचों को दाएं से बाएं ओर ओवरलैप करने की प्रक्रिया (हालांकि मैच फिर बाएं से दाएं सूचीबद्ध होते हैं)। इसका मतलब है कि हम हर नंबर को एक रन में मैच कर सकते हैं, और मैच रन की शुरुआत तक फैला हुआ है। प्रत्येक मैच को और अधिक विवश किया जाता है कि प्रत्येक अतिरिक्त मिलान की गई संख्या पहले से मिलान की गई अतिरिक्त संख्या से कम होनी चाहिए, या यदि कोई अतिरिक्त संख्या अभी तक मिलान नहीं हुई है तो पहली संख्या होगी।

L$...
Excelsior$#1*!

प्रत्येक मैच के लिए, Excelsiorवांछित के रूप में रन में अतिरिक्त संख्या की संख्या के साथ आउटपुट ।

— नील
स्रोत

2

पायथ, 32 बाइट्स

j+L"Excelsior"*L\!fT.u*hN<0Y.+Q0

इसे यहाँ ऑनलाइन आज़माएँ , या यहाँ पर सभी परीक्षण मामलों को सत्यापित करें ।

j+L"Excelsior"*L\!fT.u*hN<0Y.+Q0   Implicit: Q=eval(input())
                            .+Q    Get forward difference between consecutive elements of Q
                    .u         0   Reduce the above, returning all steps, with current value N starting at 0, next element as Y, using:
                       hN            N+1
                      *              Multiplied by
                         <0Y         1 if 0<Y, 0 otherwise
                  fT               Filter to remove 0s
              *L\!                 Repeat "!" each element number of times
 +L"Excelsior"                     Prepend "Excelsior" to each
j                                  Join on newlines, implicit print

— सोक
स्रोत

2

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

<Ɲ‘×¥\ḟ0”!ẋ“Ø6ḥ»;Ɱ

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

आउटपुट टीआईओ के ऊपर पूर्वनिर्धारित था।

— आउटगोल्फ को एरिक करें
स्रोत

2

लुआ , 88 87 83 82 96 95 113 बाइट्स

मूल प्रश्न की भावना का पालन करने के लिए धन्यवाद @ केविन क्रूज़सेन।

s=io.read()n=9 e="Excelsior!"f=e
for c in s.gmatch(s,"%S+")do if n<c+0then print(e)e=e..'!'else e=f end n=c+0 end

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

— ouflak
स्रोत

1

क्षमा करें, लेकिन आपको नियमों के अनुसार विस्मयादिबोधक चिह्न को प्रिंट करने की आवश्यकता है (तेजी से अधिक संख्या के वर्तमान रन की लंबाई के अनुसार एक विस्मयादिबोधक चिह्न)।

— चार्ली

कोई दिक्कत नहीं है। मुझे लगता है कि मैंने यहां जितना कुछ किया है, जब तक कोई और कुछ नहीं देखता ...

— ouflak

1

मैं लुआ को बहुत अच्छी तरह से नहीं जानता, लेकिन यहां आपके कोड के लिए एक फिक्स है, इसलिए यह सभी परीक्षण मामलों को सही ढंग से चलाता है। वर्तमान में आप बस एक "प्रिंट करते हैं!" हर बार एक संख्या पिछले की तुलना में अधिक होती है, लेकिन जब ऐसा नहीं होता है तो आप इसे वापस 1 पर रीसेट नहीं करते हैं। अधिक शायद गोल्फ हो सकता है, लेकिन चूंकि मैंने लुआ में कभी गोल्फ नहीं खेला है, इसलिए मैंने इसे केवल मामूली गोल्फों के साथ तय करने पर ध्यान केंद्रित किया है। पुनश्च: यकीन है कि अगर इनपुट हमेशा एकल अंक सही हैं मान रहे हैं ..

— केविन क्रूज़सेन

2

चूँकि @ चेरली ने चुनौती वर्णन के नीचे एक टिप्पणी में उल्लेख किया है कि इनपुट के रूप में बहु-अंकीय संख्याओं को लेना संभव होना चाहिए, यहाँ स्पेस-सीमांकित इनपुट लेने और उस पर विभाजित करने से एक संभावित निर्धारण हो सकता है ।

— केविन क्रूजेसेन

मैंने फैसला किया कि केविन क्रूज़सेन संशोधन ओपी की अपेक्षा के साथ अधिक इनलाइन हैं। धन्यवाद!

— 15

2

सी ++ 14 (जी ++), 123 118 बाइट्स

[](auto a){for(int n=0,i=0;++i<a.size();)a[i]>a[i-1]?puts(&("Excelsior"+std::string(++n,33))[0]):n=0;}

सौभाग्य std::stringसे एक कंस्ट्रक्टर है जो दोहराता है char। इसे यहाँ ऑनलाइन आज़माएँ ।

गैस्ट्रोपनर के लिए धन्यवाद5 बाइट बचाने ।

Ungolfed:

[] (auto a) { // void lambda taking a std::array of integer

    for(int n = 0, // length of the current run
        i = 0; // loop variable
        ++ i < a.size(); ) // start with the second element and loop to the last
        a[i] > a[i - 1] // if the current element is greater than the previous ...
        ? puts( // ... print a new line:
               &("Excelsior" + // "Excelsior, followed by ...
                std::string(++ n, 33)) // ... the appropriate number of exclamation marks (33 is ASCII code for '!'); increment the run length
               [0]) // puts() takes a C string
        : n = 0; // else reset run length

}

— OOBalance
स्रोत

आप एक और 5 बाइट्स

— गैस्ट्रोपनर

2

सी # (.NET कोर) , 115 107 105 बाइट्स

a=>{var b="";for(int i=0;++i<a.Length;)if(a[i]>a[i-1])Console.WriteLine("Excelsior"+(b+="!"));else b="";}

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

-8 बाइट्स: एक स्ट्रिंग होल्डिंग में बदल b गया! "" एक इंट काउंटर से
-2 बाइट्स से: एक इनलाइन फ़ंक्शन के रूप में सेट b+="!" किया गया ( Zac Faragher के लिए धन्यवाद )

इनपुट में खींचने के लिए एक्शन प्रतिनिधि का उपयोग करता है और रिटर्न की आवश्यकता नहीं होती है।

Ungolfed:

a => {
    var b = "";                         // initialize the '!' string (b)
    for(int i = 0; ++i < a.Length;)     // from index 1 until the end of a
        if(a[i] > a[i - 1])                 // if the current index is greater than the previous index
            Console.WriteLine("Excelsior" +     // on a new line, print "Excelsior"
                                    (b += "!"));    // add a "!" to b, and print the string
        else                                // if the current index is not greater than the previous index
            b = "";                             // reset b
}

— Meerkat
स्रोत

1

आप b+="!"एक्सेलसियर के साथ इनलाइन बनाकर 2 बाइट बचा सकते हैंif(a[i]>a[i-1])Console.WriteLine("Excelsior"+(b+="!")); इसे ऑनलाइन आज़माएं!

— ज़ैक फ़रागेर

2

पीएचपी , 117 109 बाइट्स

<?php do{$i=next($argv);if($p!==null&&$p<$i){$e.='!';echo "
Excelsior$e";}else$e='';$p=$i;}while($i!==false);

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

— scoots
स्रोत

2

जे, 50 बाइट्स

'Excelsior',"1'!'#"0~[:;@(([:<+/\);._1)0,2</\ ::0]

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

ungolfed

'Excelsior' ,"1 '!' #"0~ [: ;@(([: < +/\);._1) 0 , 2 </\ ::0 ]

— जोनाह
स्रोत

1

जावा, 113 बाइट्स

String i="";for(int a=0;a<s.length-1;a++){if(s[a+1]>s[a]){i+="!";System.out.println("Excelsior"+i);}else{i="";}}

— isaace
स्रोत

1

VBA, 114 बाइट्स

For i=0 To UBound(a)-LBound(a)-1 If a(i+1)>a(i)Then s=s&"!" Debug.Print("Excelsior"&s&"") Else s="" End If Next i

— isaace
स्रोत

दुर्भाग्य से, यह एक वैध समाधान नहीं है क्योंकि यह स्पष्ट रूप से परिभाषित चर होने पर निर्भर करता है a,। उस ने कहा, यदि आप फ़ंक्शन को एक के रूप में परिभाषित करते हैं subroutineजो इनपुट को अपेक्षित प्रकार के सरणी के रूप में लेता है, तो आप अपने दृष्टिकोण को एक वैध समाधान में बदल सकते हैं। उस दृष्टिकोण का एक गोल्फ संस्करण sub f(x) For i=0To UBound(x)-1 If x(i+1)>x(i)Then s=s+"!":Debug.?"Excelsior"s:Else s="" Next End Sub, जहां कोड ब्लॉक के बीच विराम नई लाइनों का प्रतिनिधित्व करता है

— टेलर स्कॉट

1

पायथन 3, 87 बाइट्स

c='!'
for i in range(1,len(n)):
    if n[i]>n[i-1]:print('Excelsior'+c);c+='!'
    else:c='!'

या 97 निम्नलिखित के साथ:

c='!';n=input()
for i in range(1,len(n)):
    if n[i]>n[i-1]:print('Excelsior'+c);c+='!'
    else:c='!'

यह मानता है कि इनपुट प्रारूप में होगा:

32105
12345
<null input>
1
1213415
333343

— हेनरी टी
स्रोत

1

आपका पहला कार्यक्रम अमान्य है क्योंकि यह पूर्वनिर्धारित चर के माध्यम से इनपुट लेता है। दूसरा अमानवीय है क्योंकि यह कई अंकों के साथ संख्याओं के बीच अंतर नहीं कर सकता है। पायथन 2 का उपयोग क्यों न करें या इसके बजाय इसे फ़ंक्शन में बदल दें ?

— जो राजा

1

जाप , 25 बाइट्स

ä< ®?`ExlÐâ`+'!p°T:T=0
f

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

— ओलिवर
स्रोत

अधिक से अधिक महिमा के लिए आगे और आगे!

चुनौती

नियम

उदाहरण

जावास्क्रिप्ट (ईएस 6), 58 54 बाइट्स

टिप्पणी की गई

पिछले मान को संग्रहीत करने के लिए एक [] का फिर से उपयोग क्यों सुरक्षित है

पायथन 2 , 84 83 81 70 68 बाइट्स

05AB1E , 26 24 23 बाइट्स

पर्ल 6 , 60 58 57 बाइट्स

जावा -8 118 113 बाइट्स

आर , 86 बाइट्स

05AB1E , 20 19 बाइट्स

C (gcc / clang), 106 99 97 बाइट्स

जाप -R, 25 22 बाइट्स

आम लिस्प, 111 बाइट्स

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

स्टैक्स , 17 बाइट्स

आर , 111 बाइट्स

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

कैसे?

पर्ल 5 -n , 41 बाइट्स

जाप , 22 बाइट्स

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

पॉवरशेल , 87 85 बाइट्स

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

पायथ, 32 बाइट्स

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

लुआ , 88 87 83 82 96 95 113 बाइट्स

सी ++ 14 (जी ++), 123 118 बाइट्स

सी # (.NET कोर) , 115 107 105 बाइट्स

पीएचपी , 117 109 बाइट्स

जे, 50 बाइट्स

ungolfed

पायथन 3, 87 बाइट्स

जाप , 25 बाइट्स

जाप `-R`, 25 22 बाइट्स

पर्ल 5 `-n` , 41 बाइट्स