संख्या में वृद्धि जबकि पत्र में वृद्धि

18

अक्षरों की संख्या में कमी आने पर यादृच्छिक रूप से प्रेरित

मिश्रित पत्र और पूर्णांकों (जैसे, की एक सूची को देखते हुए ['a', 2, 3, 'b']) को बढ़ाने के पत्र वर्णमाला (कम से रैपिंग में एक स्थान से zकरने के लिए a) और कमी 1. द्वारा संख्या ऊपर उदाहरण के लिए, उत्पादन होना चाहिए ['b', 1, 2, 'c']।

  • इनपुट एक मिश्रित प्रकार की सूची, एक सीमांकित स्ट्रिंग, तारों की एक सूची आदि हो सकती है।
  • zलपेटता है a, लेकिन 1जाता है 0, और 0जाता है -1, आदि।
  • इनपुट केवल [a-z]और कभी भी पूर्णांक होगा। [A-Z]यदि आप आपके लिए आसान हैं तो आप इनपुट के रूप में कैपिटल लेटर चुन सकते हैं ।
  • इनपुट गैर-रिक्त की गारंटी है।
  • इनपुट में केवल नंबर या केवल अक्षर हो सकते हैं।

उदाहरण:

Input
Output

['a', 2, 3, 'b']
['b', 1, 2, 'c']

['a', 'b', 'z']
['b', 'c', 'a']

[-1, 0, 257, 'x']
[-2, -1, 256, 'y']

[0, 3, 1, 20382876]
[-1, 2, 0, 20382875]

नियम और स्पष्टीकरण

  • इनपुट और आउटपुट किसी भी सुविधाजनक विधि द्वारा दिया जा सकता है ।
  • आप परिणाम को STDOUT में प्रिंट कर सकते हैं या इसे फ़ंक्शन परिणाम के रूप में वापस कर सकते हैं।
  • आउटपुट का इनपुट के समान प्रारूप होना आवश्यक नहीं है (उदाहरण के लिए, आप इनपुट को स्ट्रिंग के रूप में ले सकते हैं और सूची के रूप में आउटपुट)।
  • या तो एक पूर्ण कार्यक्रम या एक समारोह स्वीकार्य हैं।
  • यदि लागू हो, तो आप इनपुट / आउटपुट पूर्णांकों को अपनी भाषा की मूल intश्रेणी में फिट कर सकते हैं ।
  • मानक खामियों को मना किया जाता है।
  • यह कोड-गोल्फ है इसलिए सभी सामान्य गोल्फिंग नियम लागू होते हैं, और सबसे छोटा कोड (बाइट्स में) जीतता है।
code-golf  integer  alphabet 
— AdmBorkBork
स्रोत
1
यदि संख्या Integer.MinValue के बराबर है या किसी हस्ताक्षरित पूर्णांक का सबसे कम मूल्य मेरी भाषा में है, तो क्या मुझे Integer.maxValue को कम करना चाहिए या क्या मुझे गिनती जारी रखनी चाहिए?
— नजला
1
@ निज़ल अपरिभाषित व्यवहार। नियमों और स्पष्टीकरण के तहत 5 वीं गोली बिंदु निर्दिष्ट करता है कि इनपुट और आउटपुट पूर्णांक दोनों आपकी भाषाओं में देशी intश्रेणी में आते हैं, इसलिए आपको Integer.MinValueइनपुट के रूप में कभी नहीं मिलेगा ।
— AdmBorkBork

जवाबों:

5

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

lambda a:[i-1if''!=i*0else chr(97+(ord(i)+8)%26)for i in a]

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

-1 बाइट थैंक्स टू एरिक द आउटगोलर

