घुमा शब्द!


34

घुमा शब्द!

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

उदाहरण इनपुट / आउटपुट

इनपुट

Programming Puzzles & Code Golf
4

उत्पादन

Prog
mmar
ing 
zzuP
les 
oC &
de G
 flo

इनपुट

इनपुट STDIN, या फ़ंक्शन तर्क के माध्यम से लिया जा सकता है। इनपुट में एक स्ट्रिंग और एक सकारात्मक पूर्णांक शामिल होगा, एन । पूर्णांक प्रत्येक मुड़ रेखा की लंबाई निर्धारित करेगा।

स्ट्रिंग आगे-पीछे मुड़ जाती है। HELLO, WORLD!और 5 का इनपुट इस तरह दिखेगा:

नमस्ते दुनिया!

उत्पादन

आउटपुट ट्विस्टेड टेक्स्ट होगा। यह कोई अनुगामी व्हॉट्सएप नहीं हो सकता है। यदि इनपुट स्ट्रिंग की लंबाई विभाज्य नहीं है, तो लाइन की लंबाई हो, पंक्ति भरे जाने तक एक स्थान जोड़ें:

इसका एक उदाहरण:

इनपुट

Hello, World!
5

आउटपुट (बहुत अंत में व्हाट्सएप पर ध्यान दें)

Hello
roW ,
ld!  


यह कोई अनुगामी व्हॉट्सएप नहीं हो सकता है। एक क्रिया दूर गोल्फ?
एडम

क्या हम लाइनों की सूची लौटा सकते हैं?
एडम

जवाबों:


10

पायथ, १ ९ १५

VPc+z*dQQ_W~!ZN

स्ट्रिंग को प्री-पैड करता है, फिर एक दूसरे की रेखा को उलट देता है क्योंकि यह इसे प्रिंट करता है। पैडिंग बॉक्स के आकार के बराबर है, लेकिन इनपुट को काटने के बाद अंतिम पंक्ति को छोड़ दिया जाता है।

इसे यहाँ आज़माएँ


6

CJam, 19 बाइट्स

