Преобразовать в ракетку (схема)

У меня есть этот код, который работает на питоне. Я новичок в DRrACKET, как мне перевести его на DRrACKET. Я изо всех сил пытаюсь написать код DRRACKET, который дает точный результат.

Ваша помощь высоко ценится.

# python program to find the length of the largest subarray which has all contiguous elements 

def length_sub_(arr, n):
max_len = 1
for i in range(0,n - 1):

    myset = set()
    myset.add(arr[i])

    # Initialize max and min in
    # current subarray
    mn = arr[i]
    mx = arr[i]
    for j in range(i + 1,n):

        # If current element is already
        # in hash set, then this subarray
        # cannot contain contiguous elements
        if arr[j] in myset:
            break


        # Else add current element to hash
        # set and update min, max if required.
        myset.add(arr[j])
        mn = min(mn, arr[j])
        mx = max(mx, arr[j])

        # We have already checked for
        # duplicates, now check for other
        #property and update max_len
        # if needed
        if mx - mn == j - i:
            max_len = max(max_len, mx - mn + 1)

 return max_len # Return result



arr = [6, 1, 1, 10, 10, 111, 100]
print("Length of the longest contiguous subarray is : ",
                            length_sub_(arr,len(arr)))

Ожидаемый результат:

Длина самого длинного непрерывного подмассива: 2