— Jitse
स्रोत
1
— आउटगोल्फर
@EriktheOutgolfer पूर्णांक बनाम स्ट्रिंग तुलना आपके समाधान में काम नहीं करती प्रतीत होती है।
— १२:५४ पर Jitse
ओह ठीक है, उसके लिए आपको पायथन 2 चाहिए।
— 13
आह हाँ, तो यह काम करने लगता है। फिर भी के -96साथ प्रतिस्थापन +8एक बाइट बचाता है।
— १२:०५ पर Jitse
''!=i*0तीन बाइट्स है मेरी str(i)>'9', अच्छी नौकरी से छोटी है
— ब्लैक उल्लू काई
5

माणिक , 34 बाइट्स

प्रत्येक तत्व के लिए, तत्व -1 को वापस करने का प्रयास। स्ट्रिंग्स ऐसा नहीं कर सकते हैं, इसलिए वे त्रुटि करते हैं और rescueखंड द्वारा उठाए जाते हैं , जो इसके बजाय succवर्णमाला के अगले अक्षर को वापस करने के लिए कहते हैं। succ"रोल ओवर" हालांकि zऔर रिटर्न करता aaहै, इसलिए हम बस लौटे स्ट्रिंग में पहला चरित्र लेते हैं।

->a{a.map{|e|e-1rescue e.succ[0]}}

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

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

पायथन 3 , 182 130 118 बाइट्स

-51 बाइट्स @AdmBorkBork और @Black उल्लू काई के लिए धन्यवाद, -1 byte धन्यवाद @Black उल्लू काई के साथ, -12 बाइट्स के .append()साथ की +=[]जगह और n+1साथ की जगह-~n

def a(x):
 b='abcdefghijklmnopqrstuvwxyz';c=[]
 for d in x:
  try:c+=[d-1]
  except:c+=[b[(-~b.find(d)%26)]]
 return c

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

मैंने इसे बनाया, जबकि सवाल सैंडबॉक्स में था, लेकिन इसे अभी तक पोस्ट नहीं किया गया था। : पी

Ungolfed

def a(x):
    b = 'abcdefghijklmnopqrstuvwxyz'
    c = []
    for d in x:
        try:
            c.append(d - 1)
        except:
            c.append(b[((b.find(d) + 1) % 26)])
    return c

व्याख्या

इनपुट की गई सूची में प्रत्येक तत्व के लिए x, यह 1 को घटाना और अंतिम रिटर्न की सूची में जोड़ने की कोशिश करता है। यदि कोई त्रुटि होती है (क्योंकि तत्व एक स्ट्रिंग है), वर्णमाला में अक्षर का सूचकांक 1 से जोड़ा जाता है और यह 26 लिया जाता है। मॉड 26, 26 के 0 से 0 के सूचकांक को लपेटता है।

— asdf60367134
स्रोत
CodeGolf एसई में आपका स्वागत है! मैं पाइथन का विशेषज्ञ नहीं हूं, लेकिन मुझे लगता है कि आप बाइट्स का एक गुच्छा बचाने के लिए टैब के लिए 4 स्थान स्वैप कर सकते हैं।
— AdBBorkBork
व्हॉट्सएप को खत्म करके मैंने इसे 131 बाइट्स में ला दिया। एक और बाइट को साकार किया जा सकता है, जिसका (x+27)%26परिणाम उसी प्रकार है(x+1)%26
— ब्लैक उल्लू काई
@AdmBorkBork BlackOwlKai मदद के लिए धन्यवाद! मैंने पोस्ट को एडिट किया है।
— asdf60367134
आप str(d)==dएक स्ट्रिंग का उपयोग कर सकते हैं यह जांचने के लिए कि क्या यह एक स्ट्रिंग है या नहीं, इसके बजाय कोशिश / छोड़कर पर निर्भर है। फिर, चूँकि आपको अब प्रयास / छोड़कर की आवश्यकता नहीं है, आप पूरी बात एक सूची समझ में कर सकते हैं! मैं आपको इसके बारे में थोड़ा और सोचने देता हूं लेकिन आप इस तरह से 100 बाइट आसानी से प्राप्त कर सकते हैं;)
— वैल्यू इंक
— वैल्यू इंक
2

गामा , 55 वर्ण

