एक इमरजेंसी कॉरिडोर बनाओ

46

कुछ देशों में सड़कों पर आपातकालीन गलियारे बनाने की सिफारिशें या कानून हैं जो प्रति दिशा में कई लेन हैं। (निम्नलिखित में हम केवल हम जिस दिशा में यात्रा कर रहे हैं वहां जाने वाली गलियों पर विचार करते हैं।) ये वे नियम हैं जो जर्मनी में हैं:

  • यदि केवल एक लेन है, तो सभी को दाईं ओर ड्राइव करना चाहिए ताकि बचाव वाहन बाईं ओर से गुजर सकें।
  • यदि दो या अधिक लेन हैं, तो बाईं ओर की लेन पर चलने वाली कारों को बाईं ओर चलना चाहिए, और बाकी सभी को दाईं ओर ले जाना चाहिए।

चुनौती

N>0नियमित गलियों की संख्या को देखते हुए, गलियों के लेआउट का उत्पादन करते हैं जब N+1ASCII वर्णों की एक स्ट्रिंग का उपयोग करके एक आपातकालीन गलियारा बनाया जाता है । आप ASCII कोड से किसी भी दो अक्षर का उपयोग कर सकते 33करने के लिए 126आपात गलियारे निरूपित करने के लिए एक, और कारों को संकेतित के लिए एक। ट्रेलिंग या अग्रणी स्थान, लाइन ब्रेक आदि की अनुमति है।

उदाहरण

यहां हम Eआपातकालीन कॉरिडोर के लिए, और Cकारों के लिए उपयोग कर रहे हैं ।

N  Output
1  EC
2  CEC
3  CECC
4  CECCC
5  CECCCC
6  CECCCCC
   etc
code-golf  ascii-art  number 
— flawr
स्रोत
18
मैं इस के लिए गिर नहीं होगा! तुम बस अपनी खुद की एक गली के लिए देख रहे हो तुम डरपोक साँप के माध्यम से।
— orlp
16
@PmanAce मुझे नहीं लगता कि त्रुटिपूर्ण को इसके लिए हमारी मदद की जरूरत है: P
— orlp
8
+1 क्योंकि यह वास्तव में जर्मनी में काम करता है। पिछले सप्ताहांत में स्थिति में था।
— एलपीड्रो
10
@ msh210 मुझे लगता है कि जर्मन WP पेज की तस्वीरें इसे सबसे अच्छा समझाती हैं।
— flawr
9
तुम्हें पता है, पहली बार में यह एक चुनौती के साथ एक बिंदु की तरह लग रहा था Cऔर E, लेकिन इस चुनौती के लिए बहुत अच्छे दृष्टिकोण संभव हैं! शीर्ष उत्तर के लिए C=1/ E=2या C=2/ E=3जैसे गणितीय कार्यों का उपयोग करना ; का उपयोग C=0/ E=1साथ 10^(n-1); दशमलव स्वरूपण के द्वारा C=0/ उपयोग करके ; उपयोग करके / उपयोग करके ; आदि आदि एक चुनौती के लिए बहुत सारी अनोखी संभावनाएँ जो पहली बार में बहुत महत्वपूर्ण थीं। बहुत बुरा मैं केवल एक बार +1 कर सकता हूं। ;)E=.0.0C=1E=--1
— केविन क्रूज़सेन

जवाबों:

29

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

lambda n:10**n*97/30-1/n*9

उदाहरण:

>>> f(1)
23
>>> f(2)
323
>>> f(3)
3233
— orlp
स्रोत
आपको n = 1 मामले में 21 उत्पादन करने की आवश्यकता है
— डैनियलइंडी
1
@ डैनियलइंडी :( निश्चित लेकिन अब यह बदसूरत है।
— orlp
अभी भी एक बहुत ही रचनात्मक समाधान :)
— दोष
1
@orlp सॉरी :) लेकिन फिर भी एक अच्छा समाधान :)
— डैनियलइंडी
3
10**n*97/30-1/n*9एक और बाइट देता है, f(5) == 323333आदि
— लिन
28

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

