21
\$\begingroup\$

Read two strings from stdin.
Output Yes if one string is a rotated version of the other.
Otherwise output No

Testcases

Input

CodeGolf GolfCode

Output

Yes

Input

stackexchange changestackex

Output

Yes

Input

stackexchange changestack

Output

No

Input

Hello World

Output

No
\$\endgroup\$
6
  • \$\begingroup\$ So (abcdefAB, ABabcdef) is a "YES"? \$\endgroup\$
    – Eelvex
    Mar 9, 2011 at 12:06
  • \$\begingroup\$ Should it really be a rotation or is a combination fine too? eg. what will Stackexchange Stackchangeex return? \$\endgroup\$
    – jpjacobs
    Mar 9, 2011 at 12:08
  • 1
    \$\begingroup\$ @Eelvex, yes. @jpjacobs, It would return No. The rotation is a shift, like those LED scrolling signs \$\endgroup\$
    – gnibbler
    Mar 9, 2011 at 12:19
  • \$\begingroup\$ Are the strings always whitespace-free and separated by whitespace? \$\endgroup\$
    – Joey
    Mar 9, 2011 at 15:20
  • \$\begingroup\$ More specifically, what characters are allowed in those strings? \$\endgroup\$
    – Joey
    Mar 9, 2011 at 15:48

46 Answers 46

19
\$\begingroup\$

Ruby 49 41

a,b=$*;puts (a*2).sub(b,'')==a ?:yes: :no

Edit: replaced gets.split by $*

\$\endgroup\$
3
  • \$\begingroup\$ That's an ingenious idea. \$\endgroup\$
    – Joey
    Mar 9, 2011 at 21:40
  • \$\begingroup\$ Very clever. :) \$\endgroup\$
    – st0le
    Mar 18, 2011 at 4:56
  • \$\begingroup\$ $* is argv when the question specified stdin though. \$\endgroup\$ Nov 19, 2018 at 1:00
7
\$\begingroup\$

APL (28)

Takes input on two lines.

'No' 'Yes'[1+(⊂⍞)∊⌽∘A¨⍳⍴A←⍞]

Explanation:

  • A←⍞: read a line of input and store it in A
  • ⌽∘A¨⍳⍴A: Rotate A by x, for each x in [1..length A]. Gives a list, i.e. estT stTe tTes Test
  • (⊂⍞)∊: read another line of input, and see if it is in this list.
  • 1+: add one to this, giving 1 if the strings were not rotated and 2 if they were
  • 'No' 'Yes'[...]: Select either the first or second element from the list 'No' 'Yes' depending on whether the strings were rotated or not.
  • This value is output automatically.
\$\endgroup\$
7
\$\begingroup\$

Python, 70 bytes

a,b=raw_input().split()
print ['No','Yes'][a in b*2and len(a)==len(b)]

Testing ...