<N>=@sub{$1;1}
z=a
<L>=@int-char{@add{@char-int{$1};1}}

गंदा घोल। पत्र वृद्धि पर चारों ओर लपेटना दर्दनाक रूप से लंबा है, इसलिए एक अलग नियम मिला।

इनपुट कुछ भी हो सकता है, बस कुछ विभाजकों का उपयोग करें। (आप संख्याओं और अक्षरों के बीच विभाजकों को भी छोड़ सकते हैं। बदलने के लिए 1 वर्ण की कीमत के साथ<L1> आपके बीच भी विभाजनों कर सकते हैं।)

नमूना रन:

bash-5.0$ gema '<N>=@sub{$1;1};z=a;<L>=@int-char{@add{@char-int{$1};1}}' <<< "['a', 2, 3, 'b']"
['b', 1, 2, 'c']

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

गीमा, 66 वर्ण

<N>=@sub{$1;1}
<L>=@cmpi{$1;z;@int-char{@add{@char-int{$1};1}};a;}

साफ समाधान। आधा अपेक्षाकृत कुशल, फिर आधा शुद्ध दर्द।

नमूना रन:

bash-5.0$ gema '<N>=@sub{$1;1};<L>=@cmpi{$1;z;@int-char{@add{@char-int{$1};1}};a;}' <<< "['a', 2, 3, 'b']"
['b', 1, 2, 'c']

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

— आदमी काम पर है
स्रोत
2

आर , 77 85 बाइट्स

धन्यवाद @Giuseppe एक बाइटिंग 8 बाइट्स के लिए

function(l)Map(function(x)"if"(i<-match(x,L<-c(letters,"a"),0),L[i+1],x-1),l)

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

सूची के रूप में इनपुट लेता है। @Giuseppe द्वारा एक बड़े बदलाव के बाद, यह Mapएक फ़ंक्शन को सूची में लागू करने के लिए उपयोग करता है। यह matchएक चरित्र के लिए परीक्षण का उपयोग करता है । परीक्षण के दौरान विस्तारित पत्र सूची और सूचकांक वापसी के लिए सहेजे जाते हैं।

— MickyT
स्रोत
मुझे लगता है characterरों परिमित क्योंकि वे करने के लिए डाली कर रहे हैं नहीं कर रहे हैं numericके द्वारा is.finiteऔर इस तरह कर रहे हैं NA?
— Giuseppe
@Giuseppe ने सोचा कि यह उन लाइनों के साथ कुछ होगा। भले ही यह बाइट्स के समान ही है। डबल मुझे इसके इस्तेमाल की जरूरत है :)
— मिकी
— Giuseppe
अपने से छुटकारा पाने के लिए क्षमा करें is.finite, मैंने सोचा कि मैं स्वयं इस पर एक दरार लूंगा
— Giuseppe
1
@Giuseppe बहुत अच्छा, के बारे में सोचा नहीं होगा Mapऔर match। हर दिन कुछ सीखना अच्छा है :)
— मिकी
2

रेटिना , 52 50 48 58 41 37 बाइट्स

T`zl`l
\b0
-
\d+
*
-_*
-$.0
_(_*)
$.1

-4 बाइट्स @FryAmTheEggman के लिए धन्यवाद (और उल्लेख करने के लिए मेरे पास एक बग था: 1 → -1इसके बजाय 1 → 0)।
+10 बाइट्स के साथ एक बग को ठीक करने के लिए 1और 0.. इस तरह के एक कष्टप्रद किनारे का मामला जो मुझे काफी समय से खराब कर दिया था .. लेकिन अब इसे 41 बाइट्स तक पहुंचा दिया है। (अब मैं टिप्पणियों में उल्लिखित <40 बाइट्स संस्करणों @Neil और @CowsQuack के बारे में उत्सुक हूं .. धन्यवाद को परिवर्तित 0करने -और पहले नकारात्मक मानों से निपटने के लिए @Neil का । पूर्णांक से पूर्णांक के बराबर उन राइट्स को परिवर्तित करना । बहुत मदद की।)
जाहिर है मुझे इस बिंदु पर सीमाओं की आवश्यकता नहीं है, इसलिए -4 बाइट्स ..>>।>

