From 0974e756466142e8a24020f5ff4c3391143b73c2 Mon Sep 17 00:00:00 2001 From: Aleksander Sadikov Date: Tue, 6 Sep 2016 00:03:16 +0200 Subject: English translation for len/2 added. --- prolog/problems/lists_advanced/len_2/en.py | 85 +++++++++++++++++++++++++++++- prolog/problems/lists_advanced/len_2/sl.py | 2 +- 2 files changed, 84 insertions(+), 3 deletions(-) (limited to 'prolog') diff --git a/prolog/problems/lists_advanced/len_2/en.py b/prolog/problems/lists_advanced/len_2/en.py index 9202c2d..33b1675 100644 --- a/prolog/problems/lists_advanced/len_2/en.py +++ b/prolog/problems/lists_advanced/len_2/en.py @@ -2,10 +2,91 @@ name = 'len/2' slug = 'find the length of a list' description = '''\ -

len(L, Len): Len is the length of the list L.

+

len(L, Len): Len is the length of list L.

 ?- len([1,2,3], Len).
   Len = 3.
''' -hint = {} +plan = ['''\ +

A list is not very long if it's empty, and if it's not empty it must have a head and a tail.

+''', '''\ +

If the tail (list without a head) is of length LenT, then the whole list +is of length LenT + 1.

+''', '''\ +

If I take away the head, and the recursion solves this smaller problem (tail), and if I add 1 to the +result returned by the recursion, then I got the length of the whole list.

+'''] + +hint = { + 'eq_instead_of_equ': '''\ +

The operator == is "stricter" than operator = in the sense that +for the latter it is enough to be able to make the two operands equal (unification). Perhaps by using = +you can make the predicate conc/3 more general (e.g. able to work with output arguments becoming inputs).

+

Of course, you can also solve the exercise without explicit use of either of these two operators, just +remember that unification is implicitly performed with the predicate's arguments (head of clause).

+''', + + 'eq_instead_of_equ_markup': '''\ +

Perhaps the operator for unification (=) would be better?

+''', + + 'base_case': '''\ +

Did you think of a base case? Which list is the shortest list in the world?

+''', + + 'recursive_case': '''\ +

The base case is ok. However, what about the general recursive case?

+''', + + 'predicate_always_false': '''\ +

It seems your predicate is always "false". Did you give it the correct name, +or is it perhaps misspelled?

+

If the name is correct, check whether something else is misspelled, perhaps there is a full stop instead of +a comma or vice versa, or maybe you typed a variable name in lowercase?

+

It is, of course, also possible that your conditions are too restrictive, or even impossible to satisfy +(as would be, for example, the condition that N is equal to N + 1, +or something similarly impossible).

+''', + + 'timeout': '''\ +

Is there an infinite recursion at work here? How will it ever stop?

+

Or perhaps is there a missing, faulty, or simply incompatible (with the general recursive case) base case?

+''', + + 'arbitrary_base_case': '''\ +

What's the length of an empty list? Give a number!

+''', + + 'args_not_instantiated': '''\ +

The error that prolog reported means that when it encountered an arithmetic operation, not all the +values were known. Unfortunately, the ordering of goals is important when dealing with arithmetics.

+

Perhaps you can try moving the arithmetic operation more towards the end of the predicate?

+''', + + '=_instead_of_is': '''\ +

Did you use the operator = instead of is? Operator = is used for +unification and tries to leave both its operands with as little modifications as possible while still making +them equal. Operator is, on the other hand, performs actual arithmetic evaluation of its +second operand and only then attempts the unification of both operands.

+''', + + '+H_instead_of_+1': '''\ +

Did you really add the element's value instead of its length (one)? ;)

+''', + + 'forcing_result_onto_recursion': ''' +

Don't force the result onto recursion, don't tell it what it should return. Just assume it will do its job. +If this assumption is correct, then the rule will work for a larger case.

+

Is your recursive call of the form len(T, LenT + 1)? This forces the recursive call to +return the length of the whole list, not just the tail! This will not work. It is your job to +increase by one the result returned by the recursion. In short, add one outside the recursive call.

+''', + + 'same_var_on_both_sides_of_is': '''\ +

Does one of your goals look similar to N is N + 1? Let's assume N is equal to 3. +With this goal you just stated that 3 must be equal to 4 (3+1). Prolog is a logical language and will +gladly say "false" to such a statement! Just use a new variable. The garbage collector will take care of +those not needed anymore automatically.

+''', +} diff --git a/prolog/problems/lists_advanced/len_2/sl.py b/prolog/problems/lists_advanced/len_2/sl.py index c95796b..49b9eea 100644 --- a/prolog/problems/lists_advanced/len_2/sl.py +++ b/prolog/problems/lists_advanced/len_2/sl.py @@ -21,7 +21,7 @@ hint = { 'eq_instead_of_equ': '''\

Operator == je strožji od operatorja = v smislu, da je za slednjega dovolj, da elementa lahko naredi enaka (unifikacija). Morda z uporabo = narediš predikat -memb/2 delujoč tudi v kakšni drugi smeri.

+len/2 delujoč tudi v kakšni drugi smeri.

Seveda pa lahko nalogo rešiš brez obeh omenjenih operatorjev, spomni se, da lahko unifikacijo narediš implicitno že kar v argumentih predikata (glavi stavka).

''', -- cgit v1.2.1