परिचय

जब मैं टीवी देख रहा था, तब मैंने दूसरे दिन इस (बेकार) पैटर्न को ठोकर मार दी। मैंने इसे "9 पैटर्न" नाम दिया क्योंकि इसका उपयोग करने वाला पहला नंबर था 9. इसका सार यह है कि, आप एक संख्या दर्ज करते हैं (मान लीजिए x ), और फिर आप वापस आ गए:

एक्स
x + ( x / 3) [चलो इस y को कॉल करें ]
दो तिहाई y [चलो इस z को कॉल करें ]
z + १

इसलिए, अगर मैं इस पैटर्न को x के रूप में संख्या 9 के अंदर रखता हूं, तो यह वही होगा जो बाहर आएगा:

९ ( ९ )
12 ( 9 + 9/3 ) [9 ओवर 3 3 है, और 9 + 3 12 है]
8 ( 12 गुना दो-तिहाई) [12 का एक तिहाई 4 है, और 4 * 2 8 है]
9 ( 8 + 1 9)

चुनौती

मुझे एक फ़ंक्शन (किसी भी प्रोग्रामिंग भाषा में) लिखें जो एक संख्या में लेता है, और पैटर्न का उपयोग करके एक पूर्णांक सरणी को आउटपुट करता है।
कुछ इस तरह से psuedo- कोड:

function ninePattern(int myInt) returns IntegerArray {  
    int iterationA = myInt + (myInt / 3);  
    int iterationB = iterationA * (2 / 3); 
    int iterationC = iterationB + 1;  
    IntegerArray x = [myInt, iterationA, iterationB, iterationC];  
    return x;  
}

स्पष्टीकरण

प्रश्न की विशिष्टताओं के बारे में टिप्पणियों में चर्चा हुई है। यह खंड उनमें से कुछ को स्पष्ट करने के लिए है।

"वर्णों की तुलना में बाइट्स में गिनना बेहतर है"

मैंने पात्रों को चुना क्योंकि (मेरे लिए, कम से कम) यह न्याय करना आसान होगा। बेशक, मैं इसे अब नहीं बदल सकता। (बहुत सारे उत्तर पहले से ही पोस्ट किए गए हैं)

"गोलाई"

राउंडिंग इस कविता का अनुसरण करता है:

यदि यह 5 या अधिक है, तो स्कोर बढ़ाएं
यदि यह 4 या उससे कम है, तो इसे आराम करने दें

सीधे शब्दों में कहें, अगर यह 4.7 या 3.85 की तरह कुछ है, तो उन्हें क्रमशः 5 और 4 के लिए गोल करें।

उदाहरण

Input => Result
9 => [9, 12, 8, 9]
8 => [8, 11, 7, 8]
6 => [6, 8, 5, 6]
23 => [23, 31, 21, 22]
159 => [159, 212, 141, 142]

यदि, हालांकि, संख्याएँ 2.3 या 10.435446 जैसी कुछ हैं, तो उन्हें क्रमशः 2 और 10 पर गोल करें।

"भाषा समर्थन"

आप फ़ंक्शंस और / या सरणियों का उपयोग न करने के लिए स्वतंत्र हैं I केवल और केवल यदि आपकी पसंद की भाषा उनका समर्थन नहीं करती है। यदि यह करता है (भले ही यह आपके पात्रों की संख्या में वृद्धि करेगा), तो आपको उनका उपयोग करना होगा ।

code-golf array-manipulation integer

— InitializeSahib
स्रोत

1

आउटपुट एक सरणी होना चाहिए, या संख्याओं को खुद से पर्याप्त होना चाहिए (जैसे कि पाइथ उत्तर)?

— डेविड

2

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

— ट्राइकोप्लेक्स

1

कर रहे हैं इनपुट और आउटपुट के लिए चूक भी। फिर से, आपको उनका अनुसरण करने की आवश्यकता नहीं है, यह केवल आपको बताने के लिए है।

— ट्राइकोप्लेक्स

3

-1 मनमानी सरणी और फ़ंक्शन आवश्यकताओं के लिए, जो बिना सरणी / सूची प्रकार या फ़ंक्शंस से प्रतिस्पर्धा करने वाली भाषाओं को रोकता है।

— मेगो

4

इसके अलावा, आपको प्रतियोगियों को बाइट्स में स्कोर करना चाहिए, न कि पात्रों में। हमारे पास एक सैंडबॉक्स है , जहां आप लाइव होने से पहले अपने पोस्ट पर प्रतिक्रिया प्राप्त कर सकते हैं।

