वहां, मैंने इसे (कैंची से) तोड़ दिया

Question

चुनौती

कटिंग नियम और एक अन्य स्ट्रिंग का वर्णन करने वाले एक स्ट्रिंग को देखते हुए, पहले स्ट्रिंग द्वारा वर्णित नियम का उपयोग करके दूसरे स्ट्रिंग में से भागों को काटें।

दोनों तार में अक्षर होंगे a-zया A-Z, जो भी आप चुनते हैं (उन्हें उसी तरह से प्रतिनिधित्व नहीं करना है)। जिस तरह से दूसरी स्ट्रिंग को संशोधित किया जाना है वह नीचे वर्णित है:

कलन विधि

पहले स्ट्रिंग को लें और गैर-आसन्न (बढ़ते) अक्षरों के बीच अंतराल में भरने की कल्पना करें =; उदाहरण के लिए, abcfg=> abc==fg। फिर, दो तारों को पंक्तिबद्ध करें और पहले अक्षर से सभी अक्षर लौटाएं जो समान चिह्न से ऊपर नहीं हैं। उदाहरण के लिए, दिए गए abcfgऔर qrstuvwइनपुट के रूप में:

qrstuvw - Modify
abc==fg - Modifier

qrs--vw -> qrsvw

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

संशोधक को सॉर्ट करने की गारंटी नहीं है।

परीक्षण के मामलों

abcfg, qrstuvw -> qrsvw
abqrs, qwertyuiopasdfghjklzxcvbnm -> qwjklzxcvbnm
za, qr -> qr
azazaz, qwertyuioplkjhgfdsazxcvbnmnbvcxzasdfghjklpoiuytrewq -> qmn

संदर्भ कार्यान्वयन (परीक्षण मामलों को उत्पन्न करने के लिए उपयोग किया जाता है) -> TIO

नियम

• स्टैंडर्ड लोफॉल्स लागू होते हैं
• आप इनपुट को दो स्ट्रिंग्स के रूप में ले सकते हैं, पात्रों की दो सूचियाँ, वर्णों का एक मैट्रिक्स, आदि (कोई भी अन्य उचित प्रारूप स्वीकार्य है)
• आप एक स्ट्रिंग या पात्रों की सूची (या स्ट्रिंग के लिए कुछ अन्य मानक प्रारूप) के रूप में आउटपुट कर सकते हैं
• यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा में बाइट्स में सबसे छोटा उत्तर अपनी भाषा के लिए विजेता घोषित किया जाता है। कोई उत्तर स्वीकार नहीं किया जाएगा।
• या तो स्ट्रिंग खाली हो सकती है।

हैप्पी गोल्फिंग!

_{^{केविन क्रूज़सेन की हालिया दो चुनौतियों से प्रेरित, "वहां, मैंने इसे ( टेप / रस्सी के साथ ) तय किया "}}

Comments

वहाँ, मैंने इसे (टेप के साथ) तय किया , वहाँ, मैंने इसे (रस्सी के साथ) तय किया

— एरिक द आउटग्राफर

बहुत आम चलन यहाँ देख रहा है

— L_Church

@L_Church चुनौतियां कभी-कभी रुझानों का अनुसरण करती हैं। दो संबंधित चुनौतियों को पोस्ट किया गया था, इसलिए मैंने प्रवृत्ति के साथ जारी रखने का फैसला किया: DI एक और "मैं इसे ठीक कर दिया" चुनौती पोस्ट करने जा रहा था, लेकिन एक) मुझे चीजों को बेहतर ढंग से तोड़ना पसंद है 2) मैं एक और रचनात्मक और पर्याप्त रूप से पर्याप्त के बारे में नहीं सोच सकता "इसे तय किया "विचार: पी

— हाइपरन्यूट्रीनो

अगली चुनौती:There, I blew it up (with a segfault)

— मैजिक ऑक्टोपस Urn

@MagicOctopusUrn किसी ने आपको इसे हराया :(

— caird coinheringaahing

Answer 1

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

करी सिंटैक्स में इनपुट लेता है (modify)(modifier)।

s=>g=([c,...a],d=i=0,x=s[k=parseInt(c,36),i+=c?d&&(k-d+26)%26:1])=>x?x+g(a,k):''

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

टिप्पणी की गई

s =>                       // outer function, taking the string s to modify
  g = (                    // recursive inner function g(), taking:
    [c, ...a],             //   c = current modifier character; a[] = remaining characters
    d = i = 0,             //   d = code of previous modifier character; i = pointer in s
    x = s[                 //   x = i-th character of s
      k = parseInt(c, 36), //     k = code of the current modifier character in [10..35]
      i += c ?             //     update i; if c is defined:
        d &&               //       if d = 0, let i unchanged
        (k - d + 26) % 26  //       otherwise, add the difference between k and d (mod 26)
      :                    //     else:
        1                  //       just pick the next character by adding 1
    ]                      //   end of character lookup in s
  ) =>                     //
    x ?                    // if x is defined:
      x + g(a, k)          //   append x and do a recursive call to g()
    :                      // else:
      ''                   //   stop recursion

Answer 2

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

lambda a,b:[x for x,y in zip(a,''.join(d+(ord(c)+~ord(d))%26*'='for c,d in zip(b[1:],b))+a)if'='<y]

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

Answer 3

05AB1E , 20 17 बाइट्स

ćsv¹Ç¥Nè<yú«}SðÊÏ

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