lambda N:'C'*(N>1)+'EC'+'C'*(N-2)

संपादित करें: f=2 बाइट्स को बचाने के लिए छोड़ने , @dylnan के अनुस्मारक के लिए धन्यवाद ।

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

इसकी कल्पना करने के लिए:

lambda N:'🚘'*(N>1)+'🚔🚘'+'🚘'*(N-2)

आउटपुट:

1 🚔🚘
2 🚘🚔🚘
3 🚘🚔🚘🚘
4 🚘🚔🚘🚘🚘
5 🚘🚔🚘🚘🚘🚘
6 🚘🚔🚘🚘🚘🚘🚘

ऑनलाइन 🚔 कोशिश करो!

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

एक सीधा समाधान:

lambda N:str(10**N).replace('100','010')

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

— गौयांग किन
स्रोत
2
मुझे लगता है कि 'सीधा' समाधान के बाद अनावश्यक व्हाट्सएप हैlambda N:
— कोई 14
@someone मुझे उस बारे में पता नहीं था, धन्यवाद।
— गुआयांग किन
14

जप, 5 4 बाइट्स

qकारों के +लिए और गलियारे के लिए उपयोग करता है ।

ç¬iÄ

कोशिश करो

ऑलिवर को श्रेय, जिन्होंने 4 बाइट्स की थी उसी समय को बंद कर दिया जैसा मैंने किया था।

व्याख्या

एक संक्षिप्त समाधान लेकिन एक मुश्किल व्याख्या!

सबसे पहले सामान सीधे: çविधि, जब किसी पूर्णांक पर लागू होती है, तो कई बार अपने स्ट्रिंग तर्क को दोहराता है। iविधि 2 तर्कों (लेता है sऔर n) और आवेषण sसूचकांक में nस्ट्रिंग यह पर लागू की गई की।

उपयोग किए गए 2 यूनिकोड शॉर्टकट का विस्तार करना हमें देता है çq i+1, जो जेएस के लिए ट्रांसप्लान्ड हो जाता है U.ç("q").i("+",1), Uइनपुट कहां है। इसलिए हम q Uबार-बार दोहरा रहे हैं और फिर एक +इंडेक्स 1 पर डाल रहे हैं ।

अंतिम चाल यह है कि, जाप के इंडेक्स रैपिंग के लिए धन्यवाद, जब U=1, इंडेक्स में iसम्मिलित करेगा , आप इसके लिए जो भी मूल्य फ़ीड करेंगे ।+0n

— झबरा
स्रोत
मैं ç0 iQ16 बाइट्स के लिए पोस्ट करने जा रहा था , लेकिन अगर आप इसे इस्तेमाल करते हैं तो बेहतर होगा।
— ओलिवर
धन्यवाद, @ ऑलिवर हालांकि इस बीच यह 5 बाइट्स तक गिर गया।
— झबरा
1
ç¬iÅ4 बाइट्स के लिए;) मैंने कभी भी जप्ट को इतना अधिक गाली नहीं दी।
— ओलिवर
मैं बस :) के Äबजाय के साथ ऐसा ही करने वाला थाÅ
— झबरा
7

आर, 50 बाइट्स

-११ ग्यूसेप के लिए धन्यवाद!

pryr::f(cat("if"(x<2,12,c(21,rep(2,x-1))),sep=""))

आपातकालीन गलियारे के लिए आउटपुट 1 और सामान्य गलियों के लिए 2

मेरी कोशिश, 61 बाइट्स

यहाँ देखने के लिए कुछ भी फैंसी नहीं है, लेकिन चलो स्कोरबोर्ड पर आर प्राप्त करें =)

q=pryr::f(`if`(x<2,cat("EC"),cat("CE",rep("C",x-1),sep="")))

उपयोग:

