Schema - Müssen, ersetzen Sie den Wert von einem element in der Liste

Meiner Liste packt Benutzereingaben, und erstellt eine Liste - diese Liste wird in Zeichen.

Ich würde gerne in der Lage sein zu überprüfen, ob die (car myList) ist ein Zeichen wie #\1 oder #\2, und ändern Sie dann das Auto von der Liste in 1 oder 2.

Ich bin mit DrRacket.

Das problem bisher wurde versucht, rufen Sie entweder (set! (car myList) 1) oder (list-set! (car myList) 1 )

Beide sind Undefinierte Referenzen in meiner Umgebung.

Ich habe gerade angefangen zu arbeiten, die mit dem Schema heute für eine Universität Abtretung an.

Jede Hilfe wäre sehr dankbar wenn jemand Zeit hat

Dank

InformationsquelleAutor jordan | 2011-11-20
  1. 7

    Standardmäßig Schläger nicht mutable-pairs, also nicht veränderbarer Listen entweder. Das bedeutet, dass die Werte von Paaren und Listen sind unveränderlich.

    Allerdings können Sie (require racket/mpair), die, wie der name schon sagt, bietet mutable-pairs. Sie verwenden dann mcons, mcar, mcdr, mlist usw. statt cons, car, cdr, list.

    InformationsquelleAutor Chris Jester-Young
  2. 5

    Die anderen Antworten sind richtig, aber möglicherweise nicht, was Sie wollen. Die mehr idiomatische Scheme/Racket Weg, dies zu tun wäre, um eine Funktion schreiben, verbraucht der ursprünglichen Eingabe, und liefert eine neue, separate Liste mit den änderungen, die Sie wollen. (Dies ist besonders bevorzugt, daher Listen Unveränderbarkeit) eingestellt werden. So, zum Beispiel, könnten Sie schreiben

    (define (numberify-head lst)
  (cond
    [(eq? (car lst) #\1) (cons 1 (cdr lst))]
    [(eq? (car lst) #\2) (cons 2 (cdr lst))]
    [else lst]))

    Dein Programm würde dann so etwas

    (let* ([input (read-input-from-the-user)]
       [processed-list (numberify-head input)])
  ;; ... code that uses processed-list ...
  )
    InformationsquelleAutor jacobm
  3. 0

    Pairs im Schema sind veränderlich. Aber Sie mutieren nicht Sie mit (set! (car myList) 1 ); vielmehr würden Sie tun (set-car! myList 1). Sie müssen zuerst das paar, das Sie wollen, zu mutieren, und rufen Sie dann set-car! oder set-cdr! auf das paar (sobald Sie das tun car oder cdr drauf, das ist nur der Zugriff auf das paar und nicht mutiert es).

    InformationsquelleAutor newacct
  4. 0

    Habe ich eine stack-Implementierung, die von dieser Website:

    http://zoo.cs.yale.edu/classes/cs201/Fall_2007/materials/pdfs/stacks.pdf

    Dem stack lassen Sie mich , denke auch ich, dass der "Spiegel" auf meiner Liste. nachdem ich überprüft, welches symbol dem Benutzer eingegebenen Zeichen war, würde ich einfach mit einem Tastendruck auf den entsprechenden Charakter auf meinem Stapel.

    (define (makeListFromSymbols myList)

  (display "Length of List = ")
  (display(length myList)) (newline)
   (cond

      ((null? myList) 
       (display "LIST IS NULL")(newline)

       (popTheRestOfStack)

       )
      ((eq? #\0 (car myList)) 
       (display "Equals 0") 
       (stackForExpression 'push! #\0)
       (makeListFromSymbols(cdr myList))
       (newline)
       )
      ((eq? #\1 (car myList)) 
       (display "Equals 1") 
       (stackForExpression 'push! #\1)
       (makeListFromSymbols(cdr myList) )
       (newline)
       )
      ((eq? #\2 (car myList)) 
       (display "Equals 2") 
       (stackForExpression 'push! #\2)
       (makeListFromSymbols(cdr myList))
       (newline)
       )
      ((eq? #\3 (car myList)) 
       (display "Equals 3") 
       (stackForExpression 'push! #\3)
       (makeListFromSymbols(cdr myList))
       (newline)
       )
      ((eq? #\4 (car myList)) 
       (display "Equals 4") 
       (stackForExpression 'push! #\4)
       (makeListFromSymbols(cdr myList))
       (newline)
       )
      ((eq? #\5 (car myList)) 
       (display "Equals 5") 
       (stackForExpression 'push! #\5)
       (makeListFromSymbols(cdr myList))
       (newline)
       )
      ((eq? #\6 (car myList)) 
       (display "Equals 6") 
       (stackForExpression 'push! #\6)
       (makeListFromSymbols(cdr myList))
       (newline)
       )
      ((eq? #\7 (car myList)) 
       (display "Equals 7") 
       (stackForExpression 'push! #\7)
       (makeListFromSymbols(cdr myList))
       (newline)
       )
      ((eq? #\8 (car myList)) 
       (display "Equals 8") 
       (stackForExpression 'push! #\8)
       (makeListFromSymbols(cdr myList))
       (newline)
       )
      ((eq? #\9 (car myList)) 
       (display "Equals 9") 
       (stackForExpression 'push! #\9)
       (makeListFromSymbols(cdr myList))
       (newline)
       )
      ((eq? #\+ (car myList)) 
       (display "Equals +") 
       (handleAdditionOperator)
       (makeListFromSymbols(cdr myList))
       (newline)
       )
      ((eq? #\/(car myList)) 
       (display "Equals /") 
       (handleDivisionOperator)
       (makeListFromSymbols(cdr myList))
       (newline)
       )
      ((eq? #\- (car myList)) 
       (display "Equals -") 
       (handleSubtractionOperator)
       (makeListFromSymbols(cdr myList))
       (newline)
       )
      ((eq? #\* (car myList)) 
       (display "Equals *") 
       (handleMultiplicationOperator)
       (makeListFromSymbols(cdr myList))
       (newline)
       )
      ((eq? #\( (car myList)) 
       (display "Equals (")
       (stack1 'push! #\( )

       (makeListFromSymbols(cdr myList))
       (newline)
       )
      ((eq? #\) (car myList)) 
       (display "Equals )") 

       (popAndTransferUntilLeftBracket) 

       (makeListFromSymbols(cdr myList))
       (newline)
       )
      (else (display "Character is invalid")(newline) (makeListFromSymbols(cdr myList)))
      )

  )

    wenn jemand hat ähnliche Fragen, die auf dieser oder über meinen code /Funktionen, mailen Sie mir. ( ich glaube, mein E-Mail ist auf meine Benutzer-Seite?)

    ich habe auch eine pseudo-code-Algorithmus für die Umwandlung von infix zu post-fix-notation (das war die Zuordnung hier)

    InformationsquelleAutor jordan
Schreibe einen Kommentar