— लवजो

11

मारियोलैंग, 659 621 591 582 556 543 516 458 418 401 352 308 369 बाइट्स

गोलाई काफी महंगी है: /

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

;>>[![( [( [( [( [( [<(([!)))!+(((-<>( >((+
:"==#================"===#== #=====""[ "==
)(  -[!)>>[![)  [)[<(!>)[<)) >))) [!!-[!((
 (  )"#="==#======="=#==="=<="=====##==#==<
 +  +>) )-+<>+)[!)+! +))![-[)>[ [([-[![<<:
 +  )-+ )(=""===#==#  ==#===)"=======#=====
 +  >!>)!>  !(- < !:+:))<  ))!((++)))< 
 )  "#"=#===#===" ======" ===#======="
 !
=#========================

वैसे यह उम्मीद से ज्यादा मजेदार था, यह शायद इष्टतम नहीं है लेकिन मुझे लगता है कि मैं वहां पहुंच रहा हूं।

स्पष्टीकरण का समय:

( 352 बाइट्स संस्करण के लिए)

पहले हम तर्क प्राप्त करते हैं और उसे प्रिंट करते हैं:

;
:

काफी सरल

हम तब कार्यक्रम के थोक में जाते हैं: विभाजन इनपुट / 3

;>>[![              [( [( [<result
:"==#======================"======
)   -[!)>>[![        [<((((!   
)   )"#="==#=========="====#
+(  +>) )  +>(+)[!)+))!
+(  )-+ )  -"====#====#
+   >!>)!  >! -  <
    "#"=#  "#===="
 !
=#

जो ब्रेनफॉक डिवीजन का थोड़ा संशोधित रूपांतरण है

[->+>-[>+>>]>[+[-<+>]>+>>]<<<<<<]

जो इनपुट के लिए लेते हैं

n 0 d 0 0

और तुम वापस दे दो

0 n d-n%d n%d n/d

एक बार जब हमें डिवीजन मिल गया तो हम इसका उपयोग n और n / d का योग पाने के लिए और इसे प्रिंट करने के लिए करते हैं

;>>[![              [( [( [<    !+(((-<
:"==#======================"===)#====="
)   -[!)>>[![        [<((((!    >))) [!(((
)   )"#="==#=========="====#   ="=====#==:
+(  +>) )  +>(+)[!)+))!
+(  )-+ )  -"====#====#
+   >!>)!  >! -  <
    "#"=#  "#===="
 !
=#

हमें फिर एक और विभाजन करने की आवश्यकता है: (2 * (n + n / d)) / 3

तो हमें मिलता है (2 * (n + n / d)

;>>[![              [( [( [<    !+(((-<
:"==#======================"===)#====="
)   -[!)>>[![        [<((((!    >))) [!(((
)   )"#="==#=========="====#   ="=====#==:
+(  +>) )  +>(+)[!)+))! 2*2n/d>[   -[![  <
+(  )-+ )  -"====#====# ======"======#====
+   >!>)!  >! -  <            !((++))<
    "#"=#  "#===="            #======"
 !
=#

और इसे 3 डिवीजन में वापस डाल दिया

;>>[![              [( [( [<    !+(((-<
:"==#======================"===)#====="
)   -[!)>>[![        [<((((!    >))) [!(((
)   )"#="==#=========="====#   ="=====#==:
+(  +>) )  +>(+)[!)+))!      )>[   -[![  <
+(  )-+ )  -"====#====#      )"======#====
+   >!>)!  >! -  <       +++))!((++))<
    "#"=#  "#====" ===========#======"
 !
=#=================

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

और यह तय करने के लिए कि हमें पहले और दूसरे डिवीजन के बीच अंतर करने के लिए एक रास्ता चाहिए, यह समाप्त हो जाता है कि, हे आनंद, हम एक तरह से करते हैं

;>>[![              [( [( [<([!)!+(((-<
:"==#======================"==#)#====="
)   -[!)>>[![        [<((((!))< >))) [!(((
)   )"#="==#=========="====#)="="=====#==:
+(  +>) )  +>(+)[!)+))!!:+:)))>[   -[![  <
+(  )-+ )  -"====#====#======)"======#====
+   >!>)!  >! -  <       +++))!((++))<
    "#"=#  "#====" ===========#======"
 !
=#=================

मूल रूप से हम देखते हैं कि क्या x अंदर है

x 0 n d-n%d n%d n/d

यह 0 है, अगर इसका मतलब है कि हम पहले विभाजन पर हैं

और हम दूसरे डिवीजन पर हैं, और हम सिर्फ डिवीजन के परिणाम को प्रिंट करते हैं, 1 जोड़ते हैं और फिर इसे प्रिंट करते हैं

और पाई के रूप में आसान voilà ।

— ईथर मेंढक
स्रोत

PPCG में आपका स्वागत है!

— बजे एरिक आउटफोलर

प्रश्न द्वारा प्रदान किए गए चश्मे के लिए गोल नहीं है (निश्चित रूप से, मैंने आपके उत्तर को पोस्ट करने के बाद इसे अपडेट किया था, लेकिन आपको नए चश्मे को फिट करने के लिए कम से कम अपने उत्तर को अपडेट करना चाहिए)

— InitializeSahib

किया हुआ। जब हम परीक्षण के मामले के बारे में बात कर रहे हैं, तो आपको 10 संख्याओं को जोड़ना चाहिए, जो कि आप मुट्ठी के ऑपरेशन में गोल करते हैं।

— ईथर मेढक

9

Emotinomicon 99 बाइट्स, 33 अक्षर

😷😭,😲🆙🆙😼🆙😨😎⏬😎🆙😍➗➕🆙😨😎⏬😎😉✖😍➗🆙😨😎⏬😎😅➕😨

स्पष्टीकरण:

😷                                 clear output
 😭                                begin quote string
  ,                               
   😲                              end quote string
    🆙                             duplicate top of stack
     🆙                            duplicate top of stack
      😼                           take numeric input
       🆙                          duplicate top of stack
        😨                         pop N and output as a number
         😎                        reverse stack
          ⏬                       pops and outputs top of stack as character
           😎                      reverse stack
            🆙                     duplicate top of stack
             😍                    push 3 to the stack
              ➗                   divide top two elements on stack
               ➕                  add top two elements on stack
                🆙                 duplicate top of stack
                 😨                pop N and output as a number
                  😎               reverse stack
                   ⏬              pops and outputs top of stack as character
                    😎             reverse stack
                     😉            push 2 to the stack
                      ✖           multiply top two elements on stack
                       😍          push 3 to the stack
                        ➗         divide top two elements on stack
                         🆙        duplicate top of stack
                          😨       pop N and output as a number
                           😎      reverse stack
                            ⏬     pops and outputs top of stack as character
                             😎    reverse stack
                              😅   push 1 to the stack
                               ➕  add top two elements on stack
                                😨 pop N and output as a number

— Bálint
स्रोत

3

अपरंपरागत भाषाओं के लिए याय! : पी

— user48538

4

MATL, 14 बाइट्स

Xot4*3/tE3/tQv

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

बहुत सरल, vएक सरणी में ढेर को समेटता है। Xoएक पूर्णांक डेटा-प्रकार में कनवर्ट करता है, और उसके बाद सभी ऑपरेशन पूर्णांक ऑपरेशन होते हैं।

— डेविड
स्रोत

3

युक्ति एक सरणी वापस करने के लिए है, केवल अंतिम परिणाम नहीं है।

— मूल्य स्याही

3

<2 मिनट में हटाने के लिए झंडोत्तोलन करने वालों के लिए भी योग्य: D

— डेविड

@ दाविद डी: मुझे नहीं लगता कि मैं

— डिलीट

@ दाविद ने आपके जवाब को मेरी संवेदना के रूप में उतारा। :)

— इनिशियलाइज़ाहिब

1

मुझे पूरा यकीन है कि यह कोई फ़ंक्शन नहीं है, अगर मैं गलत हूं तो मुझे सुधारें।

— माल्टीसेन

4

चेडर , 27 बाइट्स

b=8/9*$0
[$0,$0+$0/3,b,b+1]

$0इनपुट के साथ परिवर्तनशील है। चेडर सिर्फ एक गोल्फ भाषा नहीं है (\ _ (_) _ / also, यह भी गैर-प्रतिस्पर्धी है क्योंकि इस चुनौती के बाद चेडर की इनपुट कार्यक्षमता बनाई गई थी।

Ungolfed:

IterationB := 8 / 9 * $0  // 8/9ths of the Input
[ $0,                     // The input
  $0 + $0 / 3,            // Input + (Input/3)
  IterationB,             // (see above)
  IterationB + 1          // above + 1
]

— Downgoat
स्रोत

1

ख़ुशी के आंसू! इतनी दूर चला गया है! : D

— कॉनर ओ'ब्रायन

3

जावा, 86 82 84 85 वर्ण

class c{int[]i(int I){int a=I+(I/3),b=(int)(a*(2d/3d));return new int[]{I,a,b,b+1};}}

dपूर्णांक के ठीक बाद रखा गया अक्षर पूर्णांक बनाता है double।

Ungolfed:

class c{
    int[] i(int I) {
        int a = I + (I / 3),
            b = (int)(a * (2d / 3d));
        return new int[]{I, a, b, b + 1};
    }
}

वर्ग के बिना ( class c{}8 वर्ण लंबा है), यह 76 वर्णों तक कम हो जाता है:

int[]i(int I){int a=I+(I/3),b=(int)(a*(2d/3d));return new int[]{I,a,b,b+1};}

110 वर्णों में अधिक सटीक संस्करण (एनम के साथ 118) - यह floatएस का उपयोग करता है क्योंकि ढलाई के लिए किसी को जगह नहीं मिली Math#round(double):

int[]i(int I){float a=I+(I/3f),b=(a*(2f/3f));return new int[]{I,Math.round(a),Math.round(b),Math.round(b+1)};}

— user8397947
स्रोत

मुझे लगता है कि मुझे पायथ सीखना चाहिए।

— user8397947

5

+1, क्योंकि फिर पता है, जावा

— जेम्स

1

@dorukayhan अजीब, मुझे लगता है कि जब मैं इसे एक्लिप्स में चलाने की कोशिश कर रहा हूं, तो मुझे एक त्रुटि मिल सकती है, यह डबल से इंट में परिवर्तित नहीं हो सकता है। मैं देखूंगा कि क्या मैं पता लगा सकता हूं कि कल क्या समस्या है।

— लोजोवो

1

मैंने अभी कोड तय किया है

— user8397947

1

मैं देख रहा हूं लेकिन यह 8 या 10 जैसे इनपुट के लिए सही परिणाम नहीं देता है। पहला जोड़ ठीक से काम नहीं कर रहा है क्योंकि I + (I / 3)पूर्णांक विभाजन का उपयोग कर रहा है , जिसका अर्थ है कि अंशों को छोड़ दिया गया है और इस प्रकार परिणाम ठीक से गोल नहीं हुआ है।

— फ्रोज़न

3

जावा, 56 80 बाइट्स

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

int[]h(int a){int[]b={a,Math.round(a+a/3f),a=Math.round(a*8f/9),++a};return b;}

या 60 बाइट्स लैम्डा संस्करण

a->new int[]{a,Math.round(a+a/3f),a=Math.round(a*8f/9),++a}

~~गोल्फ संस्करण~~

~~int[]g(int a){int[]b={a,a+a/3,a*8/9,a*8/9+1};return b;}~~

और अपुष्ट

int[] g(int a) {
        int[] b = { a, a + a / 3, a * 8 / 9, a * 8 / 9 + 1 };
        return b;
    }

या 36 बाइट्स को लैम्ब्डा के रूप में परिभाषित किया गया है

a->new int[]{a,a+a/3,a*8/9,a*8/9+1}

— user902383
स्रोत

प्रश्न द्वारा राउंडिंग आवश्यक नहीं है।

— मार्व

1

जैसा कि @Marv ने कहा कि यह सवाल सही नहीं है, उदाहरण के लिए इनपुट 8 के लिए अपेक्षित परिणाम [8,11,7,8] होगा, लेकिन यह [8,10,7,8] है

— फ्रोज़न

नीचे क्यों? मैंने इसे ठीक कर दिया और यह अब सही ढंग से काम कर रहा है?

— user902383

आपके द्वारा इसे ठीक करने के बाद डाउनवोट के लिए क्षमा करें। डाउनवोट को अब बंद कर दिया गया है, इसलिए मैं इसे तब तक नहीं हटा सकता जब तक आप अपने उत्तर में कोई बदलाव नहीं करते (कोई भी तुच्छ परिवर्तन पर्याप्त है)

— edc65

@ edc65 ok, किया

— user902383

2

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

int[]f(int i){return new int[]{i,i+=i/3+0.5,i-=i/3-0.5,i+=1.5};}

Ungolfed

int[] f(int i) {
    return new int[]{
            i, 
            i += i / 3 + 0.5, 
            i -= i / 3 - 0.5, 
            i += 1.5};
}

आई = 9 के साथ आउटपुट

[9, 12, 8, 9]

— मार्व
स्रोत

1

+1। क्यूज,

— यस

User902383 के समाधान के समान ही, यह सही ढंग से काम नहीं करता है, उदाहरण के लिए 8 अपेक्षित [8,11,7,8] लेकिन [8,10,7,8], 6 अपेक्षित [6,8,5,6] के लिए लेकिन [6,8,6,7]

— फ्रोज़न

3

@ यह समाधान ठीक से काम नहीं कर रहा है और साथ ही परीक्षण मामलों के लिए जो आपने मेरे पुराने समाधान ideone.com/LVK8FU के

— user902383

2

स्क्रैच, 33 बाइट्स

इनपुट के लिए पूछता है, इनपुट के लिए सेट aगोल, सेट bऔर cउनके संबंधित परिवर्तनों के लिए, फिर कहते हैं कि सभी चार नंबर, अल्पविराम द्वारा अलग किए गए हैं।

— weatherman115
स्रोत

2

जावा 8 लैम्ब्डा, 109 81 79 75 वर्ण

क्योंकि ... तुम्हें पता है ... यहां तक कि जावा गोल्फ हो सकता है ...

a->{int b=(int)(.5+a*4./3),c=(int)(.5+b*2./3);return new int[]{a,b,c,++c};}

लैम्ब्डा क्लास में अनफॉर्म्ड:

class C {  
   static int[] a(int a) {
        int b = (int) (.5 + a * 4. / 3),
            c = (int) (.5 + b * 2. / 3);
        return new int[]{a, b, c, ++c};
    }
}

मुझे लगता है कि मुझे लंबे समय तक उपयोग करने की अनुमति है क्योंकि वे एक पूर्णांक प्रकार भी हैं। अफसोस की बात है कि पूर्णांक को सही ढंग से गोल करने की आवश्यकता है और इस प्रकार "शॉर्ट" कास्ट काम नहीं करता है। लोंगो का उपयोग करके हमें चक्कर लगाने के परिणाम वापस किलों में डालने की जरूरत नहीं है।

अपडेट करें

अच्छी छोटी + 0.5 और बाद की चाल का उपयोग करके हम सही गोलाई लेते रहते हैं और 2 चार्ट बचाते हैं!

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

— Frozn
स्रोत

PPCG में आपका स्वागत है!

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

धन्यवाद :) मैंने कुछ समय के लिए इधर-उधर के सवालों का पालन किया और मुझे लगा कि यह एक ऐसा प्रश्न हो सकता है, जिसमें मैं भाग ले सकता हूं, हालांकि इसका उत्तर मेरे होने की अपेक्षा अधिक लंबा है।

— फ्रोज़न

मैं "+1" हूं, उम्मीद है कि आप अनिवार्य जोड़ देंगे "क्योंकि ... आप जानते हैं ... जावा!"

— ओलिवियर दुलक

@ फ़िरोज़ मुझे यकीन नहीं है कि अगर आप -5 बाइट्स के लिए a->{और फाइनल निकाल सकते हैं }।

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

@OlivierDulac अभी तक नहीं :)

— एग्रीगेलर

1

गणितज्ञ - 21 बाइट्स

बस मेरे भाइयों आरपीआई से मैथेमेटिका मिली, इसलिए इसे मज़े के लिए आज़माया, और पीपीसीजी चुनौती से बेहतर तरीका क्या हो सकता है।

{#,4#/3,8#/9,8#/9+1}&

एक अनाम फ़ंक्शन को परिभाषित करता है। इसे आज़माएं:

In[26]:= x:={#,4#/3,8#/9,8#/9+1}&                                             

In[27]:= x[9]                                                                 

Out[27]= {9, 12, 8, 9}

— Maltysen
स्रोत

क्या यह पूर्णांक, या अंश के रूप में पूर्णांक देगा?

— डेविड

@ पूर्णांक पूर्णांक, जब तक कि परिणाम गैर-अभिन्न न हों, जिस स्थिति में भिन्न हैं।

— माल्टसेन

1

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

f=lambda i:map(round,[i,i*4/3,i*8/9,i*8/9+1])

इस कोड को ideone.com पर देखें

— बाइट कमांडर
स्रोत

1

लूआ, 52 बाइट्स

यह प्रोग्राम कमांड-लाइन तर्क द्वारा एक संख्या लेता है और संबंधित सरणी को वापस करता है। लुआ में कार्यक्रम तकनीकी रूप से कार्य करते हैं, क्योंकि दुभाषिया हमेशा उन्हें एक फ़ंक्शन में संलग्न कर सकता है। यह भी यह मैकेनिक है जिसका उपयोग अन्य फ़ाइलों में कोड को "कॉल" करने के लिए किया जाता है (यह मूल रूप से उपयोग करता है loadfile/ dofile)।

m=math.floor x=...z=m(x*8/9)return{x,m(x*4/3),z,z+1}

— Katenkyo
स्रोत

1

दरअसल, 21 बाइट्स

`;;3@/+;32/*;uk1½+♂≈`

यह कार्यक्रम एक फ़ंक्शन की घोषणा करता है जो शीर्ष स्टैक मान पर आवश्यक संचालन करता है।

इसे ऑनलाइन आज़माएं! (अतिरिक्त. अंत फ़ंक्शन का मूल्यांकन करता है और परिणाम प्रिंट करता है)

स्पष्टीकरण:

`;;3@/+;32/*;uk1½+♂≈`
 ;;                    make two copies of x
   3@/+                divide by 3, add that to x to get y
       ;32/*           make a copy of y and multiply by 2/3 to get z
            ;u         make a copy of z and add one
              k        push stack as a list
               1½+     add 0.5 to each element
                  ♂≈   apply int() to each element (make integers from floats by flooring; this is equivalent to rounding half-up because of adding 0.5)

— मै जाऊं
स्रोत

1

मथकड, [tbd] बाइट्स

मठक कोडगोल्फ बाइट समतुल्यता अभी निर्धारित नहीं की गई है। कीबोर्ड की गिनती को किसी न किसी समकक्ष के रूप में लेना, समाधान लगभग 40 बाइट्स है।

— स्टुअर्ट ब्रुफ़
स्रोत

1

05AB1E , 15 बाइट्स

कोड:

Ð3/+D·3/D>)1;+ï

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं! ।

— अदनान
स्रोत

1

पाइके, 11 बाइट्स

D}[}3/bD)[h

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

            - implicit input()
D           - a,b = ^
 }          - b*=2
  [}3/bD)   - macro:
   }        -   tos*=2
    3/      -   tos/=3
      b     -   tos = round(tos)
       D    -   old_tos = tos = tos
            - macro
         [  - macro
          h - d +=1

— नीला
स्रोत

1

जावास्क्रिप्ट, 50 बाइट्स

मैं अपने जावा समाधान को जावास्क्रिप्ट में परिवर्तित करता हूं और इसे थोड़ा कम करता हूं।

var r=Math.round,g=a=>[a,r(a+a/3),a=r(a*8/9),++a]

— user902383
स्रोत

1

सी ++ 0x - 95 102 185 189 109 129 चार्ट

int * n(int p){static int a[3];a[0]=p;a[1]=round(p+(p/3));a[2]=round((a[1]/3)*2);a[3]=a[2]+1;return a;}

यह काम करने के लिए cmath हेडर की आवश्यकता है ।

Degolfed

#include <cmath>
int * ninePattern(int p) {
        static int a[3]; // pattern array
        a[0] = p; // sets first iteration
        a[1] = round(p + (p / 3)); // sets second iteration
        a[2] = round((a[1] / 3) * 2); // sets third iteration
        a[3] = a[2] + 1; // sets fourth iteration
        return a; // returns array
}

— InitializeSahib
स्रोत

2

सी ++ विशेषज्ञ नहीं होने पर भी आप पहले से गणना किए गए मानों को पुनः उपयोग करके इसे छोटा कर सकते हैं जो आपके पास है। इसके अलावा, आप बीच में कुछ सफेद जगह निकाल सकते हैं) और {नहीं जानते कि C ++ कितना सख्त है।

— फ्रोज़न

क्या वर्तमान संस्करण में अंतिम दो सही हैं? क्योंकि मैंने अभी-अभी आपको गणना करते हुए p+(p/3)*(2/3)देखा है कि p+(2*p/9)इसके बजाय(p+(p/3))*(2/3)

— फ्रोज़न

यह मेरी ओर से एक त्रुटि थी। मैंने अंतिम पुनरावृत्ति के लिए +1 के बजाय 1 डाला: पी

— इनिशियलाइज़ाहिब

0

एर्लैंग, 80 बाइट्स

-module(f).
-export([f/1]).
f(X)->Y=X+(X/3),Z=trunc(Y*(2/3)),[X,trunc(Y),Z,Z+1].

चलाने के लिए, f.erl के रूप में सहेजें , फ़ंक्शन को संकलित करें और कॉल करें। यह किलों की सूची लौटाएगा:

fxk8y@fxk8y:/home/fxk8y/Dokumente/erlang/pcg# erl
Erlang/OTP 18 [erts-7.0] [source] [64-bit] [smp:4:4] [async-    threads:10] [kernel-poll:false]

Eshell V7.0  (abort with ^G)
1> c(f).
{ok,f}
2> f:f(9).
"\t\f\b\t"
3>

ध्यान दें कि यदि आप ASCII मान श्रेणी में हैं तो Erlang स्वचालित रूप से int s को ASCII वर्ण में कनवर्ट करता है क्योंकि Erlang में char प्रकार नहीं है । 100 के साथ फ़ंक्शन को कॉल करना आपको बेहतर पठनीय [100,133,88,89] देता है ।

Ungolfed:

-module(f).
-export([f/1]).

f(X) ->
  Y = X+(X/3),
  Z = trunc(Y*(2/3)),
  [X, trunc(Y), Z, Z+1].

— fxk8y
स्रोत

0

एर्लैंग, 46 बाइट्स

@ Fxk8y से प्रेरित उत्तर (मैं उनके जवाब के लिए एक टिप्पणी पोस्ट नहीं कर सकता)

F=fun(X)->Z=round(X*4/9),[X,Z*3,Z*2,Z*2+1]end.

इसके अलावा आप परिणाम देख सकते हैं:

2> io:fwrite("~w~n", [F(9)]).                         
[9,12,8,9]
ok

— डोमिनिक पावलक
स्रोत

0

अजगर, 20 बाइट्स

m.RdZ[Jc*4Q3Kc*2J3hK

स्पष्टीकरण:

            (Implicit print)
m           For each d in array, d =
.RdZ        Round d to zero decimal places
[           The array of
  J         The result of setting J to
    c       The float division of
      *4Q   Input * 4
      3     and 3
            ,
  K         The result of setting K to
    c       The float division of
      *2J   J * 2
      3     and 3
            , and
  hK        K + 1.
            (Implicit end array)

यहाँ परीक्षण करें

— आर।
स्रोत

0

जोल्फ, 17 बाइट्स

Ώ‘Hγ+H/H3Βώ/γ3hΒ’

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

— कोनोर ओ ब्रायन
स्रोत

जोल्फ बन रहा है धीरे-धीरे ईस्मीन की पुष्टि हो रही है ??? : पी

— डाउनगोट

@Upgoat आंख यह ग्रीक है। और आधी रात फिर से। : पी

— कॉनर ओ'ब्रायन

> _> ओह। बहुत खेद है अगर मैंने आपको जगाया> _> _> _>

— डाउगोनेट

@Upgoat अभी तक सो नहीं;)

— कॉनर ओ'ब्रायन

: | idk अगर यह अच्छी बात है तो मैंने आपको जगाया या बुरी बात है कि आप अभी भी जाग रहे हैं

— Downgoat

0

गणितज्ञ, 51 बाइट्स

FoldList[#2@#&,{#,Round[4#/3]&,Round[2#/3]&,#+1&}]&

अनाम फ़ंक्शन जो पोस्ट के वर्तमान (पोस्टिंग के समय) संस्करण के अनुरूप है, जिसका अर्थ है कि हर चरण में गोलाई।

FoldListप्रोग्रामिंग में एक विशिष्ट ऑपरेशन है। इसे FoldList[f, list]दो-तर्क फ़ंक्शन के रूप में लागू किया जाता हैf परिणाम (या पहली पुनरावृत्ति में सूची का पहला तत्व) के लिए बार बार है, सूची के अगले तत्व को अपने दूसरे तर्क के रूप में लेता है।

अनगोल्डेड: #2 @ # &एक अनाम फ़ंक्शन है जो इसके दूसरे तर्क को पहले पर लागू करता है। इसलिए, FoldListइनपुट पर लागू किए जाने वाले क्रमिक कार्यों के सूची तर्क शामिल हैं।

FoldList[#2 @ # &,
  {#, (* note the absence of '&' here, 
         this '#' stands for the argument
         of the complete function and is 
         covered by the & at the end      *)
   Round[4 # / 3] &, (* anonymous function that rounds 4/3 of its input *)
   Round[2 # / 3] &, (* ditto, 2/3 *)
   # + 1 &           (* add one function *)
  }] &               (* and the '&' makes the entire 
                        thing an anonymous function,
                        whose argument is the '#' up
                        at the top.                  *)

क्योंकि इनपुट पूर्णांक है और विभाजन 3 से हैं, इसलिए 4.5 जैसा परिणाम कभी नहीं होगा, इसलिए अंतिम अंक 5हमेशा होने पर राउंडिंग के नियमों के बारे में चिंता करने की कोई आवश्यकता नहीं है : यह हमेशा स्पष्ट रूप से एक पूर्णांक, या किसी अन्य के करीब होगा।

— LLlAMnYP
स्रोत

0

दिल्लोग एपीएल , 33 बाइट्स

(⌽,{1+⊃⍵})∘{⍵,⍨3÷⍨2×⊃⍵}(3÷⍨4∘×),⊢

— एडम
स्रोत

0

डेसमोस, 37 बाइट्स

a=9
b=a+\frac{a}{3}
c=\frac{2}{3}b
d=c+1

इसे
अपरंपरागत भाषाओं के लिए ऑनलाइन याय आज़माएं !

— weatherman115
स्रोत

0

सीजेएम, 21 बाइट्स

qi__3d/+mo_2d3/*i_)]`

प्रतिक्रिया का स्वागत है

व्याख्या

qi__ - इनपुट को पूर्णांक के रूप में पढ़ें और इसे दो बार डुप्लिकेट करें
3D/+mo - इनपुट के एक उदाहरण को 3 से विभाजित करें, फिर इसे y बनाने के लिए दूसरे उदाहरण में जोड़ें
_2d3/*i - डुप्लिकेट y, फिर इसे 6 से गुणा करें
_)] `- डुप्लिकेट, वेतन वृद्धि, सरणी में लपेटें, सरणी के रूप में प्रिंट करें (` ऑपरेटर के कारण कोड में नहीं :()

संपादित करें: पहले तीन को एक डबल बनाना भूल गया, इसलिए कार्यक्रम टूट गया। फिक्स्ड।

— The_Basset_Hound
स्रोत

0

एक्सोम, 59 बाइट्स

g(x)==round(x)::INT;f(x)==[x,a:=g(x+x/3.),b:=g(a*2./3),b+1]

परीक्षा

(3) -> [[i,f(i)] for i in [9,8,6,23,159]]
   (3)
   [[9,[9,12,8,9]], [8,[8,11,7,8]], [6,[6,8,5,6]], [23,[23,31,21,22]],
    [159,[159,212,141,142]]]
                                                      Type: List List Any

— RosLuP
स्रोत

0

PHP, 60 बाइट्स

print_r([$a=$argn,$b=round($a+$a/3),$c=round($b*2/3),$c+1]);

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

— जार्ग हुल्सरमन
स्रोत

आप एक बाइट को $ 4 * / 3 कर सकते हैं।

— jstnthms

0

PHP, 67 बाइट्स

function f($x){return [$x,$y=round($x*4/3),$z=round($y*2/3),$z+1];}

— jstnthms
स्रोत

द नाइन पैटर्न

परिचय

चुनौती

स्पष्टीकरण

"वर्णों की तुलना में बाइट्स में गिनना बेहतर है"

"गोलाई"

उदाहरण

"भाषा समर्थन"

मारियोलैंग, 659 621 591 582 556 543 516 458 418 401 352 308 369 बाइट्स

Emotinomicon 99 बाइट्स, 33 अक्षर

MATL, 14 बाइट्स

चेडर , 27 बाइट्स

जावा, 86 82 84 85 वर्ण

जावा, 56 80 बाइट्स

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

टिप्पणियाँ

Ungolfed

आई = 9 के साथ आउटपुट

स्क्रैच, 33 बाइट्स

जावा 8 लैम्ब्डा, 109 81 79 75 वर्ण

अपडेट करें

गणितज्ञ - 21 बाइट्स

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

लूआ, 52 बाइट्स

दरअसल, 21 बाइट्स

मथकड, [tbd] बाइट्स

05AB1E , 15 बाइट्स

पाइके, 11 बाइट्स

जावास्क्रिप्ट, 50 बाइट्स

सी ++ 0x - 95 102 185 189 109 129 चार्ट

Degolfed

एर्लैंग, 46 बाइट्स

अजगर, 20 बाइट्स

जोल्फ, 17 बाइट्स

गणितज्ञ, 51 बाइट्स

दिल्लोग एपीएल , 33 बाइट्स

डेसमोस, 37 बाइट्स

सीजेएम, 21 बाइट्स

व्याख्या

एक्सोम, 59 बाइट्स

PHP, 60 बाइट्स

PHP, 67 बाइट्स