scheme zadania

-Napisać funkcje która jako parametr przyjmuje listę i funkcje fun a rezultatem zwraca nowa liste taka aby kazdy element listy byl zmieniony poprzez funkcje fun np zwiekszony o 5.

-Napisać funkcjie ktora oblicza liczbę wartości nie parzystych na liście

-Napisać funkcje która z listy wybiera liczby na parzysych indexach i zapisuje je w nowej liscie

Mam zrobić takie zadanka przeczytałem kilka razy informacji na temat tego języka ale nie mogę nic spłodzić jak już myślę ze działa to sie nie kompiluje;/ w języku Scheme

(define (fun list fun)
  (map fun list))

Chyba powinno być tak, ale nie jestem 100% pewien.
Do pozostałych będziesz potrzebował makro loop.

//EDIT: Ten kod na pewno działa

Skoro nie potrafisz w nim programować, to musisz:
1.Mieć sporo kasy
2.Napisać to w dziale praca
3.Zapłacić temu, kto to wykona

Za free nikt zadań nie zrobi...

Lub pokazać, co napisałeś do tej pory...

winerfresh napisał(a)

(define fun (list fun)
  (map fun list))

Chyba powinno być tak, ale nie jestem 100% pewien.
Do pozostałych będziesz potrzebował makro loop.

Ten kod nawet koło Scheme nie leżał, koło Common Lispu zresztą też nie. Scheme nie posiada makra loop, które jest tutaj bardziej niż zbędne (jak i "imperatywna" konstrukcja do). Scheme to język funkcyjny, chociaż strasznie prymitywny:

(define (my-map lst f)
  (if (null? lst)
      ()
      (cons (f (car lst)) (my-map (cdr lst) f))))

(define (number-of-odds lst)
  (letrec ((number-of-odds
            (lambda (lst acc)
              (if (null? lst) 
                  acc
                  (number-of-odds (cdr lst) 
                                  (if (odd? (car lst)) (+ 1 acc) acc))))))
    (number-of-odds lst 0)))
           
    