q~1$S*+/W<{(N@Wf%}h

इनपुट उदाहरण:

5 "Hello, World!"

स्पष्टीकरण

q~         e# Input n and the string.
1$S*+      e# Append n spaces to the string.
/W<        e# Split by each n characters, and remove the last chunk.
{          e# While the array of chunks isn't empty:
    (N     e# Extract the first chunk and push a newline.
    @Wf%   e# Reverse every chunk left in the array.
}h

5

स्नोमैन 1.0.1 , 91 बाइट्स

{vg10vg|sB*#.'aGal'NdE'aaAaL|al!*+#5nS" "'aR'!#aCwR|.aC2aG:0aa|sP"
"sP'NdE|1aA.aNsP"
"sP;aE

या 2 बाइट्स की कीमत पर सभी एक लाइन पर (सौंदर्यशास्त्र के लिए, या अधिक विशेष रूप से, सौंदर्यशास्त्र विरोधी)

{vg10vg|sB*#.'aGal'NdE'aaAaL|al!*+#5nS" "'aR'!#aCwR|.aC2aG:0aa|sP10wRsP'NdE|1aA.aNsP10wRsP;aE

स्नोमैन के लिए यह रास्ता बहुत छोटा है। (यह संभवतः सबसे छोटा है, हालांकि इसे प्राप्त कर सकता हूं; मैंने इस पर लंबे समय तक काम किया है।)

इसका एक चेतावनी है: यह एक त्रुटि के साथ बाहर निकल जाएगा (लेकिन अभी भी सही उत्पादन का उत्पादन करता है) 50% समय, जब अंतिम पंक्ति उलट नहीं होती है। (ऐसा इसलिए है क्योंकि मैं agदो तत्वों के समूहों में सरणी तत्वों को समूहित करने के लिए उपयोग करता हूं ताकि मैं हर दूसरे को उलट सकूं, लेकिन मैं यह नहीं जांचता कि अंतिम तत्व में दोनों अपेक्षित तत्व हैं या नहीं, इसलिए यह किसी भी असंगत तत्व तक पहुंचने का प्रयास करेगा यदि विषम संख्या में रेखाएँ हैं।)

अघोषित / स्पष्टीकरण:

{vg10vg|sB*#      // get input, convert second string to number and store
.'aG              // split string into groups of n chars
al'NdE'aaAaL      // take out the last element of the array
|al!*+#5nS" "'aR  // subtract its length from 5, repeat that many spaces
'!#aCwR|.aC       // concat spaces to last el. and that back to the array
2aG               // split in groups of 2, so we can reverse every other string
// for each sub-group in the array of groups...
:
    0aa|sP10wRsP         // print the first element as is
    'NdE|1aA.aNsP10wRsP  // print the second element, reversed
;aE

5

अजगर 2, 60

s,n=input()
d=1
while s:print(s+n*' ')[:n][::d];s=s[n:];d=-d

के nएक समय से पात्रों को ले जाता है s, उन्हें एक दिशा के साथ छपाई करता है dजो 1और के बीच वैकल्पिक होता है -1। अंतिम पंक्ति पर रिक्ति के लिए , कटा हुआ होने से पहले अंत में रिक्त स्थान के sसाथ गद्देदार nहोता है, जो केवल इसे प्रभावित करता है जब इसमें nवर्ण कम शेष होते हैं।

एक पुनरावर्ती समाधान एक चार (59) को बचाएगा, सिवाय इसके कि यह एक अनुगामी न्यूलाइन छोड़ता है, जिसकी अनुमति नहीं है।

f=lambda s,n,d=1:s and(s+n*' ')[:n][::d]+"\n"+f(s[n:],n,-d) 

4

हास्केल , 83 75 बाइट्स

(id!)
(f![])_=[]
(f!l)n=f(take n$l++cycle" ")++'\n':((f.reverse)!drop n l)n

सरल chunksOfटेक एंड ड्रॉप के साथ कार्यान्वयन, आउटपुट पर एक या विषम संख्या को लागू करते हुए जैसे हम जाते हैं।

पांच बाइट्स के लिए @ बीएमओ और तीन बाइट्स के लिए @ orjanJohansen को धन्यवाद!

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


2
cycle5 बाइट्स का उपयोग करके , इसे ऑनलाइन आज़माएं!
ბიმო

निकालें gऔर स्वैप करके तीन और बाइट्स बचाएं : nऔर इसे ऑनलाइन आज़माएं! l
अर्जन जोहान्सन

3

अटक , 42 41 40 38 बाइट्स

यह बहुत लंबा है, शायद अधिक गोल्फ करने की कोशिश करेगा!

tg;_lu_@%u;-_0G<*' *+0GKE"];2%;Y_Y?p":

इनपुट की तरह होना चाहिए "string"|n

स्पष्टीकरण:

tg                 # Take input, place each item on stack, save the int to variable stack                                        
;_l                # Swap the top two items, duplicate the string and obtain length
u_@%               # Rotate to the left, duplicate, rotate right and take mod
u;-                # Rotate left, swap the top two and subtract from each other
_0G<*              # duplicate this value, check if less than stored int and multiply
' *+               # Push space onto stack n times, append to starting string
0GKE               # Split this string into segments, and enumerate
"];2%;Y_Y?p":      # For each segment, determine if should be reversed, and print

2

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

(#)=splitAt
s!n=let(a,t)=n#s;(b,u)=n#t in a:reverse b:(u!n)
s%n=unlines$takeWhile(any(>' '))$(s++cycle" ")!n

यह लंबे, जीज़ की तरह है। यहाँ यह कार्रवाई में है:

*Main> putStrLn $ "Programming Puzzles & Code Golf" % 4
Prog
mmar
ing
zzuP
les
oC &
de G
 flo

letअभिव्यक्ति कैसे काम करती है?
xnor

यह letएक अर्धविराम से अलग एक दो-इन- स्टेटमेंट है - आम तौर पर आप नईलाइन्स और इंडेंटेशन का उपयोग करेंगे, लेकिन हास्केल आपको लिखने की अनुमति भी देता है let a=b; c=d in expr
लिन

मुझे नहीं पता था कि यह अनुमति दी गई थी, कार्यक्रम से बाहर रखा गया!
लीफ विलर्ट्स

1
@LeifWillerts, हाल ही में, यहाँ पर चुनौतियाँ आपको फ़ंक्शन तर्कों / परिणामों या स्टड / स्टडआउट के माध्यम से I / O करने की अनुमति देती हैं - यहाँ, मेरा समाधान (%) :: String -> String -> Stringइसके बजाय एक फ़ंक्शन है IO ()
लिन

2

पायथन 2, 109 बाइट्स

सही होने के लिए अंतिम पंक्ति के लिए रिक्त स्थान के साथ पैडिंग जोड़ना था।

इसे यहाँ आज़माएँ

I,c=input()
I+=(c-len(I)%c)*" "
L=[]
i=0
while I:s=I[:c];L+=[[s,s[::-1]][i%2]];i+=1;I=I[c:]
print"\n".join(L)

2

लुआ, 91 88 88 84 83 82 बाइट्स

पुराना संस्करण:

a=arg for i=1,#a[1],a[2]do s=a[1]:sub(i,i+a[2]-1)print(d and s:reverse()or s)d=not d end

नया संस्करण:

arg[1]:gsub((".?"):rep(arg[2]),function(s)print(d and s:reverse()or s)d=not d end)


2

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

sub f{$_=@_[0].$"x(@_[1]-1);$a.=(($i++&1?reverse$1:$1).$/)while/(.{@_[1]})/g;chop$a;$a}

पुराना संस्करण (एक नई रूपरेखा प्रिंट करता है):

sub f{$_=@_[0].$"x(@_[1]-1);print(($i++&1?reverse$1:$1).$/)while/(.{@_[1]})/g}

स्ट्रिंग को एक फ़ंक्शन तर्क के रूप में पास किया जाता है जिसमें कोई अनुगामी न्यूलाइन नहीं है। इस तरह से कॉल करें:

$_=<>;chomp;print f($_,5);

2

कण्ठमाला, 86 बाइट्स

R I,S,! S P=$L(I),$P(I," ",P)=P F Q=1:S:P S F=$E(I,Q,Q+S-1),P='P W $S('P:F,1:$RE(F)),!

यदि आप पहले निकालते हैं तो यह 2 बाइट्स कम हो सकता है '!' R कथन में वर्ण (STDIN से पढ़ें); जो इनपुट और आउटपुट के बीच एक गाड़ी रिटर्न जोड़ता है। यदि वह नहीं था, तो आउटपुट तकनीकी रूप से सही है, लेकिन पहली पंक्ति इनपुट स्ट्रिंग में संलग्न होगी। [[मानक मम्प्स टर्मिनल जो मैं उपयोग करता हूं उसमें कोई स्थानीय गूंज नहीं है। ]]   जैसा कि यह बैठता है, यहाँ परीक्षण है:

R I,S,! S P=$L(I),$P(I," ",P)=P F Q=1:S:P S F=$E(I,Q,Q+S-1),P='P W $S('P:F,1:$RE(F)),!
ABCDEFGHIJKLMNOPQRSTUVWXYZ1236
ABCDEF
LKJIHG
MNOPQR
XWVUTS
YZ123 

यह भी ध्यान दें कि, वास्तव में इनपुट के अंत में '123' और '6' के बीच एक गाड़ी वापसी / Enter कीपर है। [[स्थानीय गूंज फिर से बात ]]

अगर किसी की दिलचस्पी है तो मैं बता सकता हूं कि कोड के साथ क्या हो रहा है; लेकिन मुझे लगता है कि वहाँ एक टन के उत्साही उत्साही नहीं है ... :-)


2

पावरशेल, 102 बाइट्स

param($s,$i)$l=$s.Length;$s+' '*($i%$l)-split"(.{$i})"|?{$_}|%{$r=-not$r;@($_,($_[$l..0]-join''))[$r]}

निम्नानुसार लागू किया गया (यदि फ़ाइल में सहेजा गया है CodeGolf55051.ps1)

.\CodeGolf55051.ps1 -s '1234567890' -i 4

पिछला प्रयास

(लंबे या अमान्य)

पॉवरशेल, 110 बाइट्स

param($s,$i)$l=$s.Length;$s+' '*(($i-$l%$i)%$i)-split"(.{$i})"|?{$_}|%{$r=-not$r;@($_,($_[$l..0]-join''))[$r]}

पॉवरशेल, 111 बाइट्स

param($s,$i)$s+' '*(($i-$s.Length%$i)%$i)-split"(.{$i})"|?{$_}|%{$r=-not$r;@($_,($_[$_.length..0]-join''))[$r]}

व्याख्या

param($s,$i)                         #Take input text (s) and column width (i)
$s                                   #take the user entered string
+ ' ' * (($i - $s.Length % $i) % $i) #add the least number of spaces required to make its length divisible by i
-split"(.{$i})"                      #break it into chunks of i characters in length
| ?{$_}                              #skip any blank lines created in the process
| %{                                 #for each line
    $r = -not $r;                    #    toggle a boolean value
    @(                               #    define an array
        $_                           #    index 0 = the string going forwards
        ,($_[$_.length..0] -join '') #    index 1 = the string reversed (by taking each character from the last to the first, then joining them)
    )[$r]                            #    if our boolean value is false take the forward string (index 0), if true take the backwards one (index 1)
}                                    #next

पॉवरशेल, 180 बाइट्स

param($s,$i)$x="`${0}|{1}|`${2}";$w=$x;1..$i|%{$w=$w-f$_,$x,($i+$_)};$w=$w-replace'\||\${.*}';$r=$w-replace'\$\d+','(.)?';$s+' '*($i-$s.Length%$i)-replace$r,$w-split"(.{$i})"|?{$_}

पॉवरशेल, 196 बाइट्स

param($s,$i)$x="{0}|{1}|{2}";$w=$x;1..$i|%{$w=$w-f$_,$x,($i+$_)};$w=$w-replace'(\d+)','$$$1'-replace'\||{.*}';$r=$w-replace'\$\d+','(.)?';$s+' '*($i-$s.Length%$i)-replace$r,$w-split"(.{$i})"|?{$_}

व्याख्या

param ($s, $i)                      #Take input text (s) and column width (i)

$x = "{0}|{1}|{2}"                  #Define string format which takes 3 entries and pipe delimits them

$w = $x                             #initialise our replacement regex with this format
1..$i | %{                          #for 1 to the specified column width
    $w = $w -f $_, $x, ($i + $_)    #update the regex 1|{...}|5, 1|2|{...}|6|5, etc
}                                   #resulting in w = 1|2|3|4|{...}|8|7|6|5
$w = $w -replace '(\d+)', '$$$1'    #now prefix the numbers with a dollar (so they're regex replacement variables)
        -replace '\||{.*}'          #and remove the delimiters and superfluous `{...}` left from our middle insertion routine

$r = $w -replace '\$\d+', '(.)?'    #then create the match pattern by replacing the variables with optional single character captures

$s                                  #now take the user entered string
    + ' ' * ($i - $s.Length % $i)   #add the least number of spaces required to make its length divisible by i
    -replace $r, $w                 #perform a replacement using the regex match and replace patterns created above
    -split "(.{$i})"                #then split the string into blocks of length i
    | ?{$_}                         #removing any blank lines created in the process

( {...}उपरोक्त टिप्पणी वास्तव में है {0}|{1}|{2}; मैंने {...}बेहतर पठनीयता के लिए रखा है।

पॉवर्सशेल, 120 बाइट्स (अमान्य)

param($s,$i)$s + ' ' * ($i-$s.Length%$i) -replace '(.{4})?(.)(.)(.)(.)',"`$1`n`$5`$4`$3`$2`n" -split "`n" | ?{$_ -ne ""}

1
एक और PowerShell स्लिंगर देखने के लिए बहुत बढ़िया! एक आसान शुरुआत हर स्थान के पास खतरे से छुटकारा पाने की है param($s,$i)$s+' '*($i-$s.Length%$i)-replace'(.{4})?(.)(.)(.)(.)',"`$1`n`$5`$4`$3`$2`n"-split"`n"|?{$_-ne""}जो आपको 108 तक
पहुंचा देगा

धन्यवाद @TimmyD; बस मेरी स्क्रिप्ट के साथ मूलभूत त्रुटियों के एक जोड़े को देखा (हालांकि यह आवश्यकताओं को पूरा नहीं करता है / केवल 4 के लिए काम करने के लिए हार्डकोड किया गया है ... अब ठीक कर रहा है)
JohnLevan

परीक्षण करते समय, सही दिशा में शुरू करने के लिए प्रवाह को आगे और पीछे लाने के लिए, मुझे अंतिम [$r]सूचकांक को स्वैप करने की आवश्यकता थी[-not$r] ... अन्यथा पहली पंक्ति प्रदान किए गए उदाहरणों की तुलना में विपरीत (यानी, दाएं-बाएं) को पढ़ती है। अन्यथा, वास्तव में चालाक निष्पादन!
AdmBorkBork

1
इसके अलावा, चूंकि हमें दिया गया है कि इनपुट नंबर nसकारात्मक है, और हम गारंटी देते हैं कि स्ट्रिंग की लंबाई गैर-नकारात्मक (परिभाषा के अनुसार) है, इसका मतलब है कि चार वर्णों को सहेजने के (($i-$l%$i)%i)बराबर है ($i-$l%$i)
AdmBorkBork

1
वूप्स, मैं किसी भी तरह से टाइपो हूँ कि, मैं मूल रूप से मतलब था (-$l)%$i। पता नहीं कहाँ से आया है। दिलचस्प है, हालांकि, यह बराबर नहीं है, हालांकि यह होना चाहिए। यह स्पष्ट रूप से है कि पावरशेल (अन्य भाषाओं के बीच) मॉडुलो फ़ंक्शन को कैसे लागू करता है, जो कि I (गणित प्रमुख होने के नाते) या वोल्फ्राम-अल्फा से अलग है। जाहिर है, आप लंबे संस्करण के साथ रहना होगा। संदर्भ प्रमाण ->((y-x%y)%y) ==> ((y%y)-(x%y%y))%y ==> ((0)-(x%y))%y ==> (-x%y)%y ==> (-x)%y
AdmBorkBork

2

क्लोजर, 83 बाइट्स, 87 बाइट्स , 79 बाइट्स

(fn[n s](map #(apply str(% %2))(cycle[#(or %)reverse])(partition n n(repeat\ )s))))

नीचे दिए गए टिप्पणियों के बाद कई सुधार, धन्यवाद belowrjan

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

कोड गोल्फिंग उत्तरों से क्लोजर अक्सर उदास रूप से अनुपस्थित लगता है। यह निश्चित रूप से गोल्फ की भाषाओं के साथ बाइट लंबाई में प्रतिस्पर्धा नहीं कर सकता है, लेकिन मुझे लगता है कि कुल अनुपस्थिति कुछ हद तक अनुचित है।

स्पष्टीकरण:

  • इन-डेटा, दो तर्क एक संख्या और एक स्ट्रिंग
  • स्ट्रिंग पर निर्मित क्लोजर-इन फंक्शन पार्टीशन को रनिंग द्वारा शुरू करें, sइसे पात्रों की सूचियों के अनुक्रम में सूचीबद्ध करें जहां सूचियों की लंबाई है n। अंतिम पंक को n"पैड संग्रह" का उपयोग करके लंबाई के साथ रिक्त स्थान के साथ गद्देदार किया जाएगा , (repeat " ")जिससे रिक्त स्थान का एक अनंत आलसी अनुक्रम वापस आ जाता है
  • हम फिर तीन तर्कों के साथ मानचित्र कहते हैं :
    • एक अनाम फ़ंक्शन ( #(..))
    • एक अनंत बारी कार्यों के आलसी अनुक्रम #(or %)जो जैसे कार्यों पहचान समारोह और रिवर्स (यानी [#(or %) reverse #(or %) reverse ...]के रूप में द्वारा दिया) चक्र
    • विभाजन द्वारा लौटाए गए सूचियों के आलसी अनुक्रम का हिस्सा।
  • अंत में अनाम फ़ंक्शन #(apply ...) :
    • identityया तो या reverseवैकल्पिक रूप से एक चंक पर कॉल करता है । यह उस (% %2)अभिव्यक्ति के माध्यम से किया जाता है, जिसे भेजे गए फ़ंक्शन को अनाम फ़ंक्शन [अर्थातidentity या reverse] दूसरे तर्क का उपयोग करता है [यानी chunk] अनाम फ़ंक्शन को कॉल के तर्क के रूप में।
    • (apply str ...)वर्णों की सूची को एक स्ट्रिंग में बदलने के लिए कॉल
  • बाहरी फ़ंक्शन स्ट्रिंग्स का एक आलसी अनुक्रम लौटाता है

एक ट्रिक जो हम यहां इस्तेमाल करते हैं वह यह है कि बहुत सारे क्लोजर फ़ंक्शंस जैसे mapकि आर्गेस के रूप में संग्रह की एक मनमानी संख्या लेते हैं, यानी (map f coll1 coll2 coll3 ...)जहां फ़ंक्शन च को संग्रह के रूप में कई तर्कों को स्वीकार करने की आवश्यकता होती है। इस मामले में हम दो संग्रह में भेजते हैं, बारी-बारी से कार्य संदर्भों का एक संग्रह और कड़ा हुआ स्ट्रिंग।


1
यह अच्छा है, लेकिन इसके अंत में आवश्यक व्हाट्सएप नहीं लगता है ld!
अर्जन जोहान्सन

आप सबसे सही हैं। एक पैड संग्रह जोड़ा गया है जो इस मुद्दे को ठीक करना चाहिए ... और मेरी लागत 8 बाइट्स ...
मत्तीस बजरलैंड

मेरे पास गोल्फिंग नियमों पर एक प्रश्न है: यदि आप एक अंतर्निहित फ़ंक्शन का उपयोग कर रहे हैं जिसमें आयात या समान कथन (क्लॉजुर में आयात, जावा में आयात आदि) की आवश्यकता होती है, तो उस अंतर्निहित भाग का आयात करने की आवश्यकता है गोल्फ समाधान बाइट गिनती? मैं हाँ मानता हूँ, लेकिन यह एक ग्रे क्षेत्र की तरह एक बालक लगता है।
मतियास ब्रजलैंड

हां, आयात को गिना जाता है।
अर्जन जोहान्स

ओह, लेकिन एक और नियम है जिसे आप तोड़ रहे हैं: आप पूर्वनिर्धारित चर में इनपुट नहीं ले सकते हैं, आपको समाधान या तो एक पूरे कार्यक्रम या फ़ंक्शन को बनाने की आवश्यकता है। ( fnया तो उपयोग करना या defnठीक है।) फ्लिप पक्ष पर आपके फ़ंक्शन को प्रिंट करने के बजाय परिणाम को वापस करने की अनुमति है।
अर्जन जोहान्स

2

एपीएल (डायलॉग यूनिकोड) , 19 बाइट्स

{↑⊢∘⌽\↓↑⍵⊆⍨⌈⍺÷⍨⍳≢⍵}

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

गुलदाउदी चुनौती के लिए ngn के शानदार जवाब⊢∘⌽\ से चाल ली ।

यह समझने के बाद कि मेरा प्रस्तुतिकरण प्रमुख नईलाइन्स वाली लाइनों के लिए टूट गया है, मैंने दो और बाइट्स जोड़े हैं। नीचे पुराना सबमिशन है।

एपीएल (डायलॉग यूनिकोड) , 17 बाइट्स

{↑⊢∘⌽\⍵⊆⍨⌈⍺÷⍨⍳≢⍵}

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


2

पायथन 3, 110 108 107 103 बाइट्स

def a(s,n):l=len(s)//n+1;s+=' '*(len(s)-l);print('\n'.join([s[x*n:n*x+n][::(-1)**x]for x in range(l)]))

(अन्य उत्तरों को देखते हुए), के साथ rjust :95 93 92 90 बाइट्स

def a(s,n):print('\n'.join([s[x*n:n*x+n][::(-1)**x].rjust(n)for x in range(len(s)//n+1)]))

आपके आउटपुट की अंतिम पंक्ति गलत है। इसे यहां चलाएं। यह एक महान पहली पोस्ट है, और एक बार जब आप ठीक कर लेते हैं कि मैं कुछ बाइट्स को बंद करने के कुछ तरीके सुझाऊंगा, तो पहला यह कि आप अपने उत्तर से सभी रिक्त स्थान / टैब निकाल सकते हैं।
mbomb007

हाहा, तुम बहुत सही हो। इसे ठीक करना बहुत महंगा है, लेकिन मैं इस पर काम कर रहा हूं। धन्यवाद
०b


इसके अलावा, आपने मेरे उत्तर को काफी पहले से हरा दिया: codegolf.stackexchange.com/a/55082/34718
mbomb007

युक्तियाँ पढ़ना। धन्यवाद फिर से
bobrobbob

1

PHP, 135 बाइट्स

दिखाए गए अनुसार दो कमांड-लाइन तर्क देता है $argv

<? foreach($a=str_split($s=$argv[1],$n=$argv[2])as$k=>&$v)$v=$k%2?$v:strrev($v);echo implode("\n",$a).str_repeat(' ',$n-strlen($s)%$n);

1

कॉफ़ीस्क्रिप्ट, 131 बाइट्स

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

f=(s,n,r=l=s.length,i=0,z='')->(t=s[i...i+=n].split '';t=t.reverse()if r=!r;z+=t.join('')+(i<l&&'\n'||' '.repeat n-l%n))while i<l;z

1

जूलिया, 104 बाइट्स

f(s,n)=(L=length(s);L+=L÷n;j=0;for i=1:n:L-n+1 x=rpad(s,L)[i:i+n-1];println(j%2<1?x:reverse(x));j+=1end)

Ungolfed:

function f(s::String, n::Int)
    L = length(s) + length(s) ÷ n
    j = 0
    for i = 1:n:L-n+1
        x = rpad(s, L)[i:i+n-1]
        println(j % 2 == 0 ? x : reverse(x))
        j += 1
    end
end


1

क्ष, ४६

{-1@neg[y]$@[a;(&)(til(#)a:y cut x)mod 2;|:];}

q){-1@neg[y]$@[a;(&)(til(#)a:y cut x)mod 2;|:];}["Programming Puzzles & Code Golf";4]
Prog
mmar
ing
zzuP
les
oC &
de G
 flo

यह गलत है जब अंतिम पंक्ति छोटी है और मुड़ नहीं है, मैं अपने उत्तर में बग फिक्स पोस्ट करना चाहता था, लेकिन मुझे लगता है कि यह बेहतर होगा यदि आप इसके बजाय अपना अपडेट कर सकते हैं: {-1@[l;(&)(til(#)l:y cut x)mod 2;'[neg[y]$;|:]];}(49 बाइट्स)। प्रेरणा के लिए धन्यवाद! :)
hjk

1

क्यू, 64 56 बाइट्स

{c::neg y;-1(til(#)l){$[x mod 2;c$(|:)y;y]}'l:y cut x;}
  • {}एक फ़ंक्शन है जिसे कहा जाना चाहिए {}[x;y]
    • x स्ट्रिंग होगी।
    • y परिणामी लाइनों की लंबाई होगी।

परीक्षा:

{c::neg y;-1(til(#)l){$[x mod 2;c$(|:)y;y]}'l:y cut x;}["Programming Puzzles & Code Golf";4]
Prog
mmar
ing
zzuP
les
oC &
de G
 flo

संपादित करें : @tmartin द्वारा अन्य q उत्तर से प्रेरित के रूप में छोटे कार्यों का इस्तेमाल किया


1

पायथन 2, 82 75 बाइट्स

s,n=input()
k=0
while k<=len(s):print s[k:k+n].ljust(n)[::1-2*(k/n%2)];k+=n

मैं @willem पर टिप्पणी नहीं कर सकता लेकिन मैंने उनका कोड छोटा कर दिया।

यहाँ कोशिश करो यहाँ कोशिश करो


हाय एलेक्सएन, अच्छा है। मुझे लगता है कि 'यहाँ कोशिश करो' उदाहरण में आपकी अंतिम पंक्ति सही नहीं है। इसे सही ठहराया जाना चाहिए। इसके अलावा मैं 86 आकर्षण गिनती? अद्यतन के लिए मेरी प्रविष्टि देखें ।
विलेम

हाय विल्म, आप सही हैं, मैंने कोड को ठीक किया और पाया कि आपकी एक त्रुटि है: ideone.com/GOmMrE दाईं ओर होना चाहिए।
अलेक्जेंडर निगल

1

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

perl -p0e's/\n(.*)/$"x($1-$-[0]%$1)/e;s/.{$1}/($i++%2?reverse$&:$&)."\n"/ge;chop'

70 बाइट्स, प्लस 2 बाइट्स के लिए -p0

डेमो:

$ echo -en 'Hello, World!\n5' | perl -p0e's/\n(.*)/$"x($1-$-[0]%$1)/e;s/.{$1}/($i++%2?reverse$&:$&)."\n"/ge;chop'
Hello
roW ,
ld!  $

ध्यान दें कि STDIN से पढ़ा गया इनपुट एक नई पंक्ति के साथ समाप्त नहीं हो सकता है (जिसमें 2 अतिरिक्त बाइट खर्च होंगे)।

स्पष्टीकरण:

perl -p0e'  # Read from STDIN, splitting on null bytes,
            # and print $_ automatically at the end

    s/
        \n(.*)  # Replace everything after first newline,
                # capturing wrap length in $1...
     /
        $"x($1-$-[0]%$1)  # ...with spaces until the total length of $_ is
                          # a multiple of $1 (i.e. right-pad with spaces)
     /e;

    s/
        .{$1}  # Replace series of $1 contiguous chars...
     /
        ($i++%2?reverse$&:$&)."\n"  # ...alternately with themselves or in
                                    # reverse, with a trailing newline
     /ge;

    chop'  # Remove final newline

1

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

var t=(s,n)=>{for(var d=1,i=0,o='',l=s.length;i<l;i++){o+=d?s[i]:s[i-i%n+n-1-i%n]||' ';if(i%n==n-1){d=!d;o+='\n'}}return o}

के साथ कॉल करें t(input_string, twist_length), जो आउटपुट स्ट्रिंग लौटाता है।


1
क्षमा करें, बहुत तेजी से पोस्ट किया गया। यह तय हो चुका है।
DankMemes



0

कॉफ़ीस्क्रिप्ट, 151 बाइट्स

f=(s,n)->r="";d=n;i=0;_="\n";u=" ";l=s.length;(d--and(r+=s[i]or u;++i)or(r+=_;r+=s[c]or u for c in[i+n-1..i];i+=d=n;r+=_ if i<l))while i<(l/n+1>>0)*n;r

बहुत ज्यादा = (


0

बैश, 83 74

for((i=0;i<${#1};i+=$2));do b=cat;((i/$2%2))&&b=rev;echo ${1:i:$2}|$b;done

इसके बीच विकल्प cat और केrev पहले तर्क के दूसरे तर्क की लंबाई के साथ के लिए है।

विशेष चर का उपयोग किया जाता है

  • ${#1}(स्ट्रिंग की लंबाई $1)
  • ((i/$2%2))(एक अंकगणितीय व्यंजक को वृद्धिशील $iद्वारा विभाजित करना $2और फिर विषम बनाम को भी निर्धारित करने के लिए इसका मोडुलो लेना, जो निर्धारित करता है कि उपयोग करना है या नहीं rev)
  • ${1:i:$2}( एक लंबाई के साथ $1स्थिति में शुरू करने $iका विकल्प $2)।

हम्म, मैंने इसे दूसरे bashउत्तर से स्वतंत्र किया , जिसे मैंने केवल अभी देखा था। हमारे पास प्रभावी रूप से एक ही तर्क है। ... वास्तव में, viktorahlström का जवाब सिर्फ मुझे 9 अन्य पात्रों को शेव करने की अनुमति देता है।
एडम काट्ज़

0

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

बस मेरे ही सवाल पर मेरी खुद की दरार। यह रिक्त स्थान जोड़ देगा ताकि यह विभाज्य हो n, इस तरह यह बस विभाजन और उलट रहा है।

(s,n)=>(s+' '.repeat(n-s.length%n)).match(eval(`/.{1,${n}}/g`)).map((l,i)=>i%2?[...l].reverse().join``:l).join`
`
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.