Missão de Extração Lisp

19

Nas linguagens de estilo Lisp, uma lista é geralmente definida assim:

(list 1 2 3)

Para os propósitos deste desafio, todas as listas conterão apenas números inteiros positivos ou outras listas. Também deixaremos de fora a listpalavra-chave no início; portanto, a lista ficará assim:

(1 2 3)

Podemos obter o primeiro elemento de uma lista usando car. Por exemplo:

(car (1 2 3))
==> 1

E podemos obter a lista original com o primeiro elemento removido com cdr:

(cdr (1 2 3))
==> (2 3)

Importante: cdrsempre retornará uma lista, mesmo que essa lista tenha um único elemento:

(cdr (1 2))
==> (2)
(car (cdr (1 2)))
==> 2

As listas também podem estar em outras listas:

(cdr (1 2 3 (4 5 6)))
==> (2 3 (4 5 6))

Escreva um programa que retorne o código que usa care cdrretorne um determinado número inteiro em uma lista. No código que seu programa retorna, você pode assumir que a lista está armazenada l, o número inteiro de destino está em lalgum lugar e todos os números inteiros são exclusivos.

Exemplos:

Entrada: (6 1 3) 3

Resultado: (car (cdr (cdr l)))

Entrada: (4 5 (1 2 (7) 9 (10 8 14))) 8

Resultado: (car (cdr (car (cdr (cdr (cdr (cdr (car (cdr (cdr l))))))))))

Entrada: (1 12 1992) 1

Resultado: (car l)

absinto
fonte
Podemos pegar a entrada com o inteiro primeiro e a lista em segundo?
Martin Ender
@ MartinBüttner Claro.
absinto
Que tal (1 2 3) 16voltarmos ()?
Coredump
@coredump Boa pergunta. Você pode assumir que o número inteiro alvo sempre estará na expressão; portanto, um caso como (1 2 3) 16nunca aparecerá.
absinthe
Podemos receber duas entradas, uma para a lista e outra para o número inteiro?
Blackhole

Respostas:

1

CJam, 59

q"()""[]"er~{:AL>{0jA1<e_-_A(?j'l/"(car l)"@{2'dt}&*}"l"?}j

Experimente online

Explicação:

q                 read the input
"()""[]"er        replace parentheses with square brackets
~                 evaluate the string, pushing an array and a number
{…}j              calculate with memoized recursion using the array as the argument
                   and the number as the memozied value for argument 0
  :A              store the argument in A
  L>              practically, check if A is an array
                   if A is a (non-empty) array, compare with an empty array
                   (result 1, true)
                   if A is a number, slice the empty array from that position
                   (result [], false)
    {…}           if A is an array
      0j          get the memoized value for 0 (the number to search)
      A1<         slice A keeping only its first element
      e_          flatten array
      -           set difference - true iff the number was not in the array
      _           duplicate the result (this is the car/cdr indicator)
      A(          uncons A from left, resulting in the "cdr" followed by the "car"
      ?           choose the cdr if the number was not in the flattened first item,
                   else choose the car
      j           call the block recursively with the chosen value as the argument
      'l/         split the result around the 'l' character
      "(car l)"   push this string
      @           bring up the car/cdr indicator
      {…}&        if true (indicating cdr)
        2'dt      set the character in position 2 to 'd'
      *           join the split pieces using the resulting string as a separator
    "l"           else (if A is not an array) just push "l"
                   (we know that when we get to a number, it is the right number)
    ?             end if
aditsu
fonte
10

Lisp comum, 99

A solução de 99 bytes a seguir é uma versão CL da boa resposta do esquema .

(defun g(l n &optional(o'l))(if(eql n l)o(and(consp l)(or(g(car l)n`(car,o))(g(cdr l)n`(cdr,o))))))

Originalmente, tentei usar o positione position-if, mas acabou não sendo tão compacto quanto eu gostaria (209 bytes):

(lambda(L x &aux(p'l))(labels((f(S &aux e)(cons(or(position x S)(position-if(lambda(y)(if(consp y)(setf e(f y))))S)(return-from f()))e)))(dolist(o(print(f L))p)(dotimes(i o)(setf p`(cdr,p)))(setf p`(car,p)))))

Expandido

(lambda
  (l x &aux (p 'l))
  (labels ((f (s &aux e)
             (cons
              (or (position x s)
                  (position-if
                   (lambda (y)
                     (if (consp y)
                         (setf e (f y))))
                   s)
                  (return-from f nil))
              e)))
    (dolist (o (print (f l)) p)
      (dotimes (i o) (setf p `(cdr ,p)))
      (setf p `(car ,p)))))

Exemplo

(funcall *fun* '(4 5 (1 2 (7) 9 (10 8 14))) 14)

A lista é citada, mas se você realmente quiser, posso usar uma macro. O valor retornado é [1] :

(CAR (CDR (CDR (CAR (CDR (CDR (CDR (CDR (CAR (CDR (CDR L)))))))))))

Para testes, eu costumava gerar um formulário lambda onde lera uma variável:

(LAMBDA (#:G854) (CAR (CDR (CDR (CAR (CDR (CDR (CDR (CDR (CAR (CDR (CDR #:G854))))))))))))

Chamar isso com a lista original retorna 14.


[1] (caddar (cddddr (caddr l)))seria bom também

coredump
fonte
2
Você respondeu a uma pergunta sobre o Lisp com o Lisp! É Lisp-ception!
DanTheMan
4
@DanTheMan Lisp-cepção é muito bonito o que define Lisp ;-)
coredump
9

Retina , 170 142 125 115 114 87 84 83 75 73 70 69 68 67 bytes

Sim, menos de 50% de mais de 100 bytes da minha primeira tentativa. :)

\b(.+)\b.* \1$
(
^.
l
\(
a
+`a *\)|\d


d
+`(.*[l)])(\w)
(c$2r $1)

Para executar o código de um único arquivo, use o -ssinalizador

Ainda não estou convencido de que isso é ótimo ... Não terei muito tempo nos próximos dias, acrescentarei uma explicação eventualmente.

Martin Ender
fonte
5

Pitão, 62 bytes

JvXz"() ,][")u?qJQG&=J?K}Quu+GHNY<J1)hJtJ++XWK"(cdr "\d\aG\)\l

Experimente on-line: Demonstration or Test Suite

Explicação:

O primeiro bit JvXz"() ,][")substitui os caracteres "() "pelos caracteres "[],"da string de entrada, que termina em uma representação de uma lista no estilo Python. Eu avalio e guardo J.

Então eu reduzo a corda G = "l"com u...\l. Aplico a função interna ...repetidamente a G, até o valor de Gnão mudar mais e depois imprimo G.

A função interna faz o seguinte: Se Jjá é igual ao número de entrada, não modifique G( ?qJQG). Caso contrário, vou achatar a lista J[:1]e verificar se o número de entrada está nessa lista e salvá-lo na variável K( K}Quu+GHNY<J1)). Observe que o Pyth não possui um operador achatado, portanto isso leva alguns bytes. Se Kfor verdade, atualizo J com J[0], caso contrário com J[1:]( =J?KhJtJ). E então substituo Gpor "(cdr G)"e substituo do a, se Kfor verdadeiro ( ++XWK"(cdr "\d\aG\)).

Jakube
fonte
5

Esquema (R5RS), 102 bytes

(let g((l(read))(n(read))(o'l))(if(pair? l)(or(g(car l)n`(car,o))(g(cdr l)n`(cdr,o)))(and(eq? n l)o)))
Anders Kaseorg
fonte
1

PHP - 177 bytes

Adicionei algumas novas linhas para facilitar a leitura:

function f($a,$o,$n){foreach($a as$v){if($n===$v||$s=f($v,$o,$n))return
'(car '.($s?:$o).')';$o="(cdr $o)";}}function l($s,$n){echo f(eval(strtr
("return$s;",'() ','[],')),l,$n);}

Aqui está a versão não destruída:

function extractPhp($list, $output, $number)
{
    foreach ($list as $value)
    {
        if (is_int($value))
        {
            if ($value === $number) {
                return '(car '. $output .')';
            }
        }
        else
        {
            $subOutput = extractPhp($value, $output, $number);
            if ($subOutput !== null) {
                return '(car '. $subOutput .')';
            }
        }

        $output = '(cdr '. $output .')';
    }
}

function extractLisp($stringList, $number)
{
    $phpCode = 'return '. strtr($stringList, '() ','[],') .';';
    $list = eval($phpCode);
    echo extractPhp($list, 'l', $number);
}
Blackhole
fonte
1

Haskell, 190 188 bytes

l "(4 5 (1 2 (7) 9 (10 8 14)))" 8

avalia como

"(car (cdr (car (cdr (cdr (cdr (cdr (car (cdr (cdr l))))))))))"

l(h:s)n=c$i(show n)s""""
i n(h:s)t l|h>'/'&&h<':'=i n s(t++[h])l|t==n='a':l|h=='('=j$'a':l|h==')'=j$tail$dropWhile(=='d')l|0<1=j$'d':l where j=i n s""
c[]="l"
c(h:s)="(c"++h:"r "++c s++")"
Leif Willerts
fonte
11
Você pode ativar (e transformar uma cfunção cem uma string:c(h:s)="(c"++h:...
nimi
Uau, não acho que isso funcionaria hsendo um Char!
Leif Willerts
0

Lisp comum, 168 155 bytes

Alguma coisa estúpida de recursão, provavelmente poderia ser condensada um pouco mais:

(lambda(l e)(labels((r(l o)(setf a(car l)d(cdr l)x`(car,o)y`(cdr,o))(if(equal e a)x(if(atom a)(r d y)(if(find e l)(r d y)(if d(r d y)(r a x)))))))(r l'l)))

Bonito impresso:

(lambda (l e)
  (labels ((r (l o)
             (setf a (car l) d (cdr l)
                   x `(car ,o) y `(cdr ,o))
             (if (equal e a) x
                 (if (atom a)
                     (r d y)
                     (if (find e l)
                         (r d y)
                         (if d
                             (r d y)
                             (r a x)))))))
    (r l 'l)))
babá
fonte