q(5)
CECCCC
— जानबूझ का मजाक
स्रोत
21 = 12 + 9 का उपयोग करके 8 बाइट्स बचाएं और बिना किसी tio.run/##K/r/v6CossjKKk0jObFEw1JLI8 ...
— JayCe
6

अजगर 2, 30 29 28 बाइट्स

lambda n:`10/3.`[1/n:n-~1/n]

के 3बजाय Cऔर के .बजाय मुद्रित करें E।

स्पष्टीकरण:

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

lambda n:    # Method with integer parameter and string return-type
  `10/3.`    #  Calculate 10/3 as decimal (3.333333333) and convert it to a string
  [1/n       #   Take the substring from index 1 if `n=1`, 0 otherwise
   ,n-~      #   to index `n+1` +
       1/n]  #    1 if `n=1`, 0 otherwise

पायथन 2, 33 32 31 29 28 बाइट्स

lambda n:1%n-1or'1-'+'1'*~-n

के 1बजाय Cऔर के -बजाय प्रिंट E।

-2 बाइट्स थैंक्स टू @ovs ।
-1 बाइट @xnor के लिए धन्यवाद ।

स्पष्टीकरण:

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

lambda n:    # Method with integer parameter and string return-type
  1%n-1      #  If `n` is 1: Return '-1'
  or         #  Else:
    '1-'+    #   Return '1-', appended with:
    '1'*~-n  #   `n-1` amount of '1's
— केविन क्रूज़सेन
स्रोत
1
10/317
— जो किंग
1
@JoKing मैंने केवल ओपी के साथ स्पष्ट किया, और उन्होंने कहा " अंतर्निहित पूर्णांक प्रकार का उपयोग करना पर्याप्त है। ", जिसका अर्थ है कि n=16यदि आपका पूर्णांक अंतर्निहित 64-बिट पर्याप्त है, या इस मामले में n=16जब दशमलव मान हो सकता है ' t डिफ़ॉल्ट रूप से 15 से अधिक दशमलव अंक रखना पर्याप्त है। (समान जावा, C # .NET आदि जैसी मनमानी संख्या आकारों वाली भाषाओं का उपयोग करते हुए बहुत सारे अन्य उत्तरों पर लागू होता है)
— केविन क्रूज़सेन
5

ब्रेनफक , 42 बाइट्स

,[[>]+[<]>-]>>[<]<[<]>+>+<[<-[--->+<]>.,>]

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

चार कोड के रूप में इनपुट लेता है और Vसामान्य लेन के रूप में आउटपुट करता है और Wक्लियर लेन होता है। (आसानी से परीक्षण करने के लिए, मैं ,कई +एस के साथ बदलने की सलाह देता हूं )

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

,[[>]+[<]>-] Turn input into a unary sequence of 1s on the tape
>>[<]<[<]    Move two cells left of the tape if input is larger than 1
             Otherwise move only one space
>+>+<        Add one to the two cells right of the pointer
             This transforms:
               N=1:  0 0' 1 0  -> 0 2' 1 0
               N>1:  0' 0 1 1* -> 0 1' 2 1*
[<-[--->+<]>.,>]  Add 86 to each cell to transform to Ws and Vs and print
— मजाक कर रहा है
स्रोत
5

ऑक्टेव (MATLAB *), 31 30 28 27 22 बाइट्स

@(n)'CE'(1+(n>1==0:n))

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

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

@(n)                   %Anonymous function to take input
            n>1==0:n   %Creates [1 0] if n is 1, or [0 1 (0 ...)] otherwise
         1+(        )  %Converts array of 0's and 1's to 1-indexed
    'CE'(            ) %Converts to ASCII by addressing in string

यहाँ प्रयोग की गई ट्रिक बीज की सरणी को 0:nएक चेक के साथ एक्सनोरिंग कर रही है यदि इनपुट 1 से अधिक है। इसका परिणाम यह होता है कि n>1बीज एक तार्किक सरणी में परिवर्तित हो जाता है [0 1 (0 ...)]जबकि n==1बीज उल्टा हो जाता है [1 0], जिससे आवश्यक उलटा प्राप्त होता है।

