problems of everyday life

problems of everyday life

[Emanuel Berg]

If you are to boil one egg for 5 minutes, the other for
7 minutes, and the third one for 10 minutes, how long time
does it take to boil all three eggs?

In Lisp, there are several ways to solve this, it can be
put as

  (+ 5 7 10)

or maybe

  (apply #'+ '(5 7 10))

or ... well, what do you prefer?

-- 
underground experts united
https://dataswamp.org/~incal

Re: problems of everyday life

[Heime]

If you were a chef, 10 minutes!


------- Original Message -------
On Tuesday, November 15th, 2022 at 3:19 PM, Emanuel Berg <incal@dataswamp.org> wrote:


> If you are to boil one egg for 5 minutes, the other for
> 7 minutes, and the third one for 10 minutes, how long time
> does it take to boil all three eggs?
> 
> In Lisp, there are several ways to solve this, it can be
> put as
> 
> (+ 5 7 10)
> 
> or maybe
> 
> (apply #'+ '(5 7 10))
> 
> or ... well, what do you prefer?
> 
> --
> underground experts united
> https://dataswamp.org/~incal

Re: problems of everyday life

[Dmitry Gutov]

On 15.11.2022 17:19, Emanuel Berg wrote:
> If you are to boil one egg for 5 minutes, the other for
> 7 minutes, and the third one for 10 minutes, how long time
> does it take to boil all three eggs?

10 minutes.

Re: problems of everyday life

[Heime]

------- Original Message -------
On Tuesday, November 15th, 2022 at 4:46 PM, Dmitry Gutov <dgutov@yandex.ru> wrote:


> On 15.11.2022 17:19, Emanuel Berg wrote:
> 
> > If you are to boil one egg for 5 minutes, the other for
> > 7 minutes, and the third one for 10 minutes, how long time
> > does it take to boil all three eggs?
> 
> 
> 10 minutes.

I wonder what he is smoking or drinking!

Re: problems of everyday life

[tomas]

[-- Attachment #1: Type: text/plain, Size: 314 bytes --]

On Tue, Nov 15, 2022 at 04:19:21PM +0100, Emanuel Berg wrote:
> If you are to boil one egg for 5 minutes, the other for
> 7 minutes, and the third one for 10 minutes, how long time
> does it take to boil all three eggs?

As others have already said... c'mon. Save energy!

  (max 5 7 10)

Cheers
-- 
t

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 195 bytes --]

Re: problems of everyday life

[Juri Linkov]

> or maybe
>
>   (apply #'+ '(5 7 10))
>
> or ... well, what do you prefer?

This reminds the implementation of sleep sort:

  (dolist (i '(3 1 4 1 5 92 65 3 5 89 79 3))
    (run-with-timer (* i 0.001) nil 'message "%d" i))

The sorted output printed in the *Messages* buffer:

  1 [2 times]
  3 [3 times]
  4
  5 [2 times]
  65
  79
  89
  92

Re: problems of everyday life

[Akib Azmain Turja]

[-- Attachment #1: Type: text/plain, Size: 810 bytes --]

Heime <heimeborgia@protonmail.com> writes:

> ------- Original Message -------
> On Tuesday, November 15th, 2022 at 4:46 PM, Dmitry Gutov <dgutov@yandex.ru> wrote:
>
>
>> On 15.11.2022 17:19, Emanuel Berg wrote:
>> 
>> > If you are to boil one egg for 5 minutes, the other for
>> > 7 minutes, and the third one for 10 minutes, how long time
>> > does it take to boil all three eggs?
>> 
>> 
>> 10 minutes.

It is less than 10 minutes.  Start boiling and just do whatever you
like.  Your clock would say 10 minutes have passed, but you'd object.

>
> I wonder what he is smoking or drinking!
>

-- 
Akib Azmain Turja, GPG key: 70018CE5819F17A3BBA666AFE74F0EFA922AE7F5
Fediverse: akib@hostux.social
Codeberg: akib
emailselfdefense.fsf.org | "Nothing can be secure without encryption."

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 832 bytes --]

Re: problems of everyday life

[Akib Azmain Turja]

[-- Attachment #1: Type: text/plain, Size: 1246 bytes --]

Juri Linkov <juri@linkov.net> writes:

>> or maybe
>>
>>   (apply #'+ '(5 7 10))
>>
>> or ... well, what do you prefer?
>
> This reminds the implementation of sleep sort:
>
>   (dolist (i '(3 1 4 1 5 92 65 3 5 89 79 3))
>     (run-with-timer (* i 0.001) nil 'message "%d" i))
>
> The sorted output printed in the *Messages* buffer:
>
>   1 [2 times]
>   3 [3 times]
>   4
>   5 [2 times]
>   65
>   79
>   89
>   92
>

Someone implemented addition using sleep.  Now I have implemented
subtraction:

--8<---------------cut here---------------start------------->8---
(defun subtract (x y)
  (when (< y x)
    (let ((tmp x))
      (setq x y)
      (setq y tmp)))
  (let ((time-a (current-time)))
    (sleep-for x)
    (let ((time-b (current-time)))
      (while (< (float-time (time-subtract nil time-a)) y)
        (sleep-for 0.9))
      (floor (float-time (time-subtract nil time-b))))))

(subtract 0 1)     ; => 1
(subtract 3 5)     ; => 2
--8<---------------cut here---------------end--------------->8---

-- 
Akib Azmain Turja, GPG key: 70018CE5819F17A3BBA666AFE74F0EFA922AE7F5
Fediverse: akib@hostux.social
Codeberg: akib
emailselfdefense.fsf.org | "Nothing can be secure without encryption."

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 832 bytes --]

Re: problems of everyday life

[Emanuel Berg]

Juri Linkov wrote:

>> or maybe
>>
>>   (apply #'+ '(5 7 10))
>>
>> or ... well, what do you prefer?
>
> This reminds the implementation of sleep sort:
>
>   (dolist (i '(3 1 4 1 5 92 65 3 5 89 79 3))
>     (run-with-timer (* i 0.001) nil 'message "%d" i))
>
> The sorted output printed in the *Messages* buffer:
>
>   1 [2 times]
>   3 [3 times]
>   4
>   5 [2 times]
>   65
>   79
>   89
>   92

Haha, brilliant :)

-- 
underground experts united
https://dataswamp.org/~incal

Re: problems of everyday life

[Emanuel Berg]

Juri Linkov wrote:

>> or maybe
>>
>>   (apply #'+ '(5 7 10))
>>
>> or ... well, what do you prefer?
>
> This reminds the implementation of sleep sort:
>
>   (dolist (i '(3 1 4 1 5 92 65 3 5 89 79 3))
>     (run-with-timer (* i 0.001) nil 'message "%d" i))

This made my day :)

(defun sleep-sort (&rest lst)
  (let ((sorted))
    (dolist (i lst)
      (run-with-timer (* i 0.001) nil (lambda () (push i sorted))) )
    (while (> (length lst) (length sorted))
      (sleep-for 1) )
    (nreverse sorted) ))

(sleep-sort 3 1 4 1 5 92 65 3 5 89 79 3)

-> (1 1 3 3 3 4 5 5 65 79 89 92)

Maybe one can integrate the busy wait somehow since the
maximum wait time is known ...

-- 
underground experts united
https://dataswamp.org/~incal

Re: problems of everyday life

[Rudolf Adamkovič]

Juri Linkov <juri@linkov.net> writes:

> This reminds the implementation of sleep sort:

LOL!  Thanks for sharing.

Rudy
-- 
"Be especially critical of any statement following the word
'obviously.'"
-- Anna Pell Wheeler, 1883-1966

Rudolf Adamkovič <salutis@me.com> [he/him]
Studenohorská 25
84103 Bratislava
Slovakia

Re: problems of everyday life

[Emanuel Berg]

Rudolf Adamkovič wrote:

>> This reminds the implementation of sleep sort
>
> LOL! Thanks for sharing.

I wonder if there are input data for which it is
actually superior?

-- 
underground experts united
https://dataswamp.org/~incal

Re: problems of everyday life

[Emanuel Berg]

Akib Azmain Turja wrote:

> Someone implemented addition using sleep.  Now I have implemented
> subtraction:
>
> (defun subtract (x y)
>   (when (< y x)
>     (let ((tmp x))
>       (setq x y)
>       (setq y tmp)))
>   (let ((time-a (current-time)))
>     (sleep-for x)
>     (let ((time-b (current-time)))
>       (while (< (float-time (time-subtract nil time-a)) y)
>         (sleep-for 0.9))
>       (floor (float-time (time-subtract nil time-b))))))
>
> (subtract 0 1)     ; => 1
> (subtract 3 5)     ; => 2

What about recursive counting?

(defun recursive-count (n)
  (if (zerop n)
      0
    (1+ (recursive-count (1- n))) ))

(recursive-count 5) ; 5

-- 
underground experts united
https://dataswamp.org/~incal

Re: problems of everyday life

[North Year]

Emanuel Berg <incal@dataswamp.org> writes:

> If you are to boil one egg for 5 minutes, the other for
> 7 minutes, and the third one for 10 minutes, how long time
> does it take to boil all three eggs?
>
> In Lisp, there are several ways to solve this, it can be
> put as
>
>   (+ 5 7 10)
>
> or maybe
>
>   (apply #’+ ’(5 7 10))
>
> or … well, what do you prefer?

This leads to a dynamic programming problem I guess.

x eggs to be boiled each of which need x_i times to be boiled.
y pots can be used to boil egges each of which has capacity to cook y_i eggs at one time.

Never tried to writing algorithm codes in elisp. This would be interesting.

Re: problems of everyday life

[Emanuel Berg]

North Year wrote:

> This leads to a dynamic programming problem I guess.
>
> x eggs to be boiled each of which need x_i times to be
> boiled. y pots can be used to boil egges each of which has
> capacity to cook y_i eggs at one time.
>
> Never tried to writing algorithm codes in elisp. This would
> be interesting.

Be sure to post it here :)

-- 
underground experts united
https://dataswamp.org/~incal

Re: problems of everyday life

[Emanuel Berg]

North Year wrote:

> This leads to a dynamic programming problem I guess.
>
> x eggs to be boiled each of which need x_i times to be
> boiled. y pots can be used to boil egges each of which has
> capacity to cook y_i eggs at one time.
>
> Never tried to writing algorithm codes in elisp. This would
> be interesting.

Is this correct?

(require 'cl-lib)

(defun boil-eggs (eggs pots)
  (setq eggs (sort eggs #'>))
  (setq pots (sort pots #'>))
  (setf (cdr (last pots)) pots)
  (let ((time 0))
    (while eggs
      (cl-incf time (car eggs))
      (setq eggs (cl-subseq eggs (min (car pots) (length eggs))))
      (pop pots) )
    time) )

(boil-eggs '(5 7 8 10)   '(2)) ; 17
(boil-eggs '(5 7 8 10) '(2 3)) ; 15

-- 
underground experts united
https://dataswamp.org/~incal

Re: problems of everyday life

[Emanuel Berg]

North Year wrote:

> This leads to a dynamic programming problem I guess.
>
> x eggs to be boiled each of which need x_i times to be
> boiled. y pots can be used to boil egges each of which has
> capacity to cook y_i eggs at one time.
>
> Never tried to writing algorithm codes in elisp. This would
> be interesting.

;;; -*- lexical-binding: t -*-
;;
;; this file:
;;   https://dataswamp.org/~incal/emacs-init/eggs.el

(require 'cl-lib)

(defun boil-eggs (eggs pots)
  (unless pots
    (error "No pot! Have you been smoking some weed in Sweeden?"))
  (setq eggs (sort eggs #'>))
  (setq pots (sort pots #'>))
  (setf (cdr (last pots)) pots)
  (let ((time 0))
    (while eggs
      (cl-incf time (car eggs))
      (setq eggs (cl-subseq eggs (min (car pots) (length eggs))))
      (pop pots) )
    time) )

;; (boil-eggs '(5) ())            ; DNC
;; (boil-eggs  () '(5))           ; 0
;; (boil-eggs '(5 7 8 10)   '(2)) ; 17
;; (boil-eggs '(5 7 8 10) '(2 3)) ; 15

-- 
underground experts united
https://dataswamp.org/~incal

Re: problems of everyday life

[Stefan Monnier via Users list for the GNU Emacs text editor]

Reminds me of those analog logic circuits which use "standard" digital
gates but represent analog values as durations during which a signal is
asserted, so you can implement the `max` and `min` functions with `or`
and `and` gates respectively.


        Stefan


Akib Azmain Turja [2022-11-16 18:10:54] wrote:

> Juri Linkov <juri@linkov.net> writes:
>
>>> or maybe
>>>
>>>   (apply #'+ '(5 7 10))
>>>
>>> or ... well, what do you prefer?
>>
>> This reminds the implementation of sleep sort:
>>
>>   (dolist (i '(3 1 4 1 5 92 65 3 5 89 79 3))
>>     (run-with-timer (* i 0.001) nil 'message "%d" i))
>>
>> The sorted output printed in the *Messages* buffer:
>>
>>   1 [2 times]
>>   3 [3 times]
>>   4
>>   5 [2 times]
>>   65
>>   79
>>   89
>>   92
>>
>
> Someone implemented addition using sleep.  Now I have implemented
> subtraction:
>
> --8<---------------cut here---------------start------------->8---
> (defun subtract (x y)
>   (when (< y x)
>     (let ((tmp x))
>       (setq x y)
>       (setq y tmp)))
>   (let ((time-a (current-time)))
>     (sleep-for x)
>     (let ((time-b (current-time)))
>       (while (< (float-time (time-subtract nil time-a)) y)
>         (sleep-for 0.9))
>       (floor (float-time (time-subtract nil time-b))))))
>
> (subtract 0 1)     ; => 1
> (subtract 3 5)     ; => 2
> --8<---------------cut here---------------end--------------->8---

Re: problems of everyday life

[Emanuel Berg]

Stefan Monnier via Users list for the GNU Emacs text editor wrote:

> Reminds me of those analog logic circuits which use
> "standard" digital gates but represent analog values as
> durations [...]

Reminds me what happens if you do 1 + 1 on a Norwegian
calculator, it says "Computing ..."

-- 
underground experts united
https://dataswamp.org/~incal

Re: problems of everyday life

[tomas]

[-- Attachment #1: Type: text/plain, Size: 526 bytes --]

On Wed, Nov 16, 2022 at 10:04:18PM -0500, Stefan Monnier via Users list for the GNU Emacs text editor wrote:
> Reminds me of those analog logic circuits which use "standard" digital
> gates but represent analog values as durations during which a signal is
> asserted, so you can implement the `max` and `min` functions with `or`
> and `and` gates respectively.

Neurons do it in a similar way (OK, OK, it is shot frequency,
but hey).

The other way around, and and or are just threshold functions.

Cheers
-- 
t

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 195 bytes --]

Re: problems of everyday life

[Yuri Khan]

On Thu, 17 Nov 2022 at 10:05, Stefan Monnier via Users list for the
GNU Emacs text editor <help-gnu-emacs@gnu.org> wrote:

> Reminds me of those analog logic circuits which use "standard" digital
> gates but represent analog values as durations during which a signal is
> asserted, so you can implement the `max` and `min` functions with `or`
> and `and` gates respectively.

Assuming all signals are phase-synchronized. Otherwise:

     _._._._._._
    |           |_._._._.  x = 6/10
           _._._._._._
    ._._._|           |_.  y = 6/10
           _._._
    ._._._|     |_._._._.  (x and y) = 3/10

Re: problems of everyday life

[Stefan Monnier]

>> Reminds me of those analog logic circuits which use "standard" digital
>> gates but represent analog values as durations during which a signal is
>> asserted, so you can implement the `max` and `min` functions with `or`
>> and `and` gates respectively.
>
> Assuming all signals are phase-synchronized. Otherwise:
>
>      _._._._._._
>     |           |_._._._.  x = 6/10
>            _._._._._._
>     ._._._|           |_.  y = 6/10
>            _._._
>     ._._._|     |_._._._.  (x and y) = 3/10

Indeed, these are synchronous circuits just like in standard
digital circuits.


        Stefan

Re: problems of everyday life

[Jean Louis]

* Emanuel Berg <incal@dataswamp.org> [2022-11-15 19:40]:
> If you are to boil one egg for 5 minutes, the other for
> 7 minutes, and the third one for 10 minutes, how long time
> does it take to boil all three eggs?
> 
> In Lisp, there are several ways to solve this, it can be
> put as
> 
>   (+ 5 7 10)
> 
> or maybe
> 
>   (apply #'+ '(5 7 10))
> 
> or ... well, what do you prefer?

I prefer Kottbullar with eggs on side, and you are the one to cook.

-- 
Jean

Take action in Free Software Foundation campaigns:
https://www.fsf.org/campaigns

In support of Richard M. Stallman
https://stallmansupport.org/