Determine if a move exists in a Bejeweled/match 3 game Background
In Bejeweled and similar games, the player must swap any two adjacent gems (no diagonals) in an 8x8 grid of gems in order to match three of the same color in a row. The gems can be matched horizontally or vertically. Gameplay continues until there no move exists that can be made resulting in three in a row, at which point the game is over.
Task
The goal is to write a program that determines whether a game of Bejeweled is not over yet. In other words, it must check to see if there is a possible move that makes at least three in a row. There can be more than three gems in a row and it is still a valid move.
Input
Your program must accept via standard input an 8x8 representation of a Bejeweled grid. Each of the seven gem colors will be represented by a digit from 1 to 7. Each line will contain one row, and 8 lines, each consisting of 8 digits, will be input. See the examples. You can assume that the input will always follow this format, and will never already contain three in a row.
Output
The program must then output (to standard output) yes or no depending on whether or not at least one valid move exists that would result in three or more gems in a row. Your program must not output anything other than a single instance of either yes or no.
Rules
Your program must not use any external files or resources, command-line arguments, or require a certain file name. The program with the least number of bytes in its source code wins.
Examples
Input:
12314131
13224145
54762673
61716653
61341144
23453774
27645426
75575656

Output: yes
Input:
35261546
76421754
15743271
62135642
35617653
64565476
54427254
15635465

Output: no
See MT0's answer below for additional test cases.
Original Solution: JavaScript - 261 255 228 227 179 153 Characters
/(\d)(\1(\d|.{6}|.{9})|(\d|.{6}|.{9})\1|.{7}\1(.|.{9})|(.|.{9})\1.{7}|(.{7,9}|.{17})\1.{8}|.{8}\1(.{7,9}|.{17}))\1/.test(s.replace(/\n/g,'A'))?'yes':'no'

Assuming that the string to test is in the variable s (to make it a function f then add f=s=&gt; to the beginning of the code or, otherwise, to take input from a prompt then replace s with prompt()).
Outputs is to the console.
3rd Solution: JavaScript (ECMAScript 6) - 178 Characters
p=x=&gt;parseInt(x,36);for(t=&quot;2313ab1b8a2a78188h9haj9j8iaiir9r&quot;,i=v=0;s[i];i++)for(j=0;t[j];v|=s[i]==s[i+a]&amp;s[i]==s[i+b]&amp;i%9&lt;8&amp;(b&gt;3|(i+b-a)%9&lt;8))a=p(t[j++]),b=p(t[j++]);v?'yes':'no'

I took the 2nd solution, below, (which uses regular expressions to check for characters in certain configurations) and reworked it to just check the string for identical characters in the same configurations without using regular expressions.
The Base-36 string &quot;2313ab1b8a2a78188h9haj9j8iaiir9r&quot; gives pairs of offsets to check - i.e. the pair 23 results in the check if ith character is identical to the (i+2)th character and the (i+3)th character (the equivalent of the regular expression (.).\1\1 - with some additional checks to ensure that the non-identical character is not a newline).
2nd Solution: JavaScript (ECMAScript 6) - 204 Characters
p=x=&gt;parseInt(x,18);g=a=&gt;a?a&gt;1?&quot;(.|\\n){&quot;+a+&quot;}&quot;:&quot;.&quot;:&quot;&quot;;f=(x,a,b)=&gt;RegExp(&quot;(.)&quot;+g(a)+&quot;\\1&quot;+g(b)+&quot;\\1&quot;).test(x);for(t=&quot;10907160789879h8&quot;,i=v=0;t[i];v|=f(s,x,y)||f(s,y,x))x=p(t[i++]),y=p(t[i++]);v?'yes':'no'

Builds multiple regular expressions (see below for more details) using pairs of values taken from the  Base-18 string 10907160789879h8 and takes the OR of all the tests. To reduce it further you can note that the regular expressions come in pairs where one is the &quot;reverse&quot; of the other (ignoring the Regular Expressions for 3-in-a-row horizontally and vertically as the OP states they will never be present - if you want to add those tests back in the append 0088 to the Base-18 string).
Explanation
Start with 16 regular expressions covering all the possible configurations of valid moves:
REs=[
    /(\d)\1\1/,                 // 3-in-a-row horizontally
    /(\d).\1\1/,                // 3-in-a-row horizontally after left-most shifts right
    /(\d)\1.\1/,                // 3-in-a-row horizontally after right-most shifts left
    /(\d)(?:.|\n){9}\1\1/,  // 3-in-a-row horizontally after left-most shifts down
    /(\d)(?:.|\n){7}\1.\1/, // 3-in-a-row horizontally after middle shifts down
    /(\d)(?:.|\n){6}\1\1/,  // 3-in-a-row horizontally after right-most shifts down
    /(\d)\1(?:.|\n){6}\1/,  // 3-in-a-row horizontally after left-most shifts up
    /(\d).\1(?:.|\n){7}\1/, // 3-in-a-row horizontally after middle shifts up
    /(\d)\1(?:.|\n){9}\1/,  // 3-in-a-row horizontally after right-most shifts up
    /(\d)(?:.|\n){7,9}\1(?:.|\n){8}\1/, // 3-in-a-row vertically (with optional top shifting left or right)
    /(\d)(?:.|\n){7}\1(?:.|\n){9}\1/,   // 3-in-a-row vertically after middle shifts right
    /(\d)(?:.|\n){9}\1(?:.|\n){7}\1/,   // 3-in-a-row vertically after middle shifts left
    /(\d)(?:.|\n){8}\1(?:.|\n){7}\1/,   // 3-in-a-row vertically after bottom shifts right
    /(\d)(?:.|\n){8}\1(?:.|\n){9}\1/,   // 3-in-a-row vertically after bottom shifts left
    /(\d)(?:.|\n){17}\1(?:.|\n){8}\1/,  // 3-in-a-row vertically after top shifts down
    /(\d)(?:.|\n){8}\1(?:.|\n){17}\1/,  // 3-in-a-row vertically after bottom shifts up
];