बाकी बस बीज को पर्याप्त रूप से उन्नत कारों के साथ एक स्ट्रिंग में परिवर्तित करना है।

(*) TIO लिंक में पाद टिप्पणी में उसी बाइट की एक ही संख्या के लिए एक वैकल्पिक समाधान शामिल है जो MATLAB के साथ-साथ ऑक्टेव में भी काम करता है, लेकिन इसका परिणाम 'E' और 'के बजाय' 0 'और' 1 'के अनुक्रम में होता है। सी'। पूर्णता के लिए, वैकल्पिक है:

@(n)['' 48+(n>1==0:n)]

  • के n==1~=0:1बजाय का उपयोग करके 1 बाइट बचाया 0:1~=(n<2)। ~=पर पूर्वता है <, इसलिए मूल कोष्ठक, लेकिन ऐसा लगता है कि ~=और ==उपस्थिति के क्रम में संभाला जाता है ताकि 1 के साथ तुलना करके हम एक बाइट को बचा सकें।

  • 2 बाइट्स को बदलकर सहेजा जाता है, जहां की उपेक्षा की 2:nजाती है। यह कोष्ठक की एक जोड़ी बचाता है। हम यह भी बदलना होगा ~=करने के लिए ==तथ्य यह है कि यह बाद में नकार दिया हो जाएगा के लिए खाते में।

  • <फिर से उपयोग करके 1 बाइट को बचाया । पता चलता <है कि ==सभी के बाद एक ही मिसाल है । रखने <गणना से पहले ==निष्पादन की सही क्रम सुनिश्चित करता है।

  • दो अलग-अलग सरणियों को नहीं बनाकर 5 बाइट्स बचाए। इस तथ्य पर भरोसा करने के बजाय कि XNOR तुलना किसी भी श्रेणी को किसी भी तरह से तार्किक में बदल देगी।

— टॉम बढ़ई
स्रोत
बहुत चालाक :-)
— स्टीवी ग्रिफिन
@StewieGriffin धन्यवाद :)। एक और 5 बाइट्स और अधिक दस्तक करने में कामयाब रहे।
— टॉम कारपेंटर
4

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

lambda n:f"{'CE'[n<2:]:C<{n+1}}"

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

F- स्ट्रिंग अभिव्यक्ति को 'E'या तो प्रारूपित करने के लिए उपयोग करता है या 'CE'दाईं ओर गद्देदार होता है 'C'ताकि इसकी चौड़ाई हो n+1।

f"{          :       }    a Python 3 f-string expression.
   'CE'[n<2:]             string slice based on value of n.
             :            what to format is before the ':' the format is after.
              C           padding character
               <          left align
                {n+1}     minimum field width based on n
— RootTwo
स्रोत
4

ब्रेन-फ्लैक , 100 66 बाइट्स

{({}[()]<((((()()()()){}){}){}())>)}{}(({}<>)())<>{<>{({}<>)<>}}<>

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

"आपातकालीन लेन के !रूप में और सामान्य लेन के रूप में उपयोग करता है ।

— मजाक कर रहा है
स्रोत
सभी चीजों की इस भाषा का उपयोग करने के लिए +1। XD
— एलेक्स
2
@ एलेक्स, वेल, ब्रेन-फ्लैक अप्रैल के लिए महीने की भाषा है
— जो किंग
गंभीरता से या देर से अप्रैल फूल मजाक? महीने की भाषाएँ कहाँ से चुनी जाती हैं?
— एलेक्स
@ एलेक्स नामांकन और यहां मतदान , और फिर एक महीने का विशिष्ट पद इस
— कामिल दकरी
ओह, यह इस मंच पर है। मैं देखता हूं, धन्यवाद! :-)
— एलेक्स
4

05AB1E , 7 बाइट्स

Î>∍1I≠ǝ

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

0 सी है और 1 ई है।

व्याख्या

