Code of your own, in any language, to calculate and output all Kaprekar
numbers below 100,000,000.

https://mathworld.wolfram.com/KaprekarNumber.html

Not a ProjectEuler problem.

Break out the fingerpaint, Pedialyte and AppleScript - it's time for
some Piet Programming!

Does emacs lisp count?

;; ------------------
(defun kaprekarp (n)
(let* ((num (* n n))
(snum (number-to-string num))
(num-digits (length (number-to-string n)))
(num-list (string-split snum "" t))
(right-side (reverse (take num-digits (reverse num-list))))
(left-side (reverse (nthcdr num-digits (reverse num-list))))
(left-side-num (string-to-number (mapconcat 'identity left-side)))
(right-side-num (string-to-number (mapconcat 'identity right-side))))
(= n (+ right-side-num left-side-num))))
(defun solve-problem (low high)
(seq-keep (lambda (x)
(and (kaprekarp x) x))
(number-sequence low high)))
(solve-problem 1 100000000)
;; ------------------

A very naive solution, but I am sorry, I am very drunk right now lol
--
(yaxp me) => t

On 3/10/2024 3:41 AM, Yaxley Peaks wrote:
> Does emacs lisp count?
>
> ;; ------------------
> (defun kaprekarp (n)
> (let* ((num (* n n))
> (snum (number-to-string num))
> (num-digits (length (number-to-string n)))
> (num-list (string-split snum "" t))
> (right-side (reverse (take num-digits (reverse num-list))))
> (left-side (reverse (nthcdr num-digits (reverse num-list))))
> (left-side-num (string-to-number (mapconcat 'identity left-side)))
> (right-side-num (string-to-number (mapconcat 'identity right-side))))
> (= n (+ right-side-num left-side-num))))
> (defun solve-problem (low high)
> (seq-keep (lambda (x)
> (and (kaprekarp x) x))
> (number-sequence low high)))
> (solve-problem 1 100000000)
> ;; ------------------
>
> A very naive solution, but I am sorry, I am very drunk right now lol

ha! Were you drunk before you started writing the Lisp code?

I submitted it here:
https://rextester.com/l/common_lisp_online_compiler

And got:
Error(s), warning(s):
*** - EVAL: undefined function SEQ-KEEP

When you sober up:
------------------------------------------------------------------------
import sys, time
k=1
start = time.time()
for i in range(4,int(sys.argv[1].replace(',', ''))):
s, n = str(i**2), len(str(i))
if len(s) % 2 != 0: n-=1
p1, p2 = int(s[0:n]), int(s[n:])
if p1 + p2 == i:
print("%4d. %7d ^ 2 = %-16s %8s + %8s = %d" % (k, i, s, p1, p2,
p1+p2))
k+=1
print("%.1fs" % (time.time() - start))
------------------------------------------------------------------------

$ python Knums.py 10,000,000

1. 9 ^ 2 = 81 8 + 1 = 9
2. 45 ^ 2 = 2025 20 + 25 = 45
3. 55 ^ 2 = 3025 30 + 25 = 55
4. 99 ^ 2 = 9801 98 + 1 = 99
5. 297 ^ 2 = 88209 88 + 209 = 297
6. 703 ^ 2 = 494209 494 + 209 = 703
7. 999 ^ 2 = 998001 998 + 1 = 999
8. 2223 ^ 2 = 4941729 494 + 1729 = 2223
9. 2728 ^ 2 = 7441984 744 + 1984 = 2728
10. 4950 ^ 2 = 24502500 2450 + 2500 = 4950
11. 5050 ^ 2 = 25502500 2550 + 2500 = 5050
12. 7272 ^ 2 = 52881984 5288 + 1984 = 7272
13. 7777 ^ 2 = 60481729 6048 + 1729 = 7777
14. 9999 ^ 2 = 99980001 9998 + 1 = 9999
15. 17344 ^ 2 = 300814336 3008 + 14336 = 17344
16. 22222 ^ 2 = 493817284 4938 + 17284 = 22222
17. 77778 ^ 2 = 6049417284 60494 + 17284 = 77778
18. 82656 ^ 2 = 6832014336 68320 + 14336 = 82656
19. 95121 ^ 2 = 9048004641 90480 + 4641 = 95121
20. 99999 ^ 2 = 9999800001 99998 + 1 = 99999
21. 142857 ^ 2 = 20408122449 20408 + 122449 = 142857
22. 148149 ^ 2 = 21948126201 21948 + 126201 = 148149
23. 181819 ^ 2 = 33058148761 33058 + 148761 = 181819
24. 187110 ^ 2 = 35010152100 35010 + 152100 = 187110
25. 208495 ^ 2 = 43470165025 43470 + 165025 = 208495
26. 318682 ^ 2 = 101558217124 101558 + 217124 = 318682
27. 329967 ^ 2 = 108878221089 108878 + 221089 = 329967
28. 351352 ^ 2 = 123448227904 123448 + 227904 = 351352
29. 356643 ^ 2 = 127194229449 127194 + 229449 = 356643
30. 390313 ^ 2 = 152344237969 152344 + 237969 = 390313
31. 461539 ^ 2 = 213018248521 213018 + 248521 = 461539
32. 466830 ^ 2 = 217930248900 217930 + 248900 = 466830
33. 499500 ^ 2 = 249500250000 249500 + 250000 = 499500
34. 500500 ^ 2 = 250500250000 250500 + 250000 = 500500
35. 533170 ^ 2 = 284270248900 284270 + 248900 = 533170
36. 538461 ^ 2 = 289940248521 289940 + 248521 = 538461
37. 609687 ^ 2 = 371718237969 371718 + 237969 = 609687
38. 643357 ^ 2 = 413908229449 413908 + 229449 = 643357
39. 648648 ^ 2 = 420744227904 420744 + 227904 = 648648
40. 670033 ^ 2 = 448944221089 448944 + 221089 = 670033
41. 681318 ^ 2 = 464194217124 464194 + 217124 = 681318
42. 791505 ^ 2 = 626480165025 626480 + 165025 = 791505
43. 812890 ^ 2 = 660790152100 660790 + 152100 = 812890
44. 818181 ^ 2 = 669420148761 669420 + 148761 = 818181
45. 851851 ^ 2 = 725650126201 725650 + 126201 = 851851
46. 857143 ^ 2 = 734694122449 734694 + 122449 = 857143
47. 961038 ^ 2 = 923594037444 923594 + 37444 = 961038
48. 994708 ^ 2 = 989444005264 989444 + 5264 = 994708
49. 999999 ^ 2 = 999998000001 999998 + 1 = 999999
50. 4444444 ^ 2 = 19753082469136 1975308 + 2469136 = 4444444
51. 4927941 ^ 2 = 24284602499481 2428460 + 2499481 = 4927941
52. 5072059 ^ 2 = 25725782499481 2572578 + 2499481 = 5072059
53. 5555556 ^ 2 = 30864202469136 3086420 + 2469136 = 5555556
54. 9372385 ^ 2 = 87841600588225 8784160 + 588225 = 9372385
55. 9999999 ^ 2 = 99999980000001 9999998 + 1 = 9999999
6.2s

And 1 is somehow considered a Kaprekar number.

Le 10-03-2024, DFS <nospam@dfs.com> a écrit :
> On 3/10/2024 3:41 AM, Yaxley Peaks wrote:
>> Does emacs lisp count?
>
> I submitted it here:
> https://rextester.com/l/common_lisp_online_compiler

Emacs Lisp is neither Common Lisp nor Scheme. You have to use Emacs (or
something compatible with Emacs) to be able to run it.

--
Si vous avez du temps à perdre :
https://scarpet42.gitlab.io

On Mar 10, 2024 at 10:46:27 AM EDT, "DFS" <nospam@dfs.com> wrote:

> On 3/10/2024 3:41 AM, Yaxley Peaks wrote:
>> Does emacs lisp count?
>>
>> ;; ------------------
>> (defun kaprekarp (n)
>> (let* ((num (* n n))
>> (snum (number-to-string num))
>> (num-digits (length (number-to-string n)))
>> (num-list (string-split snum "" t))
>> (right-side (reverse (take num-digits (reverse num-list))))
>> (left-side (reverse (nthcdr num-digits (reverse num-list))))
>> (left-side-num (string-to-number (mapconcat 'identity left-side)))
>> (right-side-num (string-to-number (mapconcat 'identity right-side))))
>> (= n (+ right-side-num left-side-num))))
>> (defun solve-problem (low high)
>> (seq-keep (lambda (x)
>> (and (kaprekarp x) x))
>> (number-sequence low high)))
>> (solve-problem 1 100000000)
>> ;; ------------------
>>
>> A very naive solution, but I am sorry, I am very drunk right now lol
>
>
> ha! Were you drunk before you started writing the Lisp code?
>
>
> I submitted it here:
> https://rextester.com/l/common_lisp_online_compiler
>
> And got:
> Error(s), warning(s):
> *** - EVAL: undefined function SEQ-KEEP
>
>
>
> When you sober up:
> ------------------------------------------------------------------------
> import sys, time
> k=1
> start = time.time()
> for i in range(4,int(sys.argv[1].replace(',', ''))):
> s, n = str(i**2), len(str(i))
> if len(s) % 2 != 0: n-=1
> p1, p2 = int(s[0:n]), int(s[n:])
> if p1 + p2 == i:
> print("%4d. %7d ^ 2 = %-16s %8s + %8s = %d" % (k, i, s, p1, p2,
> p1+p2))
> k+=1
> print("%.1fs" % (time.time() - start))
> ------------------------------------------------------------------------
>
> $ python Knums.py 10,000,000
>
>
> 1. 9 ^ 2 = 81 8 + 1 = 9
> 2. 45 ^ 2 = 2025 20 + 25 = 45
> 3. 55 ^ 2 = 3025 30 + 25 = 55
> 4. 99 ^ 2 = 9801 98 + 1 = 99
> 5. 297 ^ 2 = 88209 88 + 209 = 297
> 6. 703 ^ 2 = 494209 494 + 209 = 703
> 7. 999 ^ 2 = 998001 998 + 1 = 999
> 8. 2223 ^ 2 = 4941729 494 + 1729 = 2223
> 9. 2728 ^ 2 = 7441984 744 + 1984 = 2728
> 10. 4950 ^ 2 = 24502500 2450 + 2500 = 4950
> 11. 5050 ^ 2 = 25502500 2550 + 2500 = 5050
> 12. 7272 ^ 2 = 52881984 5288 + 1984 = 7272
> 13. 7777 ^ 2 = 60481729 6048 + 1729 = 7777
> 14. 9999 ^ 2 = 99980001 9998 + 1 = 9999
> 15. 17344 ^ 2 = 300814336 3008 + 14336 = 17344
> 16. 22222 ^ 2 = 493817284 4938 + 17284 = 22222
> 17. 77778 ^ 2 = 6049417284 60494 + 17284 = 77778
> 18. 82656 ^ 2 = 6832014336 68320 + 14336 = 82656
> 19. 95121 ^ 2 = 9048004641 90480 + 4641 = 95121
> 20. 99999 ^ 2 = 9999800001 99998 + 1 = 99999
> 21. 142857 ^ 2 = 20408122449 20408 + 122449 = 142857
> 22. 148149 ^ 2 = 21948126201 21948 + 126201 = 148149
> 23. 181819 ^ 2 = 33058148761 33058 + 148761 = 181819
> 24. 187110 ^ 2 = 35010152100 35010 + 152100 = 187110
> 25. 208495 ^ 2 = 43470165025 43470 + 165025 = 208495
> 26. 318682 ^ 2 = 101558217124 101558 + 217124 = 318682
> 27. 329967 ^ 2 = 108878221089 108878 + 221089 = 329967
> 28. 351352 ^ 2 = 123448227904 123448 + 227904 = 351352
> 29. 356643 ^ 2 = 127194229449 127194 + 229449 = 356643
> 30. 390313 ^ 2 = 152344237969 152344 + 237969 = 390313
> 31. 461539 ^ 2 = 213018248521 213018 + 248521 = 461539
> 32. 466830 ^ 2 = 217930248900 217930 + 248900 = 466830
> 33. 499500 ^ 2 = 249500250000 249500 + 250000 = 499500
> 34. 500500 ^ 2 = 250500250000 250500 + 250000 = 500500
> 35. 533170 ^ 2 = 284270248900 284270 + 248900 = 533170
> 36. 538461 ^ 2 = 289940248521 289940 + 248521 = 538461
> 37. 609687 ^ 2 = 371718237969 371718 + 237969 = 609687
> 38. 643357 ^ 2 = 413908229449 413908 + 229449 = 643357
> 39. 648648 ^ 2 = 420744227904 420744 + 227904 = 648648
> 40. 670033 ^ 2 = 448944221089 448944 + 221089 = 670033
> 41. 681318 ^ 2 = 464194217124 464194 + 217124 = 681318
> 42. 791505 ^ 2 = 626480165025 626480 + 165025 = 791505
> 43. 812890 ^ 2 = 660790152100 660790 + 152100 = 812890
> 44. 818181 ^ 2 = 669420148761 669420 + 148761 = 818181
> 45. 851851 ^ 2 = 725650126201 725650 + 126201 = 851851
> 46. 857143 ^ 2 = 734694122449 734694 + 122449 = 857143
> 47. 961038 ^ 2 = 923594037444 923594 + 37444 = 961038
> 48. 994708 ^ 2 = 989444005264 989444 + 5264 = 994708
> 49. 999999 ^ 2 = 999998000001 999998 + 1 = 999999
> 50. 4444444 ^ 2 = 19753082469136 1975308 + 2469136 = 4444444
> 51. 4927941 ^ 2 = 24284602499481 2428460 + 2499481 = 4927941
> 52. 5072059 ^ 2 = 25725782499481 2572578 + 2499481 = 5072059
> 53. 5555556 ^ 2 = 30864202469136 3086420 + 2469136 = 5555556
> 54. 9372385 ^ 2 = 87841600588225 8784160 + 588225 = 9372385
> 55. 9999999 ^ 2 = 99999980000001 9999998 + 1 = 9999999
> 6.2s
>
> And 1 is somehow considered a Kaprekar number.

1 IS a Kaprekar number.

Other than 1, your list above is missing at least 4 numbers: 4879, 5292, 38962
and 627615. The reason is you are not handling zeros correctly.

But seriously, these numbers are constants. There is no need to waste my time
and computer time calculating them. Put them in an array and do a search for
whatever number you want to check. "Is 123456 a Kaprekar number?" Not in the
array, so no it is not.

Done.

If I was writing a program that used PI (3.14159265) in many places, I would
define it as a CONST. I would not waste my time calculating it every time I
needed it. PI has already been calculated to one million digits.

Why waste time re-inventing the wheel?

> And got:
> Error(s), warning(s):
> *** - EVAL: undefined function SEQ-KEEP

SEQ-KEEP was added in emacs 29, what version are you using?
https://www.gnu.org/software/emacs/manual/html_node/elisp/Sequence-Functions.html#index-seq_002dkeep

>Were you drunk before you started writing the Lisp code?
yeah :)
--
(yaxp me) => t

On 3/10/2024 11:59 AM, Yaxley Peaks wrote:
>> And got:
>> Error(s), warning(s):
>> *** - EVAL: undefined function SEQ-KEEP
>
> SEQ-KEEP was added in emacs 29, what version are you using?
> https://www.gnu.org/software/emacs/manual/html_node/elisp/Sequence-Functions.html#index-seq_002dkeep

As I said, I submitted it here:
https://rextester.com/l/common_lisp_online_compiler

Just post the output of your lisp code.

(defun kaprekarp (n)
(let* ((num (* n n))
(snum (number-to-string num))
(num-digits (length (number-to-string n)))
(num-list (string-split snum "" t))
(right-side (reverse (take num-digits (reverse num-list))))
(left-side (reverse (nthcdr num-digits (reverse num-list))))
(left-side-num (string-to-number (mapconcat 'identity left-side)))
(right-side-num (string-to-number (mapconcat 'identity
right-side))))
(= n (+ right-side-num left-side-num))))
(defun solve-problem (low high)
(seq-keep (lambda (x)
(and (kaprekarp x) x))
(number-sequence low high)))
(solve-problem 1 100000000)

On 3/10/2024 11:52 AM, Tyrone wrote:
> On Mar 10, 2024 at 10:46:27 AM EDT, "DFS" <nospam@dfs.com> wrote:

> Other than 1, your list above is missing at least 4 numbers: 4879, 5292, 38962
> and 627615. The reason is you are not handling zeros correctly.

Depends on who you ask.

https://oeis.org/A053816
https://oeis.org/A006886

> But seriously, these numbers are constants. There is no need to waste my time
> and computer time calculating them.

You just wasted your time and computer time responding to this post.

> Put them in an array and do a search for
> whatever number you want to check. "Is 123456 a Kaprekar number?" Not in the
> array, so no it is not.
>
> Done.

There are infinite K numbers.

Better to use a few lines of code to calculate/check them on demand. And
then you can generalize the K code for powers > 2 (not shown here, but
easy to do).

def isKaprekar(val,exp):
s,n = str(val**exp), len(str(val))
if len(s) % exp != 0: n-=1
p1,p2 = int(s[0:n]), int(s[n:])
if p1 + p2 == val:
return True
else:
return False

> Why waste time re-inventing the wheel?

What if I want to call out that talentless "REAL programmer /
mathematician / extraordinaire" hack Feeb Russell, so I can watch him
squirm and flub a tiny math program?

On Sun, 10 Mar 2024 15:48:47 -0400, DFS <nospam@dfs.com> wrote in
<usl2qu$34lr8$3@dont-email.me>:

> On 3/10/2024 11:52 AM, Tyrone wrote:
>> On Mar 10, 2024 at 10:46:27 AM EDT, "DFS" <nospam@dfs.com> wrote:
>
>
>> Other than 1, your list above is missing at least 4 numbers: 4879, 5292, 38962
>> and 627615. The reason is you are not handling zeros correctly.
>
> Depends on who you ask.
>
> https://oeis.org/A053816
> https://oeis.org/A006886
>
>
>> But seriously, these numbers are constants. There is no need to waste my time
>> and computer time calculating them.
>
> You just wasted your time and computer time responding to this post.
>
>
>
>> Put them in an array and do a search for
>> whatever number you want to check. "Is 123456 a Kaprekar number?" Not in the
>> array, so no it is not.
>>
>> Done.
>
> There are infinite K numbers.
>
> Better to use a few lines of code to calculate/check them on demand. And
> then you can generalize the K code for powers > 2 (not shown here, but
> easy to do).
>
> def isKaprekar(val,exp):
> s,n = str(val**exp), len(str(val))
> if len(s) % exp != 0: n-=1
> p1,p2 = int(s[0:n]), int(s[n:])
> if p1 + p2 == val:
> return True
> else:
> return False
>
>
>
> > Why waste time re-inventing the wheel?
>
> What if I want to call out that talentless "REAL programmer /
> mathematician / extraordinaire" hack Feeb Russell, so I can watch him
> squirm and flub a tiny math program?

That would be an off-charter post, like this one.

--
-v

On 3/10/2024 3:56 PM, vallor wrote:
> On Sun, 10 Mar 2024 15:48:47 -0400, DFS <nospam@dfs.com> wrote in

Telling me my post is off-charter is off-charter.

Get on-charter! Now!

On Sun, 10 Mar 2024 16:00:19 -0400, DFS <nospam@dfs.com> wrote in
<usl3gj$34lr8$4@dont-email.me>:

> On 3/10/2024 3:56 PM, vallor wrote:
>> On Sun, 10 Mar 2024 15:48:47 -0400, DFS <nospam@dfs.com> wrote in
>
>
> Telling me my post is off-charter is off-charter.
>
>
> Get on-charter! Now!

Are you threatened by the prospect of not being on charter?

ObLinux:
COMPFACE(1) General Commands Manual COMPFACE(1)

NAME
compface, uncompface - compress and expand 48x48x1 face image
files

SYNOPSIS
compface [ infile [ outfile ] ] ...

uncompface [-X] [ infile [ outfile ] ] ...
_ _ _ _ _ _ _

Does Windows have compface(1)?

--
-v

On Sun, 10 Mar 2024 16:00:19 -0400, DFS <nospam@dfs.com> wrote in
<usl3gj$34lr8$4@dont-email.me>:

> On 3/10/2024 3:56 PM, vallor wrote:
>> On Sun, 10 Mar 2024 15:48:47 -0400, DFS <nospam@dfs.com> wrote in
>
>
> Telling me my post is off-charter is off-charter.
>
>
> Get on-charter! Now!

I did, and I even asked you a question about Windows
vs. Linux.

ObLinux:
Windows has Linux as an installable component now.
Womp-womp.

--
-v

On Mar 10, 2024 at 3:48:47 PM EDT, "DFS" <nospam@dfs.com> wrote:

> What if I want to call out that talentless "REAL programmer /
> mathematician / extraordinaire" hack Feeb Russell, so I can watch him
> squirm and flub a tiny math program?

This is a ridiculous way to attempt to "call out" anyone. This code is already
available in every language you have heard of, and some you have never heard
of. For example:

<https://rosettacode.org/wiki/Kaprekar_numbers>

Here it is in Ursala:

==========
Ursala
First we define a function kd parameterized by a pair of functions p and r for
printing and reading natural numbers, which takes a natural number to its
Kaprekar decomposition if any.

#import std
#import nat

kd("p","r") = ~&ihB+ (~&rr&& ^|E/~& sum)~|^/~& "r"~~*hNCtXS+ cuts\1+ "p"+
product@iiX

#cast %nLnX

t = ^|(~&,length) (iota; :/1+ ~&rFlS+ * ^/~& kd\%np ~&h+ %nP)~~/10000 1000000
==========

Now THAT is some obscure code!

There are dozens more, from Ada to zkl. Even IBM 360 Assembly. Pick your
language and run the code.

AGAIN, there is way more to programming than just trivial math problems.
Particularly, trivial math problems that have already been solved in every
language, many years ago.

This is not a "programming challenge". It is a simple internet search
challenge.

On 3/10/2024 4:34 PM, Tyrone wrote:
> On Mar 10, 2024 at 3:48:47 PM EDT, "DFS" <nospam@dfs.com> wrote:
>
>> What if I want to call out that talentless "REAL programmer /
>> mathematician / extraordinaire" hack Feeb Russell, so I can watch him
>> squirm and flub a tiny math program?
>
> This is a ridiculous way to attempt to "call out" anyone. This code is already
> available in every language you have heard of, and some you have never heard
> of.

I didn't ask for previously-written code.

> There are dozens more, from Ada to zkl. Even IBM 360 Assembly. Pick your
> language and run the code.

I don't care.

I wrote my own python first, based on the Wolfram page, then asked Feeb
for his version in any language.

> AGAIN, there is way more to programming than just trivial math problems.

I never said there wasn't.

> Particularly, trivial math problems that have already been solved in every
> language, many years ago.

Not by Feeb.

> This is not a "programming challenge".

Of course it is.

Read the first 4 words of the original post.

> It is a simple internet search challenge.

Even though I clearly explained, you still don't get it.

On 3/9/2024 7:51 PM, DFS wrote:
> Code of your own, in any language, to calculate and output all Kaprekar
> numbers below 100,000,000.
>
> https://mathworld.wolfram.com/KaprekarNumber.html
>
> Not a ProjectEuler problem.
>
>
> Break out the fingerpaint, Pedialyte and AppleScript  -  it's time for
> some Piet Programming!

21 hours of crickets (DST adjustment made)

On Mar 10, 2024 at 4:49:07 PM EDT, "DFS" <nospam@dfs.com> wrote:

> On 3/10/2024 4:34 PM, Tyrone wrote:
>> This is not a "programming challenge".
>
> Of course it is.
>
> Read the first 4 words of the original post.

So? Is that some command that must be obeyed? I can take any code that I
find, change the functions/variables/modules/whatever names, re-arrange it and
present it as "my code".

If for some bizarre reason I needed to display Kaprekar Numbers at work, I
would certainly look first for "off-the-shelf" code that already works. I
would not waste my time writing my own.

For example. 25 years ago I was a new hire at my current job. Someone else was
working on a project that needed to export data in EBCDIC (IBM mainframe
character set) instead of ASCII (PC character set). She was not excited at the
prospect of writing an EBCDIC/ASCII conversion function. As luck would have
it, I already had written one about 5 years earlier in my previous job. I gave
her the code, she plugged it into her project and it all was working in a
short period of time. I even had utilities to view the EBCDIC data on a PC,
converting it all back into ASCII for viewing.

The point is this. When tested, production-ready code already exists you don't
waste time rolling your own. That code still exists and is still working in
that product today.

>> It is a simple internet search challenge.
>
> Even though I clearly explained, you still don't get it.

Even though I have clearly explained it, YOU still don't get it. If you really
want to challenge someone, come up with a unique problem that has not been
solved already by millions of people over the last 40 years. REAL problem
solving happens when YOU have to actually code/test/verify that YOU have
solved the problem.

What's next? "Challenge" people to print out Prime Numbers?

On 3/10/2024 7:27 PM, Tyrone wrote:
> On Mar 10, 2024 at 4:49:07 PM EDT, "DFS" <nospam@dfs.com> wrote:

> What's next? "Challenge" people to print out Prime Numbers?

It's funny that you think Feeb is a person.

On 3/10/2024 4:05 PM, vallor wrote:
> On Sun, 10 Mar 2024 16:00:19 -0400, DFS <nospam@dfs.com> wrote in
> <usl3gj$34lr8$4@dont-email.me>:
>
>> On 3/10/2024 3:56 PM, vallor wrote:
>>> On Sun, 10 Mar 2024 15:48:47 -0400, DFS <nospam@dfs.com> wrote in
>>
>>
>> Telling me my post is off-charter is off-charter.
>>
>>
>> Get on-charter! Now!
>
> Are you threatened by the prospect of not being on charter?

It consumes me.

> ObLinux:
> COMPFACE(1) General Commands Manual COMPFACE(1)
>
> NAME
> compface, uncompface - compress and expand 48x48x1 face image
> files
>
> SYNOPSIS
> compface [ infile [ outfile ] ] ...
>
> uncompface [-X] [ infile [ outfile ] ] ...
> _ _ _ _ _ _ _
>
> Does Windows have compface(1)?

Yeah, but it's an 18.5 year old version

https://gnuwin32.sourceforge.net/packages/compface.htm

On 3/10/2024 6:27 PM, Tyrone wrote:
> Even though I have clearly explained it, YOU still don't get it. If you really
> want to challenge someone, come up with a unique problem that has not been
> solved already by millions of people over the last 40 years. REAL problem
> solving happens when YOU have to actually code/test/verify that YOU have
> solved the problem.
>
> What's next? "Challenge" people to print out Prime Numbers?

I asked you to do the base conversion into e as challenge and you
weaseled your way silently out.

Why don't you do that and show your code here. Preferably in C, but even
BASIC would do. Just don't use some funky language to smear it for me to
run, and visually check your code.

--
This email has been checked for viruses by Avast antivirus software.
www.avast.com

On 3/10/2024 8:12 PM, Physfitfreak wrote:
> On 3/10/2024 6:27 PM, Tyrone wrote:
>> Even though I have clearly explained it, YOU still don't get it. If
>> you really
>> want to challenge someone, come up with a unique problem that has not
>> been
>> solved already by millions of people over the last 40 years. REAL problem
>> solving happens when YOU have to actually code/test/verify that YOU have
>> solved the problem.
>>
>> What's next?  "Challenge" people to print out Prime Numbers?
>
>
> I asked you to do the base conversion into e as challenge and you
> weaseled your way silently out.
>
> Why don't you do that and show your code here. Preferably in C, but even
> BASIC would do. Just don't use some funky language to smear it for me to
> run, and visually check your code.

Sandy,

wtf is it with you and Feeb insisting others do your challenges, but
running away when you're asked to do them?

I asked you weeks ago to write a little C to do matrix multiplication
using [i][j] addressing, and I've seen no response. Why?

Don't be afraid you won't get it exactly right. I'm not gonna laugh at
it, or criticize it. If I can suggest improvements I will. If I see
innovation I'll say so. We're here to learn and be entertained, right?

The only code I savage is from that lying, blustering, nasty asshole
Feeb. He used to make lie-excuses that he was too busy, or the code
would contain "subtleties" (meaning too difficult to get right). Now
the wimp just out and out ignores them.

---------------------------------------------------------------------------
matrix creation/fill/multiply/print using only [i][j] addressing
---------------------------------------------------------------------------
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>

double elapsedtime(clock_t start) {
return (clock() - (double)start)/CLOCKS_PER_SEC;
}

int main(void) {

clock_t start;
//2^11 = 1024 (~3 seconds)
//2^12 = 2048 (~30 seconds), after that code gets very slow
int max = 12;
srand(time(NULL));
//run for powers of 2
for (int i = 2; i < max; i++) {

//size of matrices
int N = pow(2,i);

//allocate memory for matrices A,B,C
int (*A) [N] = malloc(sizeof(int[N][N]));
int (*B) [N] = malloc(sizeof(int[N][N]));
int (*C) [N] = malloc(sizeof(int[N][N]));

//fill matrices A,B with random values
for (int i=0; i < N; i++) {
for (int j=0; j < N; j++) {
A[i][j] = rand() % N;
B[i][j] = rand() % N;
}
}

//print 4x4 or 8x8 random data
if (N==4) {
printf("\n 4x4 Random Data \n");
printf(" Matrix A Matrix B\n");
printf(" ------------- -------------\n");
}

if (N==8) {
printf("\n 8x8 Random Data \n");
printf(" Matrix A Matrix B\n");
printf(" -----------------------------
-----------------------------\n");
}

if (N==4 || N==8) {
for (int p=0; p < N; p++) {
for (int j=0; j < N; j++) {printf("%3d ",A[p][j]);}
for (int j=0; j < N; j++) {printf("%3d ",B[p][j]);}
printf("\n");
}
}

//standard matrix multiply using nested loops
start = clock();
for (int i=0; i < N; i++) {
for (int j=0; j < N; j++) {
C[i][j] = 0;
for (int k=0; k < N; k++) {
C[i][j] += A[i][k] * B[k][j];
}
}
}

//print 4x4 or 8x8 data
if (N==4 || N==8) {
printf("\nMatrix C: multiply A * B\n------------------------\n");
for (int p=0; p < N; p++) {
for (int j=0; j < N; j++) {printf("%3d ",C[p][j]);}
printf("\n");
}
printf("\n");
}

//timing results
printf("N=%4d: multiplication in %.4fs\n",N,elapsedtime(start));

//release memory
free(A);
free(B);
free(C);

}

return(0);

}
---------------------------------------------------------------------------

for max speed, compile it like this:
$ gcc -O3 codefile.c -o progname -lm

run it:
$ ./progname

Feeb posted a link

https://johnnysswlab.com/make-your-programs-run-faster-by-better-using-the-data-cache/

that showed a slightly different matrix multiplication technique they
called 'loop interchange'. It really does make a difference.

for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
C[i][j] = 0;
}
for (int k = 0; k < N; k++) {
for (int j = 0; j < N; j++) {
C[i][j] += A[i][k] * B[k][j];
}
}
}