गूढ़ प्रोग्रामिंग भाषा में घुंघराले, कार्यक्रमों में केवल घुंघराले ब्रेसिज़ {}और अर्धविराम शामिल हैं ;। इस विनम्र टूलसेट के बावजूद, कर्ली के पास ऐसे शाब्दिक हैं जो किसी भी अप्रतिष्ठित पूर्णांक का प्रतिनिधित्व कर सकते हैं। हालांकि, बिन बुलाए पढ़ने के लिए प्रारूप थोड़ा कठिन है, इसलिए चलो हमारे लिए रूपांतरण करने के लिए कुछ कोड लिखें।

संख्या का प्रारूप

निम्नलिखित नियमों के अनुसार घुंघराले नंबर संरचित हैं:

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

कुछ उदाहरण:

{;;}     2*4 = 8
{{;};};  (1*4+1)*4+1 = 21
{};;;    0*4+3 = 3

(ध्यान दें कि नियम 5 का अर्थ है 0 से 3 की संख्या एक खाली जोड़ी वाले घुंघराले ब्रेस के साथ शुरू होनी चाहिए।)

और कुछ अमान्य उदाहरण:

{{;}{;;}}  Curly brace groups side-by-side, not nested
{;}}       Unmatched brace
{;{;}}     Semicolon before curly-brace group
;;;        Number does not start with curly brace

यहाँ घुंघराले संख्या के लिए एक BNF व्याकरण है:

<number> ::= "{" <inner> "}" <semis>
<inner>  ::= <semis>
           | <number>
<semis>  ::= ";" <semis>
           | ""

संख्याएं {;;;;}(एक पंक्ति में 3 से अधिक अर्धविराम) या {{};}(अनावश्यक खाली ब्रेस समूह) को अनुचित कर्ली संख्या कहा जाता है । वे उपरोक्त व्याकरण का पालन करते हैं और सामान्य तरीके से मूल्यांकन किया जा सकता है, लेकिन वे छोटे अभ्यावेदन (उपरोक्त उदाहरणों के लिए, {{;}}और {;}क्रमशः) में भी सक्षम हैं ।

चुनौती

एक प्रोग्राम या फ़ंक्शन लिखें जो इनपुट / एक स्ट्रिंग प्राप्त करता है। यदि स्ट्रिंग एक nonnegative दशमलव पूर्णांक है, तो उस पूर्णांक के लिए उचित (यानी कम से कम संभव) घुंघराले प्रतिनिधित्व को आउटपुट / वापस करें । यदि स्ट्रिंग एक घुंघराले नंबर है, तो आउटपुट / उसका दशमलव प्रतिनिधित्व लौटाता है।

इनपुट STDIN, कमांड-लाइन तर्क या फ़ंक्शन पैरामीटर के माध्यम से प्राप्त किया जा सकता है। यह एक तार होना चाहिए; यह है, आप एक फ़ंक्शन नहीं लिख सकते हैं जो घुंघराले संख्याओं के लिए तार को स्वीकार करता है लेकिन दशमलव संख्या के लिए पूर्णांक।

आउटपुट को STDOUT में प्रिंट किया जा सकता है या फ़ंक्शन से लौटाया जा सकता है। एक फ़ंक्शन उपयुक्त होने पर पूर्णांक लौटा सकता है, या यह सभी स्थितियों में स्ट्रिंग लौटा सकता है।

आपके प्रोग्राम को खराब इनपुट (घुंघराले नंबर जो कि फॉरमेटिंग रूल्स को तोड़ते हैं, फ्लोटिंग पॉइंट नंबर, नेगेटिव पूर्णांक, रैंडम टेक्स्ट) को हैंडल करने की आवश्यकता नहीं है, और अनुचित कर्ली नंबर (लेकिन नीचे देखें) को संभालने की आवश्यकता नहीं है। इनपुट में केवल मुद्रण योग्य ASCII वर्ण शामिल होंगे।

स्कोरिंग

बाइट्स में सबसे छोटा कोड जीतता है। यदि आपका प्रोग्राम निम्न में से दोनों कर सकता है :

