पत्र, आगे बढ़ें!

Question

एक स्ट्रिंग को देखते हुए आपको वर्णमाला में अपनी स्थिति से प्रत्येक अक्षर (पहले अक्षर से शुरू) को स्थानांतरित करना होगा। यदि आप स्ट्रिंग के अंत तक पहुँचते हैं तो आपको चारों ओर लपेटना होगा। गैर-पत्रों को स्थानांतरित करने की आवश्यकता नहीं है।

उदाहरण:

Dog

Dवर्णमाला में चौथा अक्षर है, इसलिए हम इसे चार स्थानों पर दाईं ओर ले जाते हैं। चारों ओर लपेटने के बाद, वह स्ट्रिंग को बदल देता है oDg। o15 वां अक्षर है, (15 mod 3) = 0, इसलिए यह स्थानांतरित नहीं होता है। g7 वां अक्षर है - (7 mod 3) = 1, इसलिए स्ट्रिंग बन जाता है goD।

hi*bye

• h8 वां अक्षर है, इसे 8 स्थानों पर ले जाएँ - hi*bye=>i*hbye
• i9 वां अक्षर है, इसे 9 स्थानों पर ले जाएँ - i*hbye=>*hbiye
• b2 अक्षर है, इसे 2 स्थानों पर ले जाएँ - *hbiye=>*hiybe
• y25 वां अक्षर है, इसे 25 स्थानों पर ले जाएँ - *hiybe=>*hibye
• e5 वां अक्षर है, इसे 5 स्थानों पर ले जाएँ - *hibye=>*hibey

गैर-पत्रों को स्थानांतरित करने की आवश्यकता नहीं है, लेकिन वे अभी भी जगह लेते हैं।

• cat => tca
• F.U.N => .F.NU
• mississippi => msiisppssii

Comments

क्या हमें एक स्टैंडअलोन कार्यक्रम करना है या एक फ़ंक्शन पर्याप्त है? इसके अलावा, क्या हमें स्ट्रिंग को प्रिंट करना है?

— काटेन्को

इनपुट में कौन से वर्ण दिखाई दे सकते हैं? मुद्रण योग्य ASCII? Linefeeds? कोई ASCII? कोई यूनिकोड?

— मार्टिन एंडर

साथ ही दोहराया पत्रों के साथ एक परीक्षण का मामला अच्छा होगा।

— मार्टिन एंडर

@ मार्टिन कोई भी ASCII।

— जियोकॉवेल

@Katenkyo फ़ंक्शन की अनुमति है। यदि आप किसी फ़ंक्शन का उपयोग कर रहे हैं, तो आउटपुट रिटर्न वैल्यू है।

— जियोकॉवेल

Answer 1

CJam, 44 42 40 बाइट्स

qN+ee_{Xa/~\+XW=eu__el=!\'@-*m<Xa+}fXWf=

आउटपुट में एक अनुगामी लाइनफ़ीड शामिल है।

इसका परीक्षण यहां करें।

व्याख्या

स्ट्रिंग के माध्यम से अक्षरों को स्थानांतरित करने के बजाय, मैं बार-बार एक पत्र को हटाता हूं, तदनुसार स्ट्रिंग को घुमाता हूं, और फिर पत्र को पुन: स्थापित करता हूं। ऐसा करने के लिए एक पकड़ है: हमें स्ट्रिंग के अंत से स्ट्रिंग की शुरुआत को भेद करने में सक्षम होने की आवश्यकता है (जो हम एक साधारण रोटेशन के बाद नहीं कर सकते हैं)। इसलिए हम एक गार्ड के रूप में अंत में एक लाइनफ़ीड सम्मिलित करते हैं (लाइनफ़ीड से पहले पत्र स्ट्रिंग का अंत है, यह शुरुआत के बाद पत्र है)। बोनस यह है कि यह स्वचालित रूप से अंतिम स्ट्रिंग को सही रोटेशन में लौटाता है जहां स्ट्रिंग के अंत में लाइनफीड वास्तव में है ।

lN+     e# Read input and append a linefeed.
ee      e# Enumerate the array, so input "bob" would become [[0 'b] [1 'o] [2 'b] [3 N]]
        e# This is so that we can distinguish repeated occurrences of one letter.
_{      e# Duplicate. Then for each element X in the copy...
  Xa/   e# Split the enumerated string around X.
  ~     e# Dump the two halves onto the stack.
  \+    e# Concatenate them in reverse order. This is equivalent to rotating the current
        e# character to the front and then removing it.
  XW=   e# Get the character from X.
  eu    e# Convert to upper case.
  _     e# Duplicate.
  _el=! e# Check that convert to lower case changes the character (to ensure we have a
        e# letter).
  \'@-  e# Swap with the other upper-case copy and subtract '@, turning letters into 1 to
        e# 26 (and everything else into junk).
  *     e# Multiply with whether it's a letter or not to turn said junk into 0 (that means
        e# everything which is not a letter will be moved by 0 places).
  m<    e# Rotate the string to the left that many times.
  Xa+   e# Append X to the rotated string.
}fX
Wf=     e# Extract the character from each pair in the enumerated array.

यह देखने के लिए कि यह सही स्थिति में क्यों समाप्त होता है, hi*byeउदाहरण के अंतिम पुनरावृत्ति पर विचार करें । हमारे द्वारा संसाधित किए जाने के बाद e, एन्यूमरेटेड स्ट्रिंग इस स्थिति में है:

[[4 'y] [6 N] [2 '*] [0 'h] [1 'i] [3 'b] [5 'e]]

सबसे पहले, हम लाइनफीड के चारों ओर विभाजित होते हैं और रिवर्स ऑर्डर में भागों को बदलते हैं:

[[2 '*] [0 'h] [1 'i] [3 'b] [5 'e] [4 'y]]

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

[[2 '*] [0 'h] [1 'i] [3 'b] [5 'e] [4 'y] [6 N]]

कुछ अतिरिक्त परिणाम यदि कोई लंबे समय तक परीक्षण के मामलों की तुलना करना चाहता है:

Hello, World!
,W oeHlo!lrld

Programming Puzzles & Code Golf
ago fgliPomomnrr elP& uC dezzsG

The quick brown fox jumps over the lazy dog
t eg chbi ko qfTounyzrj omw epx ueoahs rlvd

abcdefghijklmnopqrstuvwxyz
aqbrcdsetfguhivjwklxmnyozp

zyxwvutsrqponmlkjihgfedcba
abcdefghijklmnopqrstuvwxyz

मुझे वह आखिरी पसंद है। :)