Î>          # Push 0 and input incremented            -- [0, 4]
  ∍         # Extend a to length b                    -- [0000]
   1I≠      # Push 1 and input falsified (input != 1) -- [0000, 1, 1] 
      ǝ     # Insert b in a at location C             -- [0100]
            # Implicit display
— Kaldo
स्रोत
ओह तुम धूर्त लोमड़ी। $<×TìsiRमैं कैसे सोच रहा था।
— मैजिक ऑक्टोपस Urn
@MagicOctopusUrn यह एक दिलचस्प तरीका है! मैंने "अगर" निर्माण पर भी ध्यान दिया है, लेकिन इसके लिए कम से कम 3 बाइट्स की आवश्यकता है, इसलिए एक अलग दृष्टिकोण की आवश्यकता है :-)
— कलाडो
05AB1E के नए संस्करण में, को गोल्फ में रखा 1Iजा सकता है $।
— केविन क्रूज़सेन
5 बाइट्स (विरासत संस्करण में भी काम करता है)।
— केविन क्रूज़सेन
4

एपीएल (डायलॉग यूनिकोड) , 21 17 16 बाइट्स

(-≠∘1)⌽'E',⍴∘'C'

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

एक और बाइट के लिए 4 बाइट और Adám को बचाने के लिए एरिक का धन्यवाद।

कैसे?

(-≠∘1)⌽'E',⍴∘'C' ⍝ Tacit function
           ⍴∘'C' ⍝ Repeat 'C', according to the input
       'E',      ⍝ Then append to 'E'
      ⌽          ⍝ And rotate
    1)           ⍝ 1
  ≠∘             ⍝ Different from the input? Returns 1 or 0
(-               ⍝ And negate. This rotates 0 times if the input is 1, and once if not.
— जे। सल्ल
स्रोत
1
(⍵>1)कोष्ठक में होने की आवश्यकता नहीं है। और आप एक टैसिट फ़ंक्शन के साथ 4 बाइट्स बचा सकते हैं (⊢×1<⊢)⌽'E',⍴∘'C':।
— आउटगोल्फर
@EriktheOutgolfer धन्यवाद! मेरे पास पोस्ट करने के बाद मौन रहने का समय नहीं था क्योंकि आज मेरी कक्षा थी। घर पहुँचते ही मैं संपादन करूँगा।
— जे। सेले
— आदम
15 बाइट्स के साथ =io = 0:'CE'[1(≠=∘⍳+)⎕]
— ngn
@ng मैं भी नहीं कर सकता ... क्या आप मुझे परीक्षण मामलों के साथ TIO लिंक प्राप्त कर सकते हैं? यह काम करने के लिए प्रतीत नहीं कर सकते ...
— जे। सल्ल।
4

हास्केल , 35 33 32 बाइट्स

2 बाइट्स ने एंगस को धन्यवाद दिया, 1 बाइट ने लिन को धन्यवाद बचाया

(!!)$"":"EC":iterate(++"C")"CEC"

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

हास्केल , 32 30 29 बाइट्स

यह शून्य अनुक्रमित है इसलिए यह चुनौती का अनुपालन नहीं करता है

g=(!!)$"EC":iterate(++"C")"CEC"

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

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

यह काम नहीं करता क्योंकि आउटपुट के लिए एक स्ट्रिंग होना आवश्यक है

f 1=21
f 2=121
f n=10*f(n-1)+1

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

यहां हम कारों के लिए 2, आपातकालीन गलियारे के लिए , तार के बजाय संख्या का उपयोग 1करते हैं। हम 1अंत में 10 से गुणा करके और जोड़कर जोड़ सकते हैं 1। यह सस्ता है क्योंकि हमें कंसंट्रेशन और स्ट्रिंग लिटरल के लिए सभी बाइट्स के लिए भुगतान नहीं करना पड़ता है।

इसके 0बजाय इसका उपयोग करना सस्ता होगा , 1लेकिन हमें अग्रणी शून्य की आवश्यकता है, जो अंत में छंटनी हो रही है।

— गेहूं का जादूगर
स्रोत
((blah)!!)(!!)$blahअपने पहले दो उत्तरों में एक बाइट को बचाने के लिए बन सकता है।
— लिन
@Lynn धन्यवाद! मैंने पहले ऐसा करने की कोशिश की थी, लेकिन मैंने बाइट्स की गलत गिनती की होगी।
— गेहूं जादूगर
4

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

lambda n:"CEC"[~n:]+"C"*(n-2)

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

ठीक है, पहले से ही बहुत सारे पायथन उत्तर हैं, लेकिन मुझे लगता है कि यह संख्याओं के बजाय "ई" और "सी" चार्ट का उपयोग करने वालों के बीच पहला उप -30 बटर है।

— किरिल एल।
स्रोत
3

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

ü♣àj#F

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

यह वर्ण "0" और "1" का उपयोग करता है। यह काम करता है क्योंकि जब आप आकार 1 की एक सारणी को घुमाते हैं, तो यह परिवर्तित नहीं होता है।

अनपैक्ड, अनगुल्फेड और टिप्पणी की गई, यह इस तरह दिखता है।

1]( left justify [1] with zeroes. e.g. [1, 0, 0, 0]
|)  rotate array right one place
0+  append a zero
$   convert to string

