На главную Наши проекты:
Журнал   ·   Discuz!ML   ·   Wiki   ·   DRKB   ·   Помощь проекту
ПРАВИЛА FAQ Помощь Участники Календарь Избранное RSS
msm.ru
  
> адача на Turbo Prolog
    нужно решить таку задачу на Turbo Prolog 2.0:
    1. Пусьть дано координати трех точек на плоскости. Если они могут бить вершинами треугольника, определити его вид (разносторонний, равнобедрений, равносторонний). Найдите длину его висот и напечатайте их в порядке убивания.
    2.user posted image
    (с помощю рекурсии)
    зарание спасибо
      Задача №2.
      В условии не определено значение функции при n=m=0. Поэтому задача не решается.
      Если доопределить C(0,0)=1, тогда вот программа

      ExpandedWrap disabled
        predicates
        c(integer,integer,real)
         
        goal
          clearwindow,
          c(5,3,X), write(X).
         
        clauses
         
        c(N,0,1):- N>=0.
        c(N,M,0):- M>N, N>=0.
        c(N,M,R):-
           N1=N-1,
           M1=M-1,
           c(N1,M1,R1),
           c(N1,M,R2),
           R=R1+R2.
        большое спасибо Swetlana. Если можеш переделать, вот уточнение к задаче №2
        user posted image
          ExpandedWrap disabled
            predicates
            c(integer,integer,real)
             
            goal
              clearwindow,
              c(5,3,X), write(X).
             
            clauses
             
            c(N,0,1):- N>0.
            c(N,M,0):- M>N, N>=0.
            c(N,N,1):- N>=0.  
            c(N,M,R):-
               N1=N-1,
               M1=M-1,
               c(N1,M1,R1),
               c(N1,M,R2),
               R=R1+R2.
            такая задача. нужно сделать на турбо пролог 2:
            Пусть дано три числа. Если они могут бить длинами сторон треугольника опредилите его вид (прямоугольний, тупоугольний, остроугольний). Вичислите длину его висот и напичатайте их в порядке убивания.
            зарания спс.

            Добавлено
            2. y=sin(x)+sin(sin(x))+...+sin(sin(sin...sin(x)))

            3. пускай дано n - натуральное число, І. сколько цифр в числе? ІІ. Чему равна сума цефр в чесле. Пример: 23 - І. в числе 2 цифр. ІІ. сума цифр равна 5.
            зарания спс.
              Цитата
              2. y=sin(x)+sin(sin(x))+...+sin(sin(sin...sin(x)))

              Константа n -количество слагаемых в сумме.

              ExpandedWrap disabled
                constants
                n=3
                predicates
                sum(integer,real,real,real)
                 
                clauses
                 
                sum(M,_,S,S):-
                  M=n,!.
                sum(M,X,S,Sum):-
                  M1=M+1,
                  X1=sin(X),
                  S1=S+X1,
                  sum(M1,X1,S1,Sum).
                 
                 
                goal
                 clearwindow,
                 write("Input X="), readreal(X),
                 X0=sin(X),S0=X0,
                 sum(1,X0,S0,S), write(S),nl.


              Добавлено
              Цитата
              3. пускай дано n - натуральное число, І. сколько цифр в числе? ІІ. Чему равна сума цефр в чесле. Пример: 23 - І. в числе 2 цифр. ІІ. сума цифр равна 5.


              ExpandedWrap disabled
                predicates
                d(integer,integer,integer)
                 
                clauses
                 
                d(0,0,0):-!.
                d(X,C,S):-
                  X1=X div 10,
                  Y1=X-X1*10, %poslednja cifra
                  d(X1,C1,S1),
                  C=1+C1,
                  S=Y1+S1.
                 
                 
                goal
                 clearwindow,
                 write("Input X="), readint(X),
                 d(X,C,S), write(C," ",S),nl.
                Еще надо решить такие задачи в Turbo Prolog (тема: Списки):

                21. Создайте предикат, вычисляющий по списку и числу, подсписок исходного списка, начинающийся с элемента с указанным номером.

                39. Создайте предикат, формирующий список простых чисел, не превосходящих данного числа.
                Сообщение отредактировано: c68c15 -
                  Цитата
                  21. Создайте предикат, вычисляющий по списку и числу, подсписок исходного списка, начинающийся с элемента с указанным номером.


                  ExpandedWrap disabled
                    domains
                    list = integer*
                     
                    predicates
                    sublist(integer,integer,list,list)
                     
                     
                    clauses
                    sublist(_,_,[],[]):-!.
                    sublist(N,N,L,L):-!.
                    sublist(M,N,[H|T],T1):-
                      M<N,
                      M1=M+1,
                      sublist(M1,N,T,T1).
                      
                     
                    goal
                      write("N="), readint(N),
                      write("L="), readterm(list,L),
                      sublist(1,N,L,L1),write(L1),nl.
                    Цитата
                    39. Создайте предикат, формирующий список простых чисел, не превосходящих данного числа.


                    Предикат p формирует список целых чисел от 2 до N.
                    Предикат prostoe возвращает успех (истину), если число является простым.
                    Предикат d формирует список делителй числа N.



                    ExpandedWrap disabled
                      domains
                      list=integer*
                       
                      predicates
                      p(integer,integer,list)
                      prostoe(integer)
                      d(integer,integer,list)
                       
                      clauses
                       
                      p(M,N,[]):-
                        M>N,!.
                      p(2,N,[2|T]):-
                        p(3,N,T).
                      p(M,N,[M|T]):-
                        prostoe(M),!,
                        M1=M+2,
                        p(M1,N,T).
                      p(M,N,L):-
                        M1=M+2,
                        p(M1,N,L).  
                        
                          
                       
                      prostoe(N):-
                        d(2,N,L),
                        L=[N].  
                       
                      d(_,1,[]):-!.
                      d(X,N,[X|T]):-
                        N mod X=0,!,
                        N1=N div X,
                        d(X,N1,T).
                      d(X,N,L):-
                        X1=X+1,
                        d(X1,N,L).
                       
                      goal
                       clearwindow,
                       write("Input N="), readint(N),
                       p(2,N,L), write(L),nl.
                      Здравствуйте!!!помогите пожалуйста написать программку в Turbo Prolog:
                      Определить предикат member(Element,List),который истинен,если число Element является элементом списка List.Например member(2,[3,2,5]) истинно (Ответ:Yes).
                        http://www.intuit.ru/department/pl/plprolog/7/2.html
                          спасибо за ссылку))))))просто я совсем не понимаю что к чему((((,так что, извините... Как мне сделать вообще код всей этой проги,что бы всё работало?!плиз))))

                          хочется автомат по экз, который вообще не айс сдавать...
                            Кристина, научить вас читать я не могу. Если вы никогда не открывали ТурбоПролог и не видели ни одной программы, то вам рано получать экзамен-автомат. В разделе полно готовых программ, работающих со списками целых чисел. Любая подойдёт к этой задаче.
                            Для тех кому не айс, функционирует раздел "Помощь студентам".

                            Цитата
                            Пример. Создадим предикат, позволяющий проверить принадлежность элемента списку. Предикат будет иметь два аргумента: первый — искомое значение, второй — список, в котором производится поиск.

                            Построим данный предикат, опираясь на тот факт, что объект принадлежит списку, если он либо является первым элементом списка, либо элементом хвоста. Это может быть записано в виде двух предложений:

                            member(X,[X|_]). /* X — первый элемент списка */
                            member(X,[_|T]) :–
                            member(X,T). /* X принадлежит хвосту T*/

                            Заметим, что в первом случае (когда первый элемент списка совпадает с исходным элементом), нам неважно, какой у списка хвост, и можно в качестве хвоста указать анонимную переменную. Аналогично, во втором случае, если X принадлежит хвосту, нам не важно, какой элемент первый.

                            Отметим, что описанный предикат можно использовать двояко: во-первых, конечно, для того, для чего мы его и создавали, т.е. для проверки, имеется ли в списке конкретное значение. Мы можем, например, поинтересоваться, принадлежит ли двойка списку [1, 2, 3]:

                            member(2, [1, 2, 3]).

                            Получим, естественно, ответ: "Yes".

                            Подобным образом можно спросить, является ли число 4 элементом списка [1, 2, 3]:

                            member(4, [1, 2, 3]).

                            Ответом, конечно, будет "No".
                              Спасибочки большое+) =) =) =) =)
                                а можете помочь мне с программой,очень надо
                                30. Создайте предикат, генерирующий все перестановки элементов списка, указанного в качестве первого аргумента предиката.
                                35. Создайте предикат, осуществляющий подсчет числа вхождений каждого элемента исходного списка. Ответом должен быть список пар, в которых первая компонента - элемент исходного списка, вторая - число его вхождений в первоначальный список.
                                заранее благодарна ;)
                                  Цитата tatoo @
                                  30. Создайте предикат, генерирующий все перестановки элементов списка, указанного в качестве первого аргумента предиката.

                                  ExpandedWrap disabled
                                    domains
                                    list=integer*
                                    predicates
                                    p(list,list)
                                    into(integer,list,list)
                                    goal
                                    clearwindow,
                                    p([1,2,3],L),write(L),nl,fail.
                                     
                                    clauses
                                    p([],[]).
                                    p([X|T],P):-
                                       p(T, T1),
                                       into(X, T1, P).
                                     
                                    into(X, L, [X|L]).
                                    into(X, [H|T], [H|T1]):-
                                       into(X, T, T1).


                                  Добавлено
                                  Цитата tatoo @
                                  Создайте предикат, осуществляющий подсчет числа вхождений каждого элемента исходного списка. Ответом должен быть список пар, в которых первая компонента - элемент исходного списка, вторая - число его вхождений в первоначальный список.
                                  заранее благодарна ;)

                                  ExpandedWrap disabled
                                    domains
                                    list=integer*
                                    pair=p(integer,integer)
                                    plist=pair*
                                     
                                    predicates
                                    culc(list,plist)
                                    into(integer,plist,plist)
                                     
                                    goal
                                     clearwindow,
                                     culc([1,2,3,2,3,3],L), write(L),nl.
                                     
                                    clauses
                                    culc([],[]):-!.
                                    culc([X],[p(X,1)]):-!.
                                    culc([H|T],L):-
                                      culc(T,T1),
                                      into(H,T1,L).
                                      
                                    into(X,[],[p(X,1)]):-!.
                                    into(X,[p(Y,N)|T],[p(Y,N1)|T]):-
                                      X=Y,!,
                                      N1=N+1.
                                    into(X,[H|T],[H|T1]):-
                                      into(X,T,T1).
                                    Спасибо большое!!!!Вы мне очень помогли!благодарю!!!! :good:
                                      У меня огромная проблема с простенькой задачкой по Прологу,Буду очень благодарна за помощь...
                                      Создайте предикат, заменяющий в исходном списке первое вхождение заданного значения другим.
                                      Очень жду ответов...:)
                                        Каким другим значением? Любым что ли?
                                        Покажите на примере, что нужно. Исходный список и целевой список.
                                          Здравствуйте помогите пожалуйста решить задачу:Определить предикат, вычисляющий функцию (система): f(x)=2,если x<2
                                          X,если >=2
                                          Сообщение отредактировано: Italiano -
                                            Цитата Italiano @
                                            Здравствуйте помогите пожалуйста решить задачу:Определить предикат, вычисляющий функцию (система): f(x)=2,если x<2
                                            X,если >=2

                                            ExpandedWrap disabled
                                              predicates
                                              p(real,real)
                                               
                                              goal
                                               clearwindow,
                                               write("X="),readreal(X),p(X,Y),write(Y),nl.
                                               
                                              clauses
                                              p(X,2):-
                                                X<2,!.
                                              p(X,X).


                                            Добавлено
                                            Цитата tatoo @
                                            не хочу показаться настойчивой,но если не трудно помогите закончить этот семестр=)))эти 3 задания последние,помогите кто чем может :wall:
                                            ФАЙЛЫ
                                            2. Напишите замену для стандартного предиката openmodify, который будет открывать файл на чтение и запись, если файл существует, и выводить соответствующее сообщение, если файл отсутствует.
                                            7. Создайте предикат, вычисляющий количество чисел, меньших среднего арифметического значения всех чисел в файле.
                                            9. Создайте предикат, дополняющий все строки, хранящиеся в файле, символом "*" до самой длинной строки.

                                            На форуме есть раздел "Помощь студентам".
                                              Цитата Swetlana @
                                              Каким другим значением? Любым что ли?
                                              Покажите на примере, что нужно. Исходный список и целевой список.

                                              Swetlana!

                                              Например:

                                              pred(2,5,[9,4,2,5,9,3,1,5,7,8,2,5,2,0,8],L);

                                              Должно получиться:

                                              L=[9,4,5,5,9,3,1,5,7,8,2,5,2,0,8]
                                                помогите решить задачку,пожалуйста :-?
                                                1. Написать замену для стандартного предиката openmodify, который будет открывать файл на чтение и запись, если файл существует, и выводить соответствующее сообщение, если файл отсутствует.
                                                2. Создать предикат, вычисляющий количество чисел, меньших среднего арифметического значения всех чисел в файле.
                                                  Цитата Dii @
                                                  Цитата Swetlana @
                                                  Каким другим значением? Любым что ли?
                                                  Покажите на примере, что нужно. Исходный список и целевой список.

                                                  Swetlana!

                                                  Например:

                                                  pred(2,5,[9,4,2,5,9,3,1,5,7,8,2,5,2,0,8],L);

                                                  Должно получиться:

                                                  L=[9,4,5,5,9,3,1,5,7,8,2,5,2,0,8]


                                                  ExpandedWrap disabled
                                                    domains
                                                    list=integer*
                                                     
                                                    predicates
                                                    p(integer,integer,list,list)
                                                     
                                                    goal
                                                     clearwindow,
                                                     p(2,5,[1,3,2,5,6,2],L),write(L),nl.
                                                     
                                                    clauses
                                                    p(H,Y,[H|T],[Y|T]):-!.
                                                    p(X,Y,[H|T],[H|T1]):-
                                                      p(X,Y,T,T1).
                                                  Сообщение отредактировано: Swetlana -
                                                    помогите решить задачки на prolog swi,пожалуйста!
                                                    Тема:
                                                    Структуры, операторы, рекурсия и поиск с возвратом.
                                                    Задание 1:
                                                    Вычислить указанное значение, считая n натуральным числом.
                                                    Использовать операторное представление структур
                                                    При отладке программы использовать возможности трассировки.
                                                    1. сумму первых n нечетных чисел.
                                                    2. сумму первых n двузначных чисел.
                                                    3. среднее арифметическое первых n чисел.
                                                      здесь только турбопролог, swi - за деньги в "Помощь студентам"
                                                        Помоготе, пожалуйста, решить задачку!

                                                        Написать программу, которая выводит на печать число положительных и число отрицательных элементов списка

                                                        Заранее благодарен! :)
                                                          Я нули считала вместе с положительными. Или нули надо было пропускать?
                                                          ExpandedWrap disabled
                                                            domains
                                                            list=integer*
                                                             
                                                            predicates
                                                            print(integer,integer,list)
                                                             
                                                            clauses
                                                            print(0,0,[]):-!.
                                                            print(Neg,Poz,[H|T]):-
                                                               H<0,!,  
                                                               print(Neg1,Poz,T),
                                                               Neg=Neg1+1.
                                                            print(Neg,Poz,[H|T]):-
                                                               print(Neg,Poz1,T),  
                                                               Poz=Poz1+1.
                                                              
                                                            goal
                                                            print(N,P,[1,-3,-5,7,-9]), write(N," ",P), nl.
                                                            Цитата Swetlana @
                                                            Я нули считала вместе с положительными. Или нули надо было пропускать?
                                                            ExpandedWrap disabled
                                                              domains
                                                              list=integer*
                                                               
                                                              predicates
                                                              print(integer,integer,list)
                                                               
                                                              clauses
                                                              print(0,0,[]):-!.
                                                              print(Neg,Poz,[H|T]):-
                                                                 H<0,!,  
                                                                 print(Neg1,Poz,T),
                                                                 Neg=Neg1+1.
                                                              print(Neg,Poz,[H|T]):-
                                                                 print(Neg,Poz1,T),  
                                                                 Poz=Poz1+1.
                                                                
                                                              goal
                                                              print(N,P,[1,-3,-5,7,-9]), write(N," ",P), nl.

                                                            Большое спасибо! :)
                                                            А в Strawberry Prolog эта задача решается точно так же или как-то иначе?
                                                              Цитата
                                                              А в Strawberry Prolog эта задача решается точно так же или как-то иначе?

                                                              Рекурсия, она и в Африке рекурсия.
                                                                Необходима помощь в решении еще одной задачки!
                                                                Найти максимальный элемент в списке (только без использования стандартной функции max)!
                                                                Заранее благодарен! :)
                                                                  Это задача?
                                                                  Если в списке один элемент, то он и есть максимальный.
                                                                  Иначе больший среди первого и максимального из оставшихся.
                                                                    ExpandedWrap disabled
                                                                      domains
                                                                      list=integer*
                                                                       
                                                                      predicates
                                                                      max(list,integer)
                                                                       
                                                                      clauses
                                                                      max([X],X):-!.
                                                                      max([H|T],Y):-
                                                                         max(T,Y),  
                                                                         H<Y,!.
                                                                      max([H|T],H).  
                                                                       
                                                                        
                                                                      goal
                                                                      max([1,-3,-5,7,-9],X), write(X), nl.
                                                                      Большое спасибо! :)
                                                                        Можете мне сказать почему даная программа ничего не выводит?
                                                                        Должна выводить No/Yes


                                                                        ExpandedWrap disabled
                                                                          domains
                                                                          misto, kraina = symbol
                                                                           
                                                                          predicates
                                                                          city(misto,kraina)
                                                                           
                                                                          clauses
                                                                          city (london, england).
                                                                          city (petersburg, russia).
                                                                          city (kyiv, ukraine).
                                                                          city (pekin, china).
                                                                          city (warszaw, poland).
                                                                          city (berlin, germany).
                                                                          city (X, europe):- city (X, ukraine).
                                                                          city (X, europe):- city (X, poland).
                                                                          city (X, europe):- city (X, germany).
                                                                          city (X, europe):- city (X, england).
                                                                          goal
                                                                          city(berlin, europe).
                                                                        Сообщение отредактировано: CBuilder -
                                                                          В goal надо печать поставить

                                                                          ExpandedWrap disabled
                                                                            goal
                                                                            city(berlin, europe), write("Yes");
                                                                            write("No").
                                                                            Спасибо, а можете еще подсказать что тут нетак?

                                                                            ExpandedWrap disabled
                                                                              domains
                                                                               
                                                                              tato, mama, chadot,chadom = symbol
                                                                              per, par = symbol
                                                                              GChild, GFather = symbol
                                                                               
                                                                              predicates
                                                                              father(tato, chadot)
                                                                              mother(mama, chadom)
                                                                              parent(per, par)
                                                                              grandFather(GChild, GFather)
                                                                               
                                                                               
                                                                              clauses
                                                                              father("Ostap", "Peter").
                                                                              father("Pavlo", "Ostap").
                                                                              father("Severyn", "Yuriy").
                                                                              mother("Ulia", "Taras").
                                                                               
                                                                              parent(Person, Parent) :-
                                                                              father(Person, Parent); mother(Person, Parent). // - Здесь на тип ругаеться
                                                                               
                                                                              grandFather(GrandChild, GrandFather) :-
                                                                              father(GrandChild, Father),
                                                                              father(Father, GrandFather).
                                                                               
                                                                              goal
                                                                              clearwindow,father(Ostap, Peter), write("Yes");
                                                                              write("No").
                                                                            Сообщение отредактировано: CBuilder -
                                                                              Зачем типов столько наделали?
                                                                              father(tato, chadot)
                                                                              parent(per, par)

                                                                              У вас внутри одного правила одна переменная не может иметь то тип tatj, то тип per.
                                                                              Правило определения дедушки неправильно написали. Дедушка не только по отцу, а по любому родителю.
                                                                              ExpandedWrap disabled
                                                                                father(tato, chadot)
                                                                                mother(mama, chadom)
                                                                                parent(per, par)
                                                                                Спасибо!
                                                                                  Можете ище подсказать...
                                                                                  Как мне опридилить оператор возведения в степень 2?
                                                                                    Цитата CBuilder @
                                                                                    Как мне опридилить оператор возведения в степень 2?

                                                                                    ExpandedWrap disabled
                                                                                      predicates
                                                                                      f(real,real)
                                                                                       
                                                                                      clauses
                                                                                      f(X,Y):-
                                                                                        Y=X*X.
                                                                                       
                                                                                      goal
                                                                                      f(3,Y),write(Y),nl.
                                                                                      Спасибо а можно както через ор(Priority, Assoc, Op).... Мне нужно назначить оператору приоритет...
                                                                                        Здесь Турбопролог, у вас какой-то другой. Больше ничем помочь не могу.
                                                                                          Помогите с программой, которая обрабатывает элементы списка.
                                                                                          Исходный список вводится пользователем и содержит целые числа (за исключением 0). Признаком конца ввода является ввод 0.
                                                                                          Программа должна из введенного списка
                                                                                          а)получить новый список, каждый элемент которого на 1 больше соответствующего элемента введенного списка;
                                                                                          б) получить новый список удалив из исходного списка все отрицательные элементы.
                                                                                          Полученные списки поэлементно распечатать.
                                                                                            Помогите, пожалуйста, решить такую вот задачку:
                                                                                            Найти число решений логической задачи о расстановке ферзей для доски 8 на 8, при условии, что в квадрате 2.2 и 4.3 есть один ферзь.
                                                                                            Заранее благодарен!
                                                                                            Сообщение отредактировано: jekahm -
                                                                                              Цитата Ya-Feya @
                                                                                              Помогите с программой, которая обрабатывает элементы списка.
                                                                                              Исходный список вводится пользователем и содержит целые числа (за исключением 0). Признаком конца ввода является ввод 0.
                                                                                              Программа должна из введенного списка
                                                                                              а)получить новый список, каждый элемент которого на 1 больше соответствующего элемента введенного списка;
                                                                                              б) получить новый список удалив из исходного списка все отрицательные элементы.
                                                                                              Полученные списки поэлементно распечатать.

                                                                                              ExpandedWrap disabled
                                                                                                domains
                                                                                                list=integer*
                                                                                                 
                                                                                                predicates
                                                                                                inpp(list)
                                                                                                print(list)
                                                                                                p1(list,list)
                                                                                                p2(list,list)
                                                                                                 
                                                                                                goal
                                                                                                write("Input list "),inpp(L),
                                                                                                p1(L,L1),p2(L,L2),
                                                                                                print(L1),nl,nl,print(L2).
                                                                                                 
                                                                                                clauses
                                                                                                inpp([H|T]):-
                                                                                                  readint(H),H<>0,!,
                                                                                                  inpp(T).
                                                                                                inpp([]).
                                                                                                 
                                                                                                print([]):-!.
                                                                                                print([H|T]):-
                                                                                                  write(H),nl,print(T).
                                                                                                  
                                                                                                p1([],[]):-!.
                                                                                                p1([H|T],[H1|T1]):-
                                                                                                   H1=H+1,
                                                                                                   p1(T,T1).  
                                                                                                 
                                                                                                p2([],[]):-!.
                                                                                                p2([H|T],[H|T1]):-
                                                                                                   H>0,!,
                                                                                                   p2(T,T1).
                                                                                                p2([H|T],T1):-
                                                                                                   p2(T,T1).


                                                                                              Добавлено
                                                                                              Цитата jekahm @
                                                                                              Помогите, пожалуйста, решить такую вот задачку:
                                                                                              Найти число решений логической задачи о расстановке ферзей для доски 8 на 8, при условии, что в квадрате 2.2 и 4.3 есть один ферзь.
                                                                                              Заранее благодарен!

                                                                                              Эта задача и в инете есть решённая, и в разделе. В разделе, по-моему, задача о расстановке махараджей. Там и расстановка ферзей обсуждалась.
                                                                                                Спасибо большое!
                                                                                                  Надо найти номера элементов в списке(т.е. по эл-там найти номера.)

                                                                                                  n_element([X|_],1,X)-!.
                                                                                                  n_element([_|L],N,Y):–
                                                                                                  N1=N–1,
                                                                                                  n_element(L,N1,Y).

                                                                                                  он ругается что N - свободная переменная=((

                                                                                                  как исправить ошибку?
                                                                                                    Что является входными данными?
                                                                                                    Задан список и задан один элемент, найти его номер?
                                                                                                      да, или номера (если эл-т встречается несколько раз).
                                                                                                        ExpandedWrap disabled
                                                                                                          domains
                                                                                                          list=integer*
                                                                                                          predicates
                                                                                                          num(list,integer,integer)
                                                                                                           
                                                                                                          clauses
                                                                                                           num([X|_],X,1).
                                                                                                           num([_|T],X,N):-
                                                                                                             num(T,X,N1),
                                                                                                             N=N1+1.
                                                                                                           
                                                                                                          goal
                                                                                                           findall(N,num([2,2,3,2,2],2,N),L),write(L).
                                                                                                          Помогите написать предикат для вычисления моды списка!!

                                                                                                          P.S. Мода — это число, чаще всех встречающееся в наборе чисел. Например, мода набора чисел 2, 3, 3, 5, 7 и 10 будет равна 3.
                                                                                                            ExpandedWrap disabled
                                                                                                              domains
                                                                                                              list=integer*
                                                                                                               
                                                                                                              predicates
                                                                                                              moda(list,integer,integer)
                                                                                                              count(integer,list,integer)
                                                                                                              del(integer,list,list)
                                                                                                              max(integer,integer,integer,integer,integer,integer)
                                                                                                               
                                                                                                              clauses
                                                                                                               moda([X],X,1):-!.
                                                                                                               moda([H|T],M,N2):-
                                                                                                                 count(H,[H|T],N),
                                                                                                                 del(H,T,T1),
                                                                                                                 moda(T1,X,N1),
                                                                                                                 max(H,N,X,N1,M,N2).
                                                                                                               
                                                                                                               count(X,[],0):-!.
                                                                                                               count(X,[X|T],N):-
                                                                                                                 count(X,T,N1),
                                                                                                                 N=N1+1.  
                                                                                                               count(X,[H|T],N):-
                                                                                                                 count(X,T,N).  
                                                                                                               
                                                                                                               del(X,[],[]):-!.
                                                                                                               del(H,[H|T],T1):-
                                                                                                                 del(H,T,T1).
                                                                                                               del(X,[H|T],[H|T1]):-
                                                                                                                 del(X,T,T1).    
                                                                                                               
                                                                                                               max(X1,N1,X2,N2,X1,N1):-
                                                                                                                 N1>=N2,!.
                                                                                                               max(X1,N1,X2,N2,X2,N2).    
                                                                                                                
                                                                                                               
                                                                                                              goal
                                                                                                                moda([2,2,3,2,3,2],X,N),write(X," ",N).
                                                                                                              Спасибо большое!!
                                                                                                                Здравствуйте,помоги пожалуйста....
                                                                                                                1)Описать предикат Р(list1, list2), который истинен,если list1 состоит из повторяющихся более 3 раз элементов списка list2.
                                                                                                                2)Определить предикат Р(list1, list2), который истинен,если list2 состоит из элементов списка list1, входящих в него наибольшее количество раз.
                                                                                                                Помогите пожалуйста,тяжко с Прологом!!!
                                                                                                                  На ТурбоПрологе?
                                                                                                                  Цитата
                                                                                                                  2)Определить предикат Р(list1, list2), который истинен,если list2 состоит из элементов списка list1, входящих в него наибольшее количество раз.

                                                                                                                  Не поняла заданье. Покажи на примере.
                                                                                                                    например: list1 [1,2,4,1,5,1,2,2], list2 [1,2], элементы "1" и "2" входят по 3 раза в список 1, а список 2 состоит как раз из этих элементов, тогда ответ: да
                                                                                                                      Первое заданье

                                                                                                                      ExpandedWrap disabled
                                                                                                                        domains
                                                                                                                        li=integer*
                                                                                                                         
                                                                                                                        predicates
                                                                                                                        p(li,li)
                                                                                                                        count(integer,li,integer)
                                                                                                                         
                                                                                                                        goal
                                                                                                                        clearwindow,
                                                                                                                        p([2,1],[3,2,1,2,1,2,1,3]), write("yes");
                                                                                                                        write("no").
                                                                                                                         
                                                                                                                        clauses
                                                                                                                         
                                                                                                                         
                                                                                                                        p([],_):-!.
                                                                                                                        p([H|T],L):-
                                                                                                                          count(H,L,N),!,
                                                                                                                          N>=3,
                                                                                                                          p(T,L).
                                                                                                                         
                                                                                                                        count(X,[],0):-!.
                                                                                                                        count(H,[H|T],N1):-
                                                                                                                          count(H,T,N),
                                                                                                                          N1=N+1.
                                                                                                                        count(X,[H|T],N):-
                                                                                                                          count(X,T,N).
                                                                                                                        Второе

                                                                                                                        ExpandedWrap disabled
                                                                                                                          domains
                                                                                                                          li=integer*
                                                                                                                           
                                                                                                                          predicates
                                                                                                                          count(integer,li,integer)
                                                                                                                          del(integer,li,li)
                                                                                                                          max(li,integer)
                                                                                                                          p2(li,li)
                                                                                                                           
                                                                                                                          goal
                                                                                                                          clearwindow,
                                                                                                                          p2([3,2,1,2,1,2,1,3,1],[1]), write("yes");
                                                                                                                          write("no").
                                                                                                                           
                                                                                                                           
                                                                                                                          clauses
                                                                                                                          p2(_,[]):-!.
                                                                                                                          p2(L,[H|T]):-
                                                                                                                            max(L,N),!,
                                                                                                                            count(H,L,N),
                                                                                                                            p2(L,T).
                                                                                                                           
                                                                                                                          max([],0):-!.
                                                                                                                          max([H|T],N):-
                                                                                                                            count(H,[H|T],N1),
                                                                                                                            del(H,T,T1),
                                                                                                                            max(T1,N),
                                                                                                                            N>=N1.
                                                                                                                          max([H|T],N):-
                                                                                                                            count(H,[H|T],N).  
                                                                                                                           
                                                                                                                          del(_,[],[]):-!.
                                                                                                                          del(H,[H|T],T1):-
                                                                                                                            del(H,T,T1),!.
                                                                                                                          del(X,[H|T],[H|T1]):-
                                                                                                                            del(X,T,T1).  
                                                                                                                           
                                                                                                                          count(X,[],0):-!.
                                                                                                                          count(H,[H|T],N1):-
                                                                                                                            count(H,T,N),
                                                                                                                            N1=N+1.
                                                                                                                          count(X,[H|T],N):-
                                                                                                                            count(X,T,N).
                                                                                                                          Спасибо огромное!!!
                                                                                                                            Здравствуйте, не могу решить задачу "Вычислить x^n". Вроде должно выглядеть вот так, но в ошибке пишется типа see declrations power. В чём ошибка?
                                                                                                                            ExpandedWrap disabled
                                                                                                                              PREDICATES
                                                                                                                              %первый аргумент - основание степени, второй - показатель степени,
                                                                                                                              % третий - результат
                                                                                                                              power (real, integer, real)
                                                                                                                               
                                                                                                                              CLAUSES
                                                                                                                              %любое число в нулевой степени равно 1
                                                                                                                              power (_, 0, 1):- !.
                                                                                                                              %xn=x(n-1)*x
                                                                                                                              power (X, N, X_powerN):- M=N-1,
                                                                                                                              %в следующей этой строке ошибка
                                                                                                                              power (M, X_powerM),  
                                                                                                                              Xpower_N=Xpower_M*X.
                                                                                                                               
                                                                                                                              GOAL
                                                                                                                              write ("Основание степени? "), readreal (X),
                                                                                                                              write ("Показатель степени? "), readint (N),
                                                                                                                              power (X, N, Result), write (X, " в степени ", N" =", Result).
                                                                                                                              ExpandedWrap disabled
                                                                                                                                p(X,0,1):-!.
                                                                                                                                p(0,X,0):-!.
                                                                                                                                p(X,1,X):-!.
                                                                                                                                p(X,N,R):-
                                                                                                                                  N1=N-1,
                                                                                                                                  p(X,N1,R1),
                                                                                                                                  R=X*R1.
                                                                                                                                Большое спасибо. Работает
                                                                                                                                  Помогите пожалуйста к зачёту, очень надо.
                                                                                                                                  1)добавить к списку заданный элемент и найти длину хвоста списка

                                                                                                                                  2)посчитать сумму ряда, если N дано.
                                                                                                                                  1/((3N-2)(3N+1))

                                                                                                                                  3)задано 3 числа (Х1,У1) (Х2,У2) (Х3,У3)
                                                                                                                                  Найти их взаимное расположение, если:
                                                                                                                                  1)они образуют прямую;
                                                                                                                                  2)они образуют невырожденный треугольник.
                                                                                                                                    ЛИСИКА, с получением зачёта помогают в разделе "Помощь студентам", платно.
                                                                                                                                      Цитата Swetlana @
                                                                                                                                      Второе

                                                                                                                                      ExpandedWrap disabled
                                                                                                                                        domains
                                                                                                                                        li=integer*
                                                                                                                                         
                                                                                                                                        predicates
                                                                                                                                        count(integer,li,integer)
                                                                                                                                        del(integer,li,li)
                                                                                                                                        max(li,integer)
                                                                                                                                        p2(li,li)
                                                                                                                                         
                                                                                                                                        goal
                                                                                                                                        clearwindow,
                                                                                                                                        p2([3,2,1,2,1,2,1,3,1],[1]), write("yes");
                                                                                                                                        write("no").
                                                                                                                                         
                                                                                                                                         
                                                                                                                                        clauses
                                                                                                                                        p2(_,[]):-!.
                                                                                                                                        p2(L,[H|T]):-
                                                                                                                                          max(L,N),!,
                                                                                                                                          count(H,L,N),
                                                                                                                                          p2(L,T).
                                                                                                                                         
                                                                                                                                        max([],0):-!.
                                                                                                                                        max([H|T],N):-
                                                                                                                                          count(H,[H|T],N1),
                                                                                                                                          del(H,T,T1),
                                                                                                                                          max(T1,N),
                                                                                                                                          N>=N1.
                                                                                                                                        max([H|T],N):-
                                                                                                                                          count(H,[H|T],N).  
                                                                                                                                         
                                                                                                                                        del(_,[],[]):-!.
                                                                                                                                        del(H,[H|T],T1):-
                                                                                                                                          del(H,T,T1),!.
                                                                                                                                        del(X,[H|T],[H|T1]):-
                                                                                                                                          del(X,T,T1).  
                                                                                                                                         
                                                                                                                                        count(X,[],0):-!.
                                                                                                                                        count(H,[H|T],N1):-
                                                                                                                                          count(H,T,N),
                                                                                                                                          N1=N+1.
                                                                                                                                        count(X,[H|T],N):-
                                                                                                                                          count(X,T,N).

                                                                                                                                      Swetlana,ввожу p2([3,2,2,1,2,1,2,1,3,1,2],[1]) пишет "да"
                                                                                                                                      или p2([3,2,1,2,1,2,1,3,1,2],[1]),тоже пишет "да"
                                                                                                                                      ((((
                                                                                                                                        PEOPLE NEED HELP!!! Полный завал с прологом! :wall:
                                                                                                                                        Нужно описать предикат P(L1,L2), который истинен если в L2 повторяються только те элементы которые повторяються в L1.
                                                                                                                                        Например L1=[1,2,2,4,6,6,6,3] а L1=[8,4,2,2,6,6,6]
                                                                                                                                        Здесь пролог должен вывести ДА.
                                                                                                                                        Буду рад любой помощи!) :(
                                                                                                                                          Здравствуйте, помогите пожалуйста решить хоть что-нибудь из этого? Prolog
                                                                                                                                          Заранее огромное спасибо)


                                                                                                                                          1) Родственные отношения. Имеется N объектов и заданы отношения между
                                                                                                                                          ними: родитель, мужчина, женщина. Требуется определить новое отношение (в
                                                                                                                                          задании указано жирным шрифтом) и выявить круг лиц, ему удовлетворяющих.

                                                                                                                                          Определить предикат потомок и найти всех потомков и потомков конкретного
                                                                                                                                          лица.

                                                                                                                                          2) Логические головоломки. Написать программу на языке Prolog, реализующую
                                                                                                                                          логическую головоломку.

                                                                                                                                          На международном конгрессе встретились 4 делегата из разных стран.
                                                                                                                                          Каждый из них владел только двумя языками из 4 (английский, французский,
                                                                                                                                          итальянский и немецкий). Однако оказалось, что не было такого языка, на
                                                                                                                                          котором они могли бы разговаривать вчетвером. И только был один язык, на
                                                                                                                                          котором могли вести беседу трое из них. Никто из делегатов не владеет
                                                                                                                                          французским и немецким языками одновременно. Хотя физик не говорит по-
                                                                                                                                          английски, он может служить переводчиком, если математик и биолог
                                                                                                                                          захотят поговорить друг с другом. Биолог говорит по-немецки и может
                                                                                                                                          говорить с химиком, хотя тот не знает немецкого. Физик, математик и химик
                                                                                                                                          не могут беседовать втроем на одном языке.
                                                                                                                                          ? Какими двумя языками владеет каждый из них ?

                                                                                                                                          3) Логические головоломки. Написать программу на языке Prolog, реализующую
                                                                                                                                          логическую головоломку.

                                                                                                                                          Корнеев, Докшин, Мареев и Скобелев – жители нашего города. Их профессии –
                                                                                                                                          пекарь, врач, инженер и милиционер. Корнеев и Докшин – соседи и всегда на
                                                                                                                                          работу ездят вместе. Докшин старше Мареева. Корнеев регулярно обыгрывает
                                                                                                                                          Скобелева в пинг-понг. Пекарь на работу всегда ходит пешком. Милиционер не
                                                                                                                                          живет с врачом. Инженер и милиционер встречались единожды, когда
                                                                                                                                          милиционер оштрафовал инженера за нарушение правил. Милиционер старше
                                                                                                                                          врача и инженера.
                                                                                                                                          ? Определите профессии ?

                                                                                                                                          4) Списки. Задан список целых чисел L.

                                                                                                                                          Сформировать список L1 из элементов: минимальный элемент всего списка L,
                                                                                                                                          минимальный элемент из последних n-1 элементов L и т.д.

                                                                                                                                          5) Список структур
                                                                                                                                          Сформировать список структур. Предусмотреть предикат, дополняющий этот список
                                                                                                                                          информацией, вводимой с клавиатуры. Сформировать из исходного списка новый список
                                                                                                                                          структур и вывести его на экран.
                                                                                                                                          Определены структуры «дата рождения», «Ф.И.О.» (фамилия, имя, отчество),
                                                                                                                                          «персона» (Ф.И.О., дата рождения) и «супруги» (Ф.И.О., Ф.И.О.). Заданы N лиц,
                                                                                                                                          информация о которых представлена в виде фактов, содержащих структуры «персона»
                                                                                                                                          или «супруги».

                                                                                                                                          Найти все тупоугольные треугольники.
                                                                                                                                            Помогите решить задачу в Turbo Prolog

                                                                                                                                            Задайте отношение между числами a, b и x, так чтобы х являлось корнем уравнения ax+b=0.

                                                                                                                                            Зарание блпгодарен !!!
                                                                                                                                              f(0,0,_):-
                                                                                                                                              write("any x"),!.
                                                                                                                                              f(0,B,_):-
                                                                                                                                              write("No solution"),!.
                                                                                                                                              f(A,B,X):-
                                                                                                                                              X=-B/A,
                                                                                                                                              write("x=",X).
                                                                                                                                                Цитата Swetlana @
                                                                                                                                                f(0,0,_):-
                                                                                                                                                write("any x"),!.
                                                                                                                                                f(0,B,_):-
                                                                                                                                                write("No solution"),!.
                                                                                                                                                f(A,B,X):-
                                                                                                                                                X=-B/A,
                                                                                                                                                write("x=",X).

                                                                                                                                                Это я так понимаю раздел clauses ???
                                                                                                                                                А в predicates что нужно написать ???
                                                                                                                                                  Вроде задание звучит задайте отношение.

                                                                                                                                                  ExpandedWrap disabled
                                                                                                                                                    predicates
                                                                                                                                                    f(real,real,real)
                                                                                                                                                     
                                                                                                                                                    goal
                                                                                                                                                    write("a="), readreal(A), nl,
                                                                                                                                                    write("b="), readreal(B), nl, f(A,B,X).
                                                                                                                                                     
                                                                                                                                                    clauses
                                                                                                                                                    f(0,0,_):-
                                                                                                                                                    write("any x"),!.
                                                                                                                                                     
                                                                                                                                                    f(0,B,_):-
                                                                                                                                                    write("No solution"),!.
                                                                                                                                                     
                                                                                                                                                    f(A,B,X):-
                                                                                                                                                    X=-B/A,
                                                                                                                                                    write("x=",X).
                                                                                                                                                    Swetlana
                                                                                                                                                    Спасибо большое за помощь
                                                                                                                                                      Задача - вычислить длину списка, т.е. количество элементов в списке. Исходные данные берутся из БД.
                                                                                                                                                      Мое решение:
                                                                                                                                                      ExpandedWrap disabled
                                                                                                                                                        domains
                                                                                                                                                            list=integer*
                                                                                                                                                            num=integer
                                                                                                                                                        database
                                                                                                                                                            length(list)
                                                                                                                                                        predicates
                                                                                                                                                            length_inp(list, num)
                                                                                                                                                            start  
                                                                                                                                                        clauses
                                                                                                                                                        start:-
                                                                                                                                                            consult("db.ddb"),
                                                                                                                                                            readterm(list,length(list)),
                                                                                                                                                            length_inp([], 0).
                                                                                                                                                            length_inp([_|T], L) :-
                                                                                                                                                                      length_inp(T, L_T),
                                                                                                                                                                      L = L_T + 1.
                                                                                                                                                        goal
                                                                                                                                                            start,
                                                                                                                                                            length_inp(_, L),
                                                                                                                                                            write(L).

                                                                                                                                                      Не знаю как связать базу данных и предикаты. Жду помощи. Заранее благодарен!
                                                                                                                                                        Доброго времени суток!
                                                                                                                                                        Необходимо реализовать программу, реализующую предикат concat с помощью repeat-цикла.
                                                                                                                                                        Сейчас есть что-то такое:
                                                                                                                                                        ExpandedWrap disabled
                                                                                                                                                          concat(X, Y, Res) :- Res = X, repeat, concat_ext(X, Y, Res), !.
                                                                                                                                                          concat_ext (X, [], Res).
                                                                                                                                                          concat_ext (X, Y, [El | Res]) :- getLastElement(Y, YNew, El), fail.
                                                                                                                                                           
                                                                                                                                                          repeat.
                                                                                                                                                          repeat :- repeat.

                                                                                                                                                        Вот. concat_ext - совершает действия по объединению списков. Если возвращает true (собрали новый список полностью) - выполнение цикла прекращается. Если список не пуст, по идее, нужно отрезать у него крайний элемент, соединить со списомом Res и вернуть на уровень выше. Так до тех пор, пока список не станет пустым.
                                                                                                                                                        Но теперь проблема: как в цикл вернуть список, у которого мы отрезали крайний элемент?
                                                                                                                                                        Или я чего-то не понимаю, или ошибочно спроектировал программу. Везде примеры repeat-циклов, которые не возвращают значений, а только выполняют какие-либо действия (вроде - считать и распечатать).
                                                                                                                                                        Прошу подсказать в чем проблема. Заранее спасибо!
                                                                                                                                                          помогите пожалуйста с турбопрологом :wall:
                                                                                                                                                          Для произвольных чисел a,b,c, определить количество действительных корней уравнения.
                                                                                                                                                            Помогите переделать код, чтобы было 2 игрока, а не игрок и компьютер. турбо пролог 2.0
                                                                                                                                                            Мною это непостижимо...

                                                                                                                                                            [HIGHLIGHT="prolog"]database
                                                                                                                                                            db(integer,integer,symbol)
                                                                                                                                                            Predicates
                                                                                                                                                            predicates
                                                                                                                                                            pole
                                                                                                                                                            go(integer,symbol,symbol)
                                                                                                                                                            protect(symbol,symbol)
                                                                                                                                                            type(integer,symbol)
                                                                                                                                                            etc(symbol,symbol)
                                                                                                                                                            goal
                                                                                                                                                            write("who starts?"),nl, write("1 - I, 0 - Computer."),
                                                                                                                                                            readint(Who),write("type?"),nl,write("1 - X, 0 - O."),
                                                                                                                                                            readint(What),type(What,I1),etc(I1,I2),go(Who,I1,I2),!,
                                                                                                                                                            nl,nl; write("Error."),nl.
                                                                                                                                                            clauses
                                                                                                                                                            db(1,1,"-"). db(1,2,"-"). db(1,3,"-"). db(2,1,"-").db(2,2,"-").
                                                                                                                                                            db(2,3,"-"). db(3,1,"-"). db(3,2,"-"). db(3,3,"-").

                                                                                                                                                            type(1,x). type(0,o). etc(x,o). etc(o,x).

                                                                                                                                                            go(0,Comp,_):- protect(Comp,Comp),!,pole,nl,write("You are a loser.").
                                                                                                                                                            go(0,Comp,You):- protect(Comp,You),!,pole,go(1,You,Comp).
                                                                                                                                                            go(0,Comp,You):- retract(db(2,2,"-")),!,assert(db(2,2,Comp)),
                                                                                                                                                            pole,go(1,You,Comp).
                                                                                                                                                            go(0,Comp,You):- db(R,St,"-"), (R+St) mod 2=0,retract(db(R,St,"-")),!,
                                                                                                                                                            assert(db(R,St,Comp)),pole,go(1,You,Comp).
                                                                                                                                                            go(0,Comp,You):- retract(db(R,St,"-")),!,assert(db(R,St,Comp)),
                                                                                                                                                            pole,go(1,You,Comp).
                                                                                                                                                            go(1,You,Comp):- db(_,_,"-"),write("next:","line (ot 1 do 3): "),
                                                                                                                                                            readint®,R>0,R<4,write("column (ot 1 do 3): "),
                                                                                                                                                            readint(St),St>0,St<4,retract(db(R,St,"-")),!,
                                                                                                                                                            assert(db(R,St,You)),go(0,Comp,You).
                                                                                                                                                            go(_,_,_):- not(db(_,_,"-")),nl,write("Draw.").

                                                                                                                                                            protect(Comp,You):- db(N1,St,You),db(N2,St,You),N1<>N2,
                                                                                                                                                            retract(db(N3,St,"-")),!,assert(db(N3,St,Comp));
                                                                                                                                                            db(R,N1,You),db(R,N2,You),N1<>N2,retract(db(R,N3,"-")),!,
                                                                                                                                                            assert(db(R,N3,Comp));
                                                                                                                                                            db(I,I1,You),I=I1,db(J,J1,You),J=J1,I<>J,db(K,K1,"-"),K=K1,
                                                                                                                                                            retract(db(K,K1,"-")),!,assert(db(K,K1,Comp));
                                                                                                                                                            db(I,J,You),I+J=4,db(N,K,You),N<>I,N+K=4,db(M,L,"-"),M+L=4,
                                                                                                                                                            retract(db(M,L,"-")),!,assert(db(M,L,Comp)).

                                                                                                                                                            pole:- db(1,1,S1),db(1,2,S2),db(1,3,S3),db(2,1,S4),db(2,2,S5),
                                                                                                                                                            db(2,3,S6),db(3,1,S7),db(3,2,S8),db(3,3,S9),!,nl,nl,
                                                                                                                                                            write(S1,S2,S3),nl,write(S4,S5,S6),nl,write(S7,S8,S9),nl,nl.
                                                                                                                                                            [/HIGHLIGHT]

                                                                                                                                                            Добавлено
                                                                                                                                                            Это код игры крестики нолики.Помогите переделать код, чтобы было 2 игрока, а не игрок и компьютер. турбо пролог 2.0
                                                                                                                                                            Мною это непостижимо...

                                                                                                                                                            ExpandedWrap disabled
                                                                                                                                                              database
                                                                                                                                                              db(integer,integer,symbol)  
                                                                                                                                                              Predicates
                                                                                                                                                              predicates
                                                                                                                                                              pole
                                                                                                                                                              go(integer,symbol,symbol)
                                                                                                                                                              protect(symbol,symbol)
                                                                                                                                                              type(integer,symbol)    
                                                                                                                                                              etc(symbol,symbol)
                                                                                                                                                              goal
                                                                                                                                                              write("who starts?"),nl, write("1 - I, 0 - Computer."),
                                                                                                                                                              readint(Who),write("type?"),nl,write("1 - X, 0 - O."),
                                                                                                                                                              readint(What),type(What,I1),etc(I1,I2),go(Who,I1,I2),!,
                                                                                                                                                              nl,nl; write("Error."),nl.
                                                                                                                                                              clauses
                                                                                                                                                              db(1,1,"-"). db(1,2,"-"). db(1,3,"-"). db(2,1,"-").db(2,2,"-").
                                                                                                                                                              db(2,3,"-"). db(3,1,"-"). db(3,2,"-"). db(3,3,"-").
                                                                                                                                                               
                                                                                                                                                              type(1,x). type(0,o). etc(x,o). etc(o,x).
                                                                                                                                                               
                                                                                                                                                              go(0,Comp,_):- protect(Comp,Comp),!,pole,nl,write("You are a loser.").
                                                                                                                                                              go(0,Comp,You):- protect(Comp,You),!,pole,go(1,You,Comp).
                                                                                                                                                              go(0,Comp,You):- retract(db(2,2,"-")),!,assert(db(2,2,Comp)),
                                                                                                                                                                pole,go(1,You,Comp).
                                                                                                                                                              go(0,Comp,You):- db(R,St,"-"), (R+St) mod 2=0,retract(db(R,St,"-")),!,
                                                                                                                                                                assert(db(R,St,Comp)),pole,go(1,You,Comp).
                                                                                                                                                              go(0,Comp,You):- retract(db(R,St,"-")),!,assert(db(R,St,Comp)),
                                                                                                                                                                pole,go(1,You,Comp).
                                                                                                                                                              go(1,You,Comp):- db(_,_,"-"),write("next:","line (ot 1 do 3): "),
                                                                                                                                                                readint(R),R>0,R<4,write("column (ot 1 do 3): "),
                                                                                                                                                                readint(St),St>0,St<4,retract(db(R,St,"-")),!,
                                                                                                                                                                assert(db(R,St,You)),go(0,Comp,You).
                                                                                                                                                              go(_,_,_):- not(db(_,_,"-")),nl,write("Draw.").
                                                                                                                                                               
                                                                                                                                                              protect(Comp,You):- db(N1,St,You),db(N2,St,You),N1<>N2,
                                                                                                                                                                retract(db(N3,St,"-")),!,assert(db(N3,St,Comp));
                                                                                                                                                                db(R,N1,You),db(R,N2,You),N1<>N2,retract(db(R,N3,"-")),!,
                                                                                                                                                                assert(db(R,N3,Comp));
                                                                                                                                                                db(I,I1,You),I=I1,db(J,J1,You),J=J1,I<>J,db(K,K1,"-"),K=K1,
                                                                                                                                                                retract(db(K,K1,"-")),!,assert(db(K,K1,Comp));
                                                                                                                                                                db(I,J,You),I+J=4,db(N,K,You),N<>I,N+K=4,db(M,L,"-"),M+L=4,
                                                                                                                                                                retract(db(M,L,"-")),!,assert(db(M,L,Comp)).
                                                                                                                                                               
                                                                                                                                                              pole:- db(1,1,S1),db(1,2,S2),db(1,3,S3),db(2,1,S4),db(2,2,S5),
                                                                                                                                                                db(2,3,S6),db(3,1,S7),db(3,2,S8),db(3,3,S9),!,nl,nl,
                                                                                                                                                                write(S1,S2,S3),nl,write(S4,S5,S6),nl,write(S7,S8,S9),nl,nl.
                                                                                                                                                              Помогите решить задачу в пролог:
                                                                                                                                                              Проверить встречается ли в списке четный элемент.Заранее спасибо..
                                                                                                                                                                Цитата NIKAAA @
                                                                                                                                                                Помогите решить задачу в пролог:
                                                                                                                                                                Проверить встречается ли в списке четный элемент.Заранее спасибо..

                                                                                                                                                                ExpandedWrap disabled
                                                                                                                                                                  domains
                                                                                                                                                                  list = integer*
                                                                                                                                                                  predicates
                                                                                                                                                                  find(list,integer)
                                                                                                                                                                   
                                                                                                                                                                  goal
                                                                                                                                                                  find([5,5,20,5],X), write(X).
                                                                                                                                                                   
                                                                                                                                                                  clauses
                                                                                                                                                                    
                                                                                                                                                                  find([H|T],H):-
                                                                                                                                                                    H mod 2 =0,!.
                                                                                                                                                                  find([_|T],Y):-    
                                                                                                                                                                    find(T,Y).
                                                                                                                                                                  Помогите с задачей на Турбо Пролог:
                                                                                                                                                                  За квадратным столом сидят 4 студента. Филолог сидит напротив Козыря, рядом с историком. Биолог сидит рядом с Волдайским. Соседи Шадрова - Егоркин и химик. Напротив кого сидит историк?

                                                                                                                                                                  Буду премного благодарна!
                                                                                                                                                                    огромнейшее человеческое спасибо)))
                                                                                                                                                                      Здравствуйте, никак не получается объединить 2 списка и найти и удалить максимальный элемент из него.
                                                                                                                                                                      Помогите пожалуйста.


                                                                                                                                                                      ExpandedWrap disabled
                                                                                                                                                                        Domains
                                                                                                                                                                            type=integer
                                                                                                                                                                            list=type*
                                                                                                                                                                        Predicates
                                                                                                                                                                            append(list,list,list)
                                                                                                                                                                                nondeterm max(list,integer)
                                                                                                                                                                        Clauses
                                                                                                                                                                            append([],L,L):-!.
                                                                                                                                                                            append([H|T],P,[H|Y]):-append(T,P,Y).
                                                                                                                                                                                max([X],X).
                                                                                                                                                                                max([H|Tail],H):-max(Tail,M),H>M,!.
                                                                                                                                                                                max([_|Tail],M):-max(Tail,M).


                                                                                                                                                                      совсем неправильно делаю? поправьте пожалуйста.
                                                                                                                                                                        Crazy_meat, всё правильно, только предикат max детерминированный.
                                                                                                                                                                        max([X],X):-!.
                                                                                                                                                                        max([H|Tail],H):-max(Tail,M),H>M,!.
                                                                                                                                                                        max([_|Tail],M):-max(Tail,M).

                                                                                                                                                                        И удаление не сделано. Щас свою программку напишу.

                                                                                                                                                                        Добавлено
                                                                                                                                                                        ExpandedWrap disabled
                                                                                                                                                                          domains
                                                                                                                                                                          list = integer*
                                                                                                                                                                           
                                                                                                                                                                          predicates
                                                                                                                                                                          conc(list,list,list)
                                                                                                                                                                          max(list,integer)
                                                                                                                                                                          del_max(list,list)
                                                                                                                                                                           
                                                                                                                                                                          goal
                                                                                                                                                                           L1=[1,2,30], L2=[4,5,6],
                                                                                                                                                                           conc(L1,L2,L),
                                                                                                                                                                           del_max(L,P),write(P),nl.
                                                                                                                                                                           
                                                                                                                                                                          clauses
                                                                                                                                                                          conc([],L,L):-!.
                                                                                                                                                                          conc([H|T],L,[H|T1]):-
                                                                                                                                                                            conc(T,L,T1).
                                                                                                                                                                            
                                                                                                                                                                          max([X],X):-!.
                                                                                                                                                                          max([H|T],H):-
                                                                                                                                                                            max(T,X),
                                                                                                                                                                            H>=X,!.
                                                                                                                                                                          max([H|T],X):-
                                                                                                                                                                            max(T,X).
                                                                                                                                                                           
                                                                                                                                                                          del_max([_],[]):-!.
                                                                                                                                                                          del_max([H|T],T):-
                                                                                                                                                                            max([H|T],H),!.
                                                                                                                                                                          del_max([H|T],[H|T1]):-
                                                                                                                                                                            del_max(T,T1).
                                                                                                                                                                          Swetlana,
                                                                                                                                                                          Огромное Спасибо)
                                                                                                                                                                            Цитата Ryslanka @
                                                                                                                                                                            огромнейшее человеческое спасибо)))

                                                                                                                                                                            Неправильно решила, сори. Только половину условий перечислила, т.к. тут симметрия.
                                                                                                                                                                            То есть пишу, что напротив Козыря сидит филолог
                                                                                                                                                                            sosed_naprotiv("kozir",Y2,X2,"filolog")
                                                                                                                                                                            и тут же надо симметрично записать, что напротив филолога сидит Козырь
                                                                                                                                                                            sosed_naprotiv(X1,"filolog",'kozir",Y2)
                                                                                                                                                                            Можно, конечно, и пооптимальней написать, но уже правильно работает, выдаёт единственное решение
                                                                                                                                                                            Волдайский химик

                                                                                                                                                                            ExpandedWrap disabled
                                                                                                                                                                              domains
                                                                                                                                                                                list = symbol*
                                                                                                                                                                               
                                                                                                                                                                              predicates
                                                                                                                                                                              member(symbol,list)
                                                                                                                                                                              check(symbol,symbol,symbol,symbol)
                                                                                                                                                                              sosed_naprotiv1(symbol,symbol,symbol,symbol)
                                                                                                                                                                              sosed_naprotiv11(symbol,symbol,symbol,symbol)
                                                                                                                                                                              sosed_naprotiv2(symbol,symbol,symbol,symbol)
                                                                                                                                                                              sosed_naprotiv22(symbol,symbol,symbol,symbol)
                                                                                                                                                                              sosed_naprotiv3(symbol,symbol,symbol,symbol)
                                                                                                                                                                              sosed_naprotiv33(symbol,symbol,symbol,symbol)
                                                                                                                                                                              sosed_naprotiv4(symbol,symbol,symbol,symbol)
                                                                                                                                                                              sosed_naprotiv44(symbol,symbol,symbol,symbol)
                                                                                                                                                                              sosed_naprotiv5(symbol,symbol,symbol,symbol)
                                                                                                                                                                               
                                                                                                                                                                              clauses
                                                                                                                                                                              sosed_naprotiv1("kozir",Y1,X2,"filolog"):-
                                                                                                                                                                                Y1<>"filolog", Y1<>"istorik".
                                                                                                                                                                              sosed_naprotiv1(X1,Y1,X2,Y2):-
                                                                                                                                                                                X1<>"kozir".
                                                                                                                                                                                
                                                                                                                                                                              sosed_naprotiv11(X1,"filolog","kozir",Y2):-
                                                                                                                                                                                Y2<>"filolog", Y2<>"istorik".
                                                                                                                                                                              sosed_naprotiv11(X1,Y1,X2,Y2):-
                                                                                                                                                                                X2<>"kozir".
                                                                                                                                                                               
                                                                                                                                                                              sosed_naprotiv5(X1,"filolog",X2,Y2):-
                                                                                                                                                                                Y2<>"istorik".
                                                                                                                                                                              sosed_naprotiv5(X1,Y1,X2,Y2):-
                                                                                                                                                                                Y1<>"filolog".  
                                                                                                                                                                                    
                                                                                                                                                                              sosed_naprotiv2("voldajsky",Y1,X2,Y2):-
                                                                                                                                                                                Y2<>"biolog", Y1<>"biolog".
                                                                                                                                                                              sosed_naprotiv2(X1,Y1,X2,Y2):-
                                                                                                                                                                                X1<>"voldajsky".
                                                                                                                                                                               
                                                                                                                                                                              sosed_naprotiv22(X1,Y1,"voldajsky",Y2):-
                                                                                                                                                                                Y2<>"biolog", Y1<>"biolog".
                                                                                                                                                                              sosed_naprotiv22(X1,Y1,X2,Y2):-
                                                                                                                                                                                X2<>"voldajsky".
                                                                                                                                                                                
                                                                                                                                                                              sosed_naprotiv3("shadrov",Y1,X2,Y2):-
                                                                                                                                                                                Y2<>"himik", Y1<>"himik", X2<>"egorkin".
                                                                                                                                                                              sosed_naprotiv3(X1,Y1,X2,Y2):-
                                                                                                                                                                                X1<>"shadrov".
                                                                                                                                                                                
                                                                                                                                                                              sosed_naprotiv33(X1,Y1,"shadrov",Y2):-
                                                                                                                                                                                Y2<>"himik", Y1<>"himik", X1<>"egorkin".
                                                                                                                                                                              sosed_naprotiv33(X1,Y1,X2,Y2):-
                                                                                                                                                                                X2<>"shadrov".
                                                                                                                                                                               
                                                                                                                                                                              sosed_naprotiv4("egorkin",Y1,X2,"himik"):-  
                                                                                                                                                                                Y1<>"himik", X2<>"shadrov".  
                                                                                                                                                                              sosed_naprotiv4(X1,Y1,X2,Y2):-
                                                                                                                                                                                X1<>"egorkin".
                                                                                                                                                                                
                                                                                                                                                                              sosed_naprotiv44(X1,"himik","egorkin",Y2):-  
                                                                                                                                                                                Y2<>"himik", X1<>"shadrov".  
                                                                                                                                                                              sosed_naprotiv44(X1,Y1,X2,Y2):-
                                                                                                                                                                                X2<>"egorkin".  
                                                                                                                                                                               
                                                                                                                                                                              check(X1,Y1,X2,Y2):-
                                                                                                                                                                                 sosed_naprotiv1(X1,Y1,X2,Y2),
                                                                                                                                                                                 sosed_naprotiv11(X1,Y1,X2,Y2),
                                                                                                                                                                                 sosed_naprotiv5(X1,Y1,X2,Y2),
                                                                                                                                                                                 sosed_naprotiv2(X1,Y1,X2,Y2),
                                                                                                                                                                                 sosed_naprotiv22(X1,Y1,X2,Y2),
                                                                                                                                                                                 sosed_naprotiv3(X1,Y1,X2,Y2),
                                                                                                                                                                                 sosed_naprotiv33(X1,Y1,X2,Y2),
                                                                                                                                                                                 sosed_naprotiv4(X1,Y1,X2,Y2),
                                                                                                                                                                                 sosed_naprotiv44(X1,Y1,X2,Y2).
                                                                                                                                                                                
                                                                                                                                                                              member(H,[H|T]).
                                                                                                                                                                              member(X,[_|T]):-
                                                                                                                                                                                member(X,T).      
                                                                                                                                                                               
                                                                                                                                                                              goal
                                                                                                                                                                              clearwindow,
                                                                                                                                                                              member(X1,["kozir","voldajsky","shadrov","egorkin"]),
                                                                                                                                                                              member(X2,["kozir","voldajsky","shadrov","egorkin"]),
                                                                                                                                                                              X1<>X2,
                                                                                                                                                                              member(Y1,["filolog","biolog","himik"]),
                                                                                                                                                                              check(X1,Y1,X2,"istorik"),
                                                                                                                                                                              write(X1,'-',Y1," ",X2,"-","istorik"),nl.
                                                                                                                                                                              Друзья, прошу помощи в решении задач:
                                                                                                                                                                              Задание 1

                                                                                                                                                                              Вычислить сумму кодов символов, вводимых с клавиатуры, до
                                                                                                                                                                              ввода символа "К". Результат показать в другом окне.


                                                                                                                                                                              Лабораторная работа 2

                                                                                                                                                                              Определение породы собак. Экспертная система.

                                                                                                                                                                              Используются следующие характеристики:

                                                                                                                                                                              1. Короткая шерсть
                                                                                                                                                                              2. Длинная шерсть
                                                                                                                                                                              3. Рост меньше 65 см.
                                                                                                                                                                              4. Рост меньше 80 см.
                                                                                                                                                                              5. Низко посаженный хвост
                                                                                                                                                                              6. Длинные уши
                                                                                                                                                                              7. Хороший характер
                                                                                                                                                                              8. Вес больше 5 кг.

                                                                                                                                                                              Для каждой породы свойственны различные характеристики

                                                                                                                                                                              1. Английский бульдог 1,3,5,7
                                                                                                                                                                              2. Гончая 1,3,6,7
                                                                                                                                                                              3. Дог 1,4,6,7,8
                                                                                                                                                                              4. Американский фокстерьер 1,5,6,7
                                                                                                                                                                              5. Коккер-спаниель 2,3,5,6,7
                                                                                                                                                                              6. Ирландский сеттер 2,4,6
                                                                                                                                                                              7. Колли 2,4,5,7
                                                                                                                                                                              8. Сенбернар 2,5,7,8
                                                                                                                                                                                Приветствую всех участников форума! Очень надеюсь на вашу помощь:
                                                                                                                                                                                Написал программу а она выводит много решений при подстановке
                                                                                                                                                                                ExpandedWrap disabled
                                                                                                                                                                                  fail
                                                                                                                                                                                после вывода ответа!

                                                                                                                                                                                Помогите разобраться. Мне сказали что надо списки поправить в задаче.
                                                                                                                                                                                Вот она собственно:
                                                                                                                                                                                ExpandedWrap disabled
                                                                                                                                                                                  domains
                                                                                                                                                                                  person=p(string,string,string)
                                                                                                                                                                                  persons=person*
                                                                                                                                                                                   
                                                                                                                                                                                  predicates
                                                                                                                                                                                  member(person,persons)
                                                                                                                                                                                  flower(string)
                                                                                                                                                                                  dom(string)
                                                                                                                                                                                  name(string)
                                                                                                                                                                                  solve
                                                                                                                                                                                   
                                                                                                                                                                                  clauses
                                                                                                                                                                                  member(H,[H|_]):-!.
                                                                                                                                                                                  member(X,[_|T]):-
                                                                                                                                                                                  member(X,T).
                                                                                                                                                                                   
                                                                                                                                                                                  flower("Rosy").
                                                                                                                                                                                  flower("Romash").
                                                                                                                                                                                  flower("Tulp").
                                                                                                                                                                                  name("Nif").
                                                                                                                                                                                  name("Nuf").
                                                                                                                                                                                  name("Naf").
                                                                                                                                                                                  dom("Solom").
                                                                                                                                                                                  dom("Derev").
                                                                                                                                                                                  dom("Kirp").
                                                                                                                                                                                  solve:-
                                                                                                                                                                                  dom(NifD),
                                                                                                                                                                                  flower(NifF),
                                                                                                                                                                                  NifD<>"Solom",
                                                                                                                                                                                  dom(NafD),
                                                                                                                                                                                  flower(NafF),
                                                                                                                                                                                  NafF<>NifF,
                                                                                                                                                                                  NafF<>"Tulp",
                                                                                                                                                                                  NafF<>"Romash",
                                                                                                                                                                                  NafD<>"Derev", NafD<>NifD,
                                                                                                                                                                                  dom(NufD),
                                                                                                                                                                                  flower(NufF),
                                                                                                                                                                                  NufF<>NafF,NufF<>NifF,
                                                                                                                                                                                  NufD<>NafD, NufD<>NifD,
                                                                                                                                                                                   
                                                                                                                                                                                   
                                                                                                                                                                                  Prs=[p(NifD,NifF,"Nif"),
                                                                                                                                                                                      p(NafD,NafF,"Naf"),
                                                                                                                                                                                      p(NufD,NufF,"Nuf")],
                                                                                                                                                                                      
                                                                                                                                                                                  member(p("Derev","Romash",_),Prs),
                                                                                                                                                                                  member(p("Solom",_,_),Prs),
                                                                                                                                                                                  member(p(_,"Rosy",_),Prs),
                                                                                                                                                                                   
                                                                                                                                                                                  write(NifD,NifF,"Nif"),nl,
                                                                                                                                                                                  write(NafD,NafF,"Naf"),nl,
                                                                                                                                                                                  write(NufD,NufF,"Nuf"),nl,fail.
                                                                                                                                                                                   
                                                                                                                                                                                   
                                                                                                                                                                                  goal
                                                                                                                                                                                  solve.


                                                                                                                                                                                Условия:
                                                                                                                                                                                Имеем три поросенка одноименных, три их домика из соломы, дерева и кирпича, и цветы около домиков: розы, ромашки, тюльпаны!

                                                                                                                                                                                Знаем: Ниф не в соломенном,
                                                                                                                                                                                Наф не в деревянном,
                                                                                                                                                                                Возле соломеннго дома не розы,
                                                                                                                                                                                Возле деревянного растут ромашки,
                                                                                                                                                                                У Нафа не тюльпаны около дома.

                                                                                                                                                                                Ну и соответственно надо вывести кто где живет и какие цветы выращивает.

                                                                                                                                                                                В общем в приведенной задаче выводится много ответов, думаю список или предикат member не так задал...
                                                                                                                                                                                  Цитата night_amir @
                                                                                                                                                                                  Лабораторная работа 2

                                                                                                                                                                                  Определение породы собак. Экспертная система.

                                                                                                                                                                                  Используются следующие характеристики:

                                                                                                                                                                                  1. Короткая шерсть
                                                                                                                                                                                  2. Длинная шерсть
                                                                                                                                                                                  3. Рост меньше 65 см.
                                                                                                                                                                                  4. Рост меньше 80 см.
                                                                                                                                                                                  5. Низко посаженный хвост
                                                                                                                                                                                  6. Длинные уши
                                                                                                                                                                                  7. Хороший характер
                                                                                                                                                                                  8. Вес больше 5 кг.

                                                                                                                                                                                  Для каждой породы свойственны различные характеристики

                                                                                                                                                                                  1. Английский бульдог 1,3,5,7
                                                                                                                                                                                  2. Гончая 1,3,6,7
                                                                                                                                                                                  3. Дог 1,4,6,7,8
                                                                                                                                                                                  4. Американский фокстерьер 1,5,6,7
                                                                                                                                                                                  5. Коккер-спаниель 2,3,5,6,7
                                                                                                                                                                                  6. Ирландский сеттер 2,4,6
                                                                                                                                                                                  7. Колли 2,4,5,7
                                                                                                                                                                                  8. Сенбернар 2,5,7,8

                                                                                                                                                                                  ExpandedWrap disabled
                                                                                                                                                                                     
                                                                                                                                                                                           /* Џа®Ја ¬¬ : ќЄбЇҐав Ї® Ї®а®¤ ¬ б®Ў Є  ” ©«:dog.pro    */
                                                                                                                                                                                           /* Ќ §­ зҐ­ЁҐ. „Ґ¬®­бва жЁп а Ў®вл нЄбЇҐав­®© бЁб⥬л,  */
                                                                                                                                                                                           /* Ў §Ёаго饩бп ­  «®ЈЁЄҐ                               */
                                                                                                                                                                                           /* ‡ ¬Ґз ­ЁҐ: нв® бЁб⥬  ¤«п Ё¤Ґ­вЁдЁЄ жЁЁ Ї®а®¤л. Ћ­  */
                                                                                                                                                                                           /* б®бв®Ёв Ё§ Ў §л §­ ­Ё© (Ѓ‡), ¬Ґе ­Ё§¬  ўлў®¤  (Њ‚)   */
                                                                                                                                                                                           /* Ё бЁбвҐ¬л Ї®«м§®ў вҐ«мбЄ®Ј® Ё­вҐадҐ©б  (‘Џ€).        */
                                                                                                                                                                                           /* Ѓ §  §­ ­Ё© а бЇ®« Ј Ґвбп ў ®ЇҐа вЁў­®© Ї ¬пвЁ       */
                                                                                                                                                                                     
                                                                                                                                                                                     
                                                                                                                                                                                                domains
                                                                                                                                                                                     
                                                                                                                                                                                                     CONDITIONS      = BNO *
                                                                                                                                                                                                     HISTORY         = RNO *
                                                                                                                                                                                                     RNO, BNO        = INTEGER
                                                                                                                                                                                                     CATEGORY        = SYMBOL
                                                                                                                                                                                     
                                                                                                                                                                                     
                                                                                                                                                                                                database
                                                                                                                                                                                     
                                                                                                                                                                                                /* ЏаҐ¤ЁЄ вл Ў §л ¤ ­­ле                */
                                                                                                                                                                                     
                                                                                                                                                                                                     rule(RNO, CATEGORY, CATEGORY, CONDITIONS)
                                                                                                                                                                                                     cond(BNO, STRING)
                                                                                                                                                                                                     yes(BNO)
                                                                                                                                                                                                     no(BNO)
                                                                                                                                                                                                     topic(string)
                                                                                                                                                                                     
                                                                                                                                                                                                predicates
                                                                                                                                                                                     
                                                                                                                                                                                                /* ЏаҐ¤ЁЄ вл бЁбвҐ¬л Ї®«м§®ў вҐ«мбЄ®Ј® Ё­вҐадҐ©б   */
                                                                                                                                                                                     
                                                                                                                                                                                     
                                                                                                                                                                                                do_expert_job
                                                                                                                                                                                                show_menu
                                                                                                                                                                                                do_consulting
                                                                                                                                                                                                process(integer)
                                                                                                                                                                                                info(CATEGORY)
                                                                                                                                                                                                goes(CATEGORY)
                                                                                                                                                                                                listopt
                                                                                                                                                                                                clear
                                                                                                                                                                                                eval_reply(HISTORY,char)
                                                                                                                                                                                                printr(HISTORY)
                                                                                                                                                                                                printc(CONDITIONS)
                                                                                                                                                                                                /* ЏаҐ¤ЁЄ вл ¬Ґе ­Ё§¬  ўлў®¤                */
                                                                                                                                                                                     
                                                                                                                                                                                                go(HISTORY, CATEGORY)
                                                                                                                                                                                                check(RNO, HISTORY, CONDITIONS)
                                                                                                                                                                                                inpq(HISTORY, RNO, BNO, STRING)
                                                                                                                                                                                                do_answer(HISTORY, RNO, STRING, BNO, INTEGER)
                                                                                                                                                                                     
                                                                                                                                                                                                goal
                                                                                                                                                                                                     clear,
                                                                                                                                                                                                     do_expert_job.
                                                                                                                                                                                                    
                                                                                                                                                                                     
                                                                                                                                                                                                clauses
                                                                                                                                                                                     
                                                                                                                                                                                                /* Ѓ §  §­ ­Ё© (Ѓ‡)                             */
                                                                                                                                                                                     
                                                                                                                                                                                                topic("dog").
                                                                                                                                                                                                topic("Є®а®вЄ®иҐабв­ п б®Ў Є ").
                                                                                                                                                                                                topic("¤«Ё­­®иҐабв­ п б®Ў Є ").
                                                                                                                                                                                     
                                                                                                                                                                                                rule(1, "dog", "Є®а®вЄ®иҐабв­ п б®Ў Є ", [1] ).
                                                                                                                                                                                                rule(2, "dog", "¤«Ё­­®иҐабв­ п б®Ў Є ", [2]  ).
                                                                                                                                                                                                rule(3, "Є®а®вЄ®иҐабв­ п б®Ў Є "," ­Ј«Ё©бЄЁ© Ўг«м¤®Ј",[3,5,7]).
                                                                                                                                                                                                rule(4, "Є®а®вЄ®иҐабв­ п б®Ў Є ","Ј®­з п",[3,6,7]).
                                                                                                                                                                                                rule(5, "Є®а®вЄ®иҐабв­ п б®Ў Є ","¤ вбЄЁ© ¤®Ј", [5,6,7,8] ).
                                                                                                                                                                                                rule(6, "Є®а®вЄ®иҐабв­ п б®Ў Є "," ¬ҐаЁЄ ­бЄЁ© д®ЄбвҐамҐа",[4,6,7]   ).
                                                                                                                                                                                                rule(7, "¤«Ё­­®иҐабв­ п б®Ў Є ", "Є®ЄЄҐа-бЇ ­Ён«м", [3,5,6,7] ).
                                                                                                                                                                                                rule(8, "¤«Ё­­®иҐабв­ п б®Ў Є ", "Ёа« ­¤бЄЁ© бҐввҐа", [4,6]     ).
                                                                                                                                                                                                rule(9, "¤«Ё­­®иҐабв­ п б®Ў Є ", "Є®««Ё", [4,5,7] ).
                                                                                                                                                                                                rule(10, "¤«Ё­­®иҐабв­ п б®Ў Є ", "ᥭЎҐа­ а", [5,7,8]   ).
                                                                                                                                                                                     
                                                                                                                                                                                     
                                                                                                                                                                                                cond(1,    "Є®а®вЄ®иҐабв­ п б®Ў Є "       ).
                                                                                                                                                                                                cond(2,    "¤«Ё­­®иҐабв­ п б®Ў Є "        ).
                                                                                                                                                                                                cond(3,    "а®бв ¬Ґ­ҐҐ 22 ¤о©¬®ў"         ).
                                                                                                                                                                                                cond(4,    "а®бв ¬Ґ­ҐҐ 30 ¤о©¬®ў"         ).
                                                                                                                                                                                                cond(5,    "­Ё§Є®Ї®б ¦Ґ­­л© ўЁбпзЁ© еў®бв").
                                                                                                                                                                                                cond(6,    "¤«Ё­­лҐ гиЁ"                  ).
                                                                                                                                                                                                cond(7,    "¤®Ўа®¤ги­л© е а ЄвҐа"         ).
                                                                                                                                                                                                cond(8,    "ўҐб Ў®«ҐҐ 100 дг­в®ў"         ).
                                                                                                                                                                                     
                                                                                                                                                                                                /* ‘Ёб⥬  Ї®«м§®ў вҐ«мбЄ®Ј® Ё­вҐадҐ©б             */
                                                                                                                                                                                     
                                                                                                                                                                                                do_expert_job :-
                                                                                                                                                                                                     makewindow(1,63,7," DOG EXPERT SYSTEM ",0,0,25,80),
                                                                                                                                                                                                     show_menu,
                                                                                                                                                                                                     nl,write(" Ќ ¦¬ЁвҐ Їа®ЎҐ«. "),
                                                                                                                                                                                                     readchar(_),
                                                                                                                                                                                                     save("dog.dat"),
                                                                                                                                                                                                     exit.
                                                                                                                                                                                     
                                                                                                                                                                                                show_menu :-
                                                                                                                                                                                                    write("                                       "),nl,
                                                                                                                                                                                                    write(" * * * * * * * * * * * * * * * * *  *  "),nl,
                                                                                                                                                                                                    write(" *          DOG EXPERT              *  "),nl,
                                                                                                                                                                                                    write(" *                                  *  "),nl,
                                                                                                                                                                                                    write(" *    1. Љ®­бг«мв жЁп               *  "),nl,
                                                                                                                                                                                                    write(" *                                  *  "),nl,
                                                                                                                                                                                                    write(" *                                  *  "),nl,
                                                                                                                                                                                                    write(" *    2. ‚л室 Ё§ бЁбвҐ¬л           *  "),nl,
                                                                                                                                                                                                    write(" *                                  *  "),nl,
                                                                                                                                                                                                    write(" * * * * * * * * * * * * * * * * *  *  "),nl,
                                                                                                                                                                                                    write("                                       "),nl,
                                                                                                                                                                                                    write("‚ и ўлЎ®а - 1 or 2 : "),nl,
                                                                                                                                                                                                    readint(Choice),
                                                                                                                                                                                                    process (Choice).
                                                                                                                                                                                     
                                                                                                                                                                                                process(1) :-
                                                                                                                                                                                                     do_consulting,clear.
                                                                                                                                                                                                process(2) :-
                                                                                                                                                                                                     removewindow,
                                                                                                                                                                                                     clear,
                                                                                                                                                                                                     exit.
                                                                                                                                                                                     
                                                                                                                                                                                                do_consulting :-
                                                                                                                                                                                                     goes(Mygoal),
                                                                                                                                                                                                     go([],Mygoal),
                                                                                                                                                                                                     !.
                                                                                                                                                                                                do_consulting :-
                                                                                                                                                                                                     nl, write(" ‘®¦ «Ґо, ­Ґ ¬®Јг ‚ ¬ Ї®¬®зм.").
                                                                                                                                                                                     
                                                                                                                                                                                                goes(Mygoal) :-
                                                                                                                                                                                                     clear,
                                                                                                                                                                                                     clearwindow,
                                                                                                                                                                                                     nl,nl,
                                                                                                                                                                                                     write("                                      "),nl,
                                                                                                                                                                                                     write("   WELCOME TO THE DOG EXPERT SYSTEM   "),nl,
                                                                                                                                                                                                     write("                                      "),nl,
                                                                                                                                                                                                     write("  ќв® - Є« ббЁдЁЄ жЁ®­­ п ќ‘.         "),nl,
                                                                                                                                                                                                     write("  „«п § ЇгбЄ  Їа®жҐбб  ўлЎ®а  б®Ў ЄЁ  "),nl,
                                                                                                                                                                                                     write(" ­ ЎҐаЁвҐ б«®ў® dog. …б«Ё ‚л ¦Ґ« ҐвҐ  "),nl,
                                                                                                                                                                                                     write(" гўЁ¤Ґвм ¤®ЇгбвЁ¬лҐ Ї®а®¤л б®Ў Є,     "),nl,
                                                                                                                                                                                                     write(" ­ ЎҐаЁвҐ §­ Є ў®Їа®б  ?.             "),nl,
                                                                                                                                                                                                     write("                                      "),nl,
                                                                                                                                                                                                     readln(Mygoal),
                                                                                                                                                                                                     info(Mygoal),!.
                                                                                                                                                                                     
                                                                                                                                                                                                info("?") :-!,
                                                                                                                                                                                                     clearwindow,
                                                                                                                                                                                                     listopt,
                                                                                                                                                                                                     nl,write("Ќ ¦¬ЁвҐ Їа®ЎҐ«. "),
                                                                                                                                                                                                     readchar(_),
                                                                                                                                                                                                     clearwindow,
                                                                                                                                                                                                     exit.
                                                                                                                                                                                     
                                                                                                                                                                                                info("dog") :-!.
                                                                                                                                                                                                
                                                                                                                                                                                                info(_) :-
                                                                                                                                                                                                    write("‘®¦ «Ґо, ­® в Є®© вҐ¬л ­Ґв. "),
                                                                                                                                                                                                    nl,write("Ќ ¦¬ЁвҐ Їа®ЎҐ«. "),
                                                                                                                                                                                                    readchar(_),
                                                                                                                                                                                                    clearwindow,
                                                                                                                                                                                                    exit.
                                                                                                                                                                                     
                                                                                                                                                                                                listopt :-
                                                                                                                                                                                                    write("Џ®а®¤л б®Ў Є : "),nl,nl,
                                                                                                                                                                                                    rule(N,_,Dog,_),
                                                                                                                                                                                                    N>=3,
                                                                                                                                                                                                    write("      ",Dog),nl,
                                                                                                                                                                                                    fail.
                                                                                                                                                                                                listopt.
                                                                                                                                                                                     
                                                                                                                                                                                                inpq(HISTORY,RNO,BNO,TEXT) :-
                                                                                                                                                                                                     write("‚®Їа®б :- ",TEXT," ? "),
                                                                                                                                                                                                     makewindow(2,7,7,"Response",10,54,9,24),
                                                                                                                                                                                                     write("‚ўҐ¤ЁвҐ 1, Ґб«Ё '¤ ' ,"),nl,
                                                                                                                                                                                                     write("‚ўҐ¤ЁвҐ 2, Ґб«Ё '­Ґв' : "),nl,
                                                                                                                                                                                                     readint(RESPONSE),
                                                                                                                                                                                                     clearwindow,
                                                                                                                                                                                                     shiftwindow(1),
                                                                                                                                                                                                     do_answer(HISTORY,RNO,TEXT,BNO,RESPONSE).
                                                                                                                                                                                     
                                                                                                                                                                                                eval_reply(HISTORY,'1') :-
                                                                                                                                                                                                   printr(HISTORY),!.
                                                                                                                                                                                                eval_reply(_,_).
                                                                                                                                                                                          
                                                                                                                                                                                                printr([]):-!.
                                                                                                                                                                                                printr([RNO|REST]):-
                                                                                                                                                                                                     rule(RNO,_,_,LIST),
                                                                                                                                                                                                     printc(LIST),
                                                                                                                                                                                                     printr(REST).
                                                                                                                                                                                                
                                                                                                                                                                                                printc([]):-!.
                                                                                                                                                                                                printc([BNO|REST]):-
                                                                                                                                                                                                     cond(BNO,X),
                                                                                                                                                                                                     write(X),nl,
                                                                                                                                                                                                     printc(REST).
                                                                                                                                                                                     
                                                                                                                                                                                    /*               ЊҐе ­Ё§¬ ўлў®¤                        */
                                                                                                                                                                                     
                                                                                                                                                                                                go(HISTORY,Mygoal) :-
                                                                                                                                                                                                     not(rule(_,Mygoal,_,_)),!,
                                                                                                                                                                                                     nl,write(" ќвЁ¬ Є зҐбвў ¬ ᮮ⢥вбвўгҐв Ї®а®¤  ", Mygoal,"."),nl,
                                                                                                                                                                                                     write("‚ ¬ е®вҐ«®бм Ўл г§­ вм, Є Є Ўл« Ї®«г祭 §в®в ўлў®¤ ?(1/2)"),
                                                                                                                                                                                                     nl,readchar(R),
                                                                                                                                                                                                     eval_reply(HISTORY,R).
                                                                                                                                                                                     
                                                                                                                                                                                                go(HISTORY, Mygoal) :-
                                                                                                                                                                                                     rule(RNO,Mygoal,NY,COND),
                                                                                                                                                                                                     check(RNO,HISTORY,COND),
                                                                                                                                                                                                     go([RNO|HISTORY],NY).
                                                                                                                                                                                     
                                                                                                                                                                                                check(RNO,HISTORY,[BNO|REST]) :-
                                                                                                                                                                                                     yes(BNO),!,
                                                                                                                                                                                                     check(RNO,HISTORY,REST).
                                                                                                                                                                                     
                                                                                                                                                                                                check(_,_,[BNO|_]) :- no(BNO),!,fail.
                                                                                                                                                                                     
                                                                                                                                                                                                check(RNO,HISTORY,[BNO|REST]) :-
                                                                                                                                                                                                     cond(BNO,TEXT),
                                                                                                                                                                                                     inpq(HISTORY,RNO,BNO,TEXT),!,
                                                                                                                                                                                                     check(RNO,HISTORY,REST).
                                                                                                                                                                                     
                                                                                                                                                                                                check(_,_,[]).
                                                                                                                                                                                                
                                                                                                                                                                                                do_answer(_,_,_,BNO,1) :-
                                                                                                                                                                                                     assert(yes(BNO)),
                                                                                                                                                                                                     shiftwindow(1),
                                                                                                                                                                                                     write(yes),nl.
                                                                                                                                                                                                do_answer(_,_,_,BNO,2) :-
                                                                                                                                                                                                     assert(no(BNO)),
                                                                                                                                                                                                     write(no),nl,
                                                                                                                                                                                                     fail.
                                                                                                                                                                                     
                                                                                                                                                                                                clear :- retract(yes(_)),fail.
                                                                                                                                                                                                clear :- retract(no(_)),fail.
                                                                                                                                                                                                clear.
                                                                                                                                                                                     
                                                                                                                                                                                           /*                 Љ®­Ґж Їа®Ја ¬¬л                   */
                                                                                                                                                                                    Помогите пжл с эт ой задачкой.
                                                                                                                                                                                    Построить семантическую модель (сеть) представления знаний в предметной области "Туристическое агенство" (работа с клиентами)
                                                                                                                                                                                      Здравствуйте. Помогите с задачей на Турбо Прологе: Создать предикат, через рекурсию, вычисляющий по натуральному числу N, сумму его нечетных чисел которая не превышает само N т.е. задаем N=10, ответ 9. Причем необходима проверка на нечетность (N-1). Паскаль почему то мне легче дался, чем Пролог. Заранее благодарен.
                                                                                                                                                                                        Здравствуйте!Помогите закончить задачу.Нужно создать файл с именем т,в нем создать строку и в этой строке удалить предпоследний символ.Затруднение вызывает удалить предпоследний символ.Вот что сделано.
                                                                                                                                                                                        domains
                                                                                                                                                                                        • file=datafile1;datafile2
                                                                                                                                                                                        • str=string
                                                                                                                                                                                        • predicates
                                                                                                                                                                                        • data(str)
                                                                                                                                                                                        • write_line
                                                                                                                                                                                        • goal
                                                                                                                                                                                        • openwrite(datafile1,"t"),
                                                                                                                                                                                        • write_line,
                                                                                                                                                                                        • closefile(datafile1),
                                                                                                                                                                                        • openmodify(datafile2,"t"),
                                                                                                                                                                                        • del_sim,
                                                                                                                                                                                        • closefile(datafile2).
                                                                                                                                                                                        • clauses
                                                                                                                                                                                        • data(abcdezf).
                                                                                                                                                                                        • write_line:-data(S),write(S),writedevice(screen),fail,write_line.
                                                                                                                                                                                        • del_sim:-writedevice(datafile2),filepos(datafile2,2,2).


                                                                                                                                                                                        Добавлено
                                                                                                                                                                                        domains
                                                                                                                                                                                        file=datafile1;datafile2
                                                                                                                                                                                        str=string
                                                                                                                                                                                        predicates
                                                                                                                                                                                        data(str)
                                                                                                                                                                                        write_line
                                                                                                                                                                                        goal
                                                                                                                                                                                        openwrite(datafile1,"t"),
                                                                                                                                                                                        write_line,
                                                                                                                                                                                        closefile(datafile1),
                                                                                                                                                                                        openmodify(datafile2,"t"),
                                                                                                                                                                                        del_sim,
                                                                                                                                                                                        closefile(datafile2).
                                                                                                                                                                                        clauses
                                                                                                                                                                                        data(abcdezf).
                                                                                                                                                                                        write_line:-data(S),write(S),writedevice(screen),fail,write_line.
                                                                                                                                                                                        del_sim:-writedevice(datafile2),filepos(datafile2,2,2).
                                                                                                                                                                                          пожалуйста помогите решить задачи:
                                                                                                                                                                                          1)выполнить разделение списка на два новых списка,один из которых содержит элементы с нечетными номерами,а другой с четными. использовать ввод из клавиатуры.
                                                                                                                                                                                          2)во внешнем файле хранится текст. написать программу,которая подсчитывает количество цифр в тексте и формирует из найденных цифр список. содержимое файла и результаты распечатать
                                                                                                                                                                                          0 пользователей читают эту тему (0 гостей и 0 скрытых пользователей)
                                                                                                                                                                                          0 пользователей:


                                                                                                                                                                                          Рейтинг@Mail.ru
                                                                                                                                                                                          [ Script execution time: 0,2100 ]   [ 15 queries used ]   [ Generated: 3.05.24, 03:20 GMT ]