Palindromes à base
Un nombre palindromique, pour rappel, est tout nombre qui lit la même chose en avant et en arrière. Cependant, qu'en est-il des palindromes dans d'autres bases?
Contribution
Tout entier boù b > 1.
Production
Tous les nombres entiers en base 10 de 0 à 1000 inclus qui sont des palindromes en base b. La sortie peut être une liste d'entiers ou des entiers séparés par un délimiteur tel qu'une virgule ou une nouvelle ligne.
Cas de 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}
Réponses
Python 3 , 78 octets
Sort les nombres par ordre décroissant 1000 -> 0et les court-circuits avec unZeroDivisionError
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)
Essayez-le en ligne!
La f(b,n-n//n) -> f(b,n-1)récursion jusqu'à 0et des erreurs car la division par zéro n'est pas définie.
Python 3 , 76 octets
Nous pouvons raccourcir la réponse de 2 octets si une sortie en virgule flottante est autorisée.
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)
Essayez-le en ligne!
C (gcc) vers l' avant, 118 117 115 octets
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);}}
Essayez-le en ligne!
C (gcc) , vers l' arrière, 115 113 bytes
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);}}
Essayez-le en ligne!
Explication
Signature C:
// Technically implicit int with a void return
void f(int base);
Boucle à travers tous les nombres de 0 à 1000, les convertit en base baseà la main, puis vérifie s'il s'agit d'un palindrome.
La version à l'envers fait la même chose, mais à l'envers.
Imprime les numéros correspondants, séparés par des virgules, sur stdout.
Version non golfée
#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);
}
}
Merci à Arnauld pour les -1 octets!
Merci à Toby Speight pour les -2 octets!
05AB1E , 7 octets
₄ÝʒIвÂQ
Essayez-le en ligne!
Expliqué
₄Ý "Push the range [0, 1000]"\
ʒ "and keep the items where:"\
Iв "After being converted to base (input)"\
ÂQ "have its reverse equal to itself"\
Gelée , 7 octets
ȷŻbŒḂ¥Ƈ
Essayez-le en ligne!
Comment ça fonctionne
ȷŻ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 octets
A³ô fÈìU êê
Essayez-le
Wolfram Language (Mathematica) , 44 octets
Pick[r=0~Range~1000,r-r~IntegerReverse~#,0]&
Essayez-le en ligne!
-13 octets de @att
JavaScript (ES6), 87 86 octets
Renvoie une chaîne séparée par des virgules.
n=>(g=k=>--k&&g(k)+((h=k=>a=k?[k%n,...h(k/n|0)]:[])(k)+''==a.reverse()?[,k]:''))(1001)
Essayez-le en ligne!
Comment?
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 octets
- Correction après Siu Ching Pong -Asuka Kenji- a souligné
BigInt« stoStringne fonctionne que pour les bases jusqu'à 36. - Économisé 1 octet grâce à la laitue @cubic .
b=>0 to 1000 filter{x=>val y=Seq.unfold(x){q=>Option.when(q>0)(q%b,q/b)};y==y.reverse}
Essayez-le en ligne!
C'est assez simple. Il fait une plage de 0 à 1000, puis filtre en vérifiant si elles égalent leur inverse en base b. Pour convertir à la base b(sous forme de chaîne), BigIntde » toStringla méthode est a été utilisé, mais maintenant Seq.unfoldest utilisé pour créer un Seqdes chiffres.
Husk , 12 11 octets
Edit: -1 octet grâce à LegionMammal978
foS=↔B⁰ŀdḋ9
Essayez-le en ligne!
Le code réel du «palindrome basé» est de 7 octets ( foS=↔B⁰), mais spécifier 0 ... 1000 coûte 5 4 octets de plus (grâce à LegionMammal978).
Nous pourrions économiser un octet s'il est correct de sortir quelques palindromes basés supplémentaires avec des valeurs allant jusqu'à 1024 décimales ( 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
Charbon , 14 octets
ＮθＩΦ⊕φ⁼↨ιθ⮌↨ιθ
Essayez-le en ligne! Le lien est vers la version verbeuse du code. Explication:
Ｎθ 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 octets
f b|let 0%m=m;n%m=div n b%(m*b+mod n b)=[n|n<-[0..1000],n==n%0]
Essayez-le en ligne!
Basé sur une bonne idée de la réponse Python de dingledooper : pour vérifier qu'il ns'agit d'un bpalindrome de base , ne générez pas la liste des bchiffres de base , mais inversez-la en ntant que bnuméro de base en exécutant une conversion de base en lisant les chiffres à partir de la fin, et vérifiez que le résultat est toujours égal n.
Le code |let 0%m=m;n%m=div n b%(m*b+mod n b)définit de manière récursive une fonction infixe %qui inverse la base n(donnée 0comme deuxième argument initial). Le définir à l'intérieur d'un letgarde nous permet d'accéder à l'argument bde la fonction principale, alors qu'une fonction autonome devrait continuer à le transmettre à chaque appel récursif.
APL (Dyalog Extended) , 17 15 octets
Merci à Razetime pour -2 octets!
Un bug corrigé grâce à Siu Ching Pong !
Nécessite l'origine de l'index 0.
⍸⎕(⊤≡∘⌽⊤)¨⍳1001
Essayez-le en ligne!
⍝ 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 octets
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;}
Explication
Suffisamment différent de ma réponse précédente pour justifier l'affichage séparément. Cette fois, nous inversons complètement le nombre, puis comparons à l'original. Nous n'avons donc pas besoin d'éliminer les zéros de fin ou les cas spéciaux 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);
}
}
}
Cette méthode fonctionne de manière fiable pour ijusqu'à INT_MAX/bet bjusqu'à INT_MAX, ou les équivalents appropriés si nous changeons le type entier utilisé. Pour les types non signés (ou avec gcc -fwrapv), cela devrait fonctionner pour la gamme complète de i.
C, 100 octets
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");}
Essayez-le en ligne
Code non golfé
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");
}
Explication
Cela génère les nombres les plus élevés en premier, car aucun ordre particulier n'a été spécifié. Pour chaque numéro candidat, nous le réduisons (as a) en le divisant successivement par la base, en utilisant le reste pour construire le nombre inverse (en z). Si adevient égal à z, alors nous avons un palindrome. Normalement, nous nous arrêtions là ( a >= zdans la condition de la boucle), mais pour le golf, nous continuons tout le chemin a==0.
Nous devons tester l'égalité avant et après le transfert du reste vers z, pour accepter les palindromes de longueur paire et impaire.
Enfin, nous imprimons 0, qui est toujours un palindrome, et il est plus facile à cas particulier qu'à inclure dans la boucle.
La méthode fonctionne pour les entiers jusqu'à INT_MAXsi nous ungolf la condition de i%b*aretour à i%b&&a, et travailleraient aussi pour d' autres types entiers.
K (ngn / k) , 18 octets
{&{x~|x}'x\'!1001}
Essayez-le en ligne!
x\'!1001convertir chacune de 0..1000 en représentation base-x{x~|x}'vérifier si chaque représentation est un palindrome&obtenir des indices de vrais
Python 3.8 (pré-version) , 92 85 octets
lambda b:[i for i in range(1001)if(f:=lambda n:n*[0]and[n%b]+f(n//b))(i)==f(i)[::-1]]
Essayez-le en ligne!
Merci à dingledooper d' avoir économisé 7 octets!
Haskell, 67 octets
b&n=take n$mod n b:b&div n b
f b=[n|n<-[0..1000],reverse(b&n)==b&n]
fest la fonction d'intérêt. Essayez-le en ligne!
La seule astuce ici est peut-être l'utilisation de take npour créer un cas de base pour la fonction d'extension de chiffres. Quand n=0, take nignore son argument et ainsi la récursion s'arrête via la paresse; quand n>0, il n'y aura certainement pas plus de nchiffres, il est donc prudent de ne conserver que le premier n. La définition suivante est équivalente (et également longue):
b&0=[]
b&n=mod n b:b&div n b
... mais la take nversion est plus amusante car elle est plus déroutante. ^ _ ^
J , 27 octets
((-:|.)@(#.inv)"0#])i.@1001
Comment
(...) i.@1001- Le tout est un crochet J, ce qui signifie que l'argument sera l'argument gauche de tout ce qui se trouve dans les parenthèses, et l'argument droit sera les entiers de 0 à 1000:i.@1001...#]La phrase à l'intérieur des parenthèses utilise la copie#pour filtrer l'argument droit]par le masque booléen résultant de la phrase à gauche de#:(-:|.)@(#.inv)"0- Le rang 0"0garantit que la phrase s'applique à chaque numéro individuel du bon argument. La phrase elle-même convertit d'abord chacun de ces nombres en une liste de chiffres dans la base donnée par l'argument de gauche(#.inv), puis vérifie si cette liste est égale à son inverse(-:|.)@. La phrase entière renverra donc 1 quand c'est vrai et 0 sinon, et ce masque booléen filtrera le bon argument comme souhaité.
Essayez-le en ligne!
Ruby 2.7 , 74 octets
->b{(0..1e3).select{(a=(g=->k,r=[]{k>0?g[k/b,r<<k%b]:r})[_1])==a.reverse}}
Essayez-le en ligne!
TIO utilise une ancienne version de Ruby, alors que dans Ruby 2.7, nous avons numéroté des paramètres, ce qui économise deux octets.
Rubis , 48 octets
->b{(0..1e3).select{|k|(k=k.to_s b)==k.reverse}}
Essayez-le en ligne!
Ne fonctionne pas pour les bases de plus de 64 ans, en raison de la limitation de la .to_sméthode.
JavaScript (V8) , 77 89 octets
Correction pour les bases supérieures à 36.
b=>{for(i=-1;i<1e3;){j=[],k=++i;while(k|=0)j.push(k%b),k/=b;''+j==j.reverse()&&print(i)}}
Essayez-le en ligne!
PowerShell ,
102
100
98
95
87
75 octets
-14 octets grâce à mazzy!
param($u)0..1e3|?{for($b=@();$_=($_-($b+=$_%$u)[-1])/$u){}"$b"-eq$b[11..0]}
Essayez-le en ligne!
R , 82 81 octets
(ou 79 octets en utilisant le délimiteur plutôt compliqué de " \n[1] ")
Edit: -1 octet grâce à caird coinheringaahing
function(b)for(i in 0:1e3)if(!i||all((a=i%/%b^(0:log(i,b))%%b)==rev(a)))cat(i,'')
Essayez-le en ligne!
Calcule manuellement les chiffres dans la nouvelle représentation de base et vérifie s'ils sont identiques à eux-mêmes inversés.
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 octets
. as$a|range(1001)|select([while(.>0;./$a|floor)|.%$a]|reverse==.)
Essayez-le en ligne!
Explication
. 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 octets
f_IjTQUh^T3
Essayez-le en ligne!
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 octets
b->{for(int i=-1;i++<1e3;){var s=b.toString(i,b);if(s.contains(new StringBuffer(s).reverse()))System.out.println(i);}}
Essayez-le en ligne.
Explication:
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