इसको चलाओ

— पुनरावर्ती
स्रोत
3

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

⁵*ṾṙỊṙ

कार लेन को 0 , आपातकालीन लेन को 1 के रूप में प्रदर्शित करता है ।

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

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

⁵*ṾṙỊṙ  Main link. Argument: n

⁵*      Compute 10**n.
  Ṿ     Uneval; get a string representation.
   ṙỊ   Rotate the string (n≤1) characters to the left.
     ṙ  Rotate the result n characters to the left.
— डेनिस
स्रोत
3

व्हॉट्सएप , 141 104 103 बाइट्स

[S S S N
_Push_0][S N
S _Duplicate_0][T   N
T   T   _Read_STDIN_as_number][T    T   T   _Retrieve][S S S T  S N
_Push_2][T  S S T   _Subtract][S N
S _Duplicate_input-2][N
T   T   N
_If_negative_Jump_to_Label_-1][S S S T  N
_Push_1][S N
S _Duplicate_1][T   N
S T _Print_as_integer][S S T    T   N
_Push_-1][T N
S T _Print_as_integer][T    S S T   _Subtract][N
S S T   N
_Create_Label_LOOP][S N
S _Duplicate][N
T   T   S N
_If_negative_Jump_to_EXIT][S S S T  N
_Push_1][S N
S _Duplicate_1][T   N
S T _Print_as_integer][T    S S T   _Subtract][N
S N
T   N
_Jump_to_LOOP][N
S S N
_Create_Label_-1][T N
S T _Print_as_integer][N
S S S N
_Create_Label_EXIT]

पत्र S(स्थान), T(टैब), और N(नई-पंक्ति) केवल हाइलाइटिंग के रूप में जोड़े गए।
[..._some_action]केवल स्पष्टीकरण के रूप में जोड़ा गया।

के 1बजाय Cऔर के -बजाय प्रिंट E।

-1 बाइट के लिए धन्यवाद @JoKing के उपयोग का सुझाव देकर 1और -1के बजाय 0और 1।

छद्म कोड में स्पष्टीकरण:

Integer i = STDIN-input as integer - 2
If i is negative (-1):
  Print i (so print "-1")
Else:
  Print "1-1"
  Start LOOP:
    If i is negative:
      EXIT program
    Print "1"
    i = i-1
    Go to the next iteration of the LOOP

उदाहरण चलता है:

इनपुट: 1

Command   Explanation                 Stack      Heap    STDIN   STDOUT   STDERR

