आउटपुट संख्या, कम या ज्यादा

Question

चुनौती

इनपुट स्ट्रिंग (या सरणी) को देखते हुए <और >पूर्णांक के अनुक्रम (सरणी या स्ट्रिंग) को आउटपुट करता है जैसे:

• आउटपुट में लगातार संख्याओं के बीच क्रम में लागू होने पर ऑपरेटर सभी सही होते हैं
• सभी पूर्णांक सकारात्मक हैं (1 या अधिक)
• पूर्णांकों का योग उतना ही छोटा है जितना गणितीय रूप से संभव है

इनपुट आपकी चुनी हुई भाषा में "से अधिक" और "से कम" से भिन्न हो सकते हैं।

वैकल्पिक आउटपुट के रूप में, आउटपुट में संख्याओं का योग निर्दिष्ट करें। राज्य जो आपके उत्तर शीर्षक में हल कर रहे हैं।

सामान्य बहिष्करण और नियम लागू होते हैं, सबसे छोटी बाइट्स जीतती हैं।

आप यह मान सकते हैं कि इनपुट स्ट्रिंग कभी भी आपकी भाषा में पूर्णांक ओवरफ़्लो की ओर नहीं ले जाएगी, यदि वह मदद करती है।

उदाहरण

• >2 1जो देता है3
• >>>4 3 2 1जो देता है10
• ><2 1 2जो देता है5
• 1जो देता है1
• >>>>>>>>>10 9 8 7 6 5 4 3 2 1जो देता है55
• >><<>><>>>3 2 1 2 3 2 1 4 3 2 1जो देता है24
• ><>><>><>2 1 3 2 1 3 2 1 2 1जो देता है18
• <<<<>1 2 3 4 5 1जो देता है16
• <<<<><<>1 2 3 4 5 1 2 3 1जो देता है22
• >><<3 2 1 2 3जो देता है11

Comments

क्या हम इसके अलावा >और प्रतीकों का उपयोग कर सकते हैं <?

— आउटगोल्फर

@JonathanAllan मुझे लगता है कि यह ऐसे उदाहरण हैं जो गलत हैं, और आपको यह मान लेना चाहिए कि जवाब देते समय, यह नहीं कि कल्पना गलत है। संपादित करें: ठीक है, फिर मुझे डर है कि वे अमान्य हैं, क्योंकि यह वह युक्ति है जो चुनौती को परिभाषित करती है, परीक्षण के मामलों को नहीं।

— आउटगोल्फर

बस <> <में एक उत्तर के लिए प्रतीक्षा कर रहा है।

— खुल्द्रेसथ न'बर्या

उदाहरणों को गड़बड़ाने के लिए सभी से क्षमा याचना! अन्य पात्रों के लिए, हाँ, बशर्ते आपकी भाषा में उनका वही अर्थ हो

— simonalexander2005

@Sroroble आपने इसे गलत बताया। यह><>

— जो किंग

Answer 1

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

0;+×¥@\
=”<µCṚÇṚ»Ç‘

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

प्रत्येक संख्या का मूल्य है अधिकतम ( की संख्या >इसके बारे में सही करने के लिए तुरंत , की संख्या <में यह के बाईं ओर तुरंत ) + 1 ।

---

वैकल्पिक रूप से ...

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

Comments

मुझे ऐसी भाषाएं पसंद नहीं हैं जिनके लिए स्टैक्स की तरह ट्रांसपाइल के प्रोग्राम की जरूरत हो ... ठीक है, जेली बॉर्डरलाइन है। (स्ट्रिंग्स को संपीड़ित करने के लिए एक कार्यक्रम की आवश्यकता होती है) कम से कम, जेली अभी भी जीतती है।

— user202729

डेनिस को छोड़कर, जो हाथ से तार को संपीड़ित करता है।

— user202729

वास्तव में, मैं वास्तव में इसे पसंद नहीं करता। लेकिन मुझे एक गोल्फ की भाषा में सबसे ज्यादा पसंद है वह चीज जो इसके कार्यक्रमों को सबसे छोटा होने की अनुमति देती है। मेरे पास अभी भी इस बारे में कुछ विचार करने के लिए कुछ उपाय हैं ...

— पुनरावर्ती

Answer 2

> <> , 40 38 बाइट्स

