घुमा सजा

Question

नियम

कार्यक्रम को इनपुट के रूप में शब्दों का एक स्ट्रिंग / सरणी प्राप्त करना चाहिए। स्ट्रिंग / सरणी में प्रत्येक शब्द के लिए, यह शब्द के आगे और पीछे से बारी-बारी से पात्रों को लेते हुए शब्द का पुनर्निर्माण करेगा।

12345 678 9 -> 15243 687 9।

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

15243 687 9 -> 15243 9 687

अंत में, यह अनुक्रमणिका पर रिक्त स्थान, टैब और न्यूलाइन को रखकर स्ट्रिंग का पुनर्निर्माण करेगा, जहां वे परिणाम को आउटपुट करने से पहले शुरू में स्थित थे।

12345 678 9-> 15243 687 9 -> 15243 9 687 -> 15243 968 7

आउटपुट इनपुट के समान डेटाटाइप होना चाहिए।

मानक ढीले निषिद्ध हैं

उदाहरण

इनपुट:
त्वरित भूरे लोमड़ी आलसी कुत्ते पर कूदती है।
आउटपुट:
तेह d.ogq kucil yaz bnrwo tehf xoo rvej supm

इनपुट:
त्वरित भूरे लोमड़ी
आलसी कुत्ते पर कूदती है ।
आउटपुट:
तेह d.ogq kucil yaz bnrwo
tehf xoo rvej supm

इनपुट:
Aflack
आउटपुट:
Akfcla

यह कोड-गोल्फ है इसलिए सबसे छोटा कोड जीतता है

Comments

यह एक डुप्लिकेट की तरह लगता है। मैंने कसम खाई है कि मैंने इससे पहले देखा है।

— Addison Crump

तो केवल टैब, स्पेस और न्यूलाइन अक्षरों को शब्द का हिस्सा नहीं माना जाता है?

— जोनाथन एलन

@JonathanAllan जो सही है

— fɛnɪt Febk

क्या हम ASCII मान सकते हैं? या यूनिकोड?

— मेयरमोनी

@MayorMonty आप मान सकते हैं कि जो भी रूप आपके लिए बहुत आसान है, जब तक कि यह रिक्त स्थान का ठीक से व्यवहार नहीं करता है।

— f --n 23

Answer 1

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

डेनिस से एक मजबूत 6 बाइट बचती है (लिंक 1 के अंदर समतल और मोल्ड को स्थानांतरित करके दो और सिर में विभाजित करने की कोई आवश्यकता नहीं है, और एक समतल वहाँ पहले से ही है इसलिए वे एक हो जाते हैं!)

żṚFṁ
Ç€Ç

(दो पंक्तियों से: żṚFœs2Ḣ और Ç€ÇFṁ⁸)

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

शब्दों की एक सरणी लेता है और नए शब्दों की एक सरणी देता है। (टीआईओ में पाद लेख इसे कॉल करता है और रिक्त स्थान के साथ सरणी में शामिल होता है इसलिए यह अच्छी तरह से प्रिंट करता है।)

नोट - एक ही स्ट्रिंग को संभालना, टैब स्पेस और नईलाइन्स पर बंटना, फिर रिम्बसमलिंग वास्तव में मुश्किल साबित हो रहा था; एक बार जब मैंने देखा कि शब्दों की सूची एक विकल्प थी तो चीजें बहुत आसान हो गईं!

कैसे?

Ç€Ç - Main link: list of words
Ç€  - call the last link (1) as a monad for €ach word
  Ç - call the last link (1) as a monad for the result

żṚFṁ - Link 1: Do a twist: list (here, a list of words or characters)
                            e.g. input = [A,B,C,D,E,F,G]
ż    - zip the list with                 [A,    B,    C,    D,    E,    F,    G]
 Ṛ   - the reverse of the list             [G,    F,    E,    D,    C,    B,    A]
                                        [[A,G],[B,F],[C,E],[D,D],[E,C],[F,B],[G,A]]
  F  - flatten into a single list        [A,G,  B,F,  C,E,  D,D,  E,C,  F,B,  G,A]
                                         [A,G,B,F,C,E,D,D,E,C,F,B,G,A]
   ṁ - mould like the input list         [A,G,B,F,C,E,D]

Comments

यह काम करना चाहिए। इसे ऑनलाइन आज़माएं!

— डेनिस

मीठा बचाना; उस पैंतरेबाज़ी को भूलना बहुत आसान है!

— जोनाथन एलन

Answer 2

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

शब्दों की एक सरणी लेता है और आउटपुट करता है।

a=>a.map(w=>(F=([a,...b])=>a?a+(b.pop()||'')+F(b):'')(a.map(F)).slice(p,p+=w.length),p=0)

परीक्षा

let f =

