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 list
palavra-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: cdr
sempre 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 car
e cdr
retorne 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 l
algum 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)
fonte
(1 2 3) 16
voltarmos()
?(1 2 3) 16
nunca aparecerá.Respostas:
CJam, 59
Experimente online
Explicação:
fonte
Lisp comum, 99
A solução de 99 bytes a seguir é uma versão CL da boa resposta do esquema .
Originalmente, tentei usar o
position
eposition-if
, mas acabou não sendo tão compacto quanto eu gostaria (209 bytes):Expandido
Exemplo
A lista é citada, mas se você realmente quiser, posso usar uma macro. O valor retornado é [1] :
Para testes, eu costumava gerar um formulário lambda onde
l
era uma variável:Chamar isso com a lista original retorna 14.
[1]
(caddar (cddddr (caddr l)))
seria bom tambémfonte
Retina ,
170142125115114878483757370696867 bytesSim,
menos de 50% demais de 100 bytes da minha primeira tentativa. :)Para executar o código de um único arquivo, use o
-s
sinalizadorAinda não estou convencido de que isso é ótimo ... Não terei muito tempo nos próximos dias, acrescentarei uma explicação eventualmente.
fonte
Pitão, 62 bytes
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 guardoJ
.Então eu reduzo a corda
G = "l"
comu...\l
. Aplico a função interna...
repetidamente aG
, até o valor deG
não mudar mais e depois imprimoG
.A função interna faz o seguinte: Se
J
já é igual ao número de entrada, não modifiqueG
(?qJQG
). Caso contrário, vou achatar a listaJ[:1]
e verificar se o número de entrada está nessa lista e salvá-lo na variávelK
(K}Quu+GHNY<J1)
). Observe que o Pyth não possui um operador achatado, portanto isso leva alguns bytes. SeK
for verdade, atualizo J comJ[0]
, caso contrário comJ[1:]
(=J?KhJtJ
). E então substituoG
por"(cdr G)"
e substituod
oa
, seK
for verdadeiro (++XWK"(cdr "\d\aG\)
).fonte
Esquema (R5RS), 102 bytes
fonte
PHP - 177 bytes
Adicionei algumas novas linhas para facilitar a leitura:
Aqui está a versão não destruída:
fonte
Haskell,
190188 bytesl "(4 5 (1 2 (7) 9 (10 8 14)))" 8
avalia como
"(car (cdr (car (cdr (cdr (cdr (cdr (car (cdr (cdr l))))))))))"
fonte
(
e transformar umac
funçãoc
em uma string:c(h:s)="(c"++h:...
h
sendo um Char!Lisp comum,
168155 bytesAlguma coisa estúpida de recursão, provavelmente poderia ser condensada um pouco mais:
Bonito impresso:
fonte