स्ट्रिंग रोटेशन - आउटपुट स्ट्रिंग बार-बार पहले चरित्र को अंत तक ले जाता है

22

यहाँ चुनौती एक स्ट्रिंग लेना है और इसके सभी घुमावों को आउटपुट करना है, पहले चरित्र को बार-बार स्थानांतरित करके, एक बार स्ट्रिंग में प्रति चरित्र, मूल स्ट्रिंग के साथ समाप्त करना:

john -> ohnj, hnjo, njoh, john

आप दूसरी दिशा में भी जा सकते हैं, अंत से वर्ण घूमते हुए:

john -> njoh, hnjo, ohnj, john

आपको प्रति अक्षर एक रोटेशन का उत्पादन करना चाहिए, भले ही मूल शब्द उस से पहले पहुंच गया हो:

heehee -> eeheeh, eheehe, heehee, eeheeh, eheehe, heehee

चरित्र सरणियों की अनुमति है, जब तक कि परिणाम ऊपर दिखाए गए अनुसार काम करता है।

सबसे छोटा जवाब जीत!

code-golf  string 
— I_P_Edwards
स्रोत
5
यदि कोई स्ट्रिंग heeheeअपनी लंबाई से कम चक्रों में मूल क्रम में वापस आती है, तो क्या हम वहां रुकते हैं? मुझे उम्मीद है कि यह कई उत्तरों के लिए एक बड़ा अंतर बनाएगा।
— xnor
क्या हम दूसरी दिशा में जा सकते हैं?
— xnor
2
मैंने आपकी स्पष्टीकरण सहित प्रश्न को संपादित किया है, इसे बदलने के लिए स्वतंत्र महसूस करें यदि यह आपका इरादा नहीं है।
— xnor
1
@xnor जो मेरे मूल पोस्ट की तुलना में बहुत स्पष्ट दिखता है, बहुत बहुत धन्यवाद!
— I_P_Edwards
1
क्या हमें इनपुट / आउटपुट कैरेक्टर सरणियों की अनुमति है? (कुछ भाषाओं में अंतर महत्वपूर्ण हो सकता है।)
— लीजियनममाल 978

जवाबों:

7

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

ṙJ

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

इसे ऑनलाइन आज़माएं! (पाद सुंदर लिंक को कॉल करके और newline वर्णों के साथ जुड़कर प्रिंट करता है)

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

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

s=input()
for c in s:s=s[1:]+c;print s

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

— XNOR
स्रोत
अजगर 3 केवल 9 और बाइट्स है।
— wizzwizz4
1
@ wizzwizz4 आपको 9 कहाँ मिलेगा? पायथन 3 - 39 बाइट्स (उद्धरण के बिना
— स्टड
@ pizzapants184 मैं भूल गया कि तार अपरिवर्तनीय थे; आप सही हे; यह केवल 1 और बाइट है।
— wizzwizz4
4

जाप, 5 3 बाइट्स

एक चरित्र सरणी के रूप में इनपुट लेता है, चरित्र सरणियों की एक सरणी आउटपुट करता है

£=é

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

£=é     :Implicit input of character array U
£       :Map
  é     :  Rotate U one element to the right
 =      :  Reassign to U for next iteration
— झबरा
स्रोत
3

ब्रेनफक , 59 बाइट्स

,[>,]<[>>[>]+[<]<[<]>-[[>]>[>]<+[<]<[<]>-]>[.>]>[.>]<[<].<]

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

नल बाइट्स द्वारा अलग किए गए प्रत्येक स्ट्रिंग को आउटपुट करता है।

स्पष्टीकरण:

,[>,]    # Get input
<[       # Start loop over input
  >>[>]       # Go to end of the string
  +           # Set it to one to mark it
  [<]<[<]>    # Move to the beginning of input
  -[[>]>[>]<+[<]<[<]>-]   # Transfer the first character to the end
  >[.>]>[.>]  # Print the rotated string
  <[<].       # Print a nul byte
<]       # Repeat loop while input
— मजाक कर रहा है
स्रोत
3

MATL , 6 5 बाइट्स

tf&+)

