list - Prologue de la liste séparée par des virgules de la chaîne

6

En SWI-Prolog vous pouvez simplement utiliser atomic_list_concat/3 et atom_string/2:
```
?- atomic_list_concat([apple, banana, oranges], ',', Atom), atom_string(Atom, String).

Atom = 'apple,banana,oranges',
String = "apple,banana,oranges".
```
Cela fonctionne pour les listes d'atomes, et c'est pratique, mais si un des éléments est complexe (comme dans [apple,ba(nana)], il se trompe.

OriginalL'auteur Grzegorz Adam Kowalski
4

En SWI-Prolog vous pouvez utiliser with_output_to/2. Ci-dessous deux versions, l'une en utilisant write/1 et les autres writeq/1. Il n'est pas clair à partir de votre question, ce genre de comportement de votre besoin.
```
?- List = [apple, 'ora\\nge'], with_output_to(codes(Codes), write(List)),
   format("~s", [Codes]).
[apple,ora\nge]
List = [apple, 'ora\\nge'],
Codes = [91, 97, 112, 112, 108, 101, 44, 111, 114|...].

?- List = [apple, 'ora\\nge'], with_output_to(codes(Codes), writeq(List)),
   format("~s", [Codes]).
[apple,'ora\\nge']
List = [apple, 'ora\\nge'],
Codes = [91, 97, 112, 112, 108, 101, 44, 39, 111|...].
```
Pouvez-vous expliquer cela?
Rechercher with_output_to dans le SWI-Prolog manuel: help(with_output_to).
L'expérimentation (parce que la documentation est à peu près inutile pour moi) je trouve que si vous venez d'exécuter les deux premières clauses, List = [apple, 'orange'], with_output_to(codes(Codes), writeq(List)), il définit Codes comme une liste de numéros correspondant à List. La première, 91, doit être le support de caractères; la fuite | signifie qu'il y a plus de gauche, unshown. format() puis l'imprime à l'écran, dans certains langue obscure où ~s veut dire ... euh ...

OriginalL'auteur Kaarel
1

si vous utilisez swi-prolog vous pouvez également effectuer les opérations suivantes:

1) utiliser le string_to_list/2 (vous pouvez donner une liste et d'obtenir une chaîne de caractères ou de donner une chaîne et d'obtenir une liste). le problème, c'est qu'il l'habitude d'insérer des virgules de sorte que vous aurez à insérer des virgules entre les éléments de votre liste manuellement; quelque chose comme
```
insert_commas([],[]).
insert_commas([H|T],[H,', '|TC]):-
   insert_commas(T,TC).
```
de sorte que votre prédicat serait quelque chose comme:
```
list_string_with_commas(L,S):-
   insert_commas(L,LC),
   string_to_list(S,LC).
```
2)vous pouvez utiliser swritef/3 et string_concat/3. swritef/3 fonctionne comme writef/2 mais au lieu d'écrire dans la sortie, il crée une chaîne de caractères avec les données.
```
list_string_with_commas([],"").
list_string_with_commas([H,T],S):-
    swritef(SH,"%t, ",[H]),
    list_string_with_commas(T,ST),
    string_concat(SH,ST,T).
```
vous voulez peut-être faire la queue de la récursivité des optimisations

OriginalL'auteur Thanos Tintinidis

Je suis un Prologue de novice, mais c'est ce que je suis venu avec.

list_codes([], "").

list_codes([Atom], Codes) :- atom_codes(Atom, Codes).

list_codes([Atom|ListTail], Codes) :-
        atom_codes(Atom, AtomCodes),
    append(AtomCodes, ",", AtomCodesWithComma),
    append(AtomCodesWithComma, ListTailCodes, Codes),
    list_codes(ListTail, ListTailCodes).

list_string(List, String) :-
    ground(List),
    list_codes(List, Codes),
    atom_codes(String, Codes).

list_string(List, String) :-
    ground(String),
    atom_codes(String, Codes),
    list_codes(List, Codes).

qui donne:

?- list_string([], S).
S = '' .

?- list_string([apple], S).
S = apple .

?- list_string([apple, orange], S).
S = 'apple,orange' .

?- list_string([apple, orange, peach], S).
S = 'apple,orange,peach' .

et:

?- list_string(L, '').
L = [] .

?- list_string(L, 'banana').
L = [banana] .

?- list_string(L, 'banana,litchi').
L = ['banana,litchi'] .

Merci pour votre réponse
J'ai une question, je veux un prédicat à partir de cette liste. J'ai une liste [pomme,orange]. J'essaie de rendre les fruits(pomme,orange). Pouvez-vous m'aider?
Si vous avez une nouvelle question, puis de publier une nouvelle question, non pas comme un commentaire à une autre réponse. Répondre à cette question bien que déjà: stackoverflow.com/questions/612604/...

OriginalL'auteur Gavin Lock

0

Désolé, de ne pas avoir assez de rep pour ajouter ce commentaire pour Gavin Verrouillage de la réponse. Gavin solution est bonne si loin que ça va, mais il faut être tordu pour éviter de donner des réponses en double (ou, plutôt, une variation sur la même réponse). Le problème est que une liste avec un seul atome d'unifier deux clauses dans list_codes/2: le deuxième ET le troisième alinéa. (Une liste avec un seul élément a toujours une queue, c'est à dire la liste vide.) Je crois que la deuxième clause de liaison est souhaitée. La troisième clause semble être conçu pour être récursive pour les listes qui ont encore au moins deux éléments. Par conséquent, je recommande la modification de cette clause:
```
list_codes([Atom,Next|ListTail], Codes) :-
    atom_codes(Atom, AtomCodes),
    list_codes([Next|ListTail], ListTailCodes),
    append(AtomCodes, ",", AtomCodesWithComma),
    append(AtomCodesWithComma, ListTailCodes, Codes).
```
Cela ne unifier lorsque la liste a au moins deux éléments, et les empêcher d'obtenir deux solutions.

OriginalL'auteur Kaitain
-1

term_string (30 char min S. O.)

Salut @user10221289, pourriez-vous fournir plus d'explications à votre réponse?
En dehors de l'explication, s'il vous plaît également envisager d'ajouter un peu de code en exemple pour démontrer l'effet de votre solution.

OriginalL'auteur user10221289

Vous devez vous connecter pour publier un commentaire.