17

एक फ़ंक्शन f (n, k) लिखें जो n से k- आयामी उलटी गिनती प्रदर्शित करता है।

5 से 1-आयामी उलटी गिनती की तरह दिखता है

5 से 2-आयामी उलटी गिनती की तरह दिखता है

अंत में, 5 से 3-आयामी उलटी गिनती की तरह दिखता है

औपचारिक परिभाषा

किसी भी n से 1-आयामी उलटी गिनती n, n-1, ..., 1 संक्षिप्त (एक नई पंक्ति के बाद) के साथ एक एकल पंक्ति है।

किसी भी k के लिए, 1 से k- डायमेंशनल काउंटडाउन सिंगल लाइन है

N> 1 और k> 1 के लिए, n से एक के-डायमेंशनल काउंटडाउन है (k-1)-n से डायमेंशनल काउंटडाउन और उसके बाद n-1 से के-डायमेंशनल काउंटडाउन।

इनपुट

दो सकारात्मक पूर्णांक k और n <= 9, आपके द्वारा चुने गए किसी भी प्रारूप में।

उत्पादन

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

स्कोरिंग

मानक गोल्फ स्कोरिंग।

बोनस का उदाहरण

यहाँ k> n के साथ एक उदाहरण है, 3 से एक 4-आयामी उलटी गिनती (अतिरिक्त टिप्पणियों के साथ जिन्हें वास्तविक समाधान में शामिल नहीं किया जाना है):

 -- 3-dimensional countdown from 3
 321
 21
 1
 21
 1
 1
 -- 4-dimensional countdown from 2:
 ---- 3-dimensional countdown from 2:
 21
 1
 1
 ---- 4-dimensional countdown from 1:
 1

स्पष्टीकरण:

एक पंक्ति के अंकों को आसन्न होने की आवश्यकता नहीं है, लेकिन उन्हें समान रूप से दूरी पर होना चाहिए।

यदि आप चाहें तो आप केवल एक फ़ंक्शन के बजाय एक पूर्ण कार्यक्रम लिख सकते हैं।

code-golf string

— एरिक ट्रेसलर
स्रोत

मुझे यकीन नहीं है कि मैं परीक्षण के मामलों को सही ढंग से समझता हूं। 3 डी और 4 डी उलटी गिनती 2 समान हैं?

— डेनिस

1

@Dennis मुझे लगता है कि इरादा है कि 2 + 4D उलटी गिनती से 2 = 3 डी उलटी गिनती से से 1 4D उलटी गिनती

— Sp3000

यह एक से 3 डी उलटी गिनती नहीं कहना चाहिए?

— विनाशकारी नींबू

आउटपुट में अतिरिक्त नईलाइनों की अनुमति है। कि अर्थ है अनुगामी नई पंक्तियों या वे कहीं भी हो सकता है?

— डेनिस

@ डेनिस एक्स्ट्रा नईलाइन्स कहीं भी आ सकती हैं। ठीक है, 543 \ n21 ठीक नहीं है, लेकिन किसी भी '1' के बाद वे ठीक हैं।

— एरिक ट्रेसलर

15

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

f=lambda n,k:n>1<k and f(n,k-1)+f(n-1,k)or'987654321\n'[~n:]

Ideone पर इसका परीक्षण करें ।

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

कश्मीर से आयामी उलटी गिनती n एक एकल आधार मामले से परिभाषित किया जा सकता:

यदि n = 1 या k = 1 , आउटपुट n है || एन -1 || ... || 1 || ¶ , जहां || संकेत देता है।

सवाल से पुनरावर्ती परिभाषा का उपयोग करना, f(n,k)रिटर्न f(n,k-1)+f(n-1,k)अगर n> 1 और कश्मीर> 1 ; अन्यथा यह अंतिम रिटर्न देता है n + 1 वर्ण देता है '987654321\n'।

— डेनिस
स्रोत

डेनिस अभी बहुत अच्छा है। हालांकि आपने इसे कैसे किया?

— clismique

यहां मेरी एकमात्र अंतर्दृष्टि यह थी कि आप दोनों आधार मामलों को जोड़ सकते हैं। बाकी केवल पुनरावर्ती परिभाषा का सीधा अनुवाद है।

— डेनिस

8

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

R¡UḌFṚp⁷

यह एक पूर्ण कार्यक्रम है जो उम्मीद करता है कमांड लाइन तर्क के रूप में n और k की है।

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

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

R¡UḌFṚp⁷  Main link. Left argument: n. Right argument: k

 ¡        Repeat the link to the left k times.