सही ढंग से अनुचित घुंघराले संख्या को संभाल, और
जब एक घुंघराले नंबर दिया जाता है, तो किसी भी अतिरिक्त वर्णों को अनदेखा करें जो कि नहीं हैं {};

फिर अपने स्कोर से 10% घटाएं। (इंटेगर इनपुट में कभी भी बाहरी अक्षर नहीं होंगे, यहां तक कि बोनस के लिए भी।)

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

Input       Output
{;;}        8
{{;};};     21
{};;;       3
{{{{;}}};}  260
{}          0
4           {;}
17          {{;}};
1           {};
0           {}
96          {{{;};;}}

बोनस के लिए:

{};;;;;     5
{{;;;;};;}  72
c{u;r;l}y;! 9
42{;} ;;;;  8

_{नोट: कर्ली अभी तक लागू नहीं हुआ है। लेकिन अगर यह सवाल अच्छा है, तो मैं इसे और विकसित कर सकता हूं।}

code-golf number balanced-string

— DLosc
स्रोत

यदि आपको कोष्ठक की संख्या मेल नहीं खा रही है तो इसे कैसे संभालना चाहिए? या मुझे लगता है कि यह कभी नहीं हुआ होगा?

— user902383

@ user902383 आप मान सकते हैं कि गैर-मिलान वाले घुंघराले ब्रेसिज़ कभी नहीं होंगे।

— DLosc

2

मैं एक रेटिना समाधान बनाने जा रहा था, लेकिन इसे एक कर्ली स्ट्रिंग (केवल 20 बाइट्स) को संभालने के बाद, मुझे एहसास हुआ कि इसे सकारात्मक पूर्णांक -> घुंघराले को संभालने की आवश्यकता है, इसलिए मैंने हार मान ली।

— mbomb007

@ डोस हाँ, यह नहीं जीतेगा, इसलिए मैं समय बिताने नहीं जा रहा हूँ।

— mbomb007

@ mbomb007 मैं इस सवाल पर विशेष रूप से था, जहां Pyth समाधान पहले से ही सबसे कम CJam समाधान से 22% कम है और बोनस के लिए अर्हता प्राप्त करता है। वैसे भी, यह कहने के लिए एक बयानबाजी का प्रयास था, "नहीं, लेकिन यह अभी भी मज़ेदार हो सकता है और कुछ उथल-पुथल को बढ़ा सकता है।" यदि आप "मजेदार" भाग से असहमत हैं, हालांकि, यह ठीक है।

— DLosc

15

पायथ, 35 32 बाइट्स - 10% = 28.8