a=>a.map(w=>(F=([a,...b])=>a?a+(b.pop()||'')+F(b):'')(a.map(F)).slice(p,p+=w.length),p=0)

console.log(
  JSON.stringify(
    f(["The","quick","brown","fox","jumps","over","the","lazy","dog."])
  )
);

स्ट्रिंग संस्करण, 112 बाइट्स

एक स्ट्रिंग लेता है और आउटपुट करता है।

s=>s.replace(/\S+/g,w=>(F=([a,...b])=>a?a+(b.pop()||'')+F(b):'')(s.split(/\s/).map(F)).slice(p,p+=w.length),p=0)

परीक्षा

let f =

s=>s.replace(/\S+/g,w=>(F=([a,...b])=>a?a+(b.pop()||'')+F(b):'')(s.split(/\s/).map(F)).slice(p,p+=w.length),p=0)

console.log(f(`The quick brown fox jumps over the lazy dog.`))

console.log(f(`The quick brown fox jumps
over the lazy dog.`))

console.log(f(`Aflack`))

Answer 3

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

-0paझंडे के लिए कोड + 3 बाइट्स के 74 बाइट्स ।

map{s/.\K/chop/ge,s/../chop/reg}@F;s/\S/($r||=$F[$i++].pop@F)=~s%.%%,$&/ge

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

सहेजे गए 8 बाइट्स एक पुराने @Ton Hospel की पोस्ट के लिए धन्यवाद जहाँ मैंने "चुराया" s/../chop/reg। (मैं पहले था $c=y///c/2,s/.{$c}$//)

Answer 4

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

{my &t={(|(.shift,.pop)xx*)[^$_]}
map({|t [.comb]},t [$_]).rotor($_».chars)».join}

इनपुट और आउटपुट शब्दों की एक सूची।

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

लैम्ब्डा के अंदर, मैंने "लैम्बडा को आगे और पीछे से बारी-बारी से ले जाने वाले पात्रों में " प्रदर्शन करने के लिए एक और लैम्ब्डा को परिभाषित किया :

my &t={                        }   # Lambda, assigned to a variable.
          .shift,.pop              # Remove an element from the front an back,
                      xx*          # an infinite number of times,
        |(           )             # and make sure this infinite list is flattened.
                          [^$_]    # Take as many elements as the input had elements.

यह काम करता है क्योंकि xx ऑपरेटर एक फ़ंक्शन की तुलना में एक मैक्रो की तरह अधिक है, इसमें वह जादुई आलसी मूल्यांकन प्रदान करता है।

फिर मुख्य मेमने में:

                   [$_]                          # Create a fresh array from the input,
                 t                               # and twist it (destructively).
map({          },                                # For each element (i.e. word):
      t [.comb]                                  #   Split it into characters and twist them,
     |                                           #   and slip them into the outer list.
                        .rotor($_».chars)        # Partition this flat list of characters,
                               $_».chars         # using the original word lengths.
                                         ».join  # Turn each sub-list into a word.

---

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

{my &t={(|(.shift,.pop)xx*)[^$_]}
my @a=map {|t [.comb]},t [.words];S:g/\S/{@a.shift}/}

यह ऊपर की एक भिन्नता है, जो इनपुट और आउटपुट एक स्ट्रिंग - विभिन्न व्हाट्सएप पात्रों को संरक्षित करता है।

Answer 5

हास्केल , 115 95 93 98 95 बाइट्स

f(a:b)=a:f(reverse b)
f e=e
a!(y:z)|elem y" \t\n"=y:a!z|b:c<-a=b:c!z
a!z=z
(!)=<<(f=<<).f.words

के साथ बुलाओ (!)=<<(f=<<).f.words $ "some string"। इसे ऑनलाइन आज़माएं!

@Nimi को इस बात के लिए धन्यवाद कि मैंने पहले चुनौती को गलत बताया।

फ़ंक्शन fकिसी सूची पर घुमा करता है, इसलिए इसका उपयोग स्ट्रिंग्स (वर्णों की सूची) और स्ट्रिंग्स की सूची पर किया जा सकता है। a!bस्ट्रिंग bमें व्हाट्सएप का आवेषण सम्मिलित करता हैa ।

(!)=<<(f=<<).f.wordsके बराबर है \s0 -> (concatMap f . f . words $ s0) ! s0:

            s0 = "The quick brown fox jumps\nover the lazy dog."
      words s0 = ["The","quick","brown","fox","jumps","over","the","lazy","dog."] = s1
          f s1 = ["The","dog.","quick","lazy","brown","the","fox","over","jumps"] = s2
concatMap f s2 = "Tehd.ogqkucilyazbnrwotehfxoorvejsupm"                           = s3
       s3 ! s0 = "Teh d.ogq kucil yaz bnrwo\ntehf xoo rvej supm"