I / O अल्पविराम से अलग किया गया है।

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

स्पष्टीकरण:

सभी "zabcdefghijklmnopqrstuvwxy(z)"को अनूदित करें "abcdefghijklmnopqrstuvwxyz":

T`zl`l

सभी स्टैंडअलोन 0एस को एक से बदलें -:

\b0
-

सभी नंबरों को unary में बदलें, उन्हें अंडरस्कोर की राशि के साथ प्रतिस्थापित करके:

\d+
*

सभी नकारात्मक मानों के लिए, इसके पीछे शून्य या अधिक असमान रेखाओं के साथ: माइनस साइन रखें, और इस मैच की कुल लंबाई (सहित -) प्राप्त करें, एक पूर्णांक में परिवर्तित:

-_*
-$.0

धनात्मक पूर्णांक के लिए: एक एकल पूर्णांक से मेल खाते हुए एक धनात्मक पूर्णांक से मेल खाता है, इसके बाद शून्य या अधिक अनारी-रेखाएँ होती हैं। और फिर उन्हें उस एकल समूह को हटाने के लिए उस कैप्चर समूह की लंबाई के साथ बदलें और उन्हें एक साथ पूर्णांक में परिवर्तित करें:

_(_*)
$.1
— केविन क्रूज़सेन
स्रोत
1

PHP , 50 बाइट्स

for(;''<$a=$argv[++$i];)echo$a<a?--$a:(++$a)[0],_;

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

टेस्ट

आउटपुट अक्षरों / पूर्णांकों को अलग करता है _ एक अनुगामी विभाजक के साथ ।

PHP में आप सीधे अक्षरों को बढ़ा सकते हैं, इसलिए मैंने इसका लाभ उठाया। लेकिन zकरने के लिए वृद्धि की जाती है aa, यह करने के लिए कन्वर्ट करने के लिए a, (++$a)[0]प्रयोग किया जाता है जो केवल वृद्धि मूल्य का पहला वर्ण आउटपुट।

— Night2
स्रोत
1

जाप -m , 13 12 बाइट्स

-1 बाइट शैगी को धन्यवाद

;¤?UÉ:Cg8+Uc

कोशिश करो

स्पष्टीकरण:

;o ?UÉ:Cg8+Uc
-m              // Map U through the input:
 o              // Try to create a range [1...U]
   ?            //   If that creates a range (number):
    UÉ          //     Return U-1
      :         //   Else, return:
;      C        //     alphabet (a...z)
        g       //     Index:
         8+Uc   //       8 + char-code of U

नोट : लोअरकेस वर्णमाला में ;बदल जाता Cहै

— ओलिवर
स्रोत
यह इस तरह से लपेटता नहीं दिखता zहै a।
— झबरा
@ शगुन वूप्स, मुझे वह याद आया। मैंने +2 बाइट्स के लिए एक अस्थायी फिक्स जोड़ा
— ओलिवर
एक टर्नरी के बिना मेरा (अभी तक) ठीक करने का एक तरीका समझ नहीं सका, जो इसे मेरी पसंद के लिए भी आपके समान बनाता है इसलिए मैं अब के लिए हटा रहा हूं। o-> ¤आप यहाँ एक बाइट बचाएंगे।
— झबरा
1
+2और फिर -1झबरा के लिए धन्यवाद अधिक सटीक होगा! : D
— झबरा
1
@ शैगी +2ऑलिवर के लिए धन्यवाद था: पी
— ओलिवर
1

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

map q
q"z"="a"
q x|x>"`"=succ<$>x|1<2=show$read x-1

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

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

