Étant donné un entier positif N, sortez le plus petit entier positif tel que ce nombre soit un palindrome (c'est-à-dire son propre inverse) et soit divisible par N.

Le palindrome (c'est-à-dire la sortie) ne doit pas avoir besoin d'un zéro de tête pour être un palindrome, par exemple 080 n'est pas la réponse valable pour 16.

L'entrée ne sera jamais un multiple de 10, pour la raison précédente.

Votre programme peut prendre autant de temps que nécessaire, même si en pratique il serait beaucoup trop long pour produire la réponse.

Entrées et sorties

• Vous pouvez prendre la saisie par STDIN tant qu'argument de fonction ou quelque chose de similaire.
• Vous pouvez imprimer la sortie sur STDOUT , la renvoyer à partir d'une fonction ou quelque chose de similaire.
• Les entrées et sorties doivent être en base décimale.

Cas de test

N        Output
1        1
2        2
16       272
17       272
42       252
111      111
302      87278
1234     28382

Notation

Il s'agit de code-golf , donc la réponse la plus courte en octets l'emporte.

2sable / 05AB1E , 6/7 octets

2sable

[DÂQ#+

Explication

[         # infinite loop
 D        # duplicate current number
  Â       # bifurcate
   Q#     # if the number is equal to its reverse, break loop
     +    # add input
          # implicitly print

Essayez-le en ligne

05AB1E

[DÂQ#¹+

La différence avec le code 2sable est que l'entrée n'est implicite qu'une seule fois dans 05AB1E, donc ici nous devons ¹récupérer la première entrée.

Essayez-le en ligne

1 octet enregistré avec 2sable comme suggéré par Adnan

Haskell, 45 37 34 octets

(+)>>=until((reverse>>=(==)).show)

Pyth, 7 octets

*f_I`*Q

Essayez-le en ligne: Démonstration

Explication

*f_I`*QT)Q   implicit endings, Q=input number
 f      )    find the first number T >= 1, which satisfies:
     *QT        product of Q and T
    `           as string
  _I            is invariant under inversion (=palindrom)
*        Q   multiply this number with Q and print

Java, 164 159 126 108 94 octets

Version golfée:

int c(int a){int x=a;while(!(x+"").equals(new StringBuffer(x+"").reverse()+""))x+=a;return x;}

Version non golfée:

int c(int a)
{
    int x = a;
    while (!(x + "").equals(new StringBuffer(x + "").reverse() + ""))
        x += a;
    return x;
}

Remerciements à Emigna et Kevin Cruijssen pour avoir apporté des améliorations et réduit les octets presque de moitié :)

C #, 103 80 octets

int f(int p){int x=p;while(x+""!=string.Concat((x+"").Reverse()))x+=p;return x;}

Non golfé

int f(int p)
{
   int x = p;
   while (x + "" != string.Concat((x + "").Reverse()))
      x += p;
   return x;
}

Python 2, 46 octets

f=lambda x,c=0:`c`[::-1]==`c`and c or f(x,c+x)

Ideone it!

Solution récursive avec ccomme compteur.

Le cas de 0est intéressant, car bien que c=0satisfaisant la condition palindrome, il ne serait pas retourné, car ccc and 0 or xxxrevient toujours xxx.

PHP, 39 octets

while(strrev($i+=$argv[1])!=$i);echo$i;

• Prend le nombre N comme argument $ argv [1];
• ; après un moment pour ne rien faire
• strrev retourner la chaîne en arrière

Même longueur avec for-loop

for(;strrev($i+=$argv[1])!=$i;);echo$i;

Brachylog , 8 octets

:L#>*.r=

Essayez-le en ligne! (environ 5 secondes pour 1234)

Vérifiez tous les cas de test. (environ 20 secondes)

:L#>*.r=
?:L#>*.r=.   Implicitly filling Input and Output:
             Input is prepended to every predicate,
             Output is appended to every predicate.

?:L  *.      Input*L is Output,
  L#>        L is positive,
      .r .   Output reversed is Output,
        =.   Assign a value to Output.

Javascript (ES6), 55 51 octets

4 octets grâce à Neil.

f=(x,c=x)=>c==[...c+""].reverse().join``?c:f(x,x+c)

<input type=number min=1 oninput=o.textContent=this.value%10&&f(+this.value)><pre id=o>

Pyke, 11 9 octets

.f*`D_q)*

Essayez-le ici!

C, 217 189 octets

Version autonome:

int a(char*b){int c=strlen(b);for(int i=0;i<c/2;i++)if(b[i]!=b[c-i-1])return 0;}int main(int e,char **f){int b,c;char d[9];b=atoi(f[1]);c=b;while(1){sprintf(d,"%d",c);if(a(d)&&(c/b)*b==c)return printf("%d",c);c++;}}

Appel à une version de fonction:

int s(char*a){int b=strlen(a);for(int i=0;i<b/2;i++)if(a[i]!=a[b-i-1])return 0;}int f(int a){int b;char c[9];b=a;while(1){sprintf(c,"%d",b);if(s(c)&&(b/a)*a==b)return printf("%d",b);b++;}}

Non golfé:

#include <stdlib.h>
#include <string.h>
#include <stdio.h>

int check_palindrome(char *str) {
  int length = strlen(str);

  for (int i = 0; i < length / 2; i++) {
    if (str[i] != str[length - i - 1])
      return 0;
  }
  return 1;
}

int main(int argc, char **argv) {
  int number;
  int pal;
  char string[15];

  number = atoi(argv[1]);
  pal = number;
  while (1) {
    sprintf(string, "%d", pal);
    if (check_palindrome(string) && (pal / number) * number == pal)
      {
        printf("%d\n", pal);
        return 1;
      }
    pal++;
  }
  return 0;
}

Appel à une fonction non golfée:

int s(char *a) {
  int b = strlen(a);

  for (int i = 0; i < b / 2; i++) {
    if (a[i] != a[b - i - 1])
      return 0;
  }
  return 1; //We can remove it, it leads to a undefined behaviour but it works
}

int f(int a) {
  int b;
  char c[9];

  b = a;
  while (1) {
    sprintf(c, "%d", b);
    if (s(c) && (b / a) * a == b)
      {
        printf("%d\n", b); //no need for the \n
        return 1; //just return whatever printf returns, who cares anyway ?
      }
    b++;
  }
  return 0; //no need for that
}

J'ai inclus la version autonome pour l'historicité.

Ceci est mon premier codegolf, tout commentaire est le bienvenu!

R, 117 113 109 109 101 octets

D=charToRaw;P=paste;S=strtoi;a=P(i<-scan()+1);while(!all(D(a)==rev(D(a))&&S(a)%%i==0)){a=P(S(a)+1)};a

Non golfé

i<-scan()        #Takes the input

D=charToRaw      #Some aliases
P=paste
S=strtoi
a=P(i+1)         #Initializes the output

while(!(all(D(a)==rev(D(a)))&&(S(a)%%i==0))) #While the output isn't a palindrom and isn't
                                             #divisible by the output...
    a=P(S(a)+1)

a

all(charToRaw(a)==rev(charToRaw(a)))vérifie si à chaque position ala valeur de aet son inverse sont identiques (c'est-à-dire si aest palindromique).
Il pourrait être possible de jouer au golf sur certains octets en jouant avec le types.

En fait , 15 14 octets

Demandé par Leaky Nun. Suggestions de golf bienvenues. Essayez-le en ligne!

╖2`╜*$;R=`╓N╜*

Ungolfing

          Implicit input n.
╖         Save n in register 0.
2`...`╓   Push first 2 values where f(x) is truthy, starting with f(0).
  ╜*$       Push register 0, multiply by x, and str().
  ;R        Duplicate str(n*x) and reverse.
  =         Check if str(n*x) == reverse(str(n*x)).
          The map will always result in [0, the x we want].
N         Grab the last (second) value of the resulting list.
╜*        Push n and multiply x by n again.
          Implicit return.

Haskell, 64 63 56 octets

x!n|mod x n==0,s<-show x,reverse s==s=x|y<-x+1=y!n
(1!)

Appelez avec (1!)16ou simplement 1!16. Essayez-le sur Ideone.

VBSCRIPT, 47 octets

do:i=i+1:a=n*i:loop until a=eval(strreverse(a))

non golfé

do                     #starts the loop
i=i+1                  #increments i, we do it first to start at 1 instead of 0
a=                     #a is the output
n*i                    #multiply our input n by i
loop until 
a=eval(strreverse(a))  #end the loop when our output is equal to its reverse

Perl, 25 octets

Comprend +2 pour -ap

Exécutez avec l'entrée sur STDIN:

palidiv.pl <<< 16

palidiv.pl:

#!/usr/bin/perl -ap
$_+="@F"while$_-reverse

SILOS , 109 octets

readIO 
n = 0
lbla
n + i
a = n
r = 0
lblb
m = a
m % 10
r * 10
r + m
a / 10
if a b
r - n
r |
if r a
printInt n

Essayez-le en ligne!

Japt , 14 octets

V±U s w ¥V?V:ß

Essayez-le en ligne!

Merci ETHproductions pour l'aide! :)

MATL , 10 octets

0`G+tVtP<a

Essayez-le en ligne!

0      % Push 0
`      % Do...while
  G+   %   Add the input. This generates the next multiple of the input
  tV   %   Duplicate, convert to string
  tP   %   Duplicate, reverse
  <a   %   Is any digit lower than the one in the reverse string? This is the
       %   loop condition: if true, the loop proceeds with the next iteration
       % End do...while
       % Implicitly display

PowerShell v2 +, 72 octets

for($i=$n=$args[0];;$i+=$n){if($i-eq-join"$i"["$i".Length..0]){$i;exit}}

Long à cause de la façon dont l'inversion est gérée dans PowerShell - pas très bien. ;-)

Prend l'entrée $args[0], stocke dans $i(notre variable de boucle) et $n(notre entrée). Boucles infinies, incrémentées $ià $nchaque fois (pour garantir la divisibilité).

A chaque itération, nous vérifions s'il $is'agit d'un palindrome. Il y a une supercherie ici, alors laissez-moi vous expliquer. Nous le prenons d'abord $iet le stringifions avec "$i". C'est ensuite indexé dans un tableau dans l'ordre inverse ["$i".length..0]avant d'être -joinréédité dans une chaîne. Cela est introduit dans le côté droit de l' -eqopérateur de ualité, qui rejette implicitement la chaîne dans un [int], puisque c'est l'opérande de gauche. Remarque: ce casting supprime tous les zéros de tête du palindrome, mais comme nous sommes garantis que l'entrée n'est pas divisible par10 , c'est OK.

Ensuite, ifc'est un palindrome, nous plaçons simplement $isur le pipeline et exit. La sortie est implicite à la fin de l'exécution.

Cas de test

PS C:\Tools\Scripts\golfing> 1,2,16,17,42,111,302,1234|%{"$_ -> "+(.\smallest-palindrome-divisible-by-input.ps1 $_)}
1 -> 1
2 -> 2
16 -> 272
17 -> 272
42 -> 252
111 -> 111
302 -> 87278
1234 -> 28382

MATLAB, 76 octets

function s=p(n)
f=1;s='01';while(any(s~=fliplr(s))) s=num2str(n*f);f=f+1;end

Le format de l'appel est le p(302)résultat est une chaîne.

Rien d'intelligent ici. Il effectue une recherche linéaire, en utilisant les fonctions num2str()et fliplr().

Cet agencement laid est une touche plus courte que l'utilisation d'un while(1) ... if ... break endmotif.

Non golfé

function s = findFirstPalindromeFactor(n)
  f = 1;                        % factor
  s = '01';                     % non-palindromic string for first try
  while( all(s ~= fliplr(s)) )  % test s not palindrome
    s = num2str( n * f );       % factor of input as string
    f = f + 1;                  % next factor
  end

Mathematica, 49 octets

(c=#;Not[PalindromeQ@c&&c~Mod~#==0]~While~c++;c)&

Starts the search at c = N, and increments c if not a palindrome and not divisible by N. When conditions are met, outputs c.

Jelly, 12 bytes

¹µ+³ßµDU⁼Dµ?

Try it online!

Explanation:

This link takes 1 argument. The µs split it into 4 parts. Starting from the last and moving left:

           ? The three parts in front of this are the if, else, and
             condition of a ternary expression.
      DU⁼D  This condition takes a number n as an argument. It converts
            n to an array of decimal digits, reverses that array, and
            then compares the reversed array to the decimalization of
            n (ie is n palindromic in decimal?)
  +³ß  This is the else. It adds the original input argument to n
       and then repeats the link with the new value of n.
¹  This is the if. It returns the value passed to it.

Elixir, 75 bytes

def f(p,a\\0),do: if'#{a+p}'|>Enum.reverse=='#{a+p}',do: a+p,else: f(p,a+p)

Python 2, 66 65 bytes

i is input and x is (eventually) output

def f(i,x):
    y=x if x%i==0&&`x`==`x`[::-1]else f(i,x+1)
    return y

After scrolling through other answers I found a shorter Python 2 answer but I put the effort into my solution so might as well throw it here. ¯\_(ツ)_/¯

REXX, 46 bytes

arg a
do n=a by a until reverse(n)=n
end
say n

Python 2, 44 bytes

x=lambda n,m=0:m*(`m`==`m`[::-1])or x(n,m+n)

Try it online!

I know that the question was posted over six months ago, but this was shorter than any other Python submission.

QBIC, 29 bytes

:{c=a*q~!c$=_f!c$||_Xc\q=q+1

Explanation:

:      Get cmd line param as number 'a'
{      DO
c=a*q  multiply 'a' by 'q' (which is 1 at the start of a QBIC program) and assign to 'c'
~      IF
!c$    'c' cast to string
=      equals
_f!c$| 'c' cast to string, the reversed
|      THEN
_Xc    Quit, printing 'c'
\q=q+1 ELSE increment q and rerun
       DO Loop is auto-closed by QBIC, as is the IF

Perl 6, 35 bytes

->\N{first {$_%%N&&$_==.flip},N..*}

->\N{first {$_==.flip},(N,N*2...*)}

->\N{(N,N*2...*).first:{$_==.flip}}

Explanation:

-> \N {
  # from a list of all multiples of the input
  # ( deduced sequence )
  ( N, N * 2 ... * )

  # find the first
  .first:

  # that is a palindrome
  { $_ == .flip }
}

Perl 6, 39 bytes

my &f={first {.flip==$_},($_,2*$_...*)}

(33 not including the my &f=)