Longest Common Subsequence
Finding the longest common subsequence of two sequences is a classic computer science problem with an equally
classic solution that dates to the folklore of computing. The longest common subsequence is the longest set of
elements that appear in order (not necessarily contiguous) in two sequences, the solution can be used in matching DNA sequences and it is also the basis of Unix “DIFF” utility.

The following SQL pattern can be used to find the Longest Common Subsequences in different group of strings.

COLUMN Largest_Common_Sequences FORMAT  A38
COLUMN in_str FORMAT  A18

CREATE TABLE  DATA AS
(Select 1 as id, 10 as grp_id, 'ABRACADABRA'       as in_str from dual
union all
select 2 as id, 10 as grp_id, 'BARRACUDA'          as in_str from dual
union all
select 3 as id, 20 as grp_id, 'HHTHHTHHT'          as in_str from dual
union all
select 4 as id, 20 as grp_id, 'THHTHTTHT'          as in_str from dual
union all
select 5 as id, 30 as grp_id, 'PROGRAMMING'        as in_str from dual
union all
select 6 as id, 30 as grp_id, 'PRAXIS'             as in_str from dual
union all
select 7 as id, 40 as grp_id, 'HUMAN'              as in_str from dual
union all
select 8 as id, 40 as grp_id, 'CHIMPANZEE'         as in_str from dual
union all
select 9 as id, 50 as grp_id,  '!T@E#N$o%n^e'      as in_str from dual
union all
select 10 as id, 50 as grp_id, 'TE*No()n+e{'       as in_str from dual
union all
select 11 as id, 50 as grp_id, '=T8EN7o?ne'        as in_str from dual
);

--------------------------------------------------------SQL Solution------------------------------------------------------

WITH MAX_COM_SEQ  AS
(SELECT DISTINCT id, grp_id, in_str, seq_str
  FROM
    (SELECT a.*, length(seq_str) len, MAX(LENGTH(seq_str)) OVER (PARTITION BY grp_id) max_len
      FROM
      (SELECT a.*,COUNT(DISTINCT id) OVER (PARTITION BY grp_id,seq_str) seq_cnt
       FROM
       (SELECT a.*, REPLACE(SYS_CONNECT_BY_PATH(chr,','),',') seq_str
         FROM (SELECT *
                FROM (SELECT a.*,COUNT(DISTINCT id) OVER(PARTITION BY grp_id, chr) cnt_chr
                       FROM (SELECT a.*, trim(COLUMN_VALUE) chr, rownum as rn
                              FROM (SELECT data.*, COUNT(*) OVER (PARTITION BY grp_id) cnt FROM data ) a,
                                    xmltable(rtrim(REGEXP_REPLACE(a.in_str,'(.)', '"\1",'), ','))
                             ) a
                     )
                WHERE cnt=cnt_chr
               ) a
         CONNECT BY id=PRIOR id AND rn > PRIOR rn
       ) a
      ) a
     WHERE cnt = seq_cnt
  )
  WHERE max_len = len
)
SELECT id, grp_id, in_str, CASE WHEN rank = 1 THEN '[ '|| STRAGG||' ]' END AS Largest_Common_Sequences
 FROM
 (SELECT id, grp_id, in_str, STRAGG, rank() OVER (PARTITION BY grp_id ORDER BY id ) AS RANK
  FROM
  (SELECT DISTINCT id, grp_id, in_str, LISTAGG(seq_str, '->') WITHIN GROUP (ORDER BY seq_str) OVER(PARTITION BY id) STRAGG
   FROM (SELECT * FROM MAX_COM_SEQ )
  )
 );

        ID     GRP_ID IN_STR             LARGEST_COMMON_SEQUENCES