Comments

पायथ को सूची में चॉप सूची की आवश्यकता है।

— isaacg

@ आइसाकग नाह, मुझे यकीन है कि यह नहीं है। ;)

— मार्टिन एंडर

क्या आप इसे बना सकते हैं इसलिए यह मल्टी-लाइन स्ट्रिंग्स का समर्थन करता है?

— जियोकॉवेल

@geokavel ओह सही, तय।

— मार्टिन एंडर

सीथ प्रसन्न है, डार्थ बंटनर।

— जियोकॉवेल

Answer 2

रूबी 125 130 132 139 बाइट्स

->q{a=q.chars.map{|c|[c,c=~/[a-z]/i&&c.ord%32]}
while i=a.index{|c,s|s}
c,s=a.delete_at i
a.insert (i+s)%q.size,[c]
end
a*''}

परीक्षणों के साथ ऑनलाइन डेमो: http://ideone.com/GYJm2u

प्रारंभिक (ungolfed संस्करण): http://ideone.com/gTNvWY

संपादित करें: उनके सुझावों के लिए मैनटवर्क का बड़ा धन्यवाद !

2 संपादित करें : निश्चित वर्ण गणना (मैं शुरू में CRLF लाइन अंत की गिनती कर रहा था।)

Comments

अभी मुश्किल से परीक्षण किया: c.upcase.ord-64→ c.ord%32।

— मैनेटवर्क

@manatwork जो ठीक काम करता है, धन्यवाद!

— क्रिस्टियन लुपस्क्यू

फिर से देख रहे हैं ... रुको! a.join??? आप कौन हैं और आपने w0lf के साथ क्या किया है? वह निश्चित रूप से इसे लिखेंगे a*''।

— मैनेटवर्क

@manatwork :) मैं while ... endअपने कोड में होने के बारे में इतना परेशान था कि मैं ऐसा करना भूल गया। ध्यान देने के लिए धन्यवाद!

— क्रिस्टियन लुपस्कू

आपको लगता है कि चालू नहीं कर सकता while ... endमें (...)while ...?

— मार्टिन एंडर

Answer 3

पायथन 3, 278 275 273 270 260 258 249 248 243 238 बाइट्स

मैं वास्तव में गोल्फ इस नीचे बेहतर होना चाहिए, लेकिन यहां मेरे समाधान, करने के लिए धन्यवाद के साथ है katenkyo और तर्क के साथ अपनी मदद के लिए, करने के लिए Cyoce और Mego गोल्फ के साथ उनकी मदद के लिए।

संपादित करें: आख़िरकार, मैंने इसे एक तुलनात्मक बयान में बदल दिया। वू! (और हां, मैं z=-zइसे a,m=m,aबिट में स्थानांतरित कर सकता हूं , लेकिन यह बाइट्स को नहीं बचाता है और यह कोड को अधिक से अधिक पिघला देता है जितना मैंने सोचा था कि आवश्यक था)

संपादित करें: बाइट की गिनती बंद थी।

def m(s):
 l=len(s);r=range(l);p=[[i,s[i]]for i in r]
 for i in r:
  if s[i].isalpha():
   a=p[i][0];p[i][0]=m=(a+ord(s[i])%32)%l;z=1
   if a>m:a,m=m,a;z=-z
   for j in r:p[j][0]-=z*(j!=i)*(a<=p[j][0]<=m) 
 return''.join(dict(p).values())

Ungolfed:

def move(string):
 length = len(string)
 places = [[i,string[i]]for i in range(length)]
 for index in range(length):
  char = string[index]
  if char.isalpha():
   a = places[index][0]
   mov = (a + ord(char)%32) % length
   places[index][0] = mov
   for j in range(length):
    k = places[j][0]
    if a <= k <= mov and j!=index:
     places[j][0]-=1
    elif mov <= k <= a and j != index:
     places[j][0]+=1
 return''.join(dict(places).values())

Comments

मैं * विश्वास है * कि p[j][0]निर्धारित करके कम किया जा सकता J=p[j];, शुरुआत में तो की घटनाओं की जगह p[j][0]के साथP[0]

— Cyoce

@ मुझे लगता है कि परेशानी यह है कि मुझे pसीधे संपादित करने की आवश्यकता है , न कि एक चर जिसे इसे p[j]सौंपा गया था। इसके अलावा, यदि आप मेरे संशोधन इतिहास को देखते हैं, तो मेरे पास तुलना के k = p[j][0]लिए एक चर था a<=k<=m, लेकिन यह पता चला कि ड्रॉपिंग kबेहतर थी क्योंकि मैंने अतिरिक्त बाइट्स से अधिक बाइट्स kबचाए थे जिनका उपयोग करके मैंने सहेजा था k।

— शर्लक