(define (select-even-items lst)
  (letrec ((select-even-items
            (lambda (lst even)
              (cond ((null? lst) ())
                    (even (cons (car lst) (select-even-items (cdr lst) #f)))
                    (else (select-even-items (cdr lst) #t))))))
    (select-even-items lst #f)))

Aby forum dyskusyjne miało sens użytkownicy powinni unikać postów pt. "coś kiedyś widziałem, pokażę się", wprowadzają tylko informacyjny szum, z którego potem ciężko coś użytecznego wyłowić zwykłemu użytkownikowi. Rzutuje to na poziom całego serwisu i efekt "google prostytutka!", gdzie ze znalezionych wątków nic nie wynika.

Bardziej dydaktyczny wariant, przez co i bardziej rozwlekły, mam nadzieję, że autor wątku raczy go przeanalizować:

(define (number-of-odds lst)
  (letrec ((number-of-odds
            (lambda (lst acc)
              (if (null? lst) 
                  acc
                  (let ((head (car lst)) (tail (cdr lst)))
                    (if (odd? head)
                        (number-of-odds tail (+ 1 acc))
                        (number-of-odds tail acc)))))))
    (number-of-odds lst 0))
           
    
(define (select-even-items lst)
  (letrec ((select-even-items
            (lambda (lst is-even-item)
              (if (null? lst)
                  ()
                  (let ((head (car lst)) (tail (cdr lst)))
                    (if is-even-item
                        (cons head (select-even-items tail #f))
                        (select-even-items tail #t)))))
    (select-even-items lst #f)))

winerfresh napisał(a)

(define (fun list fun)
  (map fun list))

Chyba powinno być tak, ale nie jestem 100% pewien.
Do pozostałych będziesz potrzebował makro loop.

//EDIT: Ten kod na pewno działa

Edytuj dalej, dziecko, edytuj, może kiedyś Ci się uda...

hauleth@niuniobook ~ $ guile
guile> (define (fun list fun)
  (map fun list))
guile> (fun '(1 2 3 4 5) (lambda (x) (+ x 1)))
(2 3 4 5 6)

Testowałem i wiem, że działa.
Po nicku sądzę, że znasz Haskella. W nim też tak kombinujesz jak musisz zrobić zwykłe map tyle, że z odwróconymi argumentami?

ZTCP elementy na liście argumentów define powinny być unikatowe, czy działa to już kwestia implementacji. Nie chodzi tutaj o napisanie normalnego programu tylko o zdefiniowanie funkcji od podstaw. Jaki sens ma, z punktu widzenia edukacji, opakowywanie standardowej funkcji funkcją z odwróconymi argumentami? Kluczowe tutaj jest właśnie to, jak funkcjonuje rekurencja wokół list, na najniższym poziomie. Czy dla problemu pt. "mam stworzyć prostą bazę danych w c" też rzucisz driver sql i pęczek zapytań?

Nie bo zgodnie z treścią zadania mam napisać bazę danych. A w tym przypadku mam napisać funkcję i ją piszę. Nie ma żadnych ograniczeń. Nie moja wina że wykładowca jest nieprecyzyjny i nie uwzględnił takiej możliwości w treści zadania.

haskell.pl napisał(a)

Bardziej dydaktyczny wariant, przez co i bardziej rozwlekły, mam nadzieję, że autor wątku raczy go przeanalizować:

(define (number-of-odds lst)
  (letrec ((number-of-odds
            (lambda (lst acc)
              (if (null? lst) 
                  acc
                  (let ((head (car lst)) (tail (cdr lst)))
                    (if (odd? head)
                        (number-of-odds tail (+ 1 acc))
                        (number-of-odds tail acc)))))))
    (number-of-odds lst 0))
           
    
(define (select-even-items lst)
  (letrec ((select-even-items
            (lambda (lst is-even-item)
              (if (null? lst)
                  ()
                  (let ((head (car lst)) (tail (cdr lst)))
                    (if is-even-item
                        (cons head (select-even-items tail #f))
                        (select-even-items tail #t)))))
    (select-even-items lst #f)))

dziękuje haskell.pl za twoja prace ale ten pierwsza funkcje zrozumiałem drugiej nie mogę o nie działa mi w dr.rocket a tego używamy na zajęciach w tym 2 programie mam wyswietlic liczby o parzystych indexach czyli np mam (define lst (list 1 1 3 2 4 1 3) to jeżeli zaczniemy liczyć od 1 elementu jako indexu 1 to ma nam wyświetlić listę (list 1 2 1) a nie widze nigdzie sprawdzania indexu i powiekszania go tylko sprawdzasz czy dana liczba jest parzysta

a w 1 funkcji letrec co to jest jest to samo co let czy let* czyli dotyczace wskaznika?

Zacznijmy od końca:

oorafalekoo napisał(a)

a w 1 funkcji letrec co to jest jest to samo co let czy let* czyli dotyczace wskaznika?

W Scheme NIE MA wskaźników. Każdy binding let to swego rodzaju abstrakcja nałożona na wywołanie funkcji lambda, różne sposoby wywołania dają różne efekty:

• let to zwykły binding, symbole będą widoczne dopiero w ciele let
• let* to prawie to samo, z tą różnicą, że symbole nie są bindowane wszystkie razem tylko pojedynczo, od lewej do prawej, dzięki czemu bindując kolejny symbol można odwołać się do poprzedniego
• letrec służy do bindowania rzeczy wymagających rekurencji, wymagających żeby bindowany symbol był widoczny już podczas bindowania.

oorafalekoo napisał(a)

w tym 2 programie mam wyswietlic liczby o parzystych indexach czyli np mam (define lst (list 1 1 3 2 4 1 3) to jeżeli zaczniemy liczyć od 1 elementu jako indexu 1 to ma nam wyświetlić listę (list 1 2 1) a nie widze nigdzie sprawdzania indexu i powiekszania go tylko sprawdzasz czy dana liczba jest parzysta

Przejrzyj kod jeszcze raz, uważnie. Nie sprawdzam czy dana liczba jest parzysta, widzisz gdzieś (even? ...)? Zapamiętuję stan indeksu - czy jest parzysty - do pierwszego wywołania funkcji podaję #f ponieważ 1 jest nieparzyste, następnie kolejne wywołanie rekurencyjne idzie z odwróconą flagą, #t, ponieważ 2 jest parzyste, następnie #f itd. Parzyste indeksy oznaczają co drugi element, odrzucając pierwszy, zgadza się? Rozwinięta do używania indeksów postać:

(define (select-even-items lst)
  (letrec ((select-even-items
            (lambda (lst index)
              (if (null? lst)
                  ()
                  (let ((head (car lst)) (tail (cdr lst)))
                    (if (even? index)
                        (cons head (select-even-items tail (+ 1 index)))
                        (select-even-items tail (+ 1 index))))))
    (select-even-items lst 1)))

oorafalekoo napisał(a)

nie działa mi w dr.rocket a tego używamy na zajęciach

Nie działa bo nie skopiowałem wszystkich nawisów. Środowisko podświetla nawiasy, kod jest prawidłowo sformatowany, sam dojdziesz gdzie czego brakuje.

haskell.pl napisał(a)

Zacznijmy od końca:

oorafalekoo napisał(a)

a w 1 funkcji letrec co to jest jest to samo co let czy let* czyli dotyczace wskaznika?

W Scheme NIE MA wskaźników. Każdy binding let to swego rodzaju abstrakcja nałożona na wywołanie funkcji lambda, różne sposoby wywołania dają różne efekty:

• let to zwykły binding, symbole będą widoczne dopiero w ciele let
• let* to prawie to samo, z tą różnicą, że symbole nie są bindowane wszystkie razem tylko pojedynczo, od lewej do prawej, dzięki czemu bindując kolejny symbol można odwołać się do poprzedniego
• letrec służy do bindowania rzeczy wymagających rekurencji, wymagających żeby bindowany symbol był widoczny już podczas bindowania.

oorafalekoo napisał(a)

w tym 2 programie mam wyswietlic liczby o parzystych indexach czyli np mam (define lst (list 1 1 3 2 4 1 3) to jeżeli zaczniemy liczyć od 1 elementu jako indexu 1 to ma nam wyświetlić listę (list 1 2 1) a nie widze nigdzie sprawdzania indexu i powiekszania go tylko sprawdzasz czy dana liczba jest parzysta

Przejrzyj kod jeszcze raz, uważnie. Nie sprawdzam czy dana liczba jest parzysta, widzisz gdzieś (even? ...)? Zapamiętuję stan indeksu - czy jest parzysty - do pierwszego wywołania funkcji podaję #f ponieważ 1 jest nieparzyste, następnie kolejne wywołanie rekurencyjne idzie z odwróconą flagą, #t, ponieważ 2 jest parzyste, następnie #f itd. Parzyste indeksy oznaczają co drugi element, odrzucając pierwszy, zgadza się? Rozwinięta do używania indeksów postać:

(define (select-even-items lst)
  (letrec ((select-even-items
            (lambda (lst index)
              (if (null? lst)
                  ()
                  (let ((head (car lst)) (tail (cdr lst)))
                    (if (even? index)
                        (cons head (select-even-items tail (+ 1 index)))
                        (select-even-items tail (+ 1 index))))))
    (select-even-items lst 1)))

oorafalekoo napisał(a)

nie działa mi w dr.rocket a tego używamy na zajęciach

Nie działa bo nie skopiowałem wszystkich nawisów. Środowisko podświetla nawiasy, kod jest prawidłowo sformatowany, sam dojdziesz gdzie czego brakuje.

(define (select-even-items lst)
(letrec ((select-even-items
(lambda (lst index)
(if (null? lst)
0
(let ((head (car lst)) (tail (cdr lst)))
(if (even? index)
(cons head (select-even-items tail (+ 1 index)))
(select-even-items tail (+ 1 index))))))) ) (select-even-items lst 1)))

poprawilem kod na w ten sposob niby sie kompiluje ale jak wczytuje listę to mam błąd cons: second argument must be of type <list or="or" cyclic="cyclic" list="list">, given 6 and 0

to na koncu select even- items lst 1 po co jest?

oorafalekoo napisał(a)

(define (select-even-items lst)
(letrec ((select-even-items
(lambda (lst index)
(if (null? lst)
0
(let ((head (car lst)) (tail (cdr lst)))
(if (even? index)
(cons head (select-even-items tail (+ 1 index)))
(select-even-items tail (+ 1 index))))))) ) (select-even-items lst 1)))

poprawilem kod na w ten sposob niby sie kompiluje ale jak wczytuje listę to mam błąd cons: second argument must be of type <list or="or" cyclic="cyclic" list="list">, given 6 and 0

Ech, ciężki przypadek, napisałem przecież "nie skopiowałem wszystkich nawisów ... kod jest prawidłowo sformatowany", miałeś dostawić nawiasy zgodnie z formatowaniem. cons przyjmuje dwa argumenty, ileś Ty tego naładował, dostawiałeś te nawiasy byle się ilościowo zgadzały? Mniej "dydaktyczna" wersja działa, wzorując się na niej nie powinieneś mieć problemu z prawidłowym dostawieniem nawiasów. Prosiłem żebyś przeanalizował kod i postarał się zrozumieć.

oorafalekoo napisał(a)

to na koncu select even- items lst 1 po co jest?

Po to jest bo zdefiniowaliśmy lokalną funkcję, która realizuje wszystkie operacje, jakoś trzeba ją odpalić. Wszystkie funkcje, z wyjątkiem my-map, korzystają z funkcji pomocniczych w identyczny sposób, widać nie wyciągnąłeś wniosków.

(define (select-even-items lst)
  (letrec ((select-even-items
            (lambda (lst is-even-item)
              (if (null? lst)
                  ()
                  (let ((head (car lst)) (tail (cdr lst)))
                    (if is-even-item
                        (cons head (select-even-items tail #f))
                        (select-even-items tail #t)))))
    (select-even-items lst #f)))

Programowanie nie polega na klepaniu na ślepo, naucz się tego raz na zawsze. Scheme używacie po to żeby nauczyć się rozwiązywania problemów przy użyciu wyłącznie podstawowych konstrukcji, bez przykładania wagi do języka. Co to za uczelnia?

studia zaoczne nie pokazane bylo jak robic takei cos a na kolosie jest;p a ta funkcja co teraz wyslales nie dziala

Cholera, wysłałem oryginalną, nie skopiowałem z emacsa. Panie student, studia polegają na studiowaniu, wskazują co masz opanować i egzekwowaniu, to nie podstawówka, nikt za rąsię nie prowadzi. Nawet nie spojrzałeś czy nie wysłałem tego samego, napisałem jasno, co z poprzednim kodem miałeś zrobić, nie zrobiłeś, po co się wysilać jak można rzucić 'nie działa'. Dwóch nawiasów w ostatnim wywołaniu rekurencyjnym brakuje.

tych 2 nawiazy dodalem na samym początku ale tez mi nie działa to widziadłem lecialem z kodem od poczatku i nie wiem co jest grane nie podswietla mi ostatnia funkcji select-**even-items: expected only one expression after the name `select-even-items', but found one extra part i zamiast **(if (null? lst) () wstawiam 0 bo nie pobiera takie czegos szukalem gdzie czegos brakuje ale nie mam pojecia gdzie

Wstawiasz 0? Wiesz że liczby to nie listy? Cały problem polega na tym, że nie byłeś łaskawy podać, którego języka używasz. Dla "prawdziwego" Scheme - standardy R5RS (najpopularniejszy) czy R6RS (najnowszy) - ten kod jest całkowicie poprawny, DrRacket pozwala wybierać z wielu dialektów. Tam ma być zwracany nil, tj. pusta lista - (). Jeżeli wybierzesz R5RS (a tylko ten język z oferowanych przez DrRacket można z czystym sumieniem Scheme nazywać) to przejdzie poprawnie. Skoro ten dziwny dialekt nie uznaje takiego zapisu, a jest on formą specjalną, to trzeba ruszyć głową: widziałeś jak poprzez formę quote zapisuje się listy z elementami, przez analogię pustą listę zapisz jako '(), nie ma prawa nie pójść.

Jeśli dla Ciebie 0 i () nie robi różnicy to chyba nie masz czego szukać na uczelni. Skoro funkcja ma zwracać listę to naprawdę trzeba mieć talent żeby wstawiać tam liczby.

w schemie nie łapę się w ogóle dla mnie to bardzo zamotany język korzystam z formy adventced student nie moge go zrozumieć trzeba bylo by przynim wiecej usiąść ja wiem jak to wyglada dla osoby co umie to robić to banalne zadania ja rozumiem jak mam je zapisać ale musial bym posiedzieć i rozpracować strukture pisanai tu programów bo sie glubi w tym jezyku funkcyjnym

(define (sumaWszystkichElementowListy lista)
(cond ((empty? lista) 0)
(else (+ (first lista)
(sumaWszystkichElementowListy (rest lista))))))

to zero wzielo mi sie z tąd ze zawsze w kazdym przykladzie byl np taki zapis

oorafalekoo napisał(a)

w schemie nie łapę się wogole dla mnie to bardzo zamotany język korzystam z formy adventced student nie moge go zrozumieć trzeba bylo by przynim wiecej usiąść ja wiem jak to wyglada dla osoby co umie to robić to banalne zadania ja rozumiem jak mam je zapisać ale musial bym posiedzieć i rozpracować strukture pisanai tu programów bo sie glubi w tym jezyku funkcyjnym

Językami funkcyjnymi władasz równie biegle co polskim i angielskim.

oorafalekoo napisał(a)

(define (sumaWszystkichElementowListy lista)
(cond ((empty? lista) 0)
(else (+ (first lista)
(sumaWszystkichElementowListy (rest lista))))))

to zero wzielo mi sie z tąd ze zawsze w kazdym przykladzie byl np taki zapis

W którym języku nie ma różnicy między liczbą a listą? "Zawsze" miałeś jako element neutralny dodawania zwracany w przypadku bazowym. Nie masz problemu z programowaniem funkcyjnym, masz problem z programowaniem w ogóle, po czymś takim nie wmówisz nam, że z programowaniem imperatywnym radzisz sobie lepiej.

(define (my-map lst f)
  (if (null? lst)
      '()
      (cons (f (car lst)) (my-map (cdr lst) f))))
 
(define (number-of-odds lst)
  (letrec ((number-of-odds
            (lambda (lst acc)
              (if (null? lst) 
                  acc
                  (number-of-odds (cdr lst) 
                                  (if (odd? (car lst)) (+ 1 acc) acc))))))
    (number-of-odds lst 0)))
 
 
(define (select-even-items lst)
  (letrec ((select-even-items
            (lambda (lst even)
              (cond ((null? lst) '())
                    (even (cons (car lst) (select-even-items (cdr lst) #f)))
                    (else (select-even-items (cdr lst) #t))))))
    (select-even-items lst #f)))

(define (number-of-odds lst)
  (letrec ((number-of-odds
            (lambda (lst acc)
              (if (null? lst) 
                  acc
                  (let ((head (car lst)) (tail (cdr lst)))
                    (if (odd? head)
                        (number-of-odds tail (+ 1 acc))
                        (number-of-odds tail acc)))))))
    (number-of-odds lst 0))
 
 
(define (select-even-items lst)
  (letrec ((select-even-items
            (lambda (lst is-even-item)
              (if (null? lst)
                  '()
                  (let ((head (car lst)) (tail (cdr lst)))
                    (if is-even-item
                        (cons head (select-even-items tail #f))
                        (select-even-items tail #t)))))))
    (select-even-items lst #f)))

Masz, "studiuj" dalej w spokoju...