इस चुनौती से प्रेरित है ।

लक्ष्य:

पहले से कॉन्फ़िगर किए गए स्विचबोर्ड और इंडेक्स की सूची को देखते हुए, दिए गए इंडेक्स पर स्विच को पलटना।

एक स्विचबोर्ड कुछ नंबरों के स्विच ( vया ^) से बना होता है -और इसे अलग-अलग लंबाई की पंक्तियों में व्यवस्थित किया जाता है। यहाँ एक उदाहरण स्विचबोर्ड है:

-v-^-v-
-^-v-
-v-^-v-

विपरीत करने के लिए / एक स्विच साधन से इसे बदलने फ्लिप vकरने के लिए ^, या से ^करने के लिए v।

स्विच को बाएं से दाएं, ऊपर से नीचे की ओर अनुक्रमित किया जाता है। जैसे, ऊपर के उदाहरण vमें, पहली पंक्ति में अंतिम स्थिति 3 में होगी और ^मध्य पंक्ति 4 पर होगी (1-इंडेक्सिंग का उपयोग करके)।

इनपुट:

एक स्ट्रिंग (या तार की सूची) स्विचबोर्ड का प्रतिनिधित्व करती है। यह regex से मेल खाने की गारंटी है ((-[v^])+-)(\n(-[v^])+-)*।
अनुक्रमणिकाओं का प्रतिनिधित्व करने वाली संख्याओं की संभवतः एक खाली सूची, 0 या 1 (या कुछ मनमानी संख्या हो सकती है) यदि आप अनुक्रमित हैं। ये ऐसे स्विच हैं जिन्हें फ़्लिप करने की आवश्यकता होती है।

आउटपुट:

निर्दिष्ट स्विच के साथ इनपुट के समान आकार में एक स्विचबोर्ड। किसी भी अनिर्दिष्ट स्विच को अपनी प्रारंभिक स्थिति को बनाए रखना चाहिए।

नियम:

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

उदाहरण:

#Using 1-indexing
input: #Empty Case
[],
-v-^-v-

output:
-v-^-v-

input: #Single switch
[1],
-v-

output:
-^-

input: #Skip a line
[3,5],
-^-v-v-
-v-
-^-^-

output:
-^-v-^-
-v-
-v-^-

input: #Flip one in each line + number wrap
[3,4,6],
-^-v-v-
-v-
-^-^-

output:
-^-v-^-
-^-
-^-v-

input: #Flip 'em all
[1,2,3,4,5,6],
-^-v-v-
-v-
-^-^-

output:
-v-^-^-
-^-
-v-v-

code-golf string ascii-art

— Veskah
स्रोत

क्या हम एक आयताकार चार सरणी का उत्पादन कर सकते हैं, जो रिक्त स्थान के साथ छोटी रेखाओं को सही तरीके से जोड़ सकते हैं? क्या हम उस रूप में भी इनपुट ले सकते हैं?

— लुइस मेंडो

@LuisMendo मैं इसे इनपुट के रूप में नहीं लेने पर कहने जा रहा हूं। जब तक यह इनपुट की तरह दिखता है तब तक सफेद स्थान को पीछे छोड़ना ठीक है।

— वीकेह

2

यदि वर्ण हैं, तो उन लोगों को संकेत दें >"-": जैसा कि इनपुट स्ट्रिंग के साथ शुरू होने की गारंटी है -, आप उस पैरामीटर / तर्क / चर नाम के खिलाफ जांच कर सकते हैं जो आप इसके बजाय उपयोग कर रहे हैं।

— झबरा

11

विम, 60, 46, 38 , 37 बाइट्स / कीस्ट्रोक्स

qq/\d
ggDJ@"/[v^]
sv^<esc>l?\V<C-r>"
x@qq4u@q

<esc>और <C-r>दोनों 1 बाइट / कीस्ट्रोक हैं। बाइट काउंटर

टेस्ट केस 1 (वर्बोज़ मोड)

टेस्ट केस 2 (वर्बोज़ मोड)

22 बाइट्स की कमी करने वाले विचारों के लिए ग्रिम का धन्यवाद :)

— DJMcMayhem
स्रोत

2