हर सूची तत्व की जांच करें: यदि स्ट्रिंग है "z", तो वापस लौटें "a"; यदि स्ट्रिंग का पहला वर्ण है>'`' (यानी एक अक्षर, एक अंक नहीं), स्ट्रिंग में चार (एस) के उत्तराधिकारी को लौटाएं; अन्यथा यह संख्या होनी चाहिए, इसलिए पूर्णांक में परिवर्तित करें, 1 घटाएं और फिर से एक स्ट्रिंग में बदल दें।

संपादित करें: -1 बाय @ धन्यवाद के लिए धन्यवाद।

— nimi
स्रोत
क्या यह 51 बाइट्स के लिए काम करता है ?
— कोल
@ कोट: हाँ यह करता है। धन्यवाद!
— nimi
1

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

®i‘ị®µ’e?€Øa©

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

जोनाथन एलन द्वारा चालाक तय ।

नोट: यह एक पूर्ण कार्यक्रम नहीं है, TIO पर पाद लेख फ़ंक्शन का परीक्षण करने के लिए कमांड-लाइन तर्क का उपयोग करके इनपुट करना संभव बनाता है।

— आउटगोल्फर को एरिक करें
स्रोत
इनपुट (या chr रेंज) में नकारात्मक के साथ काम न करें। ®i‘ị®µ’e?€Øa©मेरा मानना ​​है कि शून्य के लिए एक तय है।
— जोनाथन एलन
@JonathanAllan Hah, मैं भूल गया कि Ọवास्तव में उस मामले में काम नहीं करता है। विडंबना है, क्योंकि मैं इनपुट में एस के ~लिए खाते की स्थिति के रूप में उपयोग करने से बचता हूं -1... इसके अलावा, मैं कैसे छोटा करने जा रहा हूं ®i‘ị®...
— आउटगॉल्फ
1

C ++ 17 (gcc) , 120 बाइट्स

#define O int operator()
struct V{O(char&c){c++-90?:c=65;}O(int&i){--i;}};int f(auto&l){for(auto&x:l)std::visit(V{},x);}

यहाँ f आवश्यक कार्य है; lदोनों इनपुट और आउटपुट पैरामीटर है, और यह वस्तुओं का एक कंटेनर होने की उम्मीद है जो std::variant<char, int>इसके विपरीत या इसके साथ संगत हैं।

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

— डैनियल शेपलर
स्रोत
1

के (ओके) , 27 बाइट्स

