Rosetta Code

Distinct palindromes within decimal numbers: Difference between revisions

Page Discussion

Distinct palindromes within decimal numbers (view source)

Revision as of 11:29, 26 November 2023

3,562 bytes added ,  5 months ago
m
→‎{{header|Wren}}: Minor tidy
m (Thundergnat moved page Distinct Palindromes Within Decimal Numbers to Distinct Palindromes within decimal numbers: Standardize capitalization)
m (→‎{{header|Wren}}: Minor tidy)
 
(6 intermediate revisions by 5 users not shown)
Line 24:
=={{header|Factor}}==
{{works with|Factor|0.99 2021-02-05}}
<langsyntaxhighlight lang="factor">USING: formatting io kernel math math.ranges present prettyprint
sequences sequences.extras sets ;
 
Line 41:
1320267947849490361205695 }
[ dup dpal [ length 2 < ] reject empty? "%-25d %u\n" printf ]
each</langsyntaxhighlight>
{{out}}
<pre>
Line 90:
=={{header|Go}}==
{{trans|Wren}}
<langsyntaxhighlight lang="go">package main
 
import (
Line 166:
fmt.Printf("%-25s %t\n", num, none)
}
}</langsyntaxhighlight>
 
{{out}}
Line 212:
83071934127905179083 true
1320267947849490361205695 false
</pre>
 
=={{header|jq}}==
'''Works with [[Jq|jq]]''' (but the second task requires a version with support for "big integer" literals)
<br>
'''Works with gojq, the Go implementation of jq''' (provided `keys_unsorted` is replaced by `keys`)
 
In this entry, except for 0 itself, palindromes involving leading 0s are ignored.
 
One feature of the implementation given here is that uniqueness is achieved without
any sorting; however, if gojq is used, then `keys` would have to be used, thus entailing a sort after distinctness has been achieved.
 
Note that for the second task, and for very large integers (greater than 2^53) in general, accurate results require
gojq, or a version of jq supporting "big integer" literals.
<syntaxhighlight lang="jq">
# input: an integer
# output a stream of distinct integers, each representing an admissible palindrome
 
def palindromes:
# input: an array
def is_palindrome: . == reverse;
def all_palindromes:
(tostring|explode)
| range(0; length) as $i
| range($i+1; length+1) as $j
| .[$i:$j] # candidate
| select(is_palindrome)
| implode
# trim leading 0s:
| if length > 1 then sub("^00*"; "") else . end
| select(length>0) ;
 
INDEX(all_palindromes; .) | keys_unsorted[] | tonumber;
 
def task1:
" i palindromes",
(range(100; 126)
| "\(.) \([palindromes]|join(" "))" );
def task2:
(9, 169, 12769, 1238769, 123498769, 12346098769, 1234572098769,
123456832098769, 12345679432098769, 1234567905432098769, 123456790165432098769,
83071934127905179083, 1320267947849490361205695)
| select( any(palindromes; . > 99) );
 
task1,
"\nThe integers amongst those in the problem statement that have 2 or more digits:",
task2</syntaxhighlight>
{{out}}
<pre>
i palindromes
100 1 0
101 1 101 0
102 1 0 2
103 1 0 3
104 1 0 4
105 1 0 5
106 1 0 6
107 1 0 7
108 1 0 8
109 1 0 9
110 1 11 0
111 1 11 111
112 1 11 2
113 1 11 3
114 1 11 4
115 1 11 5
116 1 11 6
117 1 11 7
118 1 11 8
119 1 11 9
120 1 2 0
121 1 121 2
122 1 2 22
123 1 2 3
124 1 2 4
125 1 2 5
 
The integers amongst those in the problem statement that have 2 or more digits:
1320267947849490361205695
</pre>
 