@Veskah uhhhhhh vim "कुछ 0 बार" किनारे के मामलों के बारे में सुपर नकचढ़ा है। संपादित देखें

— DJMcMayhem

-13 बाइट्स के लिए नहीं :s/\%V./\='v^'[submatch(0)=='v']हो सकता है cl<C-R>='v^'['<C-R>"'=='v']? (प्रत्येक <CR> केवल एक बाइट है)।

— ग्रैमी

2

@ ग्रमी ऊह, अच्छा विचार है। इसके अलावा s == cl, -14कुल मिलाकर।

— DJMcMayhem

अन्य विचार: s^v!<Esc>?\<C-R>"<CR>xhf!xया s<CR>^v<Esc>:s/\V<C-R>"<CR>kgJ।

— ग्रैमी

1

मैंने इसके बारे में सोचा था, लेकिन यह विफल हो जाता है कि यदि चरित्र उलटा हो, एक पंक्ति के अंत में है ... लेकिन फिर इनपुट कल्पना की गारंटी है कि यह उसके बाद है -, इसलिए यह वास्तव में काम करता है! ओह।

— ग्रिम्मी

6

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

a=>s=>s.replace(/v|\^/g,x=>"^v"[a.includes(n++)^x>"^"],n=0)

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

सहेजे गए 4 बाइट्स अरनौल्ड की बदौलत ।

— झबरा
स्रोत

4

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

समाधान:

`0:{@[x;(&x>93)y;"^v"94=]};

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

स्पष्टीकरण:

त्वरित जवाब, इसे गोल्फ के लिए प्रयास करेंगे। 0 अनुक्रमित।

`0:{@[x;(&x>93)y;"^v"94=]}; / the solution
`0:                       ; / print to stdout
   {                     }  / lambda taking 2 implicit args x & y
    @[ ;        ;       ]   / apply @[var;index;function]
                     94=    / 94 (ASCII "v") equal to? returns 0 or 1
                 "v^"       / index into "v^" (ie flip switch)
               y            / index into
        (     )             / do this together
          x>93              / x greater than 93 (ASCII "]")
         &                  / indices where true
      x                     / apply to x

टिप्पणियाँ:

-4 बाइट्स >93ट्रिक के लिए धन्यवाद

— streetster
स्रोत

3

पायथन 3 , 140 134 103 बाइट्स

(-30 DJMcMayhem के लिए धन्यवाद, -1 ब्लैक उल्लू काई के लिए धन्यवाद)

def f(i,y,x=1):
 for c in y:q=c>'-';p=len(i)and x==i[0]*q;print([c,"v^"[c>'^']][p],end='');x+=q;i=i[p:]

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

Oof, दूसरा सब पर कुछ भी गोल्फ में प्रयास करें। यह केवल xवर्तमान स्विच इंडेक्स का ट्रैक रखने के लिए , स्ट्रिंग के बजाय एक अपरिष्कृत लूप का उपयोग करता है । 1-अनुक्रमण का उपयोग करता है।

Ungolfed:

def f(i,y):
     x = 1
     for c in y:
         nextchar = c # nextchar gets golfed out completely within the print
         if c in 'v^': # golfed as c>'-'
             if len(i) and x==i[0]:
                nextchar = 'v' if c=='^' else '^'
                i = i[1:]
             x += 1
         print(nextchar, end='')

— रिन के फूरियर रूपांतरण
स्रोत

107 बाइट्स

— डीजेमेकमेम

106 बाइट्स

— काले उल्लू काई

या 104 अगर अजगर 3 स्वीकार्य है

— DJMcMayhem

@DJMcMayhem Ooh, इसके बदले धन्यवाद xd को पकड़ने के लिए क्या आप पायथन 3 को एक अलग उत्तर के रूप में पोस्ट करना चाहते हैं, या आपको लगता है कि इसे संपादित करने के लिए इसे जोड़ना काफी समान है?

— रिन के फूरियर

1

इसे जोड़ने के लिए स्वतंत्र महसूस करें :) मैं एक अजगर 3 उत्तर पोस्ट कर सकता हूं, लेकिन मैं शायद पहले खुद के दृष्टिकोण के साथ आने की कोशिश करूंगा।

— DJMcMayhem

3

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

O^%5T⁴ịƲ¦40Ọ

एक स्ट्रिंग और पूर्णांक की एक सूची को स्वीकार करने वाला एक पूर्ण कार्यक्रम जो परिणाम प्रिंट करता है।

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

कैसे?

O^%5T⁴ịƲ¦40Ọ - Main Link: list of characters, S; inversion indices, I
O            - to ordinals   ('\n':10, '-':45, '^':94, 'v':118)
        ¦    - sparse application...
       Ʋ     - ...to indices: last four links as a monad: f(O(S))
  %5         -   modulo 5   (10:0, 45:0, 94:4, 118:3)
    T        -   truthy indices (giving, X, indices of '^' and 'v' in S)
     ⁴       -   4th command line argument = I
      ị      -   index into X   (giving indices of '^' and 'v' to invert in S)
 ^       40  - ...action: XOR with 40   (94:118, 118:94)
           Ọ - from ordinals
             - implicit print

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

3

पायथन 3.8 (पूर्व-रिलीज़) , 80 , 78 , 77 , 71 , 70 बाइट्स

lambda x,s,i=0:''.join([c,'^v'[c<'v']][c>s and(i:=i+1)in x]for c in s)

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

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

— जोनास ऑसेविसियस
स्रोत

1

c>s एक बाइट बचाता है।

— झबरा

3

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

->$_,\s{S:nth(s){\^|v}=$/~^'('}

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

(-2 किंग को धन्यवाद बाइट्स)

पर्ल 6 के प्रतिस्थापन ऑपरेटर Sआसानी से एक nthक्रिया विशेषण लेता है जो न केवल एक इंडेक्स को स्वीकार करता है जिस पर प्रतिस्थापन बनाने के लिए, लेकिन उनमें से एक सूची, बिल्कुल यहां आवश्यक है।

प्रतिस्थापन है $/ ~^ '(', जहां $/मिलान वाला पाठ (या तो है vया ^),~^ stringwise अनन्य या ऑपरेटर है, और (चरित्र जिसका बिट्स बारी है vमें ^और इसके विपरीत।

— शॉन
स्रोत

31 बाइट्स

— जो किंग

2

MATL , 29 बाइट्स

c!tt45>o2yfi)(2=XK)t106-E-K(!

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

इनपुट स्ट्रिंग्स का एक सेल एरे है और 1-आधारित इंडेक्सिंग के साथ संख्याओं की एक पंक्ति वेक्टर है। स्पेस के साथ आउटपुट राइट-पैडेड है।

— लुइस मेंडो
स्रोत

2

पायथन 2 , 105 97 91 बाइट्स

lambda a,s:reduce(lambda(t,i),c:(t+[c,'^v'[c<'v']][c>'-'and i in a],i+(c>'-')),s,('',0))[0]

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

6 बाइट्स द्वारा बचाया ~~चोरी~~ का उपयोग कर रिन के फूरियर परिणत 's c>'-'के बजायc in'^v' ।

0-indexed।

— चास ब्राउन
स्रोत

2

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

⁾^vḟ$€>”-T⁹ịƲ¦

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

पूरा कार्यक्रम।

यह बहुत लंबा लगता है ...

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

मुझे नहीं पता है कि जेली यह पता नहीं लगा सकती कि इसे खुद कैसे आज़माया जाए, लेकिन क्या आप ”-पहले तर्क ( ³?) के नाम से बदल सकते हैं , जो -इसके बजाय शुरू करने की गारंटी है ?

— झबरा

@ शैगी नोप, क्योंकि वेक्टरकृत होता है >। आप देख सकते हैं कि यह काम नहीं करता है ।

— २४:२४ पर आउटगोल्फ जूल

आह, यह वही है जो मैंने कोशिश की थी :) पता नहीं था कि यह मेरी जेली ज्ञान की कमी थी जो कारण या नहीं थी, हालांकि। मान लीजिए कि पहले तर्क के पहले चरित्र को प्राप्त करने के लिए कोई एकल चरित्र अंतर्निहित नहीं है?

— झबरा

@Shaggy एर्म ... कमांड लाइन तर्क के लिए केवल बनाया-इन कर रहे हैं ³, ⁴, ⁵, ⁶और ⁷, पांचवें CLA पर क्रमश: करने के लिए पहले के लिए। यदि कोई विशिष्ट अंतर्निहित फ़ंक्शन मौजूद है, तो यह जानने के लिए आप एटम्स पेज पढ़ सकते हैं ।

— आउटगॉल्फ जूल

आह, ठीक है, एक शॉट के लायक था। एक दिन, मैं होगा जेली में ठीक से गोता।

— झबरा

2

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

¿╫╦ÜΦ1▌X○!ΩTæ

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

यह 0-आधारित सूचकांकों का उपयोग करता है।

रेगेक्स के सभी सूचकांकों का पता लगाएं [v^] ।
सूचकांक में इनपुट का उपयोग करके सूचकांक सरणी सूचकांक ।
प्रत्येक परिणाम पर, इनपुट की एससीआई कोड के साथ xor करें 40। यह वह जगह है xor('v', '^')।

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

2

क्लीन , 93 बाइट्स

import StdEnv
$i=foldl(\s c=s++[if(any((==)(sum[1\\k<-s|k>'-']))i&&c>'-')if(c>'^')'^''v'c])[]

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

$ :: [Int] -> [Char] -> [Char]इंडेक्स की शून्य-अनुक्रमित सूची लेने वाले फ़ंक्शन को परिभाषित करता है और एक फ़ंक्शन को वापस करता है जो स्ट्रिंग लेता है और परिवर्तित स्ट्रिंग लौटाता है।

— Οurous
स्रोत

2

जावास्क्रिप्ट (Node.js) , 101 98 93 91 77 67 बाइट्स

a=>s=>[...s].map(c=>t+=c>s?"^v"[a.includes(i++)^c>"^"]:c,t=i=``)&&t

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

10 बाइट्स, झबरा द्वारा सुझाव के लिए thx ।

मेरे पायथन जवाब का पोर्ट । गोल्फ जावास्क्रिप्ट करने के लिए इस्तेमाल नहीं किया!

— चास ब्राउन
स्रोत

कुछ क्विक ट्विक्स

— झबरा

या 67 बाइट्स देकर आगे की बचत करने वाले अरनुल्द ने मुझे दिया।

— झबरा

@ शैगी: टिप्स की सराहना की! अभी पढ़ रहे हैं ...

— चास ब्राउन

2

वी , 20 बाइट्स

ÑñÀ/vüÞ
sv^l?Ö"
xH

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

कुछ नई सुविधाओं का उपयोग करता है, इस तरह के रूप Ñजो है अविश्वसनीय रूप से उपयोगी है।

— DJMcMayhem
स्रोत

1

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

कोड

x=>y=>{x.map(i=>eval(`y=y.replace(/(((v|\\^)[^^v]*){${i}})(v|\\^)/,(a,b,c,d,e)=>b+(e<"v"?"v":"^"))`));return y}

प्रारूप f (x) (y) में इनपुट लेता है जहां x इंडेक्स है और y स्विचबोर्ड है। सूचकांक 0 अनुक्रमित हैं

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

व्याख्या

प्रत्येक सूचकांक के लिए

x.map(i=>...

इंडेक्स का निर्माण जो इंडेक्स + 1 वें "^" या "v" को ढूंढता है

`.../(((v|\\^)[^^v]*){${i}})(v|\\^)/...`

इसे विपरीत चिन्ह "v" <-> "^" से बदलने के लिए इसे एक स्ट्रिंग में डालें

y=y.replace(...,(a,b,c,d,e)=>b+(e<"v"?"v":"^"))

फिर एक फ़ंक्शन के रूप में स्ट्रिंग का मूल्यांकन करें

eval(...)

स्विच करने के लिए सूचकांकों के माध्यम से पुनरावृत्ति करने के बाद, स्विचबोर्ड को वापस करें

return y

— fənɛtɪk
स्रोत

1

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

⁾^vK;`©⁹e€ky@€⁸¦®

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