SSSN      Push 0                      [0]
SNS       Duplicate top (0)           [0,0]
TNTT      Read STDIN as integer       [0]        {0:1}   1
TTT       Retrieve heap at 0          [1]        {0:1}
SSSTSN    Push 2                      [1,2]      {0:1}
TSST      Subtract top two            [-1]       {0:1}
SNS       Duplicate input-2           [-1,-1]    {0:1}
NTSN      If neg.: Jump to Label_-1   [-1]       {0:1}
NSSN      Create Label_-1             [-1]       {0:1}
TNST      Print top as integer        []         {0:1}           -1
NSSSN     Create Label_EXIT           []         {0:1}
                                                                         error

इसे ऑनलाइन आज़माएं (केवल कच्चे स्थानों, टैब और नई-लाइनों के साथ)।
त्रुटि के साथ रुकता है: परिभाषित नहीं किया गया है।

इनपुट: 4

Command   Explanation                   Stack      Heap    STDIN   STDOUT   STDERR

SSSN      Push 0                        [0]
SNS       Duplicate top (0)             [0,0]
TNTT      Read STDIN as integer         [0]        {0:4}   4
TTT       Retrieve heap at 0            [4]        {0:4}
SSSTSN    Push 2                        [4,2]      {0:4}
TSST      Subtract top two              [2]        {0:4}
SNS       Duplicate input-2             [2,2]      {0:4}
NTSN      If neg.: Jump to Label_-1     [2]        {0:4}
SSSTN     Push 1                        [2,1]      {0:4}
SNS       Duplicate top (1)             [2,1,1]    {0:4}
TNST      Print as integer              [2,1]      {0:4}           1
SSTTN     Push -1                       [2,1,-1]   {0:4}
TNST      Print as integer              [2,1]      {0:4}           -1
TSST      Subtract top two              [1]        {0:4}
NSSTN     Create Label_LOOP             [1]        {0:4}
 SNS      Duplicate top (1)             [1,1]      {0:4}
 NTTSN    If neg.: Jump to Label_EXIT   [1]        {0:4}
 SSSTN    Push 1                        [1,1]      {0:4}
 SNS      Duplicate top (1)             [1,1,1]    {0:4}
 TNST     Print as integer              [1,1]      {0:4}           1
 TSST     Subtract top two              [0]        {0:4}
 NSNTN    Jump to Label_LOOP            [0]        {0:4}

 SNS      Duplicate top (0)             [0,0]      {0:4}
 NTTSN    If neg.: Jump to Label_EXIT   [0]        {0:4}
 SSSTN    Push 1                        [0,1]      {0:4}
 SNS      Duplicate top (1)             [0,1,1]    {0:4}
 TNST     Print as integer              [0,1]      {0:4}           1
 TSST     Subtract top two              [-1]       {0:4}
 NSNTN    Jump to Label_LOOP            [-1]       {0:4}

 SNS      Duplicate top (-1)            [-1,-1]    {0:4}
 NTTSN    If neg.: Jump to Label_EXIT   [-1]       {0:4}
NSSSN     Create Label_EXIT             [-1]       {0:4}
                                                                            error

इसे ऑनलाइन आज़माएं (केवल कच्चे स्थानों, टैब और नई-लाइनों के साथ)।
त्रुटि के साथ रुकता है: परिभाषित नहीं किया गया है।

