गोल्फ एक संख्यात्मक बढ़ते ब्रैड

Question

ब्रैड विवरण

इस ब्रैड में, जब एक स्ट्रैंड दूसरे स्ट्रैंड के ऊपर से पार होता है, तो यह दूसरे स्ट्रैंड की वैल्यू को खुद से जोड़ता है और अन्य सभी स्ट्रैंड वैल्यू से गुजरता है। ब्रैड में तीन स्ट्रैंड होते हैं और प्रत्येक स्ट्रैंड 1 से शुरू होता है। पहला क्रॉसओवर मिडिल स्ट्रैंड के ऊपर बाईं ओर का स्ट्रैंड क्रॉसिंग होता है। अगला क्रॉसओवर नए मध्य स्ट्रैंड (पहले लेफ्टेस्ट स्ट्रैंड) पर सबसे दाहिनी स्ट्रैंड क्रॉसिंग है। क्रॉसओवर के ये दो चरण दोहराते हैं। दूसरे शब्दों में, पहला क्रॉसओवर है [a, b, c] -> [b, a+b, c]और दूसरा है [a, b, c] -> [a, b+c, b]। इन नियमों का उपयोग करते हुए यहां ब्रैड के पहले छह स्तर हैं:

1,1,1
1,2,1
1,3,2
3,4,2
3,6,4
6,9,4

आपका कार्य

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

टेस्ट केस (1-आधारित)

1 -> 1,1,1

2 -> 1,2,1

5 -> 3,6,4

10 -> 28,41,19

Comments

कुछ संबंधित अनुक्रम (मध्य संख्या के लिए)

— mbomb007

Answer 1

MATL , 18 17 16 बाइट्स

7Bi:"2:4PB@EX!Y*

इनपुट 0-आधारित है।

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

व्याख्या

एक पंक्ति वेक्टर को देखते हुए [a b c], अगले वेक्टर को पोस्ट-मैट्रिक्स-गुणा करके इसे प्राप्त किया जाता है

[1 0 0;
 0 1 1;
 0 1 0]

या

[0 1 0;
 1 1 0;
 0 0 1]

यह निर्भर करता है कि पुनरावृति सूचकांक विषम है या नहीं। उदाहरण के लिए, मैट्रिक्स उत्पाद [1 3 2]*[0 1 0; 1 1 0; 0 0 1]देता है [3 4 2]। फिर [3,4,2]*[1 0 0; 0 1 1; 0 1 0]देता है [3 6 4], और इसी तरह।

यह भी ध्यान दें कि दूसरा मैट्रिक्स पहले घुमाए गए 180 डिग्री के बराबर है, जिसका उपयोग कुछ बाइट्स को बचाने के लिए किया जा सकता है।

7        % Push 7
B        % Convert to binary. Gives [1 1 1]. This is the initial level
i        % Take input n
:        % Push range [1 2 ... n]
"        % For each
  5      %   Push 5
  I:     %   Push range [1 2 3]
  -      %   Subtract, element-wise: gives [4 3 2]
  B      %   Convert to binary. This gives the matrix [1 0 0; 0 1 1; 0 1 0]
  @      %   Push current iteration index
  E      %   Multiply by 2. Gives 2 in the firt iteration, 4 in the second etc
  X!     %   Rotate matrix 90 degrees either 2 or 0 times
  Y*     %   Matrix multiply
         % End. Implicitly display

Comments

क्या आपने चरणों की जोड़ी बनाने पर विचार किया है? इस तरह से आपके पास एक मैट्रिक्स है [[0, 1, 0], [1, 1, 1], [1, 1, 0]]और अलग-अलग शुरुआती स्थिति समान और विषम के लिए काफी समान हैंn

— पीटर टेलर

@PeterTaylor विचार के लिए धन्यवाद। इस मामले में प्रारंभिक वेक्टर को अलग-अलग करना और इनपुट को 2 से विभाजित करना अधिक बाइट-महंगा प्रतीत होता है

— लुइस मेंडो

Answer 2

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

f p@(a,b,c)=p:(b,a+b,c):f(b,a+b+c,a+b)
(f(1,1,1)!!)

यह 0-आधारित इंडेक्सिंग का उपयोग करता है। प्रयोग उदाहरण: (f(1,1,1)!!) 10-> (28,60,41)।

fब्रैड ट्रिपल्स की अनंत सूची बनाता है और (f(1,1,1)!!)nth को चुनता है। fअपने आप में एक सरल पुनरावृत्ति है जो अपने तर्क की सूची बनाता है, उसके बाद बाएं क्रॉसओवर और बाएं और दाएं क्रॉसओवर के साथ एक पुनरावर्ती कॉल होता है।

Answer 3

रूबी, 60 57 बाइट्स

->n{f=->x{x<2?1:f[x-1]+f[x-3]};[f[n-2|1],f[n],f[n-1&-2]]}

स्तर 1-आधारित हैं।

निम्नलिखित सूत्र के आधार पर:

