Выполнение двоичного поиска на некоторых элементах в Haskell

Question

Выполнение двоичного поиска на некоторых элементах в Haskell

Ответ @a_horse_with_no_name дает мне хорошее начало. Я расширяю его / ее ответ и подхожу к следующему запросу так, чтобы элементы в массиве JSON имели тот же тип данных, который определен в PostgreSQL.

select id, jsonb_object_agg(att, 
    case 
      when strval is not null then strval
      when intvalue is not null then intvalue
      else boolVal
     end 
    )
from (
  select id, 
         attributename as att,  
         case when count(*) > 1 then 
            jsonb_agg(stringvalue) filter (where stringvalue is not null) 
         else 
            to_jsonb(min(stringvalue) filter (where stringvalue is not null))     
         end as strVal, 

         case when count(*) > 1 then 
            jsonb_agg(intvalue) filter (where intvalue is not null) 
         else 
            to_jsonb(min(intvalue) filter (where intvalue is not null))     
         end as intvalue, 

         case when count(*) > 1 then 
            jsonb_agg(booleanvalue) filter (where booleanvalue is not null) 
         else 
            to_jsonb(bool_and(booleanvalue) filter (where booleanvalue is not null))     
         end as boolVal
  from eav
  group by id, attributename
) t
group by id;

6

haskell search

задан Mat 23 September 2012 в 13:17

4 ответа

Другие вопросы по тегам:

haskell search

Похожие вопросы:

score 4 · Answer 1

Преподаватель просит "литеральную транслитерацию", так используйте те же имена переменной в том же порядке. Но отметьте некоторые различия:

данная версия берет только 1 параметр, подпись, которую он дает, требует 3. Хм,
данная версия не является рекурсивной, но он просит рекурсивную версию.

В другом ответе говорится для преобразования в Массив, но для такого маленького осуществления (это - домашняя работа, в конце концов), я чувствовал, что мы могли притвориться, что списки являются прямым доступом. Я просто взял Вашу дикцию:: [Запись] и индексированный в это. Я действительно должен был преобразовать между Интервалом и Целым числом в нескольких местах.

Незначительная гнида: у Вас есть опечатка в Вашем английском значении (бакалавр наук является ярлыком на binSearch, который я сделал):

  *Main> map bs (words english)
[Entry ("A","Un"),Entry ("stitch","point"),Entry ("in","<`a>"),Entry ("time","te
mps"),*** Exception: Not found
*Main> map bs (words englishFixed)
[Entry ("A","Un"),Entry ("stitch","point"),Entry ("in","<`a>"),Entry ("time","te
mps"),Entry ("saves","en vaut"),Entry ("nine.","cent.")]
*Main>

score 3 · Answer 2

Для двоичного поиска нужен произвольный доступ, который не возможен в списке. Так, первое, что нужно сделать состояло бы в том, чтобы, вероятно, преобразовать список в Array (с listArray), и сделайте поиск на нем.

score 1 · Answer 3

вот мой код только для английской части вопроса (я протестировал его, и он отлично работает):

module Main where

class Lex a where
    (<!), (=!), (>!) :: a -> a -> Bool

data Entry = Entry String String

instance Lex Entry where
    (Entry a _) <!  (Entry b _) = a <  b
    (Entry a _) =!  (Entry b _) = a == b
    (Entry a _) >!  (Entry b _) = a >  b
  -- at this point, three binary (infix) operators on values of type 'Entry'
  -- have been defined

type Raw = (String, String)

raw_data :: [Raw]
raw_data  =  [("than a", "qu'un"), ("saves", "en vaut"), ("time", "temps"),
                ("in", "<`a>"), ("worse", "pire"), ("{", "{"), ("A", "Un"),
                ("}", "}"), ("stitch", "point"), ("crime;", "crime,"),
                ("a", "une"), ("nine.", "cent."), ("It's", "C'est"),
                ("Zazie", "Zazie"), ("cat", "chat"), ("it's", "c'est"),
                ("raisin", "raisin sec"), ("mistake.", "faute."),
                ("blueberry", "myrtille"), ("luck", "chance"),
                ("bad", "mauvais")]

cook :: Raw -> Entry
cook (x, y) = Entry x y

a :: [Entry]
a = map cook raw_data

quicksort :: Lex a => [a] -> [a]
quicksort []     = []
quicksort (x:xs) = quicksort (filter (<! x) xs) ++ [x] ++ quicksort (filter (=! x) xs) ++ quicksort (filter (>! x) xs) 

getfirst :: Entry -> String
getfirst (Entry x y) = x

getsecond :: Entry -> String
getsecond (Entry x y) = y

binarysearch :: String -> [Entry] -> Int -> Int -> String
binarysearch s e low high 
    | low > high = " NOT fOUND "
    | getfirst ((e)!!(mid)) > s = binarysearch s (e) low (mid-1)
    | getfirst ((e)!!(mid)) < s = binarysearch s (e) (mid+1) high
    | otherwise = getsecond ((e)!!(mid))
        where mid = (div (low+high) 2)

translator :: [String] -> [Entry] -> [String]
translator [] y = []
translator (x:xs) y = (binarysearch x y 0 ((length y)-1):translator xs y)

english :: String
english = "A stitch in time saves nine."

compute :: String -> [Entry] -> String
compute x y = unwords(translator (words (x)) y)

main = do
    putStr (compute english (quicksort a))

score 0 · Answer 4

Важный оператор Prelude:

(!!) :: [a] -> Integer -> a
-- xs!!n returns the nth element of xs, starting at the left and
-- counting from 0.

Таким образом, [14,7,3] !! 1 ~~> 7.