{$[9+@x;`c$97+26!8+x;x-1]}'

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

-8 धन्यवाद ngn और dzaima :)

— घसीट
स्रोत
1
31-बाइट्स {$[-9=@x;x-1;90=x;"A";`c$1+x]}'विशेष केस 'को
— अपलिंक
@ मुझे लगता है कि द्विज सही है - 'गिना जाना चाहिए। यहाँ थोड़ी लम्बी अभिव्यक्ति है जिसकी ज़रूरत नहीं है 'और "z" -> "a" का भी ख्याल रखता है:{`c`i[t]$(-26*x~'"z")+x+1-2*t:x~'0+x}
— ngn
या और भी बेहतर - अनुमानों की एक सूची बनाने के लिए और उन लोगों के साथ लागू होते हैं @': {(`c$97+26!-96+;-1+)[x~'0+x]@'x}। यहाँ -96(जो कि "a" का ascii कोड है +1) को बदल दिया जा सकता है 8क्योंकि इसे mod 26 लिया जाता है।
— ngn
पूंजी पत्रों के लिए चयन करके एक और बाइट:{(`c$65+26!14+;-1+)[x=_x]@'x}
— ngn
@dimaima तुम्हारा छोटा किया जा सकता है -9=@x->x=_x
— ngn
0

रूनिक एनकाउंटर , 36 बाइट्स

\$ka'~?*3({':+1\
R';$ >i::0Sqn=?/1-$

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

सामान्य प्रक्रिया इनपुट को पढ़ने के लिए है, एक 0 (स्ट्रिंग के लिए ज़बरदस्ती) के साथ प्रीपेन्ड करें, एक नंबर पर वापस कनवर्ट करें (एकल चार्ट हमेशा -1 लौटेगा), इनपुट के साथ तुलना करें। यदि समान है, तो यह संख्यात्मक मान होना चाहिए, 1 घटाएं और प्रिंट करें। यदि समान नहीं है, तो यह एक चार होना चाहिए, 1 को घटाना, तुलना करना {। यदि कम से कम, प्रिंट करें, अन्यथा इसे बदलेंa प्रिंट करें और प्रिंट करें।

कार्यक्रम को तब तक दोहराएं जब तक कि स्टैक अंडरफ़्लो न हो जाए।

1 बाइट; को बचाने के लिए आउटपुट को अलग किया जाता है (और पीछे एक अनुगामी होता है)। इनपुट अंतरिक्ष-पृथक है।

— Draco18s को अब SE पर भरोसा नहीं है
स्रोत
0

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

àºÇ╝'♫d▬♣ΩÜEƒ6╩╬ó

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

ऐसा लगता है कि इसे कम करना संभव होना चाहिए, लेकिन मैं अंतिम रिलीज से एक नई गति सुविधा का उपयोग करने के अवसर का विरोध नहीं कर सकता।

पूरे इनपुट को एक स्ट्रिंग के रूप में मानना:

  1. रेगेक्स अंकों के रनों को प्रतिस्थापित करता है eval(match) - 1 । यह नई विशेषता है, क्योंकि रेगेक्स ब्लॉक रिप्लेसमेंट एक स्ट्रिंग नहीं है, बल्कि एक पूर्णांक है।
  2. रेगेक्स अक्षरों के रनों को रिंग-ट्रांसलेट करके उन्हें निचली स्थिति वाले वर्णमाला के चारों ओर बदल देता है।
— पुनरावर्ती
स्रोत
0

सी #, 148 बाइट्स

(object[] o)=>{var l=new List<object>();foreach(var h in o){try{l.Add((int)h-1);}catch{var c=((char)h+1);if(c>122){c=97;}l.Add((char)c);}}return l;}

लिंक पर क्लिक करें

Ungolfed:

var inputList = new object[] {'a', 2, 'z', 6};
var outputList = new List<object>();
foreach (var currentItem in inputList)
{
    try
    {
        outputList.Add((int)currentItem-1);
    }
    catch
    {
        var currentItemPlusOne = ((char)currentItem + 1);
        if (currentItemPlusOne > 122)
        {
            currentItemPlusOne = 97;
        }
        outputList.Add((char)currentItemPlusOne);
    }
}
— Merlin04
स्रोत
0

चारकोल , 16 बाइट्स

ＷＳ⟦⎇№βι§β⊕⌕βιＩ⊖ι

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। एसटीडीआईएन पर इनपुट लेता है, प्रत्येक लाइन या तो एक लोअरकेस अक्षर या पूर्णांक होती है, और एसटीडीयूएसटी पर अलग-अलग लाइनों पर आउटपुट करता है। स्पष्टीकरण:

ＷＳ

एक खाली रेखा तक पहुंचने तक STDIN से बार-बार इनपुट।

⟦

इस अभिव्यक्ति का उत्पादन अपनी लाइन पर करें।

⎇№βι

क्या यह पूर्वनिर्धारित निचली वर्णमाला का एक विकल्प है?

§β⊕⌕βι

यदि ऐसा है तो अगले पत्र को चक्रीय रूप से अनुक्रमित प्रिंट करें।

Ｉ⊖ι

अन्यथा मूल्य में गिरावट और अंतर्निहित प्रिंट के लिए वापस स्ट्रिंग में डाल दिया।

— नील
स्रोत
0

Zsh , 47 बाइट्स

a=({a..z} a)
for i
<<<${a[$a[(i)$i]+1]:-$[--i]}

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

a=({a..z} a)                  # append extra 'a' to the end to handle 'z' case
for i                         # for i in "$@" arguments
<<<${a[$a[(i)$i]+1]:-$[--i]}
       $a[(i)$i]              # first (i)ndex of $i in list (if not found, set to after last index)
      [         +1]           # increment
   ${a[           ]        }  # value in array at index. if lookup fails, empty string
   ${              :-$[--i]}  # if empty, decrement $i and substitute instead
<<<                           # print to stdout
— GammaFunction
स्रोत
0

सी (जीसीसी) , 93 86 बाइट्स

f(int**s){for(char**p=s,*z;z=*p++;)64&*z?*z=*z-'z'?++*z:97:sprintf(z,"%d",atoi(z)-1);}

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

इनपुट एक-के- NULLमिनिमेटेड एरे है '\0', जैसे-स्ट्रिंग स्ट्रिंग्स, जैसे {"a", "b", "c", "17", NULL}।

-7 बाइट्स @ceilingcat की बदौलत

— लियो तेनाबाम
स्रोत
0

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

*>>.&{(try $_-1)||chr ord ++$_}

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

अनाम जो भी लंबोदर है जो सूची में प्रत्येक तत्व को मैप करता है और उसमें से एक को घटाने का प्रयास करता है, अन्यथा इसे बढ़ाता है और उस मामले में पहला चरित्र लेता है जो zलपेटता है aa।

— मजाक कर रहा है
स्रोत
0

SimpleTemplate, 80 बाइट्स

यह मेरे द्वारा बनाई गई भाषा पर लिखा गया था।

संकलक में सीमाओं के कारण, मैं इसे और कम नहीं कर सकता।

{@eachargv}{@if_ is matches"@\d+@"}{@incby-1_}{@echol_}{@else}{@inc_}{@echol_.0}

और अब, अपराजित:

{@each argv as value}
    {@if value is matches "@\d+@"}
        {@inc by -1 value}
    {@else}
        {@inc by 1 value}
    {@/}
    {@echo value, "\n"}
{@/}

और स्पष्टीकरण:

  • {@each argv as value}- में सभी मूल्यों के माध्यम से छोरों argv। (पास किए गए argvसभी तर्क शामिल हैं)।
    यदि as <var>मौजूद नहीं है, तो डिफ़ॉल्ट _चर मान लिया गया है।
  • {@if value is matches "@\d+@"}- valueनियमित अभिव्यक्ति के साथ मेल खाता है कि जाँच करता है "@\d+@"।
  • {@inc by -1 value} - 1 (मूल रूप से, एक वेतन वृद्धि) द्वारा मूल्य में वृद्धि।
  • {@echo value, "\n"}और {@echol_}- echolपास किए गए मानों को आउटपुट करता है और अंत में एक पंक्ति जोड़ता है।
  • {@else} - आत्म-व्याख्यात्मक
  • {@inc by 1 value}- 1 से मान बढ़ाता है। यदि by <value>गुम है, तो इसे 1 माना जाता है।
  • {@echo value.0, "\n"}और {@echol_.0}- echolपास किए गए मानों को आउटपुट करता है और अंत में एक पंक्ति जोड़ता है।
    चुनौती नियमों के कारण यह आवश्यक है z wraps to a:।
    जब एक @incस्ट्रिंग पर उपयोग किया जाता है, तो यह वर्णों को बढ़ाता है और, एक बार हिट होने पर z, यह लपेटता है aa।
    पहले चरित्र को आउटपुट करना 7 बाइट्स की लागत पर चुनौती को संतुष्ट करता है।
  • {@/}- {@else}ऊपर (वैकल्पिक) बंद कर देता है ।
  • {@/}- {@each}ऊपर (वैकल्पिक) बंद कर देता है ।

आप इस पर कोशिश कर सकते हैं: http://sandbox.onlinephpfunctions.com/code/7533641a0aa1fc8bf4699a9c758690de186b052f

प्रत्येक पारित तर्क को render()एक नया मान माना जाएगा।

— इस्माइल मिगुएल
स्रोत
-1

पर्ल, 64 बाइट्स

foreach (@ARGV){$_=~m/[a-zA-Z]/?++$_:--$_;print substr $_,0,1;}
— Hax0r778
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.