f(-1) = 1
f(0)  = 1
f(1)  = 1
f(x)  = f(x-1) + f(x-3)

braid(x) = {
    [f(x-1), f(x), f(x-2)]  if x is even,
    [f(x-2), f(x), f(x-1)]  if x is odd
}

कुछ निफ्टी बिटविन शीनिगन्स के साथ 3 बाइट्स के लिए नील को धन्यवाद ।

Comments

बिटवाइज ऑपरेटर FTW [f[n-2|1],f[n],f[n-1&-2]]:।

— नील

@ नील यह बहुत साफ है, धन्यवाद!

— दरवाज़े

Answer 4

पायथन 2 , 57 बाइट्स

f=lambda n,a=1,b=1,c=1:1/n*(c,b,a)or f(n-1,b,b+c,a)[::-1]

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

Answer 5

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

Ḋ+\;Ḣ
6BÇ⁸¡Ṛ⁸¡

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

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

6BÇ⁸¡Ṛ⁸¡  Main link. Argument: n (integer)

6B        Convert 6 to binary, yielding [1, 1, 0], which is the braid at index 0.
  Ç⁸¡     Call the helper link n times.
     Ṛ⁸¡  Reverse the resulting array n times.


Ḋ+\;Ḣ     Helper link. Argument: [a, b, c] (integer array)

Ḋ         Dequeue, yielding [b, c].
 +\       Cumulative sum, yielding [b, b+c].
   ;Ḣ     Concatenate with the head of [a, b, c], yielding [b, b+c, a].

Answer 6

टीआई-बेसिक, 58 बाइट्स

एक-आधारित।