---------- ---------- ------------------ --------------------------------------
         1         10 ABRACADABRA        [ ARACDA->BRACDA ]
         2         10 BARRACUDA
         3         20 HHTHHTHHT          [ HHTHTHT->THHTHHT ]
         4         20 THHTHTTHT
         5         30 PROGRAMMING        [ PRAI ]
         6         30 PRAXIS
         7         40 HUMAN              [ HMAN ]
         8         40 CHIMPANZEE
         9         50 !T@E#N$o%n^e       [ TENone ]
        10         50 TE*No()n+e{
        11         50 =T8EN7o?ne

11 rows selected.
SQL>

The Zebra Puzzle is a well-known logic puzzle. It is often called Einstein’s Puzzle or Einstein’s Riddle because it is said to have been invented by Albert Einstein as a boy. Some claim that Einstein said “only 2 percent of the world’s population can solve it.” It is also sometimes attributed to Lewis Carroll.

However, there is no known evidence for Einstein’s or Carroll’s authorship; and the original puzzle mentions brands of cigarette, such as Kools, that did not exist during Carroll’s lifetime or Einstein’s boyhood.

There are several versions of this puzzle, below is one of them:

The British lives in the red house.
The Swede keeps dogs as pets.
The Dane drinks tea.
The green house is on the left of the white house.
The green homeowner drinks coffee.
The man who smokes Pall Mall keeps birds.
The owner of the yellow house smokes Dunhill.
The man living in the center house drinks milk.
The Norwegian lives in the first house.
The man who smokes Blend lives next to the one who keeps cats.
The man who keeps the horse lives next to the man who smokes Dunhill.
The man who smokes Bluemaster drinks beer.
The German smokes Prince.
The Norwegian lives next to the blue house.
The man who smokes Blend has a neighbor who drinks water.

Question: Who owns the fish?

SQL solution:

WITH comb as (  ----- Permutations of number 1-5. they can be interpreted as other properties, and the position of number in string p means room number
         SELECT REPLACE(SYS_CONNECT_BY_PATH(rn,'\'),'\') AS p
           FROM (SELECT ROWNUM rn FROM DUAL CONNECT BY ROWNUM<=5)
          WHERE LEVEL=5
          CONNECT BY NOCYCLE LEVEL<=5 AND rn<>PRIOR rn
          )
     ,nationality AS (
       SELECT INSTR(p,'1') AS Englishman
             ,INSTR(p,'2') AS Swede
             ,INSTR(p,'3') AS Dane
             ,INSTR(p,'4') AS Norwegian
             ,INSTR(p,'5') AS German
        FROM comb
      )
    ,house AS (
       SELECT INSTR(p,'1') AS red
             ,INSTR(p,'2') AS white
             ,INSTR(p,'3') AS green
             ,INSTR(p,'4') AS yellow
             ,INSTR(p,'5') AS blue
        FROM comb
     )
    ,beverages AS (
       SELECT INSTR(p,'1') AS tea
             ,INSTR(p,'2') AS coffee
             ,INSTR(p,'3') AS milk
             ,INSTR(p,'4') AS beer
             ,INSTR(p,'5') AS water
        FROM comb
     )
    ,cigarettes AS (
       SELECT INSTR(p,'1') AS pall_mall
             ,INSTR(p,'2') AS dunhill
             ,INSTR(p,'3') AS blends
             ,INSTR(p,'4') AS blue_master
             ,INSTR(p,'5') AS prince
        FROM comb
        )
    ,pets AS (
       SELECT INSTR(p,'1') AS dog
             ,INSTR(p,'2') AS bird
             ,INSTR(p,'3') AS cat
             ,INSTR(p,'4') AS horse
             ,INSTR(p,'5') AS fish
        FROM comb
        )
    ,res AS (
       SELECT *
         FROM nationality
             ,house
             ,beverages
             ,cigarettes
             ,pets
       WHERE  Englishman     = red   ---- join condition: different properties appear in the same room number, or number of next room
              AND  Swede     = dog
              AND  Dane      = tea
              AND  green     = white -1
              AND  green     = coffee
              AND  pall_mall = bird
              AND  yellow    = dunhill
              AND  milk      = 3
              AND  Norwegian = 1
              AND  ABS(blends - cat)    =1
              AND  ABS(dunhill - horse) =1
              AND  blue_master = beer
              AND  German    = prince
              AND  blue      = 2
              AND  ABS(blends - water)  =1
       )
SELECT room_num
      ,DECODE(room_num,Englishman,'Englishman',Swede   ,'Swede'  ,Dane  ,'Dane'  ,Norwegian  ,'Norwegian'  ,German,'German') as nationality
      ,DECODE(room_num,red       ,'red'       ,white   ,'white'  ,green ,'green' ,yellow     ,'yellow'     ,blue  ,'blue'  ) as house
      ,DECODE(room_num,pall_mall ,'pall mall' ,dunhill ,'dunhill',blends,'blends',blue_master,'blue master',prince,'prince') as beverages
      ,DECODE(room_num,tea       ,'tea'       ,coffee  ,'coffee' ,milk  ,'milk'  ,beer       ,'beer'       ,water ,'water' ) as cigarettes
      ,DECODE(room_num,dog       ,'dog'       ,bird    ,'bird'   ,cat   ,'cat'   ,horse      ,'horse'      ,fish  ,'fish'  ) as pets
  FROM res,(SELECT ROWNUM room_num FROM DUAL CONNECT BY ROWNUM<=5)
ORDER BY room_num;

Output:
  ROOM_NUM NATIONALIT HOUSE  BEVERAGES   CIGARE PETS
---------- ---------- ------ ----------- ------ -----
         1 Norwegian  yellow dunhill     water  cat
         2 Dane       blue   blends      tea    horse
         3 Englishman red    pall mall   milk   bird
         4 German     green  prince      coffee fish
         5 Swede      white  blue master beer   dog

This Puzzles was proposed by Richard Feyman ( An American physicist)

‘A’ can be any digit; each ‘.’ can be any digit from 0 through 9 except ‘A’. There is only one solution.

         ..A.
    ---------
.A. ) ....A..
      ..AA
      ----
       ...A
        ..A
       -----
        ....
        .A..
        -----
         ....
         ....
         ----
            0

COLUMN str FORMAT  A38
COLUMN d_e_A_f FORMAT A8
COLUMN b_A_c  FORMAT  A8

-----------------------------------------------------------SQL Solution----------------------------------------------------------------------------

WITH DATA1 AS
(SELECT LEVEL n FROM DUAL CONNECT BY LEVEL < 10 ),
DATA2 AS
(SELECT LEVEL-1 n FROM DUAL CONNECT BY LEVEL  < 11 )
SELECT d_e_A_f||chr(10)||'     ------------'||chr(10)||b_A_c||'  )'||Div as str, b_A_c, d_e_A_f
FROM
(SELECT b.n|| A.n|| c.n as b_A_c ,  d.n||e.n||A.n||f.n  as d_e_A_f , to_number(b.n|| A.n|| c.n )* to_number(d.n||e.n||A.n||f.n) as Div
 FROM data2 A,  data1 b, data2 c,  data1 d,  data2 e, data2 f
 WHERE b.n != A.n
 AND   c.n != A.n
 AND   d.n != A.n
 AND   e.n != A.n
 AND   f.n != A.n
 AND length ((b.n * 100 + A.n *10 + c.n) *  (d.n *1000 + e.n *100 + A.n *10 + f.n)) =7
 AND to_number(substr((b.n * 100 + A.n *10 + c.n) *  (d.n *1000 + e.n *100 + A.n *10 + f.n), 5, 1 ) ) = A.n
 AND to_number(substr((b.n * 100 + A.n *10 + c.n) * d.n, 3, 2 ))  = to_number(A.n||A.n)
 AND to_number(substr((b.n * 100 + A.n *10 + c.n)*e.n, 3, 1 )) = A.n
 AND to_number(substr((b.n * 100 + A.n *10 + c.n) * A.n , 2, 1 ) ) = A.n
 AND e.n < d.n
);

STR                                    B_A_C      D_E_A_F
---------------------------           --------    --------
         7289                           484        7289
     ------------
484  )3527876

SQL>

So – if you look at the relationships between these two, you have:

Ann goes out with Tom. Tom is a brother of David.
Ann is a sister of Bride. Bride is married to Groom. Groom works for David.

The problem is to write a program that will get the names of two people as input.
It then needs to output a list of all the ways in which these people are related,
much in the same fashion as we showed the list of relationships between Ann and David above.

CREATE TABLE RELATIONSHIP
  ( FROM_NAME VARCHAR2(38 BYTE),
    TO_NAME VARCHAR2(38 BYTE),
    Relation_DESC VARCHAR2(100 BYTE),
    PRIMARY KEY (FROM_NAME, TO_NAME)
  ) organization index;

insert into RELATIONSHIP values (  'bride', 'groom', 'is married to');
insert into RELATIONSHIP values (  'groom', 'bride', 'is married to');
insert into RELATIONSHIP values (  'Ann',   'bride', 'is a sister of');
insert into RELATIONSHIP values (  'bride', 'Ann',   'is a sister of');
insert into RELATIONSHIP values (  'David', 'Tom',   'is a brother of');
insert into RELATIONSHIP values (  'Tom',   'David', 'is a brother of');
insert into RELATIONSHIP values (  'David', 'groom', 'is the boss of');
insert into RELATIONSHIP values (  'groom', 'David', 'works for');
insert into RELATIONSHIP values (  'Ann',   'Tom',   'dates');
insert into RELATIONSHIP values (  'Tom',   'Ann',   'dates');

commit;

COLUMN RELATIONSHIP FORMAT  A68
variable P_FROM varchar2(38)
variable P_TO varchar2(38)
exec :P_FROM:='Ann'
exec :P_TO:='David'

--------------------------------SQL Solution using Recursive Subquery Factoring-------------------------------------

WITH DATA (root, path, TO_NAME) AS
(SELECT FROM_NAME,  FROM_NAME||' '||Relation_DESC||' '||TO_NAME, TO_NAME
 FROM  RELATIONSHIP
 WHERE FROM_NAME  = :P_FROM
 UNION ALL
 SELECT  root, d.path||','||e.FROM_NAME||' '||e.Relation_DESC||' '||e.TO_NAME as path , e.TO_NAME
 FROM  DATA d,  RELATIONSHIP e
 WHERE d.TO_NAME= e.FROM_NAME
 AND e.FROM_NAME != d.root
)
SEARCH DEPTH FIRST BY TO_NAME SET seq
CYCLE TO_NAME SET is_cycle to '1' DEFAULT '0'
SELECT grp, trim(COLUMN_VALUE) relationship
FROM
(SELECT path,  ROWNUM grp
 FROM DATA
 WHERE TO_NAME = :P_TO
 AND is_cycle = 0
 ) a,  xmltable(('"'||replace(a.path, ',', '","')||'"'));

       GRP RELATIONSHIP
---------- --------------------------------------------------------------------
         1 Ann dates Tom
         1 Tom is a brother of David
         2 Ann is a sister of bride
         2 bride is married to groom
         2 groom works for David

SQL>

---------------------------------------------Alternative SQL Solution------------------------------------------------

WITH DATA AS
(SELECT ltrim(sys_connect_by_path(FROM_NAME||' '||Relation_DESC||' '||TO_NAME, ','), ',') as path, ROWNUM grp
 FROM  RELATIONSHIP
 WHERE  TO_NAME  = :P_TO
 START WITH FROM_NAME  = :P_FROM
 CONNECT BY NOCYCLE PRIOR TO_NAME = FROM_NAME
 AND FROM_NAME  != :P_FROM
)
SELECT grp, trim(column_value) AS RELATIONSHIP
FROM DATA a,  xmltable(('"'||replace(a.path, ',', '","')||'"'));

       GRP RELATIONSHIP
---------- --------------------------------------------------------------------
         1 Ann dates Tom
         1 Tom is a brother of David
         2 Ann is a sister of bride
         2 bride is married to groom
         2 groom works for David

SQL>

Multiple Dwellings
Baker, Cooper, Fletcher, Miller and Smith live on different floors of an apartment house that contains only five floors.
Baker does not live on the top floor. Cooper does not live on the bottom floor.
Fletcher does not live on either the top or the bottom floor. Miller lives on a higher floor than does Cooper.
Smith does not live on a floor adjacent to Fletcher’s.
Fletcher does not live on a floor adjacent to Cooper’s. Where does everyone live?

—————————————————————–SQL Solution——————————————————————————————

WITH DATA ( num ) AS
(select 1 from dual
 union all
 select d.num+1 from DATA d
 where d.num <5
)
select Baker.num as Baker, Cooper.num as Cooper, Fletcher.num AS Fletcher ,
Miller.num AS Miller, Smith.num AS Smith
FROM DATA Baker, DATA Cooper, DATA Fletcher, DATA Miller, DATA Smith
WHERE Baker.num  NOT IN (Cooper.num, Fletcher.num, Miller.num,  Smith.num )
AND Cooper.num   NOT IN (Baker.num,  Fletcher.num, Miller.num , Smith.num )
AND Fletcher.num NOT IN (Baker.num,  Cooper.num,  Miller.num , Smith.num )
AND Miller.num   NOT IN (Baker.num,  Cooper.num, Fletcher.num,  Smith.num )
AND Smith.num    NOT IN (Baker.num,  Cooper.num, Fletcher.num,  Miller.num )
AND Baker.num != 5
AND Cooper.num NOT IN (1,5)
AND Fletcher.num NOT IN (1,5)
AND Miller.num > Cooper.num  AND Miller.num NOT IN (1,2)
AND ABS(Smith.num -  Fletcher.num) > 1
AND ABS (Fletcher.num -  Cooper.num) >1;

     BAKER     COOPER   FLETCHER     MILLER      SMITH
---------- ---------- ---------- ---------- ----------
         3          2          4          5          1

SQL>

Anagrams
Words that are formed from the same set of letters are anagrams of each other. For instance, pots, post, stop, spot, opts, and tops are anagrams.
Your task is to write a program that, given a dictionary and an input word, prints all the anagrams of the input word.
You are also to determine the largest anagram class in your dictionary.

The flat file “C:\oracle\word.txt” contains the following words :

pots
post
stop
spot
opts
tops
pares
parse
pears
rapes
reaps
spare
spear
angor
argon
goran
grano
groan
nagor
orang
organ
rogan
—————————————————————————-SQL Solution——————————————————————————————

COLUMN largest_anagram_class FORMAT  A68
variable input_str varchar2(38)
exec :input_str:='tops'

create or replace directory tmp as 'C:\oracle'

CREATE  TABLE words (str VARCHAR2(38))
     ORGANIZATION EXTERNAL
     (
       TYPE ORACLE_LOADER
       DEFAULT DIRECTORY tmp
       ACCESS PARAMETERS
       (
         records delimited by newline
         fields terminated by whitespace
         missing field values are null
         ( str
         )
       )
       LOCATION ('word.txt')
     )
     REJECT LIMIT UNLIMITED;

--------------------------------------------------------------Find all the anagrams of the input word ---------------------------------------------------------

WITH DATA AS
(SELECT ordered_str, str,  COUNT(str) OVER (PARTITION BY ordered_str) as cnt
 FROM
 (SELECT DISTINCT REPLACE(LISTAGG(trim(column_value), ',') WITHIN GROUP (ORDER BY trim(column_value)) OVER (PARTITION BY str), ',') as ordered_str, str
  FROM words a,
  xmltable(rtrim(REGEXP_REPLACE(a.str,'(.)', '"\1",'), ','))
 )
),
INPUT AS (
SELECT DISTINCT REPLACE(LISTAGG(trim(column_value), ',') WITHIN GROUP (ORDER BY trim(column_value)) OVER (PARTITION BY str), ',') as ordered_input
  FROM (SELECT :input_str as str FROM dual) a,
  xmltable(rtrim(REGEXP_REPLACE(a.str,'(.)', '"\1",'), ','))
)
SELECT str, CASE WHEN ROWNUM = 1 THEN cnt END as cnt
FROM DATA
WHERE ordered_str IN
(SELECT ordered_input
FROM INPUT);

STR                                           CNT
-------------------------------------- ----------
tops                                            6
pots
opts
spot
post
stop

6 rows selected.

SQL>

---------------------------------------------------Determine the largest anagram class in the dictionary---------------------------------------------------------

WITH DATA AS
(SELECT ordered_str, str,  COUNT(str) OVER (PARTITION BY ordered_str) as cnt
 FROM
 (SELECT DISTINCT REPLACE(LISTAGG(trim(column_value), ',') WITHIN GROUP (ORDER BY trim(column_value)) OVER (PARTITION BY str), ',') as ordered_str, str
  FROM words a,
  xmltable(rtrim(REGEXP_REPLACE(a.str,'(.)', '"\1",'), ','))
 )
)
SELECT  '[ '||anagrams||' ]' AS  largest_anagram_class,  max_ct
 FROM
 (SELECT DISTINCT LISTAGG(str, '->') WITHIN GROUP (ORDER BY str ) OVER (PARTITION BY ordered_str) AS anagrams, cnt, MAX(cnt) OVER() AS max_ct
  FROM DATA
 )
 WHERE max_ct = cnt;

LARGEST_ANAGRAM_CLASS                                                    MAX_CT
-------------------------------------------------------------------- ----------
[ angor->argon->goran->grano->groan->nagor->orang->organ->rogan ]             9

SQL>

Dodgson’s Doublets
Charles Dodgson was an English author, mathematician and logician of the nineteenth century;
In 1879, Dodgson published the Doublets word game in the Vanity Fair magazine:

The rules of the Puzzle are simple enough. Two words are proposed, of the same length; and the Puzzle consists in linking these together by interposing other words, each of which shall differ from the next word in one letter only. That is to say, one letter may be changed in one of the given words, then one letter in the word so obtained, and so on, till we arrive at the other given word. The letters must not be interchanged among themselves, but each must keep to its own place. As an example, the word ‘head’ may be changed into ‘tail’ by interposing the words ‘heal, teal, tell, tall’. I call the given words ‘a Doublet’, the interposed words ‘Links’, and the entire series ‘a Chain’, of which I here append an example:

H E A D
h e a l
t e a l
t e l l
t a l l
T A I L

Write a program that takes two words and finds a chain between them.

create table dictionary ( word varchar2(38) PRIMARY KEY );

insert into dictionary values ('HEAD');
insert into dictionary values ('heal');
insert into dictionary values ('teal');
insert into dictionary values ('tell');
insert into dictionary values ('tall');
insert into dictionary values ('TAIL');
insert into dictionary values ('toll');
commit;

COLUMN str FORMAT  A38
variable begin_str varchar2(38)
variable end_str varchar2(38)
exec :begin_str:='head'
exec :end_str:='tail'

------------------------------------------------SQL Solution-----------------------------------------------

WITH data as (
SELECT word
FROM  dictionary
WHERE length(word) = length(:begin_str)
),
Links as
(SELECT path
 FROM
 (SELECT ltrim(sys_connect_by_path( word, ','), ',') path
  FROM data
  WHERE upper(word) = upper(:end_str)
  START WITH upper(word) = upper(:begin_str)
  CONNECT BY NOCYCLE  utl_match.edit_distance(upper(PRIOR word), upper(word) ) =1
  ORDER BY LEVEL
 )
 WHERE ROWNUM = 1
)
SELECT  rownum as rn, trim(column_value) str
FROM links a, xmltable(('"'||replace(a.path, ',', '","')||'"'));

        RN STR
---------- --------------------------------------
         1 HEAD
         2 heal
         3 teal
         4 tell
         5 tall
         6 TAIL

6 rows selected.

SQL>

--------------------------------SQL Solution using Recursive Subquery Factoring-------------------------------------

WITH data AS (
SELECT word  FROM dictionary
WHERE length(word) = length(:begin_str)
),
Links (path, h_level, word) AS
(SELECT word, 1 , word
 FROM data
 WHERE upper(word) = upper(:begin_str)
 UNION ALL
 SELECT d.path||','||e.word as path, d.h_level+1 AS h_level, e.word
 FROM Links d, data e
 WHERE utl_match.edit_distance(upper(d.word), upper(e.word) ) = 1
)
SEARCH DEPTH FIRST BY word SET seq
CYCLE word SET is_cycle to '1' DEFAULT '0'
SELECT ROWNUM as rn, trim(COLUMN_VALUE) str
FROM
(SELECT path
 FROM
 (SELECT path FROM Links
  WHERE upper(word) = upper(:end_str)
  AND is_cycle = 0
  ORDER BY  h_level
 )
 WHERE ROWNUM = 1 ) a, xmltable(('"'||replace(a.path, ',', '","')||'"'));

        RN STR
---------- --------------------------------------
         1 HEAD
         2 heal
         3 teal
         4 tell
         5 tall
         6 TAIL

6 rows selected.

SQL>

The file landmarks.xml contains a list of landmarks near ITA Software, along with their latitude and longitude in degrees. Write a program which allows users to choose a landmark and search for others that are nearby.

———————————————————————————————————————————————-
This problem is solved by using the following formula and assumptions:

The radius of the Earth is assumed to be 3,963.0 miles.
To convert latitude or longitude from decimal degrees to radians, divide the latitude and longitude values in this database by 57.29577951.

Distance (In Miles) Formula using radians:
3963.0 * arccos[sin(latitude1) * sin(latitude2) + cos(latitude1) * cos(latitude2) * cos(longitude2 - longitude1)]

COLUMN Input_landMark FORMAT  A32
COLUMN LandMark_nearBy FORMAT A32

variable input_name varchar2(38)
variable num_landMark number

exec :input_name:='11 Tewksbury Towers'
exec :num_landMark := 10

-----------------------------------SQL Solution----------------------------------

WITH DATA AS
(SELECT landmark_Name, latitude/57.29577951 as latitude  , longitude/57.29577951 as longitude
 FROM  XMLTABLE('//landmark'
                passing httpuritype('http://www.itasoftware.com/careers/puzzles/landmarks.xml').getXML()
                columns
                landmark_Name   varchar2(30) path 'name',
                latitude        number       path 'latitude',
                longitude       number       path 'longitude' )
)
SELECT CASE WHEN ROWNUM = 1 THEN Input_landMark  END AS Input_landMark,  LandMark_nearBy,  distance
FROM
(SELECT A.landmark_Name AS Input_landMark, B.landmark_Name AS LandMark_nearBy,
 3963 * ACOS (SIN(A.latitude) * SIN(B.latitude) + COS(A.latitude) * COS(B.latitude) * COS (B.longitude - A.longitude)) as distance
 FROM DATA A, DATA B
 WHERE A.landmark_Name = :input_name
 AND A.landmark_Name != B.landmark_Name
 ORDER BY  distance ASC
)
WHERE ROWNUM <=:num_landMark; 

INPUT_LANDMARK                   LANDMARK_NEARBY                    DISTANCE
-------------------------------- -------------------------------- ----------
11 Tewksbury Towers              Dog Pound                        1.28621194
                                 Department of Public Works       1.30290585
                                 Tewksbury Cemetery               2.51978566
                                 Parlmont Park                    3.49041395
                                 River Place Towers               4.47299171
                                 Avalon Drive                     4.64667122
                                 Drum Hill Shopping Center        6.35347443
                                 Greenbriar Estates               6.66743013
                                 Hallmark Gardens                 8.02860427
                                 Scotty Hollow Drive              8.56254678

10 rows selected.

exec :input_name:='Dog Pound'

PL/SQL procedure successfully completed.

SQL> /

INPUT_LANDMARK                   LANDMARK_NEARBY                    DISTANCE
-------------------------------- -------------------------------- ----------
Dog Pound                        Department of Public Works        .274595687
                                 11 Tewksbury Towers              1.28621194
                                 Parlmont Park                    2.2136777
                                 Tewksbury Cemetery               2.49289556
                                 River Place Towers               4.77456746
                                 Avalon Drive                     4.79217856
                                 Drum Hill Shopping Center        5.99881959
                                 Hallmark Gardens                 7.01671677
                                 Greenbriar Estates               7.02086724
                                 Bedford Village                  7.40305675

10 rows selected.

-------------------------------------------------------------------------------------

The "With DATA Clause" above can also be implemented as following :

WITH DATA AS
(SELECT EXTRACTVALUE(VALUE(P), '/landmark/name/text()') landmark_Name ,
 EXTRACT(VALUE(P), '/landmark/longitude/text()').getNumberVal()/57.29577951 longitude,
 EXTRACT(VALUE(P), '/landmark/latitude/text()').getNumberVal() /57.29577951 latitude
 FROM TABLE(XMLSEQUENCE(HTTPURITYPE('http://www.itasoftware.com/careers/puzzles/landmarks.xml').GETXML().EXTRACT('//landmark'))) P
)

In the game of Ghost , two players take turns building up an English word from left to right.

Each player adds one letter per turn. The goal is to not complete the spelling of a word: if you add a letter that completes a word (of 4+ letters), or if you add a letter that produces a string that cannot be extended into a word, you lose.

Write a program that allows a user to play Ghost against the computer. The computer should play optimally given the following dictionary: WORD.LST.

Allow the human to play first. If the computer thinks it will win, it should play randomly among all its winning moves; if the computer thinks it will lose, it should play so as to extend the game as long as possible (choosing randomly among choices that force the maximal game length).

—————————————————————————————————————————————————-
Here is the strategy for solving this problem: Try to add a letter to the current input string, so that there is only “one word” left in the whole dictionary for your opponent. Once your opponent adds the next letter to the input string, that will complete the spelling of the word.

Solution:
Copy the word.lst from the web to a word.txt file on the database server ( \tmp directory).

create or replace directory tmp as 'C:\oracle\tmp';

CREATE  TABLE words (str VARCHAR2(38))
     ORGANIZATION EXTERNAL
     (
       TYPE ORACLE_LOADER
       DEFAULT DIRECTORY tmp
       ACCESS PARAMETERS
       (
         records delimited by newline
         fields terminated by whitespace
         missing field values are null
         ( str
         )
       )
       LOCATION ('word.txt')
     )
     REJECT LIMIT UNLIMITED;

COLUMN input FORMAT A18
COLUMN destination FORMAT A28
COLUMN next_char   FORMAT A12

variable input varchar2(38)
SQL> exec :input :='tar'

PL/SQL procedure successfully completed.

------------------------------SQL Solution----------------- 

WITH data AS
(SELECT str, length(str) as len, :input as input, length(:input) as in_len,
        case when str like :input||'_'
             then  str
             end as flag_str
 FROM words
 WHERE str LIKE :input||'%' and length(str) >=4
),
flag_data as
(
SELECT flag_str FROM data WHERE flag_str is not null
),
Filter_data as
(
SELECT distinct a.str FROM data a , flag_data b
WHERE substr(a.str, 1, length(b.flag_str)) = b.flag_str
),
Base_data as
(SELECT str, len , in_len, input FROM data
 WHERE str not in ( SELECT str FROM Filter_data)
)
SELECT input, destination, next_char
FROM
(SELECT input, str as destination, substr(str, in_len+1, 1) as next_char
  FROM
 (SELECT a.str, a.len, input, a.in_len,
         case when mod(a.len, 2) = 0 then 1
              else case when  REGEXP_LIKE (a.str, '^'||input||'[[:alpha:]]{2}$')
                        then case when
                                 (SELECT count(*) FROM data
                                  WHERE REGEXP_LIKE (str, '^'||substr(a.str,0,length(a.input)+1)||'[[:alpha:]]{2,}$')
                                  and  not REGEXP_LIKE (str, '^'||a.str||'[[:alpha:]]+$')
                                  ) = 0
                                  then 4
                                  else 3
                             end
                        else  2
                    end
         end as flag
  FROM Base_data a
 ) ORDER BY flag desc , case when flag = 1 then len else 0 end desc
)
WHERE ROWNUM = 1;

INPUT              DESTINATION                  NEXT_CHAR
------------------ ---------------------------- ------------
tar                targe                        g

SQL> exec :input := 'bot'

SQL> /

INPUT              DESTINATION                  NEXT_CHAR
------------------ ---------------------------- ------------
bot                botch                        c

SQL> exec :input := 'aba'

SQL> /

INPUT              DESTINATION                  NEXT_CHAR
------------------ ---------------------------- ------------
aba                abamp                        m