양의 정수가 주어지면 N가장 작은 양의 정수를 출력 하여이 숫자는 회문 (즉, 자체 역수)이며로 나눌 수 N있습니다.

회문 (즉, 출력)은 회문이되기 위해 선행 0이 필요하지 않아야합니다 (예 : 080에 대한 올바른 답변이 아님) 16.

이전 이유로 인해 입력 값이 10의 배수가되지 않습니다.

실제로 답변을 출력하는 데 시간이 너무 오래 걸리더라도 프로그램에 필요한 시간이 오래 걸릴 수 있습니다.

입력 및 출력

• 를 통해 STDIN함수 인수 또는 이와 유사한 것을 통해 입력을 취할 수 있습니다 .
• 출력을로 인쇄 STDOUT하거나 함수 또는 이와 유사한 것에서 반환 할 수 있습니다 .
• 입력과 출력은 10 진 기준이어야합니다.

테스트 사례

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

채점

이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.

2sable / 05AB1E , 6/7 바이트

2 세블

[DÂQ#+

설명

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

온라인으로 사용해보십시오

05AB1E

[DÂQ#¹+

2sable 코드와의 차이점은 05AB1E에서 입력이 한 번만 암시되므로 ¹첫 번째 입력을 다시 가져와야한다는 것 입니다.

온라인으로 사용해보십시오

Adnan이 제안한대로 2 바이트로 1 바이트 저장

하스켈, 45 37 34 바이트

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

Pyth, 7 바이트

*f_I`*Q

온라인으로 사용해보십시오 : 데모

설명

*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

자바, 164 (159) 126 (108) 94 바이트

골프 버전 :

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

언 골프 버전 :

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

개선에 기여하고 바이트를 거의 반으로 줄인 Emigna와 Kevin Cruijssen에게 소리를 지 릅니다. :)

C #, 103 80 바이트

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

언 골프

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

파이썬 2, 46 바이트

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

무시 했어!

c카운터로 재귀 솔루션 .

회문 조건을 만족 0하지만 항상 반환 c=0하기 때문에 반환되지 않기 때문에 의 경우 는 흥미 롭습니다 .ccc and 0 or xxxxxx

PHP, 39 바이트

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

• 숫자 N을 인수 $ argv [1]로 사용합니다.
• ; 아무것도하지 않는 동안
• strrev 문자열을 뒤로 반환

for- 루프와 같은 길이

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

Brachylog , 8 바이트

:L#>*.r=

온라인으로 사용해보십시오! (의 경우 약 5 초 1234)

모든 테스트 케이스를 확인하십시오. (약 20 초)

: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.

자바 스크립트 (ES6), 55 51 바이트

Neil 덕분에 4 바이트.

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>

파이크, 11 9 바이트

.f*`D_q)*

여기 사용해보십시오!

C, 217 189 바이트

독립형 버전 :

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++;}}

기능 버전을 호출하십시오.

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++;}}

언 골프 :

#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;
}

ungolfed 함수를 호출하십시오.

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
}

나는 역사를 위해 독립형 버전을 포함시켰다.

이것은 나의 첫번째 codegolf입니다, 어떤 의견이라도 환영합니다!

R, 117 113 109 101 바이트

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

언 골프

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)))a값의 각 위치 a와 그 반대의 위치가 동일한 지 확인합니다 (즉, a회 문형 인 경우 ).
로 엉망이되어 일부 바이트를 골프 아웃 할 수 있습니다 types.

실제로 는 15 14 바이트

Leaky Nun의 답변을 요청했습니다. 골프 제안을 환영합니다. 온라인으로 사용해보십시오!

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

언 골핑

          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.

하스켈, 64 63 56 바이트

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

로 (1!)16또는 간단히 전화하십시오 1!16. Ideone에서 사용해보십시오.

VBSCRIPT, 47 바이트

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

언 골프

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

펄, 25 바이트

에 +2 포함 -ap

STDIN의 입력으로 실행하십시오.

palidiv.pl <<< 16

palidiv.pl:

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

SILOS , 109 바이트

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

온라인으로 사용해보십시오!

apt , 14 바이트

V±U s w ¥V?V:ß

온라인으로 사용해보십시오!

도움을 주신 ETHproductions에게 감사합니다! :)

MATL , 10 바이트

0`G+tVtP<a

온라인으로 사용해보십시오!

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 바이트

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

PowerShell에서 리버스가 처리되는 방식 때문에 오래 걸리지 않습니다. ;-)

input을 $args[0]가져와 $i(우리의 루프 변수)와 $n(우리의 입력)에 저장합니다. 매번 증분 $i하여 무한대로 반복 $n합니다 (분할 성을 보장하기 위해).

반복 할 때마다 $i회문 인지 확인합니다 . 여기에 약간의 속임수가 발생하므로 설명하겠습니다. $i먼저을 사용 하여 문자열을 지정합니다 "$i". 그런 다음 문자열로 다시 연결 ["$i".length..0]되기 전에 역순으로 배열 색인화됩니다 -join. 그것은 -equality 연산자 의 오른쪽에 공급됩니다.이 연산자 [int]는 왼쪽 피연산자이므로 문자열을 암시 적으로 다시 캐스트합니다 . 참고 :이 캐스팅은 회문에서 선행 0을 제거하지만 입력을 나누는 것이 보장되지 않으므로 10괜찮습니다.

그런 다음 if회문이며 $i파이프 라인에 간단히 배치 합니다 exit. 실행이 끝나면 출력이 내재됩니다.

테스트 사례

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 바이트

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

호출 형식은 p(302)결과가 문자열입니다.

여기에는 영리한 것이 없습니다. num2str()및 fliplr()함수를 사용하여 선형 검색을 수행합니다.

이 추악한 배열은 while(1) ... if ... break end패턴을 사용하는 것보다 터치가 짧습니다 .

언 골프

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

매스 매 티카, 49 바이트

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

에서 검색을 시작하고 회문이 아니고로 나눌 수없는 경우 c = N증가 c합니다 N. 조건이 충족되면 출력 c.

젤리, 12 바이트

¹µ+³ßµDU⁼Dµ?

온라인으로 사용해보십시오!

설명:

이 링크는 1 개의 인수를 취합니다. µ의 4 개 부분으로 분할합니다. 마지막부터 시작하여 왼쪽으로 이동 :

           ? 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.

엘릭서 , 75 바이트

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

파이썬 2, 66 65 바이트

i입력되고 x(결과적으로) 출력됩니다

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

다른 답변을 스크롤 한 후 더 짧은 Python 2 답변을 찾았지만 노력을 내 솔루션에 넣었으므로 여기에 던져 넣을 수도 있습니다. ¯ \ _ (ツ) _ / ¯

REXX, 46 바이트

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

파이썬 2 , 44 바이트

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

온라인으로 사용해보십시오!

6 개월 전에 질문이 게시되었지만 다른 Python 제출보다 짧았습니다.

QBIC , 29 바이트

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

설명:

:      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

펄 6 , 35 바이트

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

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

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

설명:

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

  # find the first
  .first:

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

펄 6, 39 바이트

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

(33 포함하지 않음 my &f=)