查找列表中的元素索引

Question

我需要在方案中获取列表中的元素索引。例如：

（... 2 '（2 3 4 5））

（... 4'（2 3 4 5））

有人可以帮忙吗？

Answer 1

我的最终解决方案：

(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))) 

Answer 2

财产以后这样

(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)))))))) 

Answer 3

以下是最明显的解决方案，我能想出：

(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)))))) 

该解决方案在很大程度上是相同的作为merriav的，除了我在最后添加了一个let以便递归调用不会不必要地重复（以书面代码或执行）。

接受的解决方案似乎没有考虑空列表或列表中不包含正在寻找的元素。

Answer 4

答案是更容易比你们预期的，也没有递归:)

简单的功能，如果你确信该元素在列表中

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

如果你考虑的情况下元素可能不在列表中。返回false如果没有找到

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

最终结果：

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

Answer 5

你可以使用反向，成员，长度和CDR如下实施指数：

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

Answer 6

下面的代码实现了目标：

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

Answer 7

如果你不需要担心元素不在列表中的情况下，下面的代码可能是最短的版本。 （如果元素不在列表中，则会发生异常。）

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

否则，使用下面的代码：

(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)))) 

例子：

> (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