एक पूरा कार्यक्रम सूचकांकों को पहले और स्ट्रिंग को दूसरे तर्क के रूप में ले रहा है। संकेतित स्विच के साथ आउटपुट प्रिंट करता है।

— निक केनेडी
स्रोत

1

रेटिना 0.8.2 , 66 62 बाइट्स

\d+
$*
T`v^`^v`.(?<=\b(?(3)$)(?<-3>1)+(,1+)*(-|¶|(v|\^))+)
1A`

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण का मामला भी शामिल है। 1 अनुक्रमित। स्पष्टीकरण:

\d+
$*

इनपुट नंबरों को यूनीरी में बदलें।

T`v^`^v`.(?<=\b(?(3)$)(?<-3>1)+(,1+)*(-|¶|(v|\^))+)

संपत्ति के साथ vऔर ^सभी वर्णों के बीच अनूदित करें कि vएस और ^एस की संख्या (समावेशी) इनपुट संख्याओं में से एक के बराबर है।

1A`

इनपुट नंबर हटाएं।

— नील
स्रोत

1

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

⭆η⎇№θ⌕ΦＬη№v^§ηλκ§v^⁼vιι

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। 0 अनुक्रमित। स्पष्टीकरण:

 η                      Input string
⭆                       Map over characters and join
  ⎇                     If
   №                    Count of (i.e. exists)
     ⌕                  Index of
               κ        Current index in
       Ｌ                Length of
        η               Input string
      Φ                 Implicit range filtered by
         №              Count of (i.e. exists)
             η          Input string
            §           Indexed by
              λ         Current value
          v^            In literal string `v^`
    θ                   In input list
                 v^     Then literal `v^`
                §       Indexed by
                     ι  Current character
                   ⁼    Equal to
                    v   Literal `v`
                      ι Else current character