=={{header|Julia}}==
<langsyntaxhighlight lang="julia">function allpalindromes(a::Vector{T}) where T
pals = Vector{Vector{T}}([[x] for x in a])
len = length(a)
Line 240 ⟶ 320:
println(rpad(n, 26), palindrome2plusfree(n))
end
</langsyntaxhighlight>{{out}}
<pre>
Number Palindromes
Line 285 ⟶ 365:
1320267947849490361205695 false
</pre>
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">ClearAll[ContainsPalindromeQ]
ContainsPalindromeQ[n_Integer, minlength_ : 1, b_ : 10] := Select[DeleteDuplicates@Subsequences[IntegerDigits[n, b], {minlength, \[Infinity]}], PalindromeQ]
ContainsPalindromeQ /@ Range[100, 125] // Column
Length[ContainsPalindromeQ[#, 2]] > 0 & /@ {9, 169, 12769, 1238769,
123498769, 12346098769, 1234572098769, 123456832098769,
12345679432098769, 1234567905432098769, 123456790165432098769,
83071934127905179083, 1320267947849490361205695}</syntaxhighlight>
{{out}}
<pre>{{1},{0},{0,0}}
{{1},{0},{1,0,1}}
{{1},{0},{2}}
{{1},{0},{3}}
{{1},{0},{4}}
{{1},{0},{5}}
{{1},{0},{6}}
{{1},{0},{7}}
{{1},{0},{8}}
{{1},{0},{9}}
{{1},{0},{1,1}}
{{1},{1,1},{1,1,1}}
{{1},{2},{1,1}}
{{1},{3},{1,1}}
{{1},{4},{1,1}}
{{1},{5},{1,1}}
{{1},{6},{1,1}}
{{1},{7},{1,1}}
{{1},{8},{1,1}}
{{1},{9},{1,1}}
{{1},{2},{0}}
{{1},{2},{1,2,1}}
{{1},{2},{2,2}}
{{1},{2},{3}}
{{1},{2},{4}}
{{1},{2},{5}}
 
{False, False, False, False, False, False, False, False, False, False, False, False, True}</pre>
 
=={{header|Nim}}==
<langsyntaxhighlight Nimlang="nim">import algorithm, sequtils, sets, strutils
 
iterator substrings(s: string): string =
Line 328 ⟶ 446:
let verb = if pals2.len == 0: " doesn't contain palindromes "
else: " contains at least one palindrome "
echo s, verb, "of two digits or more"</langsyntaxhighlight>
 
{{out}}
Line 373 ⟶ 491:
 
=={{header|Perl}}==
<langsyntaxhighlight lang="perl">#!/usr/bin/perl
 
# https://rosettacode.org/wiki/Distinct_Palindromes_Within_Decimal_Numbers
Line 391 ⟶ 509:
123456832098769, 12345679432098769, 1234567905432098769,
123456790165432098769, 83071934127905179083, 1320267947849490361205695'
=~ /\d+/g;</langsyntaxhighlight>
{{out}}
<pre>
Line 424 ⟶ 542:
 
=={{header|Phix}}==
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<span style="color: #008080;">procedure</span> <span style="color: #000000;">show_all_palindromes</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">longest</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span>
Line 461 ⟶ 579:
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\nNumber Has no &gt;2 digit palindromes\n"</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">papply</span><span style="color: #0000FF;">(</span><span style="color: #004600;">true</span><span style="color: #0000FF;">,</span><span style="color: #000000;">show_all_palindromes</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">tests</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">})</span>
<!--</langsyntaxhighlight>-->
<!--</lang>-->
{{out}}
<pre>
Line 511 ⟶ 628:
=={{header|Raku}}==
A minor modification of the [[Longest_palindromic_substrings#Raku|Longest palindromic substrings]] task. As such, works for any string, not just integers.
<syntaxhighlight lang="raku" perl6line>use Sort::Naturally;
 
sub getpal ($str) {
Line 541 ⟶ 658:
123456832098769, 12345679432098769, 1234567905432098769,
123456790165432098769, 83071934127905179083, 1320267947849490361205695,
<Do these strings contain a minimum two character palindrome?></langsyntaxhighlight>
{{out}}
<pre>All palindromic substrings including (bizarrely enough) single characters:
Line 597 ⟶ 714:
=={{header|REXX}}==
This REXX version can handle strings or numbers.
<syntaxhighlight lang="text">/*REXX pgm finds distinct palindromes contained in substrings (decimal #s or strings). */
parse arg LO HI mL $$ /*obtain optional arguments from the CL*/
if LO='' | LO="," then LO= 100 /*Not specified? Then use the default.*/
Line 635 ⟶ 752:
end /*k*/
end /*j*/
return #</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the default inputs:}}
<pre>
Line 690 ⟶ 807:
 
=={{header|Sidef}}==
<langsyntaxhighlight lang="ruby">func palindromes(arr) {
gather {
for a in (0..arr.end), b in (a .. arr.end) {
var sublist = arr.ftitems(a, ..b -> ...)
take(sublist) if (sublist == sublist.flip)
}
Line 706 ⟶ 823:
123456832098769, 12345679432098769, 1234567905432098769, 123456790165432098769,
83071934127905179083, 1320267947849490361205695, "amanaplanacanalpanama"].each {|n|
var p = palindromes(n.kind_of(Number)  ? n.digits  : n.chars).grep { .len >= 2}
say ("#{'%25s'  % n} has #{'%2d'  % p.len} palindromes of length 2 or more: ",
p.sort.map{.join}.sort_by{.len}.join(' '))
}</langsyntaxhighlight>
{{out}}
<pre>
Line 758 ⟶ 875:
{{libheader|Wren-fmt}}
{{libheader|Wren-sort}}
<langsyntaxhighlight ecmascriptlang="wren">import "./seq" for Lst
import "./fmt" for Fmt
import "./sort" for Sort
 
var substrings = Fn.new { |s|
Line 794 ⟶ 911:
var none = !ss.any { |s| s == s[-1..0] }
Fmt.print("$-25s $s", num, none)
}</langsyntaxhighlight>
 
{{out}}
PureFox
9,476

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/311114...354731"