---

प्रत्येक चार के बीच एएससीआईआई दूरी की गणना करता है, अगर यह सकारात्मक है तो कई रिक्त स्थान हैं। युक्ति के अनुसार, 0 रिक्त स्थान को जोड़ने में नकारात्मक दूरी होती है। उसके बाद, मैं स्ट्रिंग 2 के सभी सूचकांकों को पहले जोड़तोड़ स्ट्रिंग में रिक्त स्थान के समान 2 पर धकेलता हूं।

---

Input: [azaz,qwertyuiopasdfghjklzxcvbnm]
--------------------------------------------------------------------------------

ćs                # Remove head, swap                           | [a, zaz]
  v               # Iterate...                                  | ............
   ¹Ç¥            # Push deltas between each char of string 1   | [a,[25,-25,25,-25]]
      Nè          # Push delta at index...                      | [a, 25]
        <         # Decrement (for 1-indexed answer)            | [a, 24]
         y        # Push current char in iteration...           | [a, 24, z]
          ú       # Append b spaces to a...                     | [a, '(spaces)z']
           «      # Concat                                      | [a(spaces)z]
            }     # End loop.                                   | [a(spaces)za(spaces)z]
             SðÊ  # Split, push 1 for non-space elements.       | [Long array of 1/0]
                Ï # Push chars from 2 that aren't spaces in 1.  | ['qmn']

---

90% यकीन है कि मैं रिक्त स्थान का उपयोग नहीं करके एक और 2-3 बाइट्स खो सकता हूं, लेकिन सूचकांक एन पर चार को धक्का दे रहा है। फिर भी इस समय इस संस्करण पर काम कर रहा है ... मेरा "बेहतर विचार" क्या है:

05AB1E , 18 बाइट्स

Ç¥ε1‚Z}ηO0¸ìʒ²g‹}è

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

मुझे लगता है कि मुझे कुछ याद आ रहा है, यदि आप सुधार देखते हैं ε1‚Z}, ʒ²g‹}या 0¸ìlmk ...

Ç¥ε1‚Z}ηO0¸ìè13 था, लेकिन यह जब लपेटता n > |input_2|के लिए input_2[n%|input_2|]...

Comments

आपका दूसरा संस्करण Ç ¥ ε1M} हो सकता है । इन इनपुट्स के लिए तीन संस्करणों में से कोई भी काम नहीं करता है।

— एमिग्ना

ऊपर का संस्करण जोड़कर तय किया जा सकता है IgÅ1«, लेकिन शायद एक बेहतर तरीका है?

— एमिग्ना

Answer 4

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