1v!rnr~<oa
?\i:0(?^3%\+$
{/?:-{:}-1/1:

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

एक उपयुक्त भाषा। संदर्भ के लिए ><>स्वयं 2,1,2,1 उपज देता है।

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

1v   Initialise the stack as 1 and enter loop
 \i:0(?^  If we're out of input, go to the first line
        3%\ Otherwise mod the input by 3, yielding 0 for < and 2 for >
        -1/Subtract 1 to get -1 and 1 respectively
    -{:}   Copy the previous number and subtract the above from it

 /?:    If the number is not 0, repeat the loop

?\        \+$  Otherwise:
                Increment each number until we reach the original 0
{/        /1:   And enter the first loop again

      ~<    When we're out of input, pop the extra -1 from EOF
   rnr      Output the first number
1v!         Push a 1 
        oa  Print a newline and repeat, popping the extra 1 each time

Comments

+1 यह बताने के लिए कि भाषा अपने आप में क्या मान रखती है। :) (और क्योंकि यह रूप में अच्छी तरह सिर्फ एक अच्छा जवाब है, नहीं तो मैं इसे + 1-एड नहीं होती।)

— केविन Cruijssen

Answer 3

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

k=0
for r in input().split('<'):p=len(r);print(max(k,p)+1,*range(p,0,-1),end=' ');k=1+(p<1)*k

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

unscrambled:

# offset, will be explained later
k = 0 
for run in input().split('<'):
    # p = length of sequence of '>'s, which will produce p+1 decreasing integers
    p = len(run)
    # will print:
    # p+1 p p-1 ... 1    or    k+1 p p-1 ... 1
    print(max(k, p) + 1, *range(p, 0, -1), end=' ')
    # offset of the next sequence: (i.e. -1 + the minimal value of the first integer)
    k = 1 + (k if p > 0 else 0)

Comments

यह मेरा पहला गोल्फ है!

— फोंस

Answer 4

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

n%">"=r[1..n]
n%"<"=[1..n]
n%(c:b)|c==b!!0=(n+1)%b|a:s<-2%b,e:z<-r$n%[c]=r z++last(max:[min|c>'<'])a e:s
r=reverse
(2%)

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

व्याख्या

यहां विचार यह है कि हमारे पास >या तो एस या <एस के रन हैं , जो प्रत्येक नक्शे को आरोही और अवरोही श्रेणियों तक ले जाते हैं। इसलिए हम groupस्ट्रिंग को लगातार वर्णों के समूहों में विभाजित करने के लिए उपयोग करते हैं। हमारा काम तो उचित फैशन में एक साथ इन सिलाई है।

जब हमारे पास होता है <>हम उदाहरण के लिए बड़ा अंत मान लेते हुए दो सूचियों को एक साथ सिलाई करना चाहते हैं

<<<<<<>>

विभाजित है

<<<<<<  >>

रेंज में मैप किया गया

[1,2,3,4,5,6,7] [3,2,1]

फिर जब हम सिलाई करते हैं तो हम गिर जाते हैं 3क्योंकि यह छोटा होता है ( 3इससे बड़ा नहीं होता 7)।

 [1,2,3,4,5,6,7,2,1]

जब हमारे पास ><इसके विपरीत होता है, तो हम बड़े मूल्य को छोड़ देते हैं।

वास्तविक कोड एक ऑपरेटर बनाकर इसे प्राप्त करता है %। की परिभाषा %काफी जटिल है, लेकिन मूल रूप से यह बाएं से दाएं रखते हुए पढ़ता है कि लगातार कितने अक्षर समान हैं। यह ऑपरेटर के मूल्य में ऐसा करता है। जब हम किसी ऐसे स्थान पर पहुँचते हैं जहाँ अक्षर बदलते हैं तो हम सिलाई का प्रदर्शन करते हैं जैसा मैंने बताया।

Comments

अंतिम पंक्ति का उद्देश्य क्या है (2%)?

— सिराकुसा

@ सिराकुसा यही फंक्शन है। यह एक pointfree समारोह है, तो यह मूल रूप कॉल कहते हैं %के साथ 2पहले तर्क के रूप में।

— पोस्ट रॉक गार्फ हंटर

क्या यह एक सामान्य प्रथा है कि केवल एक पूर्ण mainकार्यान्वयन जोड़ने के बजाय अंतिम फ़ंक्शन कॉल को अंतिम पंक्ति पर रखा जाए?

— सिराकुसा

@ सिराकुसा हां। प्रस्तुतियाँ नामित कार्यों, अनाम फ़ंक्शन या पूर्ण कार्यक्रमों के रूप में अनुमत हैं। यह एक अनाम फ़ंक्शन है। मैं अनाम को केवल इसलिए चुनता हूं क्योंकि यह सबसे छोटा है।

— पोस्ट रॉक गार्फ हंटर

@ सिराकुसा हास्केल में गोल्फिंग नियमों के बारे में हमारी गाइड देखें ।

— लैकोनी

Answer 5

रेटिना 0.8.2 , 36 बाइट्स

1
{`\b(1+)>\1
1$&
}`(1+)<\1\b
$&1
1

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

1

एस और एस के 1बीच, पहले और बाद में <एस डालें >।

{`\b(1+)>\1
1$&
}`(1+)<\1\b
$&1

सभी तुलनाओं के संतुष्ट होने तक बार-बार वृद्धि पूर्णांक।

1

पूर्णांकों को जोड़ो और दशमलव में बदलो।

Answer 6

जावा 10, 198 181 बाइट्स

s->{var p=s.split("(?<=(.))(?!\\1)");int l=p.length,L[]=new int[l],i=l,r=0,a,b;for(;i-->0;r+=a*-~a/2-(i<l-1?p[i].charAt(0)<61?a<(b=L[i+1])?a:b:1:0))a=L[i]=p[i].length()+1;return r;}

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

स्पष्टीकरण:

s->{                      // Method with String parameter and integer return-type
  var p=s.split("(?<=(.))(?!\\1)");
                          //  Split the String into parts
                          //  (i.e. ">><<>><>>>" becomes [>>, <<, >>, <, >>>])
  int l=p.length,         //  Get the amount of parts
      L[]=new int[l],     //  Create an integer-array of the same size
      i=l,                //  Index-integer, starting at this size
      r=0,                //  Result-integer, starting at 0
      a,b;                //  Two temp integers to reduce the byte-count
  for(;i-->0;             //  Loop downwards over the array; range: (`l`,0]
      ;r+=                //    After every iteration: increase the result with:
          a*-~a/2         //     The triangle number of the current item
        -(i<l-1?          //     If it's not the last item:
           p[i].charAt(0)<61?
                          //      And the order of the current and previous is "<>":
            a<(b=L[i+1])? //       If the current item in `L` is smaller than the previous:
             a            //        Subtract the current item
            :             //       Else (the current is equal or larger than the previous):
             b            //        Subtract the previous item
           :              //      Else (the order of the two parts is "><" instead):
            1             //       Subtract 1
          :               //     Else (it's the last item in `L`):
           0))            //      Leave the result `r` unchanged
    a=L[i]=               //   Set both `a` and the current item in `L` to:
     p[i].length()+1;     //    The length of the part + 1
  return r;}              //  Return the result

Answer 7

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

r=reverse
s#c=(+1).length.takeWhile(==c)<$>scanr(:)[]s
f s=zipWith max(s#'>')$r$r s#'<'

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

मेरे जेली उत्तर का एक बंदरगाह।

Comments

आप 3 बाइट्स ले सकते हैं

— पोस्ट रॉक गार्फ हंटर

@ user56656 धन्यवाद!

— 14:20 बजे user202729

Answer 8

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

éda╓~/└↨☺∟╒←║ç Γφ5←9h

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

यह इनपुट को रन-लंबाई एन्कोडिंग द्वारा काम करता है, और फिर एक साथ उत्पन्न पर्वतमाला को समतल करता है। अनपैक्ड, अनगुल्फेड और टिप्पणी की गई, यह इस तरह दिखता है।

|R      run-length encode
{       begin block
  H^R   range from [1 .. run length]
  _hh|1 -1 ** (character code / 2)
  *     multiply run; this will reverse it iff character is '>'
m       map runs using preceding block
O       push a 1 under the top of stack
{       begin block
  h|M   get the start of the generated range, and take max of it and top of stack
  _DE   push the rest (tail) of the generated range to the stack
F       foreach generated range
L|+     sum of all values on the stack

इसको चलाओ

Answer 9

पर्ल 5 -p , 53 बाइट्स

#!/usr/bin/perl -p
s//1/g;1while s/(?=\b(1+)>\1)|(1+)<\2\b\K/1/;$_=y/1//

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

Comments

ऐसा लगता है कि यह चुनौती विनिर्देश के बजाय परीक्षण मामलों के आधार पर लागू किया गया है। दुर्भाग्य से, उन्हें गलत के रूप में पहचाना गया है ।

— एरिक आउटोलॉफ़र

@EriktheOutgolfer फिक्स्ड

— टन हास्पेल

Answer 10

लाल , 185 बाइट्स

func[s][repeat n 1 + length? s[l: 0 i: n - 1 while[i > 0 and(s/(i) = #"<")][i:  i - 1 l: l + 1]r: 0 i: n while[(i <= length? s)and(s/(i) = #">")][i: i + 1 r:
r + 1]prin[1 + max l r""]]]

User202729 के स्पष्टीकरण के बाद ...

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

f: func[s][
   repeat n 1 + length? s[
       l: 0
       i: n - 1
       while [i > 0 and (s/(i) = #"<")][ 
           i: i - 1
           l: l + 1
        ]
        r: 0
        i: n
        while [(i <= length? s) and (s/(i) = #">")][
            i: i + 1
            r: r + 1
        ]
        prin[1 + max l r ""]
    ]
]