\$\endgroup\$
4
  • \$\begingroup\$ +1 Nice, selecting the result from an array is clever! :-) \$\endgroup\$ Mar 9, 2011 at 15:24
  • 3
    \$\begingroup\$ The question states you should read two strings from stdin, which this solution does not. \$\endgroup\$
    – Ventero
    Mar 9, 2011 at 15:36
  • \$\begingroup\$ @Ventero:Fixed. \$\endgroup\$
    – Quixotic
    Mar 9, 2011 at 18:43
  • \$\begingroup\$ You can skip the space in print ['No \$\endgroup\$
    – movatica
    Aug 12, 2019 at 18:54
6
\$\begingroup\$

Python 70 Characters

a,b=raw_input().split()
print'YNeos'[len(a)<>len(b)or a not in 2*b::2]

Thanks to gnibbler for the slice trick.

\$\endgroup\$
8
  • 1
    \$\begingroup\$ Same problem as the GolfScript solution: If you input nn nfn, you get Yes, which is wrong. \$\endgroup\$ Mar 9, 2011 at 14:28
  • \$\begingroup\$ @TomWij Thanks for finding the bug. Corrected. Should work now. \$\endgroup\$
    – fR0DDY
    Mar 9, 2011 at 15:14
  • \$\begingroup\$ You can replace <> by - as that will also result in 0 if they are of equal length. \$\endgroup\$ Mar 9, 2011 at 15:28
  • \$\begingroup\$ But what if they are not of equal length? Then it doesn't work so well :-) \$\endgroup\$
    – hallvabo
    Mar 13, 2011 at 13:38
  • \$\begingroup\$ @hallvabo then the strings are not rotated version of each other. \$\endgroup\$
    – fR0DDY
    Mar 13, 2011 at 13:52
5
\$\begingroup\$

J, 47

y=:>2{ARGV
(>1{ARGV e.1|.^:(i.#y)y){'No',:'Yes'
\$\endgroup\$
5
  • \$\begingroup\$ Why the two J answers? \$\endgroup\$
    – J B
    Mar 9, 2011 at 19:49
  • \$\begingroup\$ @JB: because this one uses the buildin rotate. Both answers su^H^H are not so good btw. There is a lot of room for golfing. \$\endgroup\$
    – Eelvex
    Mar 9, 2011 at 19:57
  • \$\begingroup\$ why the other one, then, I'm tempted to ask? :-) \$\endgroup\$
    – J B
    Mar 9, 2011 at 20:06
  • \$\begingroup\$ @JB: because I thought this one is barely legal ( :p ) [ while the other one extends nicely to lisp. ] \$\endgroup\$
    – Eelvex
    Mar 9, 2011 at 20:13
  • \$\begingroup\$ errr... the other one seems to read input from the command-line as well \$\endgroup\$
    – J B
    Mar 9, 2011 at 20:15
5
\$\begingroup\$

According to the spec (same string lengths):

Perl, 42 43 chars

$.=pop;$_=(pop)x2;print+(qw'yes no')[!/$./]

If different sized strings are allowed, the solution would be:

Perl, 47 chars

$.=(pop)x8;$_=(pop)x9;print+(qw'yes no')[!/$./]

rbo

\$\endgroup\$
2
  • \$\begingroup\$ Same problem as the GolfScript solution: If you input nn nfn, you get Yes, which is wrong. \$\endgroup\$ Mar 9, 2011 at 14:17
  • 1
    \$\begingroup\$ seems to be ok (I missed the'!' in the first version) "nn nfn" => no "CodeGolf GolfCode" => yes \$\endgroup\$ Mar 9, 2011 at 14:22
5
\$\begingroup\$

Golfscript, 31

' '/:)~,\,=)~.+\/,(&'Yes''No'if

This one check length first, so it should work as expected.

\$\endgroup\$
1
  • \$\begingroup\$ :) and =) +1 for very happy code \$\endgroup\$ Oct 30, 2016 at 23:48
4
\$\begingroup\$

J, 57

{&('No';'Yes')@-:/@:((/:~@(|."0 _~i.&$))&.>)&.(;:&stdin)_

Sample use:

$ echo -n CodeGolf GolfCode | jconsole rotate.ijs
Yes
$ echo -n stackexchange changestackex | jconsole rotate.ijs
Yes
$ echo -n stackexchange changestack | jconsole rotate.ijs
No
$ echo -n Hello World | jconsole rotate.ijs
No
\$\endgroup\$
3
\$\begingroup\$

Windows PowerShell, 76

$a,$b=-split$input
('No','Yes')[+!($a.length-$b.length)*"$b$b".contains($a)]
\$\endgroup\$
3
\$\begingroup\$

JavaScript, 51

function f(a,b)a&&(a+a).replace(b,"")==a?"Yes":"No"

JavaScript doesn't have a canonical host, so this answer is written as a function of two arguments. The score goes up to 60 if we disallow JS 1.7 features (expression closures).

In the SpiderMonkey shell this would be (for a score of 71):

[a,b]=readline().split(" ");print(a&&(a+a).replace(b,"")==a?"Yes":"No")
\$\endgroup\$
1
  • \$\begingroup\$ 5 years later and now you can use the => function notation ;) \$\endgroup\$
    – J Atkin
    Feb 23, 2016 at 1:28
3
\$\begingroup\$

Python, 66 63

a,b=raw_input().split()
print'YNeos'[a!=(2*a).replace(b,"")::2]

Another solution in 69 char

a,b=raw_input().split()
print['No','Yes'][a in b*2and len(a)==len(b)]
\$\endgroup\$
2
  • 2
    \$\begingroup\$ print'YNeos'[a!=(2*a).replace(b,"")::2] \$\endgroup\$
    – gnibbler
    Oct 19, 2013 at 10:05
  • \$\begingroup\$ @gnibbler nice trick, thanks for suggestion. I updated the code \$\endgroup\$
    – Coding man
    Oct 19, 2013 at 11:26
2
\$\begingroup\$

J, 84

y=:(>1{ARGV),:(>2{ARGV)
((0{y)e.(y&((]$0{[),(]-~[:}.[:$[)$1{[)/.i.}.$y)){'No',:'Yes'
\$\endgroup\$
2
\$\begingroup\$

JavaScript (120 chars)

function f(a,b) {for (i=0,A=a.split("");A.join("")!=b&&i++<a.length;A.push(A.shift()));return A.join("")==b?'Yes':'No';}

Output:

f('CodeGolf','GolfCode'); //Yes
f('stackexchange','changestackex'); //Yes
f('stackexchange','changestack'); //No
f('Hello','World'); //No
f('nn','nBn'); //No
\$\endgroup\$
2
\$\begingroup\$

Ruby, 58 (62) characters

a,b=gets.split;$><<(a.size==b.size&&/#{a}/=~b*2?:Yes: :No)

This solution assumes the input contains only alphanumeric characters (actually everything that doesn't have a special meaning inside a regular expression is ok).

A solution that doesn't have this constraint is 4 characters longer

a,b=gets.split;$><<(a.size==b.size&&(b*2).index(a)?:Yes: :No)
\$\endgroup\$
2
\$\begingroup\$

Python, 71

a,b=raw_input().split()
print'Yes'if a in b*2and len(a)==len(b)else'No'
\$\endgroup\$
4
  • \$\begingroup\$ Same problem as the GolfScript solution: If you input nn nfn, you get Yes, which is wrong. \$\endgroup\$
    – Timwi
    Mar 9, 2011 at 14:08
  • \$\begingroup\$ Problem has been solved, remains low... :-) \$\endgroup\$ Mar 9, 2011 at 14:17
  • \$\begingroup\$ Doesn't read from stdin as specified. \$\endgroup\$
    – Wooble
    Mar 9, 2011 at 16:57
  • \$\begingroup\$ Now it does... :-) \$\endgroup\$ Mar 9, 2011 at 18:59
2
\$\begingroup\$

PHP, 61

<?echo preg_match('/^(.+)(.*) \\2\\1$/',fgets(STDIN))?Yes:No;
\$\endgroup\$
2
\$\begingroup\$

Ruby, 41

puts gets =~ /^(.+)(.*) \2\1$/ ?:Yes: :No
\$\endgroup\$
2
  • \$\begingroup\$ Doesn't print anything, results in ':No' for input 'aaa aaa' (on my machine). The regexp approach could be a good idea though. \$\endgroup\$
    – steenslag
    Mar 25, 2011 at 0:43
  • \$\begingroup\$ Fix to actually print and input from stdin instead of args: puts gets =~ /^(.+)(.*) \2\1$/ ?:Yes: :No - ups it to 41 chars. \$\endgroup\$
    – Nemo157
    Mar 25, 2011 at 4:12
2
\$\begingroup\$

Haskell (98 96 chars)

g x y@(t:r)(z:w)|x==y="Yes"|1>0=g x(r++[t])w
g _ _[]="No"
f(x:y:_)=g x y y
main=interact$f.words
\$\endgroup\$
2
\$\begingroup\$

Q (50 43 chars)

{`No`Yes x in((!)(#)y)rotate\:y}." "vs(0:)0
\$\endgroup\$
2
\$\begingroup\$

Scala 78

val b=readLine split " "
print(b(0).size==b(1).size&&(b(0)+b(0)contains b(1)))

It's a shame about the size check, without it the count drops to 54

val a=readLine split " "
print(a(0)+a(0)contains a(1))
\$\endgroup\$
1
  • \$\begingroup\$ """val b=readLine split " " print(b(0).sorted==b(1).sorted)""".length yields 56 \$\endgroup\$ Jun 1, 2012 at 3:49
2
\$\begingroup\$

bash 56

read a b
[[ $a$a =~ $b&&$b$b =~ $a ]]&&echo Yes||echo No
\$\endgroup\$
2
\$\begingroup\$

GolfScript, 25 bytes

' '/~.2*@/''+='Yes''No'if

How it works

             # STACK: "CodeGolf GolfCode"
' '/         # Split input string by spaces.
             # STACK: [ "CodeGolf" "GolfCode" ]
~            # Dump the array.
             # STACK: "CodeGolf" "GolfCode"
.            # Duplicate the topmost string.
             # STACK: "CodeGolf" "GolfCode" "GolfCode"
2*           # Repeat the topmost string.
             # STACK: "CodeGolf" "GolfCode" "GolfCodeGolfCode"
@            # Rotate the three topmost strings.
             # STACK: "GolfCode" "GolfCodeGolfCode" "CodeGolf"
/            # Split the second topmost string around the topmost one.
             # STACK: "GolfCode" [ "Golf" "Code" ]
''+          # Flatten the array of strings.
             # STACK: "GolfCode" "GolfCode"
=            # Check for equality.
             # STACK: 1
'Yes''No'if  # Push 'Yes' for 1, 'No' for 0.
             # STACK: "Yes"
\$\endgroup\$
2
\$\begingroup\$

CJam, 21 bytes

r]r_,,\f{\{(+}*}_@+^!

Try it online!

\$\endgroup\$
1
  • \$\begingroup\$ This answer seems to return 0/1 instead of No/Yes. \$\endgroup\$ Dec 15, 2017 at 20:12
2
\$\begingroup\$

Husk, 14 bytes

Not sure about the rules here, Husk doesn't do IO at all. The closest alternative is a function:

!w¨Ye∫No¨€U¡ṙ1

Try it online!

Explanation

!w¨Ye∫No¨€U¡ṙ1
           ¡    -- iterate the following for ever:
            ṙ1  --   rotate string by 1
          U     -- only keep the longest prefix with unique elements
         €      -- is the argument in that list?
  ¨Ye∫No¨       -- compressed string: "Yes No"
 w              -- split on space
!               -- modular index (1-based)
\$\endgroup\$
2
\$\begingroup\$

Jelly, 17 13 bytes

ɠṙJɠeị“Yes“No

Try it online!

How it works

ɠṙJɠeị“Yes“No - Main link. Takes no arguments
ɠ             - Read a line from STDIN
  J           - Indices; [1, 2, ..., len(S)]
 ṙ            - All rotations of S
   ɠe         - Read a line from STDIN; is that in the rotations?
     ị“Yes“No - Index that into ["Yes", "No"]
\$\endgroup\$
0
1
\$\begingroup\$

Lua 115 chars

a,b=io.read():match"(%w+) (%w+)"c=b repeat c=c:sub(2,-1)..c:sub(1,1) s=s or a==c until b==c print(s and"Yes"or"No")
\$\endgroup\$
1
\$\begingroup\$

C program - 146

char b[99],c[99],*p,*q;main(n){q=(p=b+(n=strlen(gets(c))))+n;sprintf(b,"%s%s"
,c,c);for(gets(c);p>b&&strcmp(p,c);--p,*--q=0);puts(p>b?"Yes":"No");}
\$\endgroup\$
1
\$\begingroup\$

PHP, 82 characters

<?$s=split(" ",fgets(STDIN));echo str_replace($s[1],"",$s[0].$s[0])==$s[0]?Yes:No;
\$\endgroup\$
1
\$\begingroup\$

perl, 123 chars

@s1=split(//,shift);
$s2=shift;
$i=0;
while($i<=@s1){
    if(join("",@s1) eq $s2){die "yes";}
    unshift @s1,pop @s1;
    $i++;
}
die "no";
\$\endgroup\$
1
\$\begingroup\$

Ruby, 30 37

gets
puts~/^(.+)(.*) \2\1$/?:Yes: :No

A version that prints "true" and "false" instead of "yes" and "no":

gets
p !! ~/^(.+)(.*) \2\1$/

Both of these work with different-length strings (unlike the old one)

\$\endgroup\$
1
  • \$\begingroup\$ Does work if the two strings have the same length, but fails on input like 'golfcode golf'. \$\endgroup\$
    – steenslag
    Mar 25, 2011 at 0:37

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.