1 बाइट @luis की बदौलत बच गई!

MATL ऑनलाइन पर यह कोशिश करो !

स्पष्टीकरण :

    # Implicitly grab input string
t   # Duplicate the input
f   # Create an array [1, ..., N] where N is the number of characters in the input
&+  # Add the transpose of this array to itself to create a 2D array of indices
    #
    #   +   1  2  3  4
    #       ----------
    #   1 | 2  3  4  5
    #   2 | 3  4  5  6
    #   3 | 4  5  6  7
    #   4 | 5  6  7  8
    #
)   # Use this 2D array to index into the original string using periodic indexing
    # Implicitly display the resulting character array
— Suever
स्रोत
@LuisMendo चतुर! धन्यवाद!
— स्वेअर
3

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 35 26 बाइट्स

Partition[#,Tr[1^#],1,-1]&

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

इनपुट के रूप में वर्णों की एक सूची लेता है।

Partition(लेकिन इसका StringPartitionनीचे इस्तेमाल किया गया संस्करण ) नहीं है, इसके इनपुट को चक्रीय मानने के लिए एक वैकल्पिक चौथा तर्क है (और यह निर्दिष्ट करने के लिए कि वास्तव में ऐसा कैसे किया जाए), जो इस घोल को स्ट्रिंग की तुलना में सरल बनाता है - इसके अलावा कोई भी 15 वर्ण निर्मित नहीं है -में कार्य करता है।

वोल्फ्राम लैंग्वेज (मैथमेटिका) , 44 बाइट्स

Rest@StringPartition[#<>#,StringLength@#,1]&

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

वही, लेकिन इनपुट के रूप में एक स्ट्रिंग लेता है।

में बदल जाता "john"है "johnjohn", फिर StringLength["john"]ऑफसेट 1 के साथ इस स्ट्रिंग की सभी लंबाई- सबस्ट्रिंग लेता है , उत्पादन करता है {"john","ohnj","hnjo","njoh","john"}, फिर इनमें से पहले को छोड़ता है Rest।

— मिशा लावरोव
स्रोत
चूंकि चरित्र सरणियों की अनुमति है, इसलिए Rest@Partition[#~Join~#,Length@#,1]&36 बाइट्स होंगी।
— लीजनमोनमाल 978
@ LegionMammal978 धन्यवाद! चरित्र सरणियों के साथ एक छोटा दृष्टिकोण भी है, हालांकि मैंने अभी तक कुछ भी नहीं सोचा है।
— मिशा लावरोव
2

अटैची , 13 बाइट्स

Rotate#{1:#_}

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

व्याख्या

Rotate#{1:#_}
      #          fork(f, g) = ${ f[x, g[x]] }; this forks:
Rotate               rotate's the input by
       {1:#_}        each number from 1 to the length of the input

वैकल्पिक

15 बाइट्स :{_&Rotate!1:#_}

16 बाइट्स :{Rotate[_,1:#_]}

16 बाइट्स :Rotate@Rotations

16 बाइट्स :Rotate#(1&`:@`#)

17 बाइट्स :Rotate#{1+Iota@_}

18 बाइट्स :Rotate#(1&`+@Iota)

19 बाइट्स :Rotate#(Succ=>Iota)

— कोनोर ओ ब्रायन
स्रोत
2

जे , 7 बाइट्स

#\|."{]

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

स्पष्टीकरण:

  |."{    - rotate ( "{ is short for "0 1 - rank 0 1 ) 
      ]   - the input
#\        - lenght of the successive prefixes of the input
— गैलेन इवानोव
स्रोत
2
इस "तरह का उपयोग करना बहुत ही चालाक है, और भाषा के शब्दकोश ज्ञान की आवश्यकता है। क्या पद के साथ क्रिया भी है 1 0?
— Adám
@ मुझे लगता है कि यह है "#:। मैंने इसे फ्रॉन्फ्रॉग से सीखा
— गैलेन इवानोव
2

सी (32-बिट), 58 51 50 बाइट्स

छत के लिए एक अच्छा गोल संख्या धन्यवाद के लिए -1 बाइट

i;f(s){for(i=0;i++<printf("%s%.*s\n",s+i,i,s)-2;);}

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

Degolf

i;           // "Global" i.
f(s){   // s is pointer to string, which conveniently fits in a 32 bit integer.
    for(i=0; // Initialize i.
        // Increment i and take its complement, and add it to the
        // return value of printf(); which just happens to be strlen(s)+1.
        // ~i + strlen(s) + 1 == strlen(s) + 1 - i - 1, so the last printed
        // string is the original string.
        ~++i + printf("%s%.*s\n",s+i,i,s);
        // The printf prints two strings: first until the terminating \0,
        // the second until a \0 or until i chars have been printed. It also
        // prints a linefeed.
}
के ~++i+printf("%s%.*s\n",s+i,i,s)बजाय सुझावi++<printf("%s%.*s\n",s+i,i,s)-2
— छत
@ceilingcat धन्यवाद, हमेशा की तरह!
@ceilingcat आपको वास्तव में बुलाया जाना चाहिए flooringcat।
1

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

⮌Ｅθ⭆θ§θ⁻μκ

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

  θ         Input string
 Ｅ         Map over characters
    θ       Input string
   ⭆        Map over characters and join
      θ     Input string
     §      Circularly indexed by
       ⁻    Difference between
        μ   Inner index
         κ  Outer index
⮌           Reversed
            Implicitly print each string on its own line

विपरीत दिशा में घुमाने के लिए, के Minusसाथ बदलें Plus।

— नील
स्रोत
1

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

{m:ex/^(.*)(.+)$/».&{[R~] @$_}}

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

m:ex/^(.*)(.+)$/ exhaustively m, हर संभव जगह पर दिया regex, बंटवारे इनपुट स्ट्रिंग atches को छोड़कर दूसरे सबस्ट्रिंग कम से कम एक वर्ण होना चाहिए कि - कि रोकता उत्पादन में दो बार दिखाए जाने से इनपुट स्ट्रिंग। फिर प्रत्येक परिणामी Matchऑब्जेक्ट्स के कैप्चर ग्रुप []को एक स्ट्रिंग के साथ घटाया जाता है ( ) R~, उलटा स्ट्रिंग कॉन्सेप्टेशन ऑपरेटर।

— शॉन
स्रोत
1

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

($s=$args|% t*y)|%{$h,$t=$s;-join($s=$t+$h)}

टेस्ट स्क्रिप्ट:

$f = {

($s=$args|% t*y)|%{$h,$t=$s;-join($s=$t+$h)}

}

@(
    ,('john', 'ohnj', 'hnjo', 'njoh', 'john')
    ,('heehee', 'eeheeh', 'eheehe', 'heehee', 'eeheeh', 'eheehe', 'heehee')
) | % {
    $s,$expected = $_
    $result = &$f $s
    "$result"-eq"$expected"
    $result
}

उत्पादन:

True
ohnj
hnjo
njoh
john
True
eeheeh
eheehe
heehee
eeheeh
eheehe
heehee
— Mazzy
स्रोत
1

Tcl , 80 91 बाइट्स

proc P s {time {puts [set s [string ra $s 1 e][string in $s 0]]} [string le $s]}

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

— sergiol
स्रोत
प्रत्येक बार पुन: असाइन किए गए पाठ में कुछ बाइट्स proc R t {time {puts [set t [string ra $t 1 end][string in $t 0]]} [string len $t]}
— david
यह 80 बाइट्स तक गिर गया, @david के लिए धन्यवाद
— sergiol
1

लूआ , 61 बाइट्स

function(s)for i=1,#s do print(s:sub(i+1)..s:sub(1,i))end end

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

स्ट्रिंग की एक (एक-आधारित अनुक्रमणिका) की लंबाई से क्रमिक सूचकांकों पर स्प्लिट स्ट्रिंग, रिवर्स ऑर्डर में टुकड़ों को समेटें, प्रिंट करें।

— cyclaminist
स्रोत
1

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

->s{a=s.chars.to_a;a.map{a.rotate!*''}}

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

— acornellier
स्रोत
1
साइट पर आपका स्वागत है! ऐसा नहीं लगता कि आपका TIO लिंक आपके उत्तर से मेल खाता है। यह भी लगता है कि आपका उत्तर हमारे इनपुट / आउटपुट आवश्यकताओं के अनुरूप नहीं है। आप किसी फ़ंक्शन या STDIN / STDOUT का उपयोग कर सकते हैं, लेकिन हम चर पुनर्मूल्यांकन की अनुमति नहीं देते हैं।
— गेहूं जादूगर
धन्यवाद गार्फ। यकीन नहीं होता कि कैसे मैं उन दोनों को गड़बड़ करने में कामयाब रहा। अब सब अच्छा होना चाहिए।
— एकोनेलियर
1

जावास्क्रिप्ट, 48 43 36 बाइट्स

-5 बाइट्स @ शिष्टाचार के शिष्टाचार * -7 बब्बर * के सौजन्य से

इनपुट एक चरित्र सरणी है और आउटपुट चरित्र सरणियों का एक सरणी है।

s=>s.map(_=>([a,...b]=s,s=[...b,a]))

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

— guest271314
स्रोत
1
— बुबलर
1
— झबरा
@ शिग्गी है कि एक वैध बाइट गिनती और प्रविष्टि? करता है [..."john"]से पहले समारोह कॉल एक सरणी के लिए इनपुट स्ट्रिंग के हेरफेर के रूप में गिनती नहीं?
— 271314
@ Guest271314, इनपुट एक चरित्र है और आउटपुट चरित्र सरणियों की एक सरणी है जिसे चुनौती की कल्पना और हमारे I / O चूक से अनुमति मिलती है।
— शाम्गी
@ शैगी अपडेट किया गया। क्या आप कृपया अपनी उपरोक्त टिप्पणी छोड़ सकते हैं? या भ्रम से बचने के लिए जवाब में आपकी टिप्पणी शामिल होनी चाहिए? या न ही आवश्यक है?
— गेस्ट 271314
1

MBASIC , 69 66 बाइट्स

-3 बाइट्स, धन्यवाद अर्जन जोहान्सन के लिए

1 INPUT S$:L=LEN(S$):FOR I=1 TO L:S$=MID$(S$+S$,2,L):PRINT S$:NEXT
— wooshinyobject
स्रोत
मुझे संदेह है कि आप इसे छोटा कर सकते हैं 1 INPUT S$:L=LEN(S$):FOR I=1 TO L:S$=MID$(S$+S$,2,L):PRINT S$:NEXT।
— अर्जन जोहान्सन
@ अर्जन जोहान्सन बहुत अच्छा, धन्यवाद।
— wooshinyobject
1

ब्रेनफक , 38 बाइट्स

,[>>,]<<<+>[[.>>]<<[<<]>-[+>.>-].<<+>]

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

अंतरिक्ष प्रतीकों के रूप में नल-वर्णों का उपयोग करने के जोकिंग के विचार के आधार पर। यह कोड बायीं छोर तक पहुंचने और लूप में वर्तमान अक्षरों को चिह्नित करता है।

,[>>,]<<    input string with empty cells in between
<+>         set first marker
[           main loop
  [.>>]     print remaining characters
  <<[<<]    return to start
  >-[+>.>-] print until marker (remove marker)
  .         print null
  <<+       set new marker
  >         restart loop with next character to the left
]           stop if there's no character to the left
— डोरियन
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.