Prompt N
{1,1,1
For(I,1,Ans
If fPart(I/2
Then
{Ans(2),Ans(1)+Ans(2),Ans(3
Else
{Ans(1),Ans(2)+Ans(3),Ans(2
End
End

Comments

यह 58 बाइट्स कैसे है? मैं 114 की गिनती करता हूं .. क्या मैं कुछ याद कर रहा हूं?

— रिश्वतखोर

@ ब्रायंटिस्ट टीआई-बेसिक कमांड एक या दो बाइट्स लंबे होते हैं। उदा Prompt2-बाइट कमांड है।

— जुंगह्वान मिन

@JungHwanMin शांत, एहसास नहीं हुआ। मुझे लग रहा था कि कुछ ऐसा है जो मैं नहीं देख रहा था। मैं उन लोगों के लिए अपनी टिप्पणी छोड़ दूंगा जो अपरिचित हैं।

— रिश्वतखोर

यह देखने के लिए कि कौन से टोकन एक या दो बाइट हैं, आप tibasicdev.wikidot.com/tokens

— Timtech

@JungHwanMin Prompt केवल एक बाइट है। लेकिन टोकन की अवधारणा को समझाने के लिए धन्यवाद :)

— टाइमटेक

Answer 7

पॉवरशेल 2+, 75 बाइट्स

1-आधारित सूचकांक

$a=1,1,0;1..$args[0]|%{$d=(0,2)[$_%2];$a[1],$a[$d]=($a[1]+$a[$d]),$a[1]};$a

इसे ऑनलाइन आज़माएं! या सभी टेस्ट मामलों की कोशिश करो!

लूप हमेशा एक बार चलता है ताकि ब्रैड स्तर के मामले के लिए 1मैं बस एक सरणी के साथ शुरू करूं 1,1,0ताकि एल्गोरिथ्म का परिणाम इसे बना सके 1,1,1।

$a[1]हमेशा बीच है, तो मैं सिर्फ यह निर्धारित अन्य तत्व सूचकांक (चाहे $d) होने जा रहा है 0या 2पर कि क्या मौजूदा स्तर सम या विषम है आधारित। PowerShell एक बार में कई असाइनमेंट का समर्थन करता है, इसलिए स्वैप करना उतना ही आसान हो जाता है जितना $x,$y=$y,$xकि मूल रूप से मैं सरणी तत्वों के साथ कर रहा हूं, बस उस असाइनमेंट के अतिरिक्त जोड़ रहा है।

Answer 8

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

x=>(f=y=>y<2?1:f(y-1)+f(y-3),[f(x-2|1),f(x),f(x-1&-2)])

repl.it

1-आधारित

यह @ नील के भयानक बिटवाइज़ गोल्फ के साथ @ Doorknob के रूबी जवाब का सिर्फ एक बंदरगाह है।

Answer 9

Befunge, 64 बाइट्स

110p100p1&v
01:\_v#:-1<\p00<v\+g
..g.@>_10g
\1-:!#^_\:00g+\v>10p

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

व्याख्या

110p                Initialise a to 1 (at location 1;0).  
    100p            Initialise c to 1 (at location 0;0).
        1           Initialise b to 1 (on the stack, since it'll be most frequently used).
         &v         Read n from stdin and turn down.

          <         The main loop starts here, executing right to left.
        -1          Decrement n.
    _v#:            Duplicate and check if zero; if not, continue left.
   \                Swap b to the top of the stack, leaving n below it.
01:            g    Make a duplicate copy, and read a from memory (at location 1;0). 
              +     Add a to b, the result becoming the new b.
            v\      Swap the original b to the top of the stack and turn down.
            >10p    Turn around and save the original b as a (at location 1;0).
\1-                 Swap n back to the top of the stack and decrement.
   :!#^_            Duplicate and check if zero; if not continue right.
        \           Swap b to the top of the stack, leaving n below it.
         :00g       Make a duplicate copy, and read c from memory (at location 0;0).
             +      Add c to b, the result becoming the new b.
              \v    Swap the original b to the top of the stack and turn down.
            p00<    Turn around and save the original b as c (at location 0;0).
           \        Swap n back to the top of the stack.
          <         And repeat the loop from the beginning.

      >             If either of the zero tests succeed, we end up on line 3 going right.
       _            This just drops the n that is now zero, and continues to the right.
        10g         Read the final value of a (at location 1;0).
..                  Output a along with the b that was already on the stack.
  g                 Read the final value of c (the 0;0 location is implied).
   .@               Output c and exit.

Answer 10

05AB1E , 17 बाइट्स

6bSIF¬¸s¦.pOì}¹FR

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

Answer 11

जावा 8, 121

यह एक-आधारित स्तरों का उपयोग करता है:

(int l)->{int a=1,b=a,c=a,i=a;while(i<l)if(i++%2>0){b^=a;a^=b;b=(a^b)+a;}else{b^=c;c^=b;b=(c^b)+c;}return a+","+b+","+c;}

परीक्षण कार्यक्रम के साथ अधूरा,:

import java.util.function.IntFunction;

public class GolfANumericalGrowingBraid {

  public static void main(String[] args) {
    for (int level : new int[] { 1, 2, 5, 10 }) {
      output((int l) -> {
        int a = 1, b = a, c = a, i = a;
        while (i < l) {
          if (i++ % 2 > 0) {
            b ^= a;
            a ^= b;
            b = (a ^ b) + a;
          }
          else {
            b ^= c;
            c ^= b;
            b = (c ^ b) + c;
          }
        }
        return a + "," + b + "," + c;
      } , level);
    }
  }

  private static void output(IntFunction<String> function, int level) {
    System.out.println(function.apply(level));
  }
}

आउटपुट:

1,1,1
1,2,1
3,6,4
28,41,19

Answer 12

गेममेकर लैंग्वेज, 113 बाइट्स

Doorknob के पुनरावर्ती समाधान के आधार पर एक-अनुक्रमित। कृपया यह न पूछें कि आप GameMaker में एक ही बार में एक आदिम सरणी की शुरुआत क्यों नहीं कर सकते, मैं वास्तव में नहीं जानता ...

मुख्य कार्यक्रम (69 बाइट्स):

a=argument0 if a mod 2c=1b[0]=a(a-c-1)b[1]=a(a)b[2]=a(a+c-2)return b

उपप्रोग्राम a(46 बाइट्स):

a=argument0 if a<2return 1return a(a-1)+a(a-3)

Answer 13

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

{(1 xx 3,->[\a,\b,\c]{$++%2??(a,b+c,b)!!(b,b+a,c)}...*)[$_]}

शून्य आधारित।

सीधे-आगे ने आलसी अनंत अनुक्रम उत्पन्न किया, और फिर इसे अनुक्रमित किया।
बेहतर दृष्टिकोण होने की संभावना है।

Answer 14

क्लोजर, 98 बाइट्स

#(ffirst(drop %(iterate(fn[[v[a b c d]]][[(v a)(+(v b)(v c))(v d)][b a d c]])[[1 1 0][0 1 2 1]])))

वर्तमान मूल्य का ट्रैक रखता है vऔर अगले राउंड के लिए किन पदों पर योग किया जाना चाहिए। [1 1 1]1-आधारित अनुक्रमण करने से पहले एक राज्य प्रारंभ करता है ।

Answer 15

सी # 88 86 बाइट्स

f(int n,int a=1,int b=1,int c=1)=>n>1?n--%2>0?f(n,b,a+b,c):f(n,a,b+c,b):a+","+b+","+c;

व्याख्या

f(int n,int a=1,int b=1,int c=1)=>  //Using an expression bodied function to allow for defaults and remove return statement
    n>1?                            //recurse or return result
        n--%2>0?                    //get odd or even then decrement n
            f(n,b,a+b,c)            //odd recursion
           :f(n,a,b+c,b)            //even recursion
       :a+","+b+","+c;              //build output

Answer 16

मैथमेटिका, 68 बाइट्स

If[#<3,{1,#,1},{{#,+##2,#2}&,{#2,#+#2,#3}&}[[Mod[#,2,1]]]@@#0[#-1]]&

एक अनाम फ़ंक्शन की सीधी पुनरावर्ती परिभाषा, एक पूर्णांक पूर्णांक तर्क लेती है और तीन पूर्णांकों की क्रमबद्ध सूची वापस करती है।