— केविन क्रूज़सेन
स्रोत
क्या -मुद्रण को दुरुपयोग करके स्पष्ट लेन को प्रिंट करना आसान होगा -1?
— जो किंग
@JoKing दुर्भाग्य से यह लंबा होगा। इसे ऑनलाइन 112 बाइट्स आज़माएं । यह वास्तव में बदल गया push_0; print_as_integer; push_1; print_as_integerको push_-1; print_as_integer, लेकिन बदले में दो push_0; print_as_integerके साथ बदल दिया जाता है push_45; print_as_character, जहां push_0= SSSN, और push_45= SSSTSTTSTN। और एक अतिरिक्त push_45भी जोड़ा जाना है, क्योंकि इनपुट के लिए n=1अब मैं डुप्लिकेट किए गए प्रिंट को प्रिंट करता 0हूं जो पहले से ही स्टैक पर था, इसलिए मुझे 0फिर से धक्का नहीं देना पड़ा क्योंकि 0स्टैक पर पहले से ही था।
— केविन क्रूज़सेन
मेरा मतलब था -कि जगह 1और 1जगह 0। तब आप 45 पुश करने से बचेंगे, और जहाँ तक मैं यह बता सकता हूँ कि यह सशर्त की पहली छमाही में एक नंबर को प्रिंट करने पर बचाएगा, लेकिन 1 के बजाय 1 को पुश करने पर लागत में थोड़ी वृद्धि होगी। >> मेरे गोल> <> के लिए उत्तर दें आउटपुट का एक उदाहरण मेरा मतलब है
— जो किंग
1
@JoKing मैंने इसे लागू करने की कोशिश की है, लेकिन मैं 107 बाइट्स पर समाप्त हो गया (यहां एक ही कोड जोड़ा हाइलाइटिंग और स्पष्टीकरण के साथ है )। यह वास्तव में पर बचाता print_-1प्रिंट के बजाय 0और 1, लेकिन एक अतिरिक्त print_-1लूप के बाहर आवश्यक है। संपादित करें: इसे बदलकर 103 बाइट्स तक कम करने में सक्षम subtract_1; if_0_jump_to_ONE; push_-1; print_integerको subtract_2; if_negative_jump_to_ONE; print_integer, क्योंकि -1 पहले से ही स्टैक पर है। तो -1 बाइट के लिए धन्यवाद। :)
— केविन क्रूज़सेन
3

AutoHotkey 32 बाइट्स

"C" अक्षर को "EC" से बदल देता है जब तक C> 1 की मात्रा नहीं होती है, तब यह "CEC" भेजता है और ऐप को बाहर निकालता है।

::C::EC
:*:CC::CEC^c
^c::ExitApp

C => EC
CC => CEC तब प्रोग्राम से बाहर निकलता है। कार्यक्रम से बाहर निकलने के बाद किसी भी आगे Cs दर्ज किया जाएगा।

— nelsontruran
स्रोत
3

एपीएल + विन, 20 16 बाइट्स

4 बाइट्स ने Adám को धन्यवाद दिया

पूर्णांक एन के लिए संकेत:

(-2≠⍴n)⌽n←1⎕/⍕10

कारों के लिए आपातकालीन कॉरिडोर ओ के लिए 1।

— ग्राहम
स्रोत
16:(-2≠⍴n)⌽n←1⎕/⍕10
— एडम
@ Adám धन्यवाद मैं ngn की चाल देखता हूं, 1 trick / n, उपयोगी में आ रहा है। मुहावरे की सूची के लिए एक?
— ग्राहम
आप किस मुहावरे की सूची के बारे में बात कर रहे हैं?
— एडम
@ Adám दो मुहावरे की सूची जो मैं सबसे अधिक उपयोग करता हूँ, वे हैं फिनप्ल और एपीएल २िडियम्स
— ग्राहम
मुझे यकीन नहीं है कि यहाँ क्या मुहावरा है। यह सिर्फ गोल्फ है। वैसे भी, मेरी मुहावरे की सूची में आपकी रुचि हो सकती है।
— 17
3

मठगोल्फ , 7 6 बाइट्स

ú░\┴╜╪

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

के 1लिए Eऔर के 0लिए आउटपुट C।

स्पष्टीकरण:

ú         # 10 to the power of the (implicit) input
          #  i.e. 1 → 10
          #  i.e. 4 → 10000
 ░        # Convert it to a string
          #  i.e. 10 → "10"
          #  i.e. 10000 → "10000"
  \       # Swap so the (implicit) input is at the top of the stack again
   ┴╜     # If the input is NOT 1:
     ╪    #  Rotate the string once towards the right
          #   i.e. "10000" and 4 → "01000"
          # Output everything on the stack (which only contains the string) implicitly
— केविन क्रूज़सेन
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.