— नील
स्रोत

1

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

1 अनुक्रमित।

->s,i{j=0;s.gsub(/[v^]/){i==i-[j+=1]?$&:"v^".tr($&,'')}}

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

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

1

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 73 बाइट्स

a=>b=>{int i=0;return a.Select(x=>x>45&&b.Contains(++i)?(char)(x^40):x);}

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

— अज्ञान का अवतार
स्रोत

1

@Veskah खाली मामले को शामिल करने के लिए अपडेट किया गया

— अज्ञानता का अवतार

1

जाप , 15 बाइट्स

®c^(Z>V©øT° *#(

कोशिश करो

®c^(Z>V©ø°T *#(    U = Input String, V = Array of Indices
®                  Map each Z in U
 c^                   XOR Z's charcode by
   (Z>V                 Z is 'v' or '^'
      ©                 Short-circuiting Logical and
       øT°              The current Z's index is in V
             *#(        Multiply the boolean with 40 (false = 0, true = 1)

— अज्ञान का अवतार
स्रोत

1

जाप , 16 14 बाइट्स

Ëc^#(*(D>V©øT°

कोशिश करो

Ë>V©øT° ?Dc^#(:D     :Implicit input of multi-line string U & integer array V
Ë                    :Map each D in U
 >V                  :  Greater than V? (Coerces V to a string and, conveniently, all digits are > "\n" & "-" and < "^" & "v")
   ©                 :  Logical AND with
    ø                :  Does V contain
     T°              :    T (initially 0) postfix incremented
        ?            :  If true
         Dc          :  Charcode of D
           ^#(       :  XOR with 40
              :D     :  Else D

— झबरा
स्रोत

:D

— अजी

एक स्विचबोर्ड पर कुछ स्विच को पलटना

लक्ष्य:

इनपुट:

आउटपुट:

नियम:

उदाहरण:

विम, 60, 46, 38 , 37 बाइट्स / कीस्ट्रोक्स

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

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

पायथन 3 , 140 134 103 बाइट्स

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

कैसे?

पायथन 3.8 (पूर्व-रिलीज़) , 80 , 78 , 77 , 71 , 70 बाइट्स

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

MATL , 29 बाइट्स

पायथन 2 , 105 97 91 बाइट्स

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

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

क्लीन , 93 बाइट्स

जावास्क्रिप्ट (Node.js) , 101 98 93 91 77 67 बाइट्स

वी , 20 बाइट्स

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

कोड

व्याख्या

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

रेटिना 0.8.2 , 66 62 बाइट्स

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

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

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 73 बाइट्स

जाप , 15 बाइट्स

जाप , 16 14 बाइट्स