Trouver l'index de l'élément dans la liste

J'ai besoin pour obtenir l'indice de l'élément dans la liste dans le schéma. Par exemple:

(... 2 '(2 3 4 5))

0

(... 4 '(2 3 4 5))

2

Quelqu'un peut-il aider?

Avez-vous essayé quelque chose? Aussi, quelle langue utilisez-vous?
régime, j'ai ceci: (define carte-index-pred (lambda (pred? f l) (foldr (lambda (x y) (if (pred? x) (cons (f x) y) (cons x y))) '() l))) (carte-index-pred bizarre? sqr '(2 3 4 5)) (carte-index-pred (lambda(i) (< i 2)) - '(1 2 3 4 5)) il ne fonctionne que pour les numéros (x), j'en ai besoin pour leurs indices... 🙁

OriginalL'auteur kelly | 2012-11-26

  1. 9

    Quelque chose comme ceci

    (define list-index
        (lambda (e lst)
                (if (null? lst)
                        -1
                        (if (eq? (car lst) e)
                                0
                                (if (= (list-index e (cdr lst)) -1) 
                                        -1
                                        (+ 1 (list-index e (cdr lst))))))))
    merci beaucoup! 🙂
    Votre accueil,si cela résout votre problème,merci de le marquer comme réponse

    OriginalL'auteur meirrav

  2. 6

    La suite est la solution la plus claire que je pouvais venir:

    (define (get-list-index l el)
    (if (null? l)
        -1
        (if (= (car l) el)
            0
            (let ((result (get-list-index (cdr l) el)))
                (if (= result -1)
                    -1
                    (1+ result))))))

    Cette solution est essentiellement le même que merriav sauf que j'ai ajouté un let à la fin, de sorte que l'appel récursif n'est pas inutilement répétées (dans le code écrit ou à l'exécution).

    La solution retenue ne semble pas tenir compte de la liste vide, ou une liste qui ne contient pas l'élément recherché.

    OriginalL'auteur csmith

  3. 3

    Vous pourriez mettre en œuvre indice à l'aide de inverse, membre, longueur, et cdr comme suit:

    (define (index a b)
  (let [(tail (member a (reverse b)))]
    (and tail (length (cdr tail))))

    OriginalL'auteur wedesoft

  4. 0

    ma solution finale:

    (define index
  (lambda (cislo l)
    (if (equal? (car l) cislo) 0 (+ 1 (index cislo (cdr l))))))
(define map-index-pred
  (lambda (pred? f l)
     (foldr (lambda (x y)
       (if (pred? (index x l))
         (cons (f x) y) (cons x y))) '() l)))
    Votre méthode de l'indice n'est pas la queue récursive. Avec de grosses listes, il pourrait donner des problèmes.

    OriginalL'auteur kelly

  5. 0

    La réponse est plus facile que vous les gars prévu, également sans récursivité 🙂

    Simple fonction, dans le cas où vous êtes sûr que l'élément est dans la liste

    (define element-index
  (lambda (elemento lista)
    (- (length lista) (length (memv elemento lista)))))

    Si vous considérez le cas où l'élément ne peut pas être dans la liste. Retour false si elle ne trouve pas

    (define element-index
  (lambda (elemento lista)
    (if (eqv? (list? (memv elemento lista)) #t)
        (- (length lista) (length (memv elemento lista)))
        false
        )
    ))

    Résultat Final:

    > (element-index 2 '(2 3 4 5))
0
> (element-index 4 '(2 3 4 5))
2
> (element-index 6 '(2 3 4 5))
false

    OriginalL'auteur Giacomo Tecya Pigani

  6. 0

    Le code suivant atteint l'objectif :

    (define (getpos element lst)
    (let loop ([counter 0] [temp lst])
        (if (= element (car temp)) counter
            (loop (+ counter 1) (cdr temp)))))

    OriginalL'auteur Jarvis

  7. 0

    Si vous n'avez pas besoin de s'inquiéter à propos de l'affaire que l'élément n'est pas dans la liste, le code suivant est probablement la version la plus courte. (Une exception se produit si l'élément n'est pas dans la liste.)

    (define (element-index e lst)
    (cond [(eqv? e (car lst)) 0]
          [else (+ (element-index e (cdr lst)) 1)])))

    Sinon, utilisez le code suivant:

    (define element-index
  (letrec
    ([element-index-helper
       (lambda (e lst index)
         (cond [(null? lst) #f]
               [(eqv? e (car lst)) index]
               [else (element-index-helper e (cdr lst) (+ index 1))]))])
    (lambda (e lst)
      (element-index-helper e lst 0))))

    Exemples:

    > (element-index 'a '(a b c))
0
> (element-index 'b '(a b c))
1
> (element-index 'c '(a b c))
2
> (element-index 'd '(a b c))
#f

    OriginalL'auteur Shunfan