R           Range; map each integer j in the previous return value to [1, ..., j].
  U       Upend; reverse each 1-dimensional array in the result.
   Ḍ      Undecimal; convert each 1-dimensional array from base 10 to integer.
    F     Flatten the resulting array.
     Ṛ    Reverse the result.
      p⁷  Cartesian product with '\n'. (Join is weird for singleton arrays.)

— डेनिस
स्रोत

के Yस्थान पर काम नहीं करता है p⁷?

— मील

की तरह। के लिए 5, 1, यह प्रदर्शित करता है [54321]।

— डेनिस

5

जावास्क्रिप्ट, 40 38 37 बाइट्स

सहेजे गए 1 बाइट्स @ edc65 के लिए धन्यवाद:

f=(n,k)=>k*n?f(n,k-1)+f(n-1,k):n||`
`

पिछले जवाब

38 बाइट्स @ @ नील को धन्यवाद:

f=(n,k)=>k&&n?f(n,k-1)+f(n-1,k):n||`
`

40 बाइट्स:

f=(n,k)=>k&&n?f(n,k-1)+f(n-1,k):n?n:'\n'

— Hedi
स्रोत

1

के ||बजाय का उपयोग करके एक बाइट बचाओ ?n:। `एस के अंदर एक शाब्दिक newline का उपयोग करके एक और बाइट सहेजें '\n'।

— नील

अतिरिक्त न्यूलाइन्स के बिना मैं सर्वश्रेष्ठ कर सकता था 43:f=(n,k)=>n?(k?f(n,k-1):n)+f(n-1,k):k?``:`\n`

— नील

@Neil मैं नोटपैड ++ का उपयोग कर रहा हूँ बाइट्स और शाब्दिक न्यूलाइन काउंट को 2 char के रूप में गिनने के लिए।

— हेदी

हो सकता है कि आप इसके बजाय अपने ब्राउज़र स्क्रैडपैड में इसे आज़मा सकें?

— नील

1

चतुर, १। लेकिन *इसके बजाय उपयोग करें &&।

— edc65

3

पायथन, 76 75 बाइट्स

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

c=lambda n,k:k>1and'\n'.join(c(n-i,k-1)for i in range(n))or'987654321'[-n:]

ओपी में वर्णित प्रक्रिया से बाहर निकलता है: जब हम सकारात्मक गारंटी दे रहे हैं ( तब से अधिक नहीं है जब स्ट्रिंग की पुनरावृत्ति के आधार के साथ newlines के nलिए घटते परिणामों में शामिल हो जाता हैk-1'n...1'k1k1k इनपुट की ।

आइडोन पर टेस्ट केस

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

3

पायथन, 86 81 80 बाइट्स

o=lambda d,n:"987654321"[-n:]if d<2else"\n".join([o(d-1,n-x) for x in range(n)])

dआयामों की संख्या nहै, उलटी गिनती की संख्या है।

जल्द ही स्पष्टीकरण पोस्ट करेंगे।

EDIT # 1: इसे लंबोदर में बदल दिया।

EDIT # 2: @DestructibleWatermelon के लिए 1 बाइट धन्यवाद बचे।

— clismique
स्रोत

3

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

n#1='\n':(show=<<[n,n-1..1])
1#_=1#1
n#k=n#(k-1)++(n-1)#k

प्रयोग उदाहरण: 5 # 3-> "\n54321\n4321\n321\n21\n1\n4321\n321\n21\n1\n321\n21\n1\n21\n1\n1"।

परिभाषा का प्रत्यक्ष कार्यान्वयन।

— nimi
स्रोत

2

रैकेट 215 बाइट्स

(define(g n k(s(number->string n)))(cond [(< k 2) n]
[else(define o(for/list((i(string-length s)))
(string->number(substring s i))))(for/list((x o))(g x(- k 1)))])) 
(define(f n k)(for-each println(flatten(g n k))))

परिक्षण:

(f 54321 3)

54321
4321
321
21
1
4321
321
21
1
321
21
1
21
1
1

— rnso
स्रोत

उम्म ... 3 डी मोड पर, 54321दो बार क्यों दिखाई देता है?

— आउटगॉल्फ

मैं मुद्दों को सुलझाने की कोशिश कर रहा हूं।

— rnso

@ E @Gʀɪᴋᴛʜᴇ समस्या को ठीक कर दिया गया है।

— रेनो

कूल, और मैं यह भी देख रहा हूं कि आपने बहुत सारे व्हाट्सएप को हटा दिया है!

— आउटगॉल्फ

रैकेट में, लैम्ब्डा ( λ) का उपयोग करने से हमेशा बाइट कम होती है define। इसके अलावा, इनपुट के लिए nएक संख्या निर्दिष्ट की गई थी जिसके लिए आप इनपुट का निर्माण करते हैं (range 1 n)। जब आप बाइट को बचाते हैं, तब से अपने condको बदलने के बारे में भी देखें । ifelse

— स्टीवन एच।

2

जे, 38 37 32 बाइट्स

a:":@>@-.~&,0<@-."1~0&(](-i.)"0)

यह एक ऐसा फंक्शन है जो LHS और n पर k लेता है आरएचएस पर।

@ Adám से विचारों के साथ 5 बाइट्स सहेजे गए।

प्रयोग

   f =: a:":@>@-.~&,0<@-."1~0&(](-i.)"0)
   3 f 5
5 4 3 2 1
4 3 2 1  
3 2 1    
2 1      
1        
4 3 2 1  
3 2 1    
2 1      
1        
3 2 1    
2 1      
1        
2 1      
1        
1

व्याख्या

a:":@>@-.~&,0<@-."1~0&(](-i.)"0)  Input: k on LHS, n on RHS
                    0&(        )  Repeat k times on initial value n
                        (   )"0   For each value x
                          i.        Make the range [0, x)
                         -          Subtract x from each to make the range [x, 1]
                       ]            Return the array of ranges
            0  -."1~              Remove the zeros from each row
             <@                   Box each row
          &,                      Flatten the array of boxes
a:     -.~                        Remove the empty boxes
     >@                           Unbox each
  ":@                             Convert it into a string and return

— मील की दूरी पर
स्रोत

आपको मेरे दृष्टिकोण का उपयोग करने में सक्षम होना चाहिए ।

— आदम

@ Adám धन्यवाद, मैं इसे आज़माऊँगा

— मील

2

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

के लिए संकेत देता n , तो के लिए कश्मीर ।

~∘'0'⍤1⍕(⌽⍳)⍤0⍣⎕⊢⎕

~∘'0'⍤1निकालें ( ~) ( ∘) शून्य ( '0') पंक्तियों से (⍤1 ) (आवश्यकतानुसार रिक्त स्थान के साथ पैडिंग)

⍕ के चरित्र का प्रतिनिधित्व

(⌽⍳)⍤0⍣⎕उलट ( ⌽) तक गिनती ( ⍳) प्रत्येक स्केलर ( ⍤0), दोहराया ( ⍣) इनपुट ( ⎕) बार

⊢ पर

⎕ संख्यात्मक इनपुट

TryAPL ऑनलाइन!

— एडम
स्रोत

2

सी 93 बाइट्स

Iterative कार्यान्वयन।

m,i,j;f(n,k){for(;m<k+2;m++)for(j=0;j<n;j++){for(i=m;i<n-j;i++)printf("%d",n-j-i);puts("");}}

सी 67 65 61 56 52 बाइट्स

पुनरावर्ती कार्यान्वयन

f(n,k){n*k?f(n,k-1)+f(n-1,k):puts("987654321"+9-n);}

— cleblanc
स्रोत

आप चार * का उपयोग किए बिना तारों की घोषणा नहीं कर सकते, इसलिए आपका पुनरावर्ती कार्यान्वयन संकलित नहीं करता है। लेकिन समाधान बहुत आसान है और 4 बाइट की बचत होती है: बस की जगह mके अंदर puts()के साथ कॉल "987654321"।

— जी। स्लीपेन

मैंने gcc (GCC) 3.4.4 (cygming special, gdc 0.12, dmd 0.125 का उपयोग करके) का संकलन किया। मुझे लगता है कि यह ठीक है क्योंकि मैं सिर्फ चार * से इंट में परिवर्तित कर रहा हूं, हालांकि, चूंकि आपका समाधान 4 बाइट्स छोटा है इसलिए मुझे यह पसंद है। धन्यवाद

— क्लैब्लांक

1

बैच, 117 बाइट्स

@setlocal
@set/an=%1-1,k=%2-1,p=n*k,s=987654321
@if %p%==0 (call echo %%s:~-%1%%)else call %0 %1 %k%&call %0 %n% %2

पोर्ट ऑफ डेनिस के पायथन जवाब।

— नील
स्रोत

1

रूबी, 56 बाइट्स

f=->n,k{n>1&&k>1?[f[n,k-1],f[n-1,k]]:[*1..n].reverse*""}

प्रयोग

जब आप कोई समाधान प्रदर्शित करते हैं, तो आपको "कर्नेल # पुट" का उपयोग करना चाहिए।

उदाहरण:

puts f[9,3]

— cia_rana
स्रोत