Ç«|¢Äα•è@╟╣i`vF

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

यह आस्की प्रतिनिधित्व है।

:-Z+{v0|Mt|cB]pFp

1. जोड़ीदार अंतर प्राप्त करें।
2. एक शून्य को प्राथमिकता दें।
3. अंतर अंतर, दोहराना
   4. 1 घटाएँ, और शून्य के साथ अधिकतम लें।
   5. स्ट्रिंग की शुरुआत से कई पात्रों को निकालें।
   6. अगर स्ट्रिंग खाली है तो रोकें।
4. बाकी स्ट्रिंग को प्रिंट करें।

Comments

मुझे पसंद है कि कोड कैसे कहता है╟╣i

— यूरिल

Answer 5

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

OI’R¬⁸żFḣL}aḟ0

एक डाइएडिक लिंक जो संशोधनकर्ता को बाईं ओर वर्णों की एक सूची के रूप में स्वीकार करता है और वर्णों की सूची लौटाते हुए दाईं ओर संशोधित करने के लिए वर्णों की सूची है।

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

कैसे?

OI’R¬⁸żFḣL}aḟ0 - Link list of characters Modifier, list of characters InStr
               -                       e.g.  ['a','c','g','a'], ['n','m','l','k','j']
O              - ordinals of Modifier        [97,99,103,97]
 I             - incremental differences     [2,4,-6]
  ’            - decrement                   [1,3,-7]
   R           - range                       [[1],[1,2,3],[]]
    ¬          - NOT (vectorises)            [[0],[0,0,0],[]]
     ⁸         - chain's left argument, Modifier
      ż        - zip together                [['a',[0]],['c',[0,0,0]],['g',[]],['a']]
       F       - flatten                     ['a',0,'c',0,0,0,'g','a']
         L}    - length of right (InStr)     5
        ḣ      - head to index               ['a',0,'c',0,0] (if shorter or equal, no effect)
           a   - AND with InStr (vectorises) ['n',0,'l',0,0]
            ḟ0 - filter out zeros            ['n','l']

Comments

¬मेरे उत्तर में छल का उपयोग किया । :) (हमारे पास तकनीकी रूप से समान एल्गोरिथ्म है, लेकिन आपने कम किया, अच्छी तरह से किया है!)

— को आउटगोल्फ

अरे हाँ, मैं इस बारे में टिप्पणी करने वाला था ¬, लेकिन भूल गया जब मैंने एक नॉट-रेडी 13 बाइट के प्रयास से एक मोबाइल फोन वसा-उंगली पोस्ट किया था।

— जोनाथन एलन

Answer 6

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

f=([t,...T],s,z=T[0])=>z&&s?s[0]+f(T,s.slice(t>z||(parseInt(t+z,36)-370)%37)):s

मेरे अंतिम उत्तर के रूप में अक्षरों के बीच की दूरी की गणना के लिए समान एल्गोरिथ्म का उपयोग करता है ।

परीक्षण के मामलों:

f=([t,...T],s,z=T[0])=>z&&s?s[0]+f(T,s.slice(t>z||(parseInt(t+z,36)-370)%37)):s

console.log(f('abcfg','qrstuvw')) // -> qrsvw
console.log(f('abqrs','qwertyuiopasdfghjklzxcvbnm')) // -> qwjklzxcvbnm
console.log(f('za','qr')) // -> qr
console.log(f('azazaz','qwertyuioplkjhgfdsazxcvbnmnbvcxzasdfghjklpoiuytrewq')) // -> qmn

Answer 7

APL (Dyalog Classic) , 35 34 32 बाइट्स

{⍵∩⍨⊃¨↓∘⍵¨+\0,1⌈(-2-/⎕ucs⍺),=⍨⍵}

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

Answer 8

कश्मीर (NGN / ट) , 27 24 25 बाइट्स

{y[+\0,1|1_-':x,!#y]^" "}

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

{y[+\0,1|1_-':x,!#y]^" "}

{                       } function with x and y as arguments
                 #y       the length of y
                !#y       0 1 2 ... (#y)-1
              x,          x concatenated with
           -':            differences between pairs
         1_               rm extra leading item
       1|                 max between 1 and
     0,                   prepend 0
   +\                     partial sums
 y[                ]      index y with that
                    ^" "  rm spaces due to out-of-bounds indexing

Answer 9

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

(x:r)#(y:n:s)=x:drop(length[y..n]-2)r#(n:s)
r#_=r

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

Answer 10

पर्ल 5 , 45 बाइट्स

s/./v0.$;x(ord($')-1-ord$&)/eg;$_|=<>;s/\W//g

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

Answer 11

रूबी , 68 64 बाइट्स

->m,z,i=1{z[i,[0,m[i].ord+~m[i-1].ord].max]&&='';m[i+=1]?redo:z}

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

Answer 12

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

⭆η×ιＩ§⁺⭆θ⁺×0∧μ⊖⁻℅λ℅§θ⊖μ1⭆η1κ

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

       ⭆θ⁺×0∧μ⊖⁻℅λ℅§θ⊖μ1        Fix it with tape, but map to 1s and 0s
      ⁺                 ⭆η1     Append extra 1s just in case
⭆η                              Map over the second string
     §                     κ    Get the character from the fixed string
    Ｉ                           Cast to integer
  ×ι                            Repeat the current character that many times
                                Implicitly print

नोट: यह 28 बाइट्स होना चाहिए, लेकिन Andलेखन के समय टूट जाता है।

Answer 13

जावा 8, 117 बाइट्स

a->b->{for(int i=0,j;++i<a.length;b=j>0&b.length()>=i+j?b.substring(0,i)+b.substring(i+j):b)j=a[i]+~a[i-1];return b;}

स्पष्टीकरण:

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

a->b->{                   // Method with char-array + String parameters and String return
  for(int i=0,j;++i<a.length;
                          //  Loop `i` in range [1; length_of_array)
      b=                  //    After every iteration: change the String-input to:
        j>0               //     If `j` is larger than 0,
        &b.length()>=i+j? //     and the length of `b` is larger or equal to `i+j`:
         b.substring(0,i) //      Take the substring [0; i)
         +b.substring(i+j)//      + the substring [i+j; end_of_string]
        :                 //     Else:
         b)               //      Leave `b` the same
    j=a[i]+~a[i-1];       //   Set `j` to the difference between two adjacent chars - 1
  return b;}              //  Return the modified input-String