(Note: the regexs for 3-in-a-row horizontally (0th) and vertically (part of the 9th) are irrelevant as the OP states that inputs matching these will never be present.)
Testing each of those against the input will determine if a valid move of that configuration can be found.
However, the regular expressions can be combined to give these 6:
/(\d)(?:.|(?:.|\n){9}|(?:.|\n){6})?\1\1/            // Tests 0,1,3,5
/(\d)\1(?:.|(?:.|\n){9}|(?:.|\n){6})?\1/            // Tests 0,2,6,8
/(\d)(?:.|\n){7}\1(?:.|(?:.|\n){9})\1/              // Tests 4,10
/(\d)(?:.|(?:.|\n){9})\1(?:.|\n){7}\1/              // Tests 7,11
/(\d)(?:(?:.|\n){7,9}|(?:.|\n){17})\1(?:.|\n){8}\1/ // Tests 9,14
/(\d)(?:.|\n){8}\1(?:(?:.|\n){7,9}|(?:.|\n){17})\1/ // Tests 9a,12,13,15

These can then be combined into a single regular expression:
/(\d)(?:.|(?:.|\n){9}|(?:.|\n){6})?\1\1|(\d)\2(?:.|(?:.|\n){9}|(?:.|\n){6})?\2|(\d)(?:.|\n){7}\3(?:.|(?:.|\n){9})\3|(\d)(?:.|(?:.|\n){9})\4(?:.|\n){7}\4|(\d)(?:(?:.|\n){7,9}|(?:.|\n){17})\5(?:.|\n){8}\5|(\d)(?:.|\n){8}\6(?:(?:.|\n){7,9}|(?:.|\n){17})\6/

Which just needs to be tested against the input.
Test Cases
Some test cases which other people might find useful (doesn't comply with the input format of using only digits 1-7 but that's easily corrected and is only an 8x4 grid - since that is the minimum required for a test of all the valid inputs).
In the format of a map from input string to which of the 16 regular expressions above it matches.
Tests={
    &quot;12345678\n34567812\n56781234\n78123456&quot;: -1, // No Match
    &quot;12345678\n34969912\n56781234\n78123456&quot;: 1,    // 3-in-a-row horizontally after left-most shifts right 
    &quot;12345678\n34567812\n59989234\n78123456&quot;: 2,    // 3-in-a-row horizontally after right-most shifts left
    &quot;12345978\n34567899\n56781234\n78123456&quot;: 3,    // 3-in-a-row horizontally after left-most shifts down
    &quot;12345978\n34569892\n56781234\n78123456&quot;: 4,    // 3-in-a-row horizontally after middle shifts down
    &quot;12345678\n34967812\n99781234\n78123456&quot;: 5,    // 3-in-a-row horizontally after right-most shifts down
    &quot;12399678\n34967812\n56781234\n78123456&quot;: 6,    // 3-in-a-row horizontally after left-most shifts up
    &quot;12345678\n34597912\n56789234\n78123456&quot;: 7,    // 3-in-a-row horizontally after middle shifts up
    &quot;12345998\n34567819\n56781234\n78123456&quot;: 8,    // 3-in-a-row horizontally after right-most shifts up
    &quot;12945678\n34597812\n56791234\n78123456&quot;: 9,    // 3-in-a-row vertically after top shifts right
    &quot;12349678\n34597812\n56791234\n78123456&quot;: 9,    // 3-in-a-row vertically after top shifts left
    &quot;12345978\n34569812\n56781934\n78123456&quot;: 10,   // 3-in-a-row vertically after middle shifts right
    &quot;92345678\n39567812\n96781234\n78123456&quot;: 11,   // 3-in-a-row vertically after middle shifts left
    &quot;12945678\n34967812\n59781234\n78123456&quot;: 12,   // 3-in-a-row vertically after bottom shifts right
    &quot;12349678\n34569812\n56781934\n78123456&quot;: 13,   // 3-in-a-row vertically after bottom shifts left
    &quot;12395678\n34567812\n56791234\n78193456&quot;: 14,   // 3-in-a-row vertically after top shifts down
    &quot;12345698\n34567892\n56781234\n78123496&quot;: 15,   // 3-in-a-row vertically after bottom shifts up
    &quot;12345678\n34567899\n96781234\n78123456&quot;: -1,   // No match - Matches (.)\1.\1 but not 3 in a row
    &quot;12345679\n99567812\n56781234\n78123456&quot;: -1,   // No match - Matches (.).\1\1 but not 3 in a row
};

Edit 1
Replace \ds with . - saves 6 characters.
Edit 2
Replace (?:.|\n) with [\s\S] and removed extra non-capturing groups and updated back references (as suggested by m-buettner) and added in yes/no output.
Edit 3

Added ECMAScript 6 solution to build the individual Regular Expressions from a Base-18 string.
Removed the tests for 3-in-a-row horizontally (as suggested by m-buettner).

Edit 4
Added another (shorter) solution and two more non-matching tests cases.
Edit 5

Shortened original solution by replacing newlines with a non-numeric character (as suggested by VadimR).

Edit 6

Shortened original solution by combining bits of the regular expression (as suggested by VadimR).