Palindromi basati
Un numero palindromico, come aggiornamento, è qualsiasi numero che si legge allo stesso modo in avanti e all'indietro. Tuttavia, che dire dei palindromi in altre basi?
Ingresso
Qualsiasi numero intero bdove b > 1.
Produzione
Tutti i numeri interi in base 10 da 0 a 1000 inclusi che sono palindromi in base b. L'output può essere un elenco di numeri interi o numeri interi separati da un delimitatore come una virgola o una nuova riga.
Casi test
Input->Output
10->{0,1,2,3,4,5,6,7,8,9,11,22,33,44,55,66,77,88,99,101,111,121,131,141,151,161,171,181,191,202,212,222,232,242,252,262,272,282,292,303,313,323,333,343,353,363,373,383,393,404,414,424,434,444,454,464,474,484,494,505,515,525,535,545,555,565,575,585,595,606,616,626,636,646,656,666,676,686,696,707,717,727,737,747,757,767,777,787,797,808,818,828,838,848,858,868,878,888,898,909,919,929,939,949,959,969,979,989,999}
2->{0,1,3,5,7,9,15,17,21,27,31,33,45,51,63,65,73,85,93,99,107,119,127,129,153,165,189,195,219,231,255,257,273,297,313,325,341,365,381,387,403,427,443,455,471,495,511,513,561,585,633,645,693,717,765,771,819,843,891,903,951,975}
9->{0,1,2,3,4,5,6,7,8,10,20,30,40,50,60,70,80,82,91,100,109,118,127,136,145,154,164,173,182,191,200,209,218,227,236,246,255,264,273,282,291,300,309,318,328,337,346,355,364,373,382,391,400,410,419,428,437,446,455,464,473,482,492,501,510,519,528,537,546,555,564,574,583,592,601,610,619,628,637,646,656,665,674,683,692,701,710,719,728,730,820,910,1000}
Risposte
Python 3 , 78 byte
Emette i numeri in ordine decrescente 1000 -> 0e cortocircuiti con aZeroDivisionError
def f(b,n=1000):
r=0;m=n
while m:r=r*b+m%b;m//=b
n==r==print(n);f(b,n-n//n)
Provalo online!
Le f(b,n-n//n) -> f(b,n-1)ricorsioni fino a 0, e gli errori perché la divisione per zero non è definita.
Python 3 , 76 byte
Possiamo abbreviare la risposta di 2 byte se è consentito un output in virgola mobile.
def f(b,n=1e3):
r=0;m=n
while m:r=r*b+m%b;m//=b
n==r==print(n);f(b,n-n/n)
Provalo online!
C (gcc) in avanti, 118 117 115 byte
b[11],*p,*x,i,m;f(n){for(i=-1;i++<1e3;){for(p=x=b,m=i;m;*p++=m%n,m/=n);while(p>x)m|=*--p-*x++;m||printf("%d,",i);}}
Provalo online!
C (gcc) , all'indietro, 115 113 byte
b[11],*p,*x,i,m;f(n){for(i=1001;i--;){for(p=x=b,m=i;m;*p++=m%n,m/=n);while(p>x)m|=*--p-*x++;m||printf("%d,",i);}}
Provalo online!
Spiegazione
Firma C:
// Technically implicit int with a void return
void f(int base);
Ripete tutti i numeri da 0 a 1000, li converte in base basea mano, quindi controlla se si tratta di un palindromo.
La versione all'indietro fa la stessa cosa, ma all'indietro.
Stampa i numeri corrispondenti, separati da virgole, su stdout.
Versione ungolfed
#include <stdio.h>
// A buffer to hold our converted integer.
// It is large enough for 1000 in binary.
int buffer[11];
// Start and end pointers for buffer
int *start, *end;
// Loop counter
int i;
// Temporary
int tmp;
void f(int base)
{
// Loop for 0 to 1000
#ifdef BACKWARDS
// Loop backwards
for (i = 1001; i-- != 0;) {
#else
// Loop forwards
// for (i = 0; i <= 1000; i++)
for (i = -1; i++ < 1e3; ) {
#endif
// Convert to base in buffer, tracking the length in end.
for(start = end = buffer, tmp = i; tmp != 0;) {
*end++ = tmp % base;
tmp /= base;
}
// Check if it is a palindrome.
// Loop while our starting pointer is less than our ending pointer.
// tmp will zero at the start thanks to the loop condition.
while (end > start)
// Assembly style comparison using subtraction.
// If *end == *start, tmp will still be zero.
// If not, it will be permanently set to non-zero with a binary or.
tmp |= *--end - *start++;
// If tmp is still zero (meaning it is a palindrome), print.
tmp || printf("%d,", i);
}
}
Grazie ad Arnauld per i -1 byte!
Grazie a Toby Speight per i -2 byte!
05AB1E , 7 byte
₄ÝʒIвÂQ
Provalo online!
Ha spiegato
₄Ý "Push the range [0, 1000]"\
ʒ "and keep the items where:"\
Iв "After being converted to base (input)"\
ÂQ "have its reverse equal to itself"\
Gelatina , 7 byte
ȷŻbŒḂ¥Ƈ
Provalo online!
Come funziona
ȷŻbŒḂ¥Ƈ - Main link. Takes a base b on the left
ȷ - 1000
Ż - [0, 1, 2, ..., 1000]
¥ - Group the previous 2 links into a dyad f(k, b):
b - Convert k to base b
ŒḂ - Is this a palindrome?
Ƈ - Filter [0, 1, 2, ..., 1000], keeping those k that are true under f(k, b)
Japt , 11 byte
A³ô fÈìU êê
Provalo
Wolfram Language (Mathematica) , 44 byte
Pick[r=0~Range~1000,r-r~IntegerReverse~#,0]&
Provalo online!
-13 byte da @att
JavaScript (ES6), 87 86 byte
Restituisce una stringa separata da virgole.
n=>(g=k=>--k&&g(k)+((h=k=>a=k?[k%n,...h(k/n|0)]:[])(k)+''==a.reverse()?[,k]:''))(1001)
Provalo online!
Come?
n => ( // n = input base
g = k => // g is a recursive function taking a counter k
--k && // decrement k; abort if it's equal to 0
g(k) + ( // otherwise do a recursive call and append the ...
( h = k => // ... result of the recursive function h
a = k ? // which builds an array a[]
[ k % n, // consisting of each digit of k in base n,
...h(k / n | 0) ] // dividing k by n and taking the integer part
: // for the next iteration until k = 0
[] //
)(k) + '' // invoke h with k and coerce the result to a string
== a.reverse() ? // if this is palindromic:
[, k] // append a comma followed by k to the output
: // else:
'' // just append an empty string
) //
)(1001) // initial call to g with k = 1001
Scala , 62 87 byte
- Fissato dopo Siu Ching Pong -Asuka Kenji- ha sottolineato
BigInt'iltoStringfunziona solo per le basi fino a 36. - Salvato 1 byte grazie a @cubic lettuce .
b=>0 to 1000 filter{x=>val y=Seq.unfold(x){q=>Option.when(q>0)(q%b,q/b)};y==y.reverse}
Provalo online!
Questo è piuttosto semplice. Fa un intervallo da 0 a 1000, quindi filtra controllando se sono uguali al loro inverso in base b. Per convertire alla base b(come una stringa), BigInt's toStringil metodo è stato utilizzato, ma ora Seq.unfoldviene utilizzato per creare una Seqdelle cifre.
Husk , 12 11 byte
Modifica: -1 byte grazie a LegionMammal978
foS=↔B⁰ŀdḋ9
Provalo online!
Il codice effettivo "palindromo basato" è 7 byte ( foS=↔B⁰), ma specificare 0 ... 1000 costa 5 4 (grazie a LegionMammal978) byte in più.
Potremmo salvare un byte se va bene emettere altri palindromi basati con valori fino al decimale 1024 ( foS=↔B⁰ŀ□32).
f # output the truthy values of
ŀdḋ9 # series from zero up to one less than 1001
# (decimal interpretation of binary digits of '9')
o # based on combination of 2 functions:
S=↔ # 1. is it equal to reverse of itself?
B⁰ # 2. digits in base given by argument
Carboncino , 14 byte
ＮθＩΦ⊕φ⁼↨ιθ⮌↨ιθ
Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:
Ｎθ Input the base `b`
φ Predefined variable 1000
⊕ Incremented
Φ Filter on implicit range
ι Current value
↨ θ Converted to base `b`
⁼ Equals
ι Current value
↨ θ Converted to base `b`
⮌ Reversed
Ｉ Cast to string
Implicitly print
Haskell , 63 byte
f b|let 0%m=m;n%m=div n b%(m*b+mod n b)=[n|n<-[0..1000],n==n%0]
Provalo online!
Basato su una bella idea dalla risposta Python di dingledooper : per verificare che nsia un bpalindromo di base , non generare l'elenco di bcifre di base , ma invertire ncome bnumero di base eseguendo una conversione di base leggendo le cifre dalla fine, e controlla che il risultato sia ancora uguale n.
Il codice |let 0%m=m;n%m=div n b%(m*b+mod n b)definisce ricorsivamente una funzione infix %che inverte la base n(data 0come secondo argomento iniziale). Definirlo all'interno di una letguardia ci consente di accedere all'argomento bdella funzione principale, mentre una funzione standalone dovrebbe continuare a passarlo ad ogni chiamata ricorsiva.
APL (Dyalog Extended) , 17 15 byte
Grazie a Razetime per -2 byte!
Un bug risolto grazie a Siu Ching Pong !
Richiede l'origine dell'indice 0.
⍸⎕(⊤≡∘⌽⊤)¨⍳1001
Provalo online!
⍝ tradfn taking the base as input
⍳1001 ⍝ the indices up to 1000
⍵( )¨ ⍝ apply a function to each index as a right argument and the input base as a left argument:
⌽⊤ ⍝ the reverse of the index converted to the input base
≡ ⍝ does it match
⊤ ⍝ the index converted to the input base
⍸ ⍝ all truthy indices
C - 76 byte
i=1001,a,z;f(b){for(;i--;i-z||printf("%d ",i))for(a=i,z=0;a;a/=b)z=z*b+a%b;}
Spiegazione
Sufficientemente diverso dalla mia risposta precedente per giustificare la pubblicazione separata. Questa volta, invertiamo completamente il numero, quindi confrontiamo con l'originale. Quindi non è necessario eliminare gli zeri finali o il caso speciale 0.
void fun(int b)
{
for (int i = 1001; i--;) {
int z = 0;
for (int a = i; a != 0; a /= b) {
z = z*b + a%b;
}
if (i==z) {
printf("%d ",i);
}
}
}
Questo metodo funziona in modo affidabile ifino a INT_MAX/be bfino a INT_MAXo gli equivalenti appropriati se cambiamo il tipo intero utilizzato. Per i tipi senza segno (o con gcc -fwrapv), dovrebbe funzionare per l'intera gamma di i.
C, 100 byte
i=1001,a,z;f(b){for(;--i;)for(a=i,z=0;i%b*a;a/=b)if(a==z||a==(z=z*b+a%b))printf("%d ",i);puts("0");}
Provalo online
Codice ungolfed
void fun(int b)
{
for (int i = 1001; --i;) {
if (i%b) { /* no leading/trailing zeros */
for (int a = i, z = 0; a != 0; a /= b) {
if (a==z) {
printf("%d ",i);
}
z = z*b + a%b;
if (a==z) {
printf("%d ",i);
}
}
}
}
puts("0");
}
Spiegazione
Questo restituisce i numeri più alti per primi, poiché non è stato specificato alcun ordine particolare. Per ogni numero candidato, lo riduciamo (as a) dividendo successivamente per la base, utilizzando il resto per costruire il numero inverso (in z). Se adiventa uguale a z, allora abbiamo un palindromo. Normalmente, ci fermeremmo qui ( a >= znella condizione di loop), ma per il golf continuiamo fino a a==0.
Dobbiamo testare l'uguaglianza sia prima che dopo aver trasferito il resto a z, per accettare palindromi di lunghezza pari e dispari.
Infine, stampiamo 0, che è sempre un palindromo, ed è più facile da usare in caso speciale che includere nel ciclo.
Il metodo funziona per i numeri interi fino a INT_MAXse ungolf la condizione i%b*adi nuovo a i%b&&a, e sarebbe anche il lavoro per altri tipi interi.
K (ngn / k) , 18 byte
{&{x~|x}'x\'!1001}
Provalo online!
x\'!1001converti ciascuno di 0..1000 nella rappresentazione in base-x{x~|x}'controlla se ogni rappresentazione è un palindromo&ottenere indici di verità
Python 3.8 (pre-rilascio) , 92 85 byte
lambda b:[i for i in range(1001)if(f:=lambda n:n*[0]and[n%b]+f(n//b))(i)==f(i)[::-1]]
Provalo online!
Grazie a dingledooper per aver salvato 7 byte!
Haskell, 67 byte
b&n=take n$mod n b:b&div n b
f b=[n|n<-[0..1000],reverse(b&n)==b&n]
fè la funzione di interesse. Provalo online!
Forse l'unica cosa intelligente qui è l'uso di take nper creare un caso base per la funzione di espansione delle cifre. Quando n=0, take nignora il suo argomento e così la ricorsione si ferma per pigrizia; quando n>0, sicuramente non ci saranno più di ncifre, quindi è sicuro mantenere solo il primo n. La seguente definizione è equivalente (e altrettanto lunga):
b&0=[]
b&n=mod n b:b&div n b
... ma la take nversione è più divertente perché è più confusa. ^ _ ^
J , 27 byte
((-:|.)@(#.inv)"0#])i.@1001
Come
(...) i.@1001- L'intera cosa è un gancio J, il che significa che l'argomento sarà l'arg di sinistra a tutto nelle parentesi e l'arg di destra sarà gli interi da 0 a 1000:i.@1001...#]La frase all'interno delle parentesi usa copy#per filtrare l'argomento destro]dalla maschera booleana risultante dalla frase a sinistra di#:(-:|.)@(#.inv)"0- Il rango 0"0garantisce che la frase si applichi a ogni singolo numero dell'argomento giusto. La frase stessa converte prima ciascuno di quei numeri in una lista di cifre nella base data dall'arg di sinistra(#.inv), e poi controlla se quella lista è uguale al suo contrario(-:|.)@. L'intera frase restituirà quindi 1 quando questo è vero e 0 altrimenti, e questa maschera booleana filtrerà l'argomento giusto come desiderato.
Provalo online!
Ruby 2.7 , 74 byte
->b{(0..1e3).select{(a=(g=->k,r=[]{k>0?g[k/b,r<<k%b]:r})[_1])==a.reverse}}
Provalo online!
TIO utilizza una versione precedente di Ruby, mentre in Ruby 2.7 abbiamo numerato i parametri, che risparmiano due byte.
Ruby , 48 byte
->b{(0..1e3).select{|k|(k=k.to_s b)==k.reverse}}
Provalo online!
Non funziona per basi oltre 64, a causa della limitazione nel .to_smetodo.
JavaScript (V8) , 77 89 byte
Risolto per basi maggiori di 36.
b=>{for(i=-1;i<1e3;){j=[],k=++i;while(k|=0)j.push(k%b),k/=b;''+j==j.reverse()&&print(i)}}
Provalo online!
PowerShell ,
102
100
98
95
87
75 byte
-14 byte grazie a mazzy!
param($u)0..1e3|?{for($b=@();$_=($_-($b+=$_%$u)[-1])/$u){}"$b"-eq$b[11..0]}
Provalo online!
R , 82 81 byte
(o 79 byte utilizzando il delimitatore piuttosto complicato di " \n[1] ")
Modifica: -1 byte grazie a caird coinheringaahing
function(b)for(i in 0:1e3)if(!i||all((a=i%/%b^(0:log(i,b))%%b)==rev(a)))cat(i,'')
Provalo online!
Calcola manualmente le cifre nella nuova rappresentazione di base e controlla se sono uguali a se stesse invertite.
function(b)
for(i in 0:1000) # loop i through zero to 1000
if(!i # if i is zero (always a palindrome),
|| # or
all( # if all the digits of
(a=i%/%b^(0:log(i,b))%%b) # a = the representation of i in base b
==rev(a)) # are the same as themselves reversed
)cat(i,'') # output this i
jq , 66 byte
. as$a|range(1001)|select([while(.>0;./$a|floor)|.%$a]|reverse==.)
Provalo online!
Spiegazione
. as $a | # Assign the input to $a. range(1001) | # For every item in [0..1000]: select ( # Filter out all items where: [ while(. > 0; # The list of quotients from repeatedly . / $a | floor) # short-dividing by $a |. % $a] # And then modulo-ing by $a
| reverse == .) # is equal to its reverse
```
Pyth , 11 byte
f_IjTQUh^T3
Provalo online!
f_IjTQUh^T3 | Explanation
------------+---------------------------------------
f | filter
Uh^T3 | the range [0, 1001)
jTQ | on whether each number in base <input>
_I | equals itself reversed
Java 10, 118 byte
b->{for(int i=-1;i++<1e3;){var s=b.toString(i,b);if(s.contains(new StringBuffer(s).reverse()))System.out.println(i);}}
Provalo online.
Spiegazione:
b->{ // Method with Integer parameter and no return-type
for(int i=-1;i++<1e3;){ // Loop `i` in the range [0,1000]:
var s=b.toString(i,b); // Convert `i` to base-`b` as String
if(s.contains(new StringBuffer(s).reverse()))
// If this String is a palindrome:
System.out.println(i);}} // Print `i` with trailing newline