.x.U+jb`HZ*R\;.[Z2jsz4i/R\;cz\}4

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट

संपादित करें: जैसा कि यह निकला, मैं गलती से अनुचित कर्ली नंबरों को भी संभाल सकता हूं। की योजना नहीं बनाई गई थी। ;-)

स्पष्टीकरण:

कोड में दो भाव हैं। पहला एक संख्या को एक घुंघराले संख्या में परिवर्तित करता है, और दूसरा एक घुंघराले संख्या को एक नियमित संख्या में परिवर्तित करता है। .xहैंडल, जो अभिव्यक्ति मुद्रित हो जाता है। यह पहली अभिव्यक्ति को छापने की कोशिश करेगा। यदि इनपुट में कोई गैर-अंक हैं, तो पहली अभिव्यक्ति विफल रहती है (अपवाद के माध्यम से)। .xअपवाद को पकड़ता है और दूसरे को प्रिंट करता है।

.U+jb`HZ*R\;.[Z2jsz4   # number to Curly Number
                 sz    read the input and converts it to an int
                j  4   convert to base 4
            .[Z2       pad zeros on the left, until length is >= 2
        *R\;           convert each digit to ";"s
                       lets call this list of ";"s Y
.U                     reduce this list, start with b=Y[0], 
                       Z iterates over Y[1], Y[2], ..., 
                       update b in each step with:
   jb`H                   put b into curly brackets
  +    Z                  and append Z

i/R\;cz\}4             # Curly Number to regular number
     cz\}              split the input by "}"
 /R\;                  count the ";"s in each string
i        4             convert this list from base 4 to base 10

— Jakube
स्रोत

2

पश्चिम में सबसे तेज़ बंदूक :( मेरे पास यह सटीक समाधान था सिवाय इसके कि मैं भूल गया .[Z2था कि आवश्यक था।

— orlp

12

CJam, 51 47 44 41 बाइट्स

r_'{-_@={i4bYUe[';f*{{}s@*\+}*}{'}/:,4b}?

इसे ऑनलाइन आज़माएँ: नमूना रन था | परीक्षण सूट

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

r        e# Read a token from STDIN.
_'{-     e# Remove all left curly brackets from a copy of the token.
_@       e# Copy the modified token and rotate the original on top of it.
=        e# Check for equality.
{        e# If the strings were equal:
  i4b    e#   Convert to integer, then to base 4.
  YUe[   e#   Left-pad the resulting array with zeroes to a length of 2.
  ';f*   e#   Replace each digit with that many semicolons.
  {      e#   For each string of semicolons but the first:
    {}s  e#     Push the string "{}".
    @    e#     Rotate the first string or the result of the previous 
         e#     iteration on top of the stack.
    *    e#     Join, i.e., surround the string with curly brackets.
    \+   e#     Append the current string of semicolons to the result.
  }*     e#
}{       e# Else:
  '}/    e#   Split the modified input at right curly brackets.
  :,     e#   Replace each run of 0 to 3 semicolons by its length.
  4b     e#   Convert from base 4 to integer.
}?       e#

— डेनिस
स्रोत

7

पायथन 2, 167 बाइट्स - 10% = 150.3

d=lambda x:("{"+d(x//4)+"}"if x>3 else"")+";"*(x%4)
c=lambda n:"{}"*(int(n)<4)+d(int(n))if n.isdigit()else reduce(lambda x,y:x*4+y,[x.count(";")for x in n.split("}")])

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

— ग्रेग हेविल
स्रोत

6

पायथन 266 बाइट्स - 10% = 1268.1 326.7 239.4 बाइट्स

लड़का हूँ मैं नहीं एक कोड गोल्फ खिलाड़ी अभी तक = / है, लेकिन यह 10% की मदद की मुझे बाहर एक बहुत जब मेरे स्कोर अभी भी 1000 से अधिक हो गया था!

मेरे पास इस कोड का पूरी तरह से fleshed out (और verbose) संस्करण है। यह घुंघराले संख्याओं की वैधता की पहचान करेगा, और परीक्षण के लिए संख्याओं को दर्ज करने के लिए एक लूप इंटरफ़ेस प्रदान करेगा।

(स्पष्टीकरण के लिए टिप्पणियाँ)

इस कोड को कार्रवाई में देखें

def c(t):                           # curly to int function
 v=0                                #  int value of input
 for a in t:                        #  for each character of input
  if a==';':v+=1                    #   if you find a ';', add one to total
  if a=='}':v*=4                    #   if you find a '}', multiply total by 4
 print v                            #  print value
def i(t):                           # int to curly function
 v=int(t);f,b="{}"if v<4 else"",""  #  get integer value. initialize front (f) and back (b) strings
 while 1:                           #  loop until stopped
  r,v=v%4,int(v/4)                  #   get remainder of v/4 and int value of v/4
  if r>0:b=';'*r+b                  #   if remainder exists, prepend that many ';' to back string
  if v>0:f=f+'{';b='}'+b            #   if remaining value > 4, append '{' to front and prepend '}' to back
  if v<4:b=';'*v+b;break            #   if remaining value < 4, prepend that many ';' to back string and break
 print f+b                          #  print result
t=raw_input()                       # get raw input
try:int(t);i(t)                     # use try block to determine which function to call
except:c(t)                         #

एक प्रमुख बाइट में कमी के लिए एरिक कोंस्टांटोपोलोस को धन्यवाद! आप कह सकते हैं ... वह वास्तव में एक ... बाइट ... मेरे कोड से बाहर ले गया ... * स्वयं पांच *

— टेलर लोपेज
स्रोत

4

PPCG में आपका स्वागत है! आपके कोड में बहुत सारे अप्रमाणित printकथन और एक टिप्पणी है, आपके चर नाम बहुत लंबे हैं और कुछ व्हाट्सएप को समाप्त किया जा सकता है। मैं भी पिरामिड में गोल्फ के लिए युक्तियाँ पढ़ने की सलाह देता हूं ।

— डेनिस

महान संसाधन, धन्यवाद! मैं इस कोड में उचित बदलाव करूंगा और देखूंगा कि यह मुझे कितना आगे ले जाता है। ऐसा लगता है कि अगर मैं इस साइट पर किसी को भी बनना चाहता हूं, तो मुझे या तो सीजेएम या पायथ सीखने की जरूरत है, या अपनी खुद की भाषा लिखनी चाहिए ।

— टेलर लोपेज

3

@iAmMortos जरूरी नहीं है । अगर आपको यह सुखद लगता है, या नहीं तो अजगर के साथ रहें। :)

— DLosc

2

आमतौर पर, गोल्फिंग तीन चरणों में की जाती है: 1) अपना प्रोग्राम बनाएं जैसे कि आप सामान्य रूप से करेंगे, जितना संभव हो उतना कम से कम (यानी, कोई डिबग स्टेटमेंट, अमान्य इनपुट को संभालने की कोई आवश्यकता नहीं है, न्यूनतम आउटपुट 2) जितना संभव हो उतना हटा दें : व्हॉट्सएप , नाम बदलने चर ( valueकरने के लिए vआदि), 3) चतुर गोल्फ सामान करना : इस बिंदु जहां डेनिस 'क्लिक पर देखने की जरूरत है। मैं यह देखने के लिए उत्सुक हूं कि आप इसे कितना कम कर सकते हैं!

— Sanchises

1

मैंने कभी किसी समुदाय पर इतना गर्मजोशी से स्वागत नहीं किया। योग्य, मुझे लगता है कि मुझे यह पसंद है।

— टेलर लोपेज

4

CJam, 87 बाइट्स 80.1 स्कोर (89 बाइट्स - 10% बोनस)

अद्यतन संस्करण जो 2 बाइट्स बढ़ते हुए बोनस के लिए योग्य है:

l_'{#){VX@{";{}"#)" _@+\ 4* 4/"S/=~}/;}{i_4<{"{}"\';*}{{4md\_{F'{\+'}+}{;L}?\';*+}:F~}?}?

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

पहली बार मैंने CJam में पुनरावृत्ति का इस्तेमाल किया! पूरी बात एक तरह से लंबी लग सकती है, लेकिन दो अलग-अलग रूपांतरण जोड़ते हैं।

मैंने संख्या को 4 से छोटे रूप में परिवर्तित करने के लिए एक पूरी तरह से अलग मामले का उपयोग किया। संभवत: इससे बचना संभव है, लेकिन विशेष मामले को पुनरावर्ती कार्य में मोड़ना पूरी तरह से तुच्छ नहीं होगा। और {}पोस्ट-प्रोसेसिंग कदम के रूप में अतिरिक्त जोड़ना वास्तव में किसी भी बेहतर नहीं दिखता था, भले ही मुझे थोड़ा कम होने पर फिर से कोशिश करनी चाहिए।

— रेटो कोराडी
स्रोत

क्या आपका स्कोर 80.1 नहीं होगा?

— पुरकाकूदरी

4

@ Pietu1998 धन्यवाद। न केवल मेरे समाधान बहुत लंबे हैं, जाहिर है मैं बुनियादी अंकगणित में भी विफल रहता हूं ...

— रेटो कोराडी

3

सी #, 173 - 10% = 155.7 171.0, 177.3

इस के लिए कोई मान्यता और केवल दिखता करता है ;और }अक्षर। यह {किसी भी ;वर्ण से पहले आने वाले सभी पात्रों को मानता है । मुझे सबसे मुश्किल काम {}एक घुंघराले नंबर के बीच में नहीं डालना था।

स्पष्टता के लिए लाइन ब्रेक और इंडेंट:

string C(string a,int b=0){
    int n;
    if(int.TryParse(a,out n))
        a=(n>=b?"{"+C(""+n/4,4)+"}":"")+";;;".Remove(n%4);
    else
        foreach(int c in a)
            a=""+(c==59?++n:c==125?n*=4:n);
    return a;
}

— हाथ-ए-खाना
स्रोत

आप फ़ॉरेस्ट लूप में चार के बजाय var का उपयोग करके एक बाइट बचा सकते हैं।

— raznagul

@ डोस, क्षमा करें, मैं # 1 बोनस से भ्रमित था। हालांकि मैंने इनपुट के बजाय आउटपुट पर लागू किया था।

— हाथ-ई-फूड

2

जावा 326 बाइट्स - 10% = 294 बाइट्स

यह जावा में लिखित पूरा कार्यक्रम है,

public class a{static String c(long a,int v){if(a==0)return v==0?"{}":"";String x="";for(int i=0;i<a%4;i++)x+=";";return "{"+c(a/4,v+1)+"}"+x;}public static void main(String[]c){try{System.out.println(c(Long.parseLong(c[0]),0));}catch(Exception e){System.out.println(c[0].chars().reduce(0,(a,b)->b==';'?a+1:b=='}'?a*4:a));}}}

मुझे यकीन है कि यह बहुत छोटा हो सकता है, लेकिन मुझे इसे अनुकूलित करने के लिए अभी ज्यादा समय नहीं है

— user902383
स्रोत

@ डल लानत, सही, और सोचा कि मैं जावा के साथ एक अच्छा परिणाम हो सकता है :(

— user902383

यह भी: जावा पर आम अनुकूलन से public पहले वर्ग से बचने के लिए है

— masterX244

इसके public static void main(String[]c){साथ बदलेंstatic{

— das_j

2

GNU सेड , 330 326 - 10% = 293.4

(मैंने -rबोनस 10% का दावा करने से पहले उपयोग के लिए एक जोड़ा ; मुझे आशा है कि यह सही है)

/;/{
s/[^};]//g
:c
s/(;*)\}/\1\1\1\1/
tc
:d
/;/{
s/;;;;;/v/g
s/vv/x/g
/[;v]/!s/\b/0/2
s/;;/b/g
s/bb/4/
s/b;/3/
s/v;/6/
s/vb/7/
s/v3/8/
s/v4/9/
y/;bvx/125;/
td
}
n
}
:u
s/\b9/;8/
s/\b8/;7/
s/\b7/;6/
s/\b6/;5/
s/\b5/;4/
s/\b4/;3/
s/\b3/;2/
s/\b2/;1/
s/\b1/;0/
s/\b0//
/[^;]/s/;/&&&&&&&&&&/g
tu
:v
s/;;;;/v/g
s/v+/{&}/
y/v/;/
tv

पूर्ण संस्करण से पता चलता है कि उपरोक्त में से अधिकांश दशमलव और यूनेरी के बीच रूपांतरण है:

#!/bin/sed -rf

/;/{

# Delete non-Curly characters
s/[^};]//g

# Curly to unary
:c
s/(;*)\}/\1\1\1\1/
tc

# unary to decimal
:d
/;/{
s/;;;;;/v/g
s/vv/x/g
/[;v]/!s/\b/0/2
s/;;/b/g
s/bb/4/
s/b;/3/
s/v;/6/
s/vb/7/
s/v3/8/
s/v4/9/
y/;bvx/125;/
td
}

# done
n

}


# Decimal to unary
:u
s/\b9/;8/
s/\b8/;7/
s/\b7/;6/
s/\b6/;5/
s/\b5/;4/
s/\b4/;3/
s/\b3/;2/
s/\b2/;1/
s/\b1/;0/
s/\b0//
/[^;]/s/;/&&&&&&&&&&/g
tu

# Unary to Curly
:v
s/;;;;/v/g
s/v+/{&}/
y/v/;/
tv

— टोबी स्पाईट
स्रोत

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

— टोबे स्पीट

आप सही कह रहे हैं, जो कि मेरे लिए थोड़ा सा आश्चर्यजनक है क्योंकि एकाकी को छोड़कर मेरा इरादा नहीं था। ओह ठीक है, लगता है कि अब सवाल बदलने में बहुत देर हो चुकी है। मैं अपने +1 की पुष्टि करता हूं, श्रीमान।

— १

2

पर्ल, 183 177

यह सबसे छोटा पर्ल उत्तर नहीं हो सकता है, लेकिन मुझे लगता है कि यह पोस्ट करने के लिए काफी दिलचस्प है (इनपुट $_, रिटर्न वैल्यू के रूप में आउटपुट):

sub f{if(/}/){s/[{}]/00/g;oct'0b'.s/00(;+)/sprintf'%02b',length$1/ger}else{$_=sprintf'%064b',$_;s/../oct"0b$&"/ge;s/^0+(?!$)//;$_='{'x length.$_;s/\d/'}'.';'x$&/ge;s/\Q{{}/{/r}}

हम मानते हैं कि कर्ली केवल चतुर्धातुक (आधार -4) अंकन है। पर्टल के लिए क्वाटरनरी के मूल समर्थन में कमी के कारण हम थोड़े परेशान हैं, लेकिन सौभाग्य से, प्रत्येक क्वाटर्नी बाइनरी में दो बिट्स हैं, और हम बाइनरी पढ़ सकते हैं और लिख सकते हैं। तो हमारे पास निम्नलिखित हैं:

घुंघराले दशमलव के लिए: प्रत्येक घुंघराले अंक को 2 बाइनरी अंकों में परिवर्तित करें, संक्षिप्त करें और दशमलव में परिवर्तित करें
दशमलव से घुंघराले: संख्या को बाइनरी में प्रिंट करें (अंकों की एक संख्या के लिए भी), फिर प्रत्येक बिट-जोड़ी को कर्ली में बदलें।

विस्तारित संस्करण

sub f
{
    if (/}/) {
        s/[{}]/00/g;     # digits are now 00 00; 00;; 00;;;
                         # and opening braces become harmless leading zeros
        s/00(;+)/sprintf'%02b',length $1/ge;
                         # convert semicolons to binary, leaving zeros alone
        oct "0b$_"       # now to decimal
    } else {
        $_=sprintf'%064b',$_;   # decimal to binary
        s/../oct"0b$&"/ge;      # bit-pair to quaternit
        s/^0+(?!$)//;           #/remove leading zeros
        $_='{'x length.$_;      # prefix enough opening braces
        s/\d/'}'.';'x$&/ge;     #/digit to semicolons
        s/{{}/{/r               # first empty brace, unless $_ <= {};;;
    }
}

— टोबी स्पाईट
स्रोत

1

जावास्क्रिप्ट (ईएस 6), 95 (105-10%)

f=(n,r='{}')=>-1-n?(n>3?'{'+f(n>>2,'')+'}':r)+';'.repeat(n&3):n.replace(/[;}]/g,c=>c>';'?n*=4:++n,n=0)&&n

नीचे दिए गए स्निपेट का परीक्षण करें

f=(n,r='{}')=>-1-n?(n>3?'{'+f(n>>2,'')+'}':r)+';'.repeat(n&3)
:n.replace(/[;}]/g,c=>c>';'?n*=4:++n,n=0)&&n

// Test
function out(x) { O.innerHTML=x+'\n'+O.innerHTML; }

function go() { out(I.value + ' --> ' + f(I.value)) }

;[ 
  ['{;;}', 8]
, ['{{;};};', 21 ]
, ['{};;;', 3 ]
, ['{{{{;}}};}', 260 ]
, ['{}', 0 ]
, [ 4, '{;}' ]
, [ 17, '{{;}};' ]
, [ 1,'{};' ]
, [ 0, '{}' ]
, [ 96, '{{{;};;}}' ]
, ['{};;;;;', 5 ]
, ['{{;;;;};;}' , 72 ]
, ['c{u;r;l}y;!', 9 ]
, ['42{;} ;;;;', 8 ]
].forEach(t => {
  r=f(t[0])
  k=t[1]
  out('Test ' +(r==k?'OK':'Fail')+'\nInput:  '+t[0]+'\nResult: '+r+'\nCheck:  '+k+'\n')
})

Custom test <input id=I><button onclick='go()'>-></button>
<pre id=O></pre>

स्निपेट का विस्तार करें

— edc65
स्रोत

क्या आप अपना वास्तविक कोड पोस्ट कर सकते हैं? इसके अलावा, आपका स्कोर 94.5 है।

— आउटगॉल्फ

@ErikKonstantopoulos मेरा वास्तविक कोड टेस्ट स्निपेट के शीर्ष पर पोस्ट किया गया था। अब यह जवाब के शीर्ष पर भी है। स्कोर के बारे में (जो बाइट्स में होना चाहिए), मुझे लगता है कि मैं हमेशा आधे (या कम) बाइट को मापता हूं और रौनक पसंद करता हूं

— edc65

edc65: हाँ, लेकिन राउंडिंग आपके लिए बुरा है! 94.5 <95 इस प्रकार छोटे स्कोर, जिसका अर्थ है कि यह शायद अधिक प्रस्तुतियाँ धड़कता है। इसके अलावा, "स्निपेट का शीर्ष" आपके कोड को दिखाने का स्थान नहीं है।

— आउटगोल्फर

1

रूबी, 126.9 129.6 (144 - 10%)

दशमलव को घुंघराले रूप में बदलने के लिए पुनरावर्तन का उपयोग करता है। इस समय /[;{}]/स्कोर बढ़ाने के बाहर पात्रों की अनदेखी के लिए चेक 0.4को हटा देना।

f=->s{s=~/^\d+$/?(n=s.to_i
"{#{n<1?'':f[(n/4).to_s].gsub('{}','')}}#{?;*(n%4)}"):eval(s.tr("^{;}","").gsub(/./){|c|c<?A?"+1":c>?|?")*4":"+(0"})}

— मूल्य स्याही
स्रोत

यह अब तय हो गया है। बग की रिपोर्ट करने के लिए धन्यवाद; स्कोर अपडेट कर दिया गया है।

— वैल्यू इंक

1

पर्ल 5, 154 ( 185 170 बाइट्स - 10% + 1 जुर्माना)

$e=$/;if($_=~/{/){s/[^{};]//g;s/;/+1/g;s/{/+4*(/g;s/}/+0)/g;$b=eval}else{$r=$_;$b=$r<4?"{}":"";while($r>0){if($r%4>0){$r--;$e=";$e"}else{$b.="{";$e="}$e";$r/=4}}}$_=$b.$e

Regex और eval परिलक्षित होते हैं।
कर्ल की पीढ़ी को अलग तरीके से किया जाता है।

परीक्षा

टेस्ट फाइल में बोनस के मामले भी होते हैं

$ cat curlytestcases.txt
{}
{};
{};;
{};;;
{;;}
{{;};};
{{{{;}}};}
0
1
2
3
4
17
96
{};;;;;
42{;} ;;;;
c{u;r;l}y;!
{{;;;;};;}

$ cat curlytestcases.txt |perl -p curlies.pl
0
1
2
3
8
21
260
{}
{};
{};;
{};;;
{;}
{{;}};
{{{;};;}}
5
8
9
72

— LukStorms
स्रोत

-P के लिए -1 जुर्माना जोड़ा गया। $ B = $ r <2; "{}": ""; 0 & 1. {}; के अपवाद के लिए जोड़ा गया था ;; परीक्षण में इनपुट है।

— लुकस्टॉर्म

इसे परखने के लिए कुछ समय चाहिए। यह अब तय हो गया है। :)

— LukStorms

मुझे लगता है कि -10% बोनस के बाद +1 जुर्माना आता है।

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

दिलचस्प अवलोकन। यकीन नहीं है कि अगर यह अब होना चाहिए, लेकिन यह समझ में आता है तो मैंने इसे वैसे भी बदल दिया। ऐसा नहीं है कि यह अंतिम स्कोर बदलता है।

— लुकस्टॉर्म्स

1

रेटिना , 69 64 बाइट्स

+`{(;*)}
$1$1$1$1
^\d+|^(;*)
$*;$.1
+`(;+)\1\1\1
{$1}
^;|^$
{}$&

टेस्ट सूट की कोशिश करो

व्याख्या

+`{(;*)}
$1$1$1$1

बस के लिए अंतरतम ब्रेसिज़ का विरोध करें ;। जब तक अधिक ब्रेसिज़ न हो जाए तब तक लूप करें

^\d+|^(;*)
$*;$.1

दशमलव और यूनरी के बीच कनवर्ट करें ;

+`(;+)\1\1\1
{$1}

सबसे लंबे रन का पता लगाएं, ;4 और ब्रेस्ट में घोंसला का एक बहु है, लूप जब तक कि 4+ से अधिक रन न हों।

^;|^$
{}$&

यदि परिणामी घुंघराले संख्या के साथ शुरू होता है ;या खाली स्ट्रिंग है, तो {}सामने जोड़ें ।

— TwiNight
स्रोत

1

पायथन 2 , 157 बाइट्स -10% = 141.3

lambda n:'{}'*(int(n)<4)+g(int(n))if n.isdigit()else sum((v==';')*4**n.count('}',i)for i,v in enumerate(n))
g=lambda n:'{%s}'%g(n/4)+';'*(n%4)if n>3else';'*n

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

एक अधिक गोल्फ वाला पायथन 2 उत्तर जो बोनस मामलों को संभालता है। एक टिप्पणी के रूप में इस के साथ मृत पदों necro नहीं करना चाहता था, तो यहाँ यह है।

यह घुंघराले नंबरों पर अंदर से काम करता है, 4 ^ (प्रत्येक स्ट्रिंग में बचे हुए अंत में घुंघराले कोष्ठक की संख्या) को जोड़कर प्रत्येक अर्धविराम राशि के लिए योग करता है। यदि स्ट्रिंग एक संख्या है, तो यह पुनरावर्ती रूप से उसी तरह से घुंघराले संख्या को बनाता है जैसे कि व्याकरण प्रदान करता है।

— आर्नोल्ड पाल्मर
स्रोत

वह अजीब है। मैं भी वहाँ कम से कम संख्या के लिए परीक्षण के मामले थे 2. कुल 5 बाइट्स के लिए फिक्स्ड।

— अर्नोल्ड पामर

@ मुझे लगता है कि मैं आमतौर पर यह बुरा नहीं हूँ कसम खाता हूँ। फिक्स्ड, और इसे थोड़ा और अधिक प्रतिस्पर्धी बनाने के लिए थोड़ा सा गढ़ दिया गया।

— अर्नोल्ड पामर

{घुंघराले नंबर};

संख्या का प्रारूप

चुनौती

स्कोरिंग

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

पायथ, 35 32 बाइट्स - 10% = 28.8

स्पष्टीकरण:

CJam, 51 47 44 41 बाइट्स

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

पायथन 2, 167 बाइट्स - 10% = 150.3

पायथन 266 बाइट्स - 10% = 1268.1 326.7 239.4 बाइट्स

CJam, 87 बाइट्स 80.1 स्कोर (89 बाइट्स - 10% बोनस)

सी #, 173 - 10% = 155.7 171.0, 177.3

जावा 326 बाइट्स - 10% = 294 बाइट्स

GNU सेड , 330 326 - 10% = 293.4

पर्ल, 183 177

विस्तारित संस्करण

जावास्क्रिप्ट (ईएस 6), 95 (105-10%)

रूबी, 126.9 129.6 (144 - 10%)

पर्ल 5, 154 ( 185 170 बाइट्स - 10% + 1 जुर्माना)

परीक्षा

रेटिना , 69 64 बाइट्स

व्याख्या

पायथन 2 , 157 बाइट्स -10% = 141.3