Мой DRrACKET старт Я реализовал некоторые пользовательские функции, которые действуют как вспомогательные функции для вывода, который я ожидаю

 #lang racket
 ;custom function to check if an elemet is contained in a list
 (define custom-member
  (lambda (x los)
    (cond
     ((null? los) #f)
      ((= x (car los)) #t)
      (else (custom-member x (cdr los))))))

    ;checks if all the elements in the set are unique
    (define are-all-unique 
      (lambda (v)
       (if (not (null? v))
        (and (not (custom-member (car v) (cdr v)))
         (are-all-unique (cdr v)))
         #t)))
   ;reverses the list
    (define (reverse-helper lst ACC)
     (if (null? last)
     acc
  (reverse-helper (cdr lst) (cons (car lst) ACC))))

 (define (custom-reverse last)
   (reverse-helper lst '()))

(define (unique-elements last)
  (let loop ((lst (flatten lst)) (res '()))
  (if (empty? last)
     (custom-reverse res)
     (let ((c (car lst)))
      (loop (cdr lst) (if (custom-member c res) res (cons c     res)))))))


; define the length of the list
 (define custom-length
  (lambda (list)
   (if (null? list)
     0
    (+ 1 (custom-length (cdr list))))))


;performs the actual list check
(define max-contiguous-repeated-length
 (lambda (L)
  (cond
   [(null? L) 0]
    [else (cond
           [(are-all-unique L) 1]
           [else (custom-length (unique-elements L))])]
    )
   ))

  (max-contiguous-repeated-length '(1 1 2 1 2 1 2))

Пожалуйста, отредактируйте вопрос, чтобы ограничить его конкретной проблемой с достаточной детализацией, чтобы найти адекватный ответ.

Community 23.04.2022 10:35

работает ли ваш новый код или у вас есть какие-либо вопросы по этому поводу?

Will Ness 24.04.2022 16:50

@Уилл Несс не дает желаемого результата

Calvince 24.04.2022 17:03
Анализ настроения постов в Twitter с помощью Python, Tweepy и Flair
Анализ настроения постов в Twitter с помощью Python, Tweepy и Flair
Анализ настроения текстовых сообщений может быть настолько сложным или простым, насколько вы его сделаете. Как и в любом ML-проекте, вы можете выбрать...
7 лайфхаков для начинающих Python-программистов
7 лайфхаков для начинающих Python-программистов
В этой статье мы расскажем о хитростях и советах по Python, которые должны быть известны разработчику Python.
Установка Apache Cassandra на Mac OS
Установка Apache Cassandra на Mac OS
Это краткое руководство по установке Apache Cassandra.
Сертификатная программа "Кванты Python": Бэктестер ансамблевых методов на основе ООП
Сертификатная программа "Кванты Python": Бэктестер ансамблевых методов на основе ООП
В одном из недавних постов я рассказал о том, как я использую навыки количественных исследований, которые я совершенствую в рамках программы TPQ...
Создание персонального файлового хранилища
Создание персонального файлового хранилища
Вы когда-нибудь хотели поделиться с кем-то файлом, но он содержал конфиденциальную информацию? Многие думают, что электронная почта безопасна, но это...
Создание приборной панели для анализа данных на GCP - часть I
Создание приборной панели для анализа данных на GCP - часть I
Недавно я столкнулся с интересной бизнес-задачей - визуализацией сбоев в цепочке поставок лекарств, которую могут просматривать врачи и...
1
3
121
3
Перейти к ответу Данный вопрос помечен как решенный

Ответы 3

Ответ принят как подходящий

Попытка «перевести» с Python, вероятно, не лучший подход при изучении Scheme/Racket; попробуй начать с этого заглушка, а после Racket Как проектировать функциирецепт дизайна:

(define (max-repeated-length lon) ;; ListOfNumber -> Natural
  ;; produce length of longest section of lon with equal elements
  0)

(check-expect (max-repeated-length '()) 0)

; (check-expect (max-repeated-length '(6 1 1 10 10 111 100)) 2)

Следующим шагом в методе проектирования является выбор шаблон, заменить общие идентификаторы на те, которые подходят для требуемой функции, и добавьте примеры для кодирования замен заполнителей в шаблоне.

Самый простой шаблон для функций с аргументом-списком — это «естественная рекурсия»:

(define (fn lox) ;; ListOfX -> Y                  ; *template*: (for fn with list argument)
  ;; produce a Y from lox using natural recursion ;
  (cond                                           ;
    [(empty? lox) ... ]                           ; (... = "base case value" ;; Y )
    [else (...                                    ; (... = "inventory fn(s)" ;; X Y -> Y )
           (first lox) (fn (rest lox))) ]))       ; [1]

Отредактировано для этой проблемы, это будет:

(define (max-repeated-length lon) ;; ListOfNumber -> Natural
  ;; produce length of longest section of lon with equal elements
  (cond
    [(empty? lon) 0 ]
    [else (...
           (first lon) (max-repeated-length (rest lon))) ]))

так вот как можно было бы начать разрабатывать (define max-repeated-length (lambda (L) (cond ) ) ).

Примеры могут быть:

(check-expect (max-repeated-length '(1)) 1)
(check-expect (max-repeated-length '(1 2)) 1)
(check-expect (max-repeated-length '(1 2 2)) 2)
(check-expect (max-repeated-length '(1 2 2 2 3 3)) 3)

Шаблон выше - это начало (первый тест проходит), но может быть непонятно, как начните кодировать замену для .... Как проектировать функции имеет соответствующие рецепты дизайна и шаблоны, но этот ответ не будет использовать их явно.

Проблема с использованием шаблона естественной рекурсии заключается в том, что результат должен быть произведено зависит от длины повторяющихся секций в пределах lon. С опытом программирования, видно, что текущее значение повторяется (cur-val), продолжительность текущего повтора (cur-lsf) и максимальное количество длин повторов (max-lsf), необходимы для создания требуемого значения. max-repeated-length не включает эти значения, поэтому введите функцию с их в качестве аргументов ( (max-repeats lon cur-val cur-lsf max-lsf) ) и вызовите его из max-repeated-length, что станет:

(define (max-repeated-length lon) ;; ListOfNumber -> Natural
  ;; produce length of longest section of lon with equal elements
  (cond
    [(empty? lon) 0]
    [else (max-repeats (rest lon) (first lon) 1 1) ]))

(аргументы к max-repeats выводятся из того факта, что cur-val начинается с (first lon) и т. д.)

Теперь можно записать max-repeatsзаглушка с подпись, цель и заглушкой ценность, с некоторыми тестами:

(define (max-repeats lon cur-val cur-lsf max-lsf) ;; ListOfNumber Number Natural Natural -> Natural
  ;; produce max-so-far of lengths of sections of lon with equal elements
  max-lsf)
  
(check-expect (max-repeats '() 1 1 1) 1)
(check-expect (max-repeats '(2) 1 1 1) 1)
(check-expect (max-repeats '(2) 2 1 1) 2)

max-repeats можно создать как естественную рекурсию с дополнительным условием при обнаружении повтора:

(define (max-repeats lon cur-val cur-lsf max-lsf) ;; ListOfNumber Number Natural Natural -> Natural
  ;; produce max-so-far of lengths of sections of lon with equal elements
  (cond
    [(empty? lon) max-lsf ]
    [(= (first lon) cur-val) ... ]
    [else ... ]))

(заполнители будут заменены формами, построенными из аргументов, (first lon), (max-repeats (rest lon) ... ) и (add1 cur-lsf))

Заполнитель else ... прост: это начало (возможного) нового повторения, так что вроде вызов в max-repeated-length, но с сохранением значения max-lsf. Глядя на примеры, видно, что полный max-repeats, с max-repeated-length как и прежде, и еще один тест:

(define (max-repeats lon cur-val cur-lsf max-lsf) ;; ListOfNumber Number Natural Natural -> Natural
  ;; produce max-so-far of lengths of sections of lon with equal elements
  (cond
    [(empty? lon) max-lsf ]
    [(= (first lon) cur-val)
     (max-repeats (rest lon) cur-val (add1 cur-lsf) (max max-lsf (add1 cur-lsf))) ]
    [else (max-repeats (rest lon) (first lon) 1 max-lsf) ]))

(define (max-repeated-length lon) ;; ListOfNumber -> Natural
  ;; produce length of longest section of lon with equal elements
  (cond
    [(empty? lon) 0]
    [else (max-repeats (rest lon) (first lon) 1 1) ]))

(check-expect (max-repeated-length '(1 2 3 3 4 5 5 5 6 7 7 8)) 3)

Итак, запускаем снова для проверки:

Welcome to DrRacket, version 8.4 [cs].
Language: Beginning Student with List Abbreviations [custom].
Teachpack: batch-io.rkt.
All 10 tests passed!
> 

Обратите внимание, что если = заменить на equal? [2], max-repeated-length можно применить к списки объектов схемы многих видов, например: (max-repeated-length '(a b b b c c)) ==> 3 (максимальная повторяющаяся длина '(1 '(2 3) '(2 3) '(2 3) 4 4)) ==> 3

[1]: шаблон (... (first lox) (fn (rest lox))) может указывать на более сложную форму, включающую (first lox) и (rest lox)

[2]: (Доступны другие предикаты эквивалентности)

не могли бы вы предоставить полное решение

Calvince 23.04.2022 12:19

не могли бы вы проверить отредактированный код выше и помочь оттуда

Calvince 24.04.2022 16:49

Одна приятная особенность Scheme заключается в том, что она побуждает вас искать элегантные решения, а не ползучий ужас в вопросе, уверенный в том, что элегантное решение, как правило, также будет эффективным.

Итак, поскольку это, я думаю, довольно очевидная проблема с домашним заданием, и я действительно не хочу помогать людям обманывать, вот элегантное решение в питон. В Python это, возможно, будет неэффективно, особенно для длинных массивов. Превратившись в Racket, это очевидное и эффективное решение.

def longest_contiguous(a):
    l = len(a)
    def loc(i, current, this, best):
        # i is current index, current is the element in the current
        # run, this is the length of the current run, best is the
        # length of the longest run.
        if i == l:              # we're done
            return best if best > this else this
        elif a[i] == current:   # in a run
            return loc(i + 1, current, this + 1, best)
        else:                   # new run
            return loc(i + 1, a[i], 1, best if best > this else this)
    return loc(0, a[0], 1, 1) if l > 0 else 0

А вот такое изящное решение в Racket: оформлено так, что, опять же, в качестве домашнего задания его, наверное, не сдать. Это будет работать как с векторами, так и со списками и многими другими вещами. И помимо длины самой длинной непрерывной последовательности, он скажет вам, где эта последовательность начинается.

(require racket/stream
         racket/generic)

(define-generics to-stream
  ;; Turn something into a stream in a way which could be extended
  (->stream to-stream)
  #:fast-defaults
  ((stream?
    (define ->stream identity))
   (sequence?
    (define ->stream sequence->stream))))

(define (length-of-longest-contiguous-subthing thing
                                               #:same? (same? eqv?)
                                               #:count-from (count-from 0))
  (define s (->stream thing))
  (if (stream-empty? s)
      (values 0 count-from)
      (let los ([st (stream-rest s)]
                [current (stream-first s)]
                [count (+ count-from 1)]
                [this 1]
                [this-start 0]
                [best 0]
                [best-start 0])
        (cond
          [(stream-empty? st)
           (if (> this best)
               (values this this-start)
               (values best best-start))]
          [(same? (stream-first st) current)
           (los (stream-rest st) current (+ count 1)
                (+ this 1) this-start
                best best-start)]
          [else
           (if (> this best)
               (los (stream-rest st)
                    (stream-first st) (+ count 1)
                    1 count
                    this this-start)
               (los (stream-rest st)
                    (stream-first st) (+ count 1)
                    1 count
                    best best-start))]))))

Теперь, например:

> (length-of-longest-contiguous-subthing '(1 2 3 4 4 5 6 6 6 7))
3
6

Самая длинная непрерывная подпоследовательность состоит из 3 логарифмических элементов и начинается с 6-го элемента.

Но и:

> (call-with-input-file
   "/tmp/x"
   (λ (p)
     (length-of-longest-contiguous-subthing (in-lines p)
                                            #:same? string=?
                                            #:count-from 1)))

Самая длинная последовательность одинаковых строк в /tmp/x равна 2, и она начинается со строки 2, считая с 1.

Это не домашнее задание, это я учусь, схема, меня не интересует код Python. хотя спасибо за старание

Calvince 23.04.2022 11:50

@ аватар пользователя ignis volens - Спасибо, не могли бы вы сделать это проще. Это сложно. я все еще учусь

Calvince 23.04.2022 12:40

Хорошо, так что вы хотите,

[6, 1, 1, 10, 10, 111, 100] => 2
[6, 1, 1, 1, 100, 111, 100] => 3
[6, 10, 10, 20, 10, 10, 10] => 3

так как

[[6], [1, 1], [10, 10], [111], [100]] => [1,2,2,1,1] => 2
[[6], [1, 1, 1], [100], [111], [100]] => [1,3,1,1,1] => 3
[[6], [10, 10], [20], [10, 10, 10]]   => [1,2,1,3]   => 3

И поэтому, взяв на себя взгляд более высокого уровня, мы

(define (length-longest-constant-span xs equ)
  (maximum 
    (map length
      (constant-spans xs equ))))

Теперь maximum легко определить,

(define (maximum lon)
   (apply max lon))

и нам остается задача определить

(define (constant-spans xs equ)

для xs, который может быть либо пустой

  (if (null? xs)
    (list (list))     ; [[]]

(возвращая [[]], потому что [1] => [[1]] и так должно быть [] => [[]]); или непустой,

    (let* ((a (car xs))
           (d (cdr xs))

и так как мы его кодируем, мы закончим писать его когда-то, и тогда он будет доступен нам для вызова, так что мы могли бы также назови это, с меньшей частью ввода,

           (r (constant-spans d equ))

и тогда мы сможем проанализировать рекурсивный результат, который, как мы знать, никогда не будет пустым — из-за того, как мы только что определили обработку случая пустого списка выше, возвращая непустой список [[]]

           (ra (car r))
           (rd (cdr r)))

Итак, теперь, наконец, мы должны решить, что делать с этим рекурсивным результатом, в каждом конкретном случае, является ли головной элемент ra в нем пустой,

      (cond
        ((null? ra)   ; [[]] --> [[a]]
          (cons (cons a ra) rd))

или непустым, поэтому мы можем заглянуть в него и посмотреть, является ли головной элемент этото же as a, как считается equ,

        ((equ a (car ra))  ; a [[a,...],...] --> [[a,a,...],...]
          (cons (cons a ra) rd))

или нет(здесь мы делаем то же самое, что и выше, а. Так что мы можем упростить код, если захотим, позже, но сначала):

        (else              ; a [[b,...],...] --> [[a],[b,...],...]
          (cons (list a) r))))))

и это все.

Если я допустил здесь какие-либо ошибки, пожалуйста, исправьте их, чтобы все заработало.

Аккуратно: понятнее ли написать первый (cons a ra) как (list a)? я не знаю

mnemenaut 27.04.2022 11:23

Кроме того, по счастливой случайности, сегодняшний smbc (длина почтового индекса, значения constant-spans и итерация => посмотреть и сказать)

mnemenaut 27.04.2022 11:24

re [a] может быть, но тогда он станет отличным от следующего случая. (в комиксе: искать... это слишком сложно для меня!)

Will Ness 27.04.2022 11:27

посмотрел второй раз, понял. :) :) @mnemenaut

Will Ness 27.04.2022 12:15

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