구어체로도 " 티미 번호 "라고도 알려진 "기자 번호" 는 숫자가 피라미드를 나타내는 임의의 숫자입니다 ( A134810 ). 예를 들어, "12321"은 다음과 같이 시각화 될 수 있기 때문에 기자 번호입니다.

  3  
 2 2
1   1

그러나 피라미드의 상단에 두 자리 숫자가 있기 때문에 "123321"과 같은 것은 기자 번호가 아닙니다.

  33  
 2  2
1    1

즉, 다음 조건이 모두 충족되면 숫자는 기자 번호입니다.

• 홀수의 자릿수가 있고 가운데 자릿수가 가장 큽니다.

• 회문 (동일한 앞뒤로 읽음)이며

• 숫자의 전반부는 1 씩 엄격하게 증가합니다. (이것은 회 문식이어야하기 때문에, 숫자의 후반은 1 씩 엄격히 감소해야 함을 의미합니다)

양의 정수를 입력으로 사용하는 전체 프로그램 또는 함수를 작성하고 그것이 숫자인지 여부를 판별해야합니다. 입력을 문자열 또는 숫자로 사용할 수 있습니다. 그 경우 이다 기자 번호, A는 출력 truthy 값 . 그렇지 않으면 잘못된 값입니다.

총 45 개의 기자 숫자가 있으므로 이러한 입력 중 하나를 사용하면 진실한 가치를 얻을 수 있습니다.

1
2
3
4
5
6
7
8
9
121
232
343
454
565
676
787
898
12321
23432
34543
45654
56765
67876
78987
1234321
2345432
3456543
4567654
5678765
6789876
123454321
234565432
345676543
456787654
567898765
12345654321
23456765432
34567876543
45678987654
1234567654321
2345678765432
3456789876543
123456787654321
234567898765432
12345678987654321

다른 입력은 잘못된 값을 제공해야합니다. 물론 양수가 아닌 숫자, 정수가 아닌 숫자 또는 숫자가 아닌 잘못된 입력을 처리 할 필요는 없습니다.

평소와 같이, 이것은 code-golf 이므로 표준 허점은 금지되며 바이트 단위의 최단 답변이 승리합니다!

파이썬 2, 48 47 46 바이트

lambda s:s[~len(s)/2:]in'987654321'>s==s[::-1]

Ideone에서 테스트하십시오 .

작동 원리

파이썬에서 연쇄 비교는 모든 개별 비교가 동일한 경우에만 True를 반환합니다 . 이 경우 람다는 다음 조건이 모두 충족되는 경우에만 True를 반환합니다 .

• s[~len(s)/2:]in'987654321'

  문자열을 s의 길이 2N + 1 , ~len(s)/2반환 (2N + 2) / 2 = - -은 (N + 1) ~ (2N + 1) / 2 = 그래서 s[~len(s)/2:]가장 오른쪽을 산출 N + 1 개 의 문자 들 .

  마찬가지로, 문자열 의 길이의 2N , ~len(s)/2복귀 ~ (2N)는 / 2 = - (2N + 1) / 2 = - (N + 1) 항상 원형 방향 (정수 나눗셈 -∞이 있으므로 s[~len(s)/2:]한번 우단 수득 + N을 s의 1 자

  가장 오른쪽의 n + 1 문자가 하위 문자열을 구성하는 경우에만 비교에서 True를 반환합니다 .987654321

  그들이하고있는 경우주의 의가 있다 2N 문자를, S는 회문 수 없습니다; N 개의 ^번째 및 (N + 1) ^번째 오른쪽 문자 구별 될 것이고, 후자 인 N ^번째 왼쪽 문자.

• '987654321'>s

  이것은 문자열을 사전 식으로 비교합니다. 이후 9 로 시작하는 유일한 기자 번호 9 , 모든 기자 번호가이 비교를 만족시킨다.

  이러한 문자열을 비교한다고해서 결정 문제의 일부가되는 것은 아닙니다. >s보다 짧은 3 자 and s입니다.

• s==s[::-1]

  s 가 회 문인 경우에만 True를 반환합니다 .

펄, 39 37 42 39 + 1 = 40 바이트

새로운 방법을 사용하여 엄청난 양의 바이트를 줄였습니다. -n플래그로 실행하십시오 . 런타임시 입력을 반복적으로 수용하여 0 또는 1을 인쇄합니다.

그것없이 5 바이트를 추가해야했기 때문에 코드는 기자 번호가 아닌 1234567900987654321과 같은 입력에서 작동했습니다. 기자 숫자에는 숫자 0이 포함되지 않으며 (필수적으로 모든 오 탐지에는 숫자 0이 포함됨)이 5 바이트가이를 설명합니다.

say!/0/*($_- s/..?/1/gr**2)=~/^(.)\1*$/

설명:

say!/0/*($_- s/..?/1/gr**2)=~/^(.)\1*$/  #$_ contains input by default.
   !/0/                                  #Ensure that the initial text doesn't contain the number 0
       *                                 #Since both halves of this line return either 0 or 1, multiplying them together only yields 1 if both are true (which we want).
             s/   / /gr                  #Perform a substitution regex on $_ (see below)
                                         #/g means keep replacing, /r means don't modify original string; return the result instead
               ..?                       #Replace 1 or 2 characters (2, if possible)...
                   1                     #...with the number 1
                       **2               #Square this number...
        ($_-              )              #...and subtract it from the input
                           =~            #Do a regex match on the result
                             /^      $/  #Make sure the regex matches the WHOLE string
                               (.)       #Match any character...
                                  \1*    #...followed by itself 0 or more times
say                                      #Finally, output the result of the whole line of code.

대체 정규식의 목적은 길이가 입력 길이의 절반이고 반올림 된 1의 문자열을 구성하는 것입니다. 따라서의 입력은 12321string을 생성 111한 다음 제곱됩니다 (아래 설명). 짝수 길이의 입력은 최종 정규 표현식이 성공하기에 너무 작은 문자열을 생성합니다.

이 코드가 작동하는 이유는 다음과 같습니다.

        1         =         1**2
       121        =        11**2
      12321       =       111**2
     1234321      =      1111**2
    123454321     =     11111**2
   12345654321    =    111111**2
  1234567654321   =   1111111**2
 123456787654321  =  11111111**2
12345678987654321 = 111111111**2

RHS에서 1의 수가 LHS 크기의 1/2보다 1/2이라는 것을 분명히 알 수 있습니다. (잘라 내면 1 개 더). 또한 :

567898765-123454321 = 444444444, 이는 단지 4 번 반복됩니다. 따라서 우리가 숫자에서 제곱을 빼면, 숫자가 나오면 원래 숫자는 기자 숫자입니다.

이전 코드 및 이전 방법 (58 + 1 = 59 바이트)

@Dada 덕분에 1 바이트 절약

-n플래그를 사용하여 실행 , 파이프 텍스트 사용echo

say$_==($;=join"",/(.)/..($==y///c/2+/(.)/)-1).$=.reverse$

길이와 선행 정수로 결정된 고유 한 기자 숫자를 계산하고 입력과 일치하는지 확인합니다.

Run as 그것이 기자 번호 인 경우 echo -n "123454321" | perl -M5.010 -n giza.pl 반환 1값, 그렇지 않으면 null

젤리 , 10 7 6 바이트

9ẆŒBḌċ

45 개의 기자 숫자를 모두 생성 한 다음 멤버쉽을 테스트합니다.

온라인으로 사용해보십시오! 또는 생성 된 숫자를 참조하십시오 .

작동 원리

9ẆŒBḌċ  Main link. Argument: n

9       Set the return value to 9.
 Ẇ      Windows; yield all "substrings" of [1, ..., 9].
  ŒB    Bounce; map each [a, ..., b] to [a, ..., b, ..., a].
    Ḍ   Undecimal; convert the digit arrays to integers.
     ċ  Count the number of occurrences of n.

자바 스크립트 (ES6), 46 45 42 41 바이트

f=([c,...s])=>s+s&&c-s.pop()|c-~-f(s)?0:c

입력을 문자열로 취하고 허위에 0대해 진실성을 위해 단일 숫자 문자열을 리턴합니다 .

기본 아이디어는 몇 가지 사항을 확인하는 것입니다.

• 문자열이 하나의 문자 길이 인 경우 OR
• 첫 번째 문자는 마지막 문자와 동일하며
• 가운데 부분은 기자 번호이며
• 두 번째 문자는 여기에서 첫 번째 문자보다 하나 더 많습니다.

Java 7, 128119105 바이트

boolean t(long n){long a=1,b=1,c=0;for(;a<n/10;b=b*b<=n/10?b*10+1:b,c^=1)a=a*10+1;return(n-b*b)%a<1&c<1;}

더 이상 문자열이 없습니다! 이제 111...입력 ( a)과 동일한 길이 와 더 짧은 제곱 ( b) 을 생성하여 시작합니다 . 그런 다음 b*b입력에서 빼고 나눌 수 있습니다 a. c홀수 / 짝수를 확인하기 위해 거기에 있습니다.> _>

공백 :

boolean t(long n){
    long a=1,b=1,c=0;
    for(;a<n/10;b=b*b<=n/10?b*10+1:b,c^=1)
        a=a*10+1;
    return(n-b*b)%a<1&c<1;
}

이전 방법, 119 바이트

boolean g(char[]a){int i=1,l=a.length,b=1,d;for(;i<l;b*=i++>l/2?d==-1?1:0:d==1?1:0)d=a[i]-a[i-1];return b>0?l%2>0:0>1;}

각 자릿수 사이의 1 (또는 절반에 따라 -1)의 차이를 확인하면서 배열을 탐색합니다. 그런 다음 길이가 홀수인지 확인합니다.

공백 :

boolean g(char[]a){
    int i=1,l=a.length,b=1,d;
    for(;i<l;b*=i++>l/2?d==-1?1:0:d==1?1:0)
        d=a[i]-a[i-1];
    return b>0?l%2>0:0>1;
}

05AB1E , 9 8 바이트

Truthy는 1 이고, 거짓은 0 입니다.

9LŒ€ûJ¹å

CP-1252 인코딩을 사용합니다 . 온라인으로 사용해보십시오!

파이썬 2, 77, 76, 64 , 63 바이트

f=lambda s:2>len(s)or(s[0]==s[-1]==`int(s[1])-1`and f(s[1:-1]))

간단한 재귀 솔루션. 첫 번째 숫자와 마지막 숫자가 서로 같고 두 번째 숫자에서 1을 뺀 것과 같은지 확인합니다. 그런 다음 중간도 기자 번호인지 확인합니다. 한 자리수로 떨어지면 true를 반환합니다.

1 바이트 @Rod하기 위해, 덕분에 저장된 톤 바이트가 DLosc 및 ETHProductions 덕분에 저장된!

PowerShell을 V3 +, 147 (108) 67 바이트

$args[0]-in(1..9+(1..8|%{$i=$_;++$_..9|%{-join($i..$_+--$_..$i)}}))

급격히 바뀐 접근 방식. 가능한 모든 기자 숫자를 생성 한 다음 입력 $args[0]이 -in해당 콜렉션 인지 확인합니다 . 아래는 기자 번호 수집 방법입니다.

1..9+(1..8|%{$i=$_;++$_..9|%{-join($i..$_+--$_..$i)}})
      1..8|%{                                       }  # Loop from 1 up to 8
             $i=$_;                                    # Set $i to the current number
                   ++$_..9|%{                      }   # Loop from one higher up to 9
                                   $i..$_+--$_..$i     # Build two ranges and concatenate
                                                       # E.g., 2..5 + 4..2
                             -join(               )    # Join into a single string
1..9+(                                               ) # Array concatenate with 1 to 9

예제 실행 :

PS C:\Tools\Scripts\golfing> 12321,5678765,121,4,123321,1232,5678,13631|%{"$_ --> "+(.\giza-numbers.ps1 "$_")}
12321 --> True
5678765 --> True
121 --> True
4 --> True
123321 --> False
1232 --> False
5678 --> False
13631 --> False

파이썬 3, 65 바이트

lambda x:len(x)<18and x[:len(x)//2+1]in'0123456789'and x[::-1]==x

나는 확실하지 않지만 이것이 효과가 있다고 생각합니다.

파이썬 2, 68 73 66 바이트

lambda n:n==`int('1'+len(n)/2%9*'1')**2+int(len(n)*`int(n[0])-1`)`

11^2=121, 111^2=12321등등, 나는 이것을 계산 1111..하고 오프셋으로 충분한 시간을 추가 한다는 사실을 남용합니다 .
예 :
23432=111^2+11111*1
676=11^2+111*5

펄, 41 바이트

40 바이트의 코드 + -p플래그

s/(.)(?=(.))/$1-$2/ge;$_=/^(-1(?1)1|).$/

입력이 기자 번호 인 경우 1을 출력하고, 그렇지 않으면 아무것도 출력하지 않습니다. 마지막 개행없이 입력을 제공하여 실행하십시오.

echo -n '123456787654321' | perl -pe 's/(.)(?=(.))/$1-$2/ge;$_=/^(-1(?1)1|).$/'

설명 : 먼저, s/(.)(?=(.))/$1-$2/ge각 숫자 $1(뒤에 $2)를로 바꿉니다 $1-$2. 기자 숫자 인 경우, 각 숫자는 처음에 다음 숫자보다 1이 적고 끝이 하나 더 있으면 문자열은 -1첫 번째 부분과 1두 번째 부분 에만 포함되어야합니다 (마지막으로 남은 부분 제외). . 이것이 두 번째 부분에서 /^(-1(?1)1|).$/확인하는 것입니다. -1다음은 재귀 와 a를 찾습니다 1.

Martin Ender 덕분에 -1 바이트.

내 이전 버전은 15 바이트 더 깁니다 (여기서는 매우 다르므로 여기에 알려 드리겠습니다).

echo -n '123456787654321' | perl -F -pe '$\=$_ eq reverse;$\&=$F[$_-1]+1==$F[$_]for 1..@F/2}{'

> <> FISH 57 52 49 48 바이트

i:1+?!vi00.;n1<
%?v0n;>~l:1-?!^2
{:<11 ^?:=@:$+=

편집 1 : =는 true이면 0 또는 1을 반환하므로 검사를 제거 하고이 값을 사용하여 증가시킨 다음 어쨌든 동등성을 검사합니다. (6 바이트를 절약하고 줄 바꿈을 위해 1을 잃었습니다).

편집 2 : 방향 마커 3 개를 제거하고 스택을 균등 한 길이로 간격을 두어 간격을 두어 false (3 바이트 저장)를 강제합니다.,

편집 3 : MOD를 확인하기 위해 스택 길이를 2와 len (1) 복제하십시오. 이는 길이를 두 번 전에했지만 행 2의 빈 공간을 채웠습니다 (1 바이트 저장).

C의 # 120 86 108 102 92 바이트

x=I=>{var Z=I.Length;return Z<2?1>0:I[0]==I[Z-1]&I[1]-0==I[0]+1?x(I.Substring(1,Z-2)):0>1;};

일부 테스트 사례가 포함 된 전체 프로그램 :

class a
{
    static void Main()
    {
        Func<string, bool> x = null;

        x = I=>
        {
            var Z=I.Length;
            return Z==1?                           // length == 1?
                     1>0:                          // return true (middle of #)
                     I[0]==I[Z-1]&I[1]-0==I[0]+1?  // else start == end and the next number is 1 above the current?
                       x(I.Substring(1,Z-2)):      // recursive call on middle
                       0>1;                        // else false
        };

        Console.WriteLine("1 -> " + (x("1") == true));
        Console.WriteLine("9 -> " + (x("9") == true));
        Console.WriteLine("121 -> " + (x("121") == true));
        Console.WriteLine("12321 -> " + (x("12321") == true));
        Console.WriteLine("4567654 -> " + (x("4567654") == true));
        Console.WriteLine("12345678987654321 -> " + (x("12345678987654321") == true));
        Console.WriteLine("12 -> " + (x("12") == false));
        Console.WriteLine("1221 -> " + (x("1221") == false));
        Console.WriteLine("16436346 -> " + (x("16436346") == false));
        Console.WriteLine("123321 -> " + (x("123321") == false));
        Console.WriteLine("3454321 -> " + (x("3454321") == false));
        Console.WriteLine("13631 -> " + (x("13631") == false));
        Console.WriteLine("191 -> " + (x("13631") == false));
        Console.Read(); // For Visual Studio
    }
}

단일 라인 조건에 대한 Hooray, 이제 Java 답변을 꺾습니다 :)! 또한 설명이 필요하지만 첫 번째 설명 주석을 작성해야합니다. 내 알고리즘 관련 문제를 찾은 @Dada에게 감사드립니다 (13631과 같이 미러링 된 숫자의 경우 사실). 이제 길이 100을 검사하는 것이 중복되므로 하위 100입니다.

배쉬, 111 바이트

최신 정보

다음 과 같이 생성 된 GIZA 번호에 첫 번째 숫자를 다시 추가하면 입력 번호 정규화를 완전히 건너 뛸 수 있습니다 .

01210 + 6 => 67876

입력과 직접 비교하면됩니다.

면책 조항 : 이것은 실제로 최적화되지 않았으므로 실제 경쟁자보다 개념 증명입니다.

골프

G() { I=`sed "s/./\0-${1::1}\n/g"<<<$1|bc`;Z=`seq 0 $((${#1}/2))`;A=`rev <<<$Z`;cmp -s <(echo $I) <<<$Z${A:1}

연산

모든 GIZA 번호는 나머지 숫자에서 첫 번째 숫자를 빼서 표준 형식으로 정규화 할 수 있습니다

67876 - 6 => 01210
78987 - 7 => 01210

특정 길이의 표준 GIZA 번호는 하나뿐입니다 .

이를 알면 입력 번호 길이를 기준으로 표준 GIZA 번호를 쉽게 생성 할 수 있습니다 .

 Z=`seq 0 $((${#1}/2))`;A=`rev <<<$Z` => $Z${A:1}

그런 다음 입력 번호를 정규화하십시오.

 I=`sed "s/./\0-${1::1}\n/g"<<<$1|bc`

그리고 비교

 cmp -s <(echo $I) <<<$Z${A:1};

테스트

for i in `seq 0 1000`; do G $i && echo $i; done

0
1
2
3
4
5
6
7
8
9    
121
232
343
454
565
676
787
898

...

G 12345678987654321 && echo "OK" || echo FALSE     
OK

G 123456789987654321 && echo "OK" || echo FALSE
FALSE

실제로 , 22 바이트

9uR;∙`xR;RdX+εj`M;░#íu

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

인용 문자열 (예 :)로 입력을 "12321"받습니다. 출력은 true 및 0false에 대한 양의 정수입니다 .

설명:

9uR;∙`xR;RdX+εj`M;░#íu
9uR;∙                   cartesian product of [1,2,3,4,5,6,7,8,9,10] with itself
     `xR;RdX+εj`M       for each pair:
      x                   construct the half-open (end-exclusive) range ([1, 5] -> [1, 2, 3, 4])
       R                  reverse
        ;RdX+             duplicate, reverse, remove first element, prepend ([1, 2, 3, 4] -> [1, 2, 3, 4, 3, 2, 1])
             εj           concatenate into a string
                 ;░     filter out empty strings
                   #íu  test for membership

하스켈, 62 바이트

(`elem`[[j..pred i]++[i,pred i..j]|i<-['1'..'9'],j<-['1'..i]])

입력은 문자열로 사용됩니다.

모든 기자 번호의 목록을 작성하여 번호가 있는지 확인합니다. 목록은 루프 i를 반복 '1'..'9'한 다음 요소 를 j통해 '1'..i작성하여 작성 j .. i-1 , i , i-1 .. j됩니다.

> <> , 62 바이트

i:0(   ?v
v!1&!~{!<:=$:@&-1=+2=*>l!-3!1(!:?
>l!;2!n=!0?!<-1=n;

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

기자 번호에 대해 1을 출력합니다. 그렇지 않으면 0입니다. 입력을 대기열 (기술적으로 가역 스택)로 밀어 넣고 양쪽 끝이 동일한 지 반복적으로 테스트하고 이전 값보다 정확히 하나 더 큰지 확인합니다.

CJam , 20 19 바이트

l_$_W=),\ci>_W<W%+=

테스트 스위트.

설명

기본 아이디어는 최소 및 최대 자릿수를 찾은 다음 해당 숫자에서 기자 번호를 만든 다음 입력과 동일한 지 확인하는 것입니다.

l       e# Read input.
_$      e# Get a sorted copy of the input.
_W=     e# Get its last character, i.e. the maximum digit M.
),      e# Get a string with all characters from the null byte up to M.
\c      e# Get the first character of the sorted string, i.e. the minimum
        e# character m.
i>      e# Convert to its character code and discard that many leading
        e# characters from the string we generated before. Now we've got
        e# a string with all digits from m to M, inclusive.
_W<W%+  e# Palindromise it, by appending a reversed copy without M.
=       e# Check that it's equal to the input.

최소 문자 대신 동일한 바이트 수로 첫 번째 문자를 사용할 수도 있습니다.

l_:e>),1$ci>_W<W%+=

Mathematica, 62 61 60 바이트

^{@MartinEnder 로 인해 2 바이트가 절약되었습니다 .}

MatchQ[{a:1...,b___}/;{b}==-{a}]@*Differences@*IntegerDigits

기능의 구성. 숫자를 입력 및 리턴 True또는 False출력으로 사용합니다.

레티 나, 55 54 36 바이트

바이트 수는 ISO 8859-1 인코딩을 가정합니다.

.
$*1:
+`^(1+:)(1\1.*)\b\1$
$2
^1+:$

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

콜론으로 구분하여 각 숫자를 단항으로 변환하십시오. 다음 자릿수가 하나 이상이면 루프, 일치하는 바깥 쪽 자릿수를 제거합니다. 남은 한 자리를 일치시킵니다.

PHP, 71 바이트

for($t=$i=max(str_split($s=$argv[1]));$t!=$s&&--$i;)$t="$i$t$i";echo$i;

입력으로부터 가장 자리를 가져와 입력과 비교 문자열이 동일 할 때까지 비교 문자열 새로운 숫자를 추가 카운트 다운 - 또는 $i이다 0.

0그렇지 않으면 Timmy Number의 가장 낮은 자릿수를 인쇄합니다 .

Pushy , 30 15 바이트

오늘 아침에 일어 났는데 답의 반 길이를 할 수 있다는 것을 깨달았습니다

s&K-kL2/OvhXwx#

_{(언어가 도전 할 때 경쟁하지 않음)}

명령 행에 입력이 제공됩니다 $ pushy gizas.pshy 3456543.. 출력 1truthy 및 0falsy합니다. 고장은 다음과 같습니다.

s                  % Split the number into its individual digits
 &K-               % Subtract all digits by the last 
    kL2/  h        % Get the halved length of the stack (+1)
        Ov X       % In stack 2, generate range (0, halved length)
            w      % Mirror the range 
             x#    % Check stack equality and output

이 알고리즘은 bash 답변에서 영감을 얻었습니다. 먼저 숫자를 정규화하고 ( 45654 -> 01210) 길이가 같은 정규화 된 기자 번호를 생성하고 비교하십시오.

오래된 솔루션

s&K-Y?kL2%?L2/:.;&OvhXx#i;;;0#

라켓 292 바이트

(let*((s(number->string n))(sn string->number)(st string)(lr list-ref)(sl(string->list s))(g(λ(i)(-(sn(st(lr sl(add1 i))))
(sn(st(lr sl i)))))))(cond[(even?(string-length s))#f][(not(equal? s(list->string(reverse sl))))#f][(andmap identity
(for/list((i(floor(/(length sl)2))))(= 1(g i))))]))

언 골프 드 :

(define(f n)
  (let* ((s (number->string n))
         (sn string->number)
         (st string)
         (lr list-ref)
         (sl (string->list s))
         (g (λ (i) (- (sn(st(lr sl (add1 i))))
                      (sn(st(lr sl i)))))))
    (cond
      [(even? (string-length s))
       #f]
      [(not(equal? s (list->string (reverse sl))))
       #f]
      [else
       (andmap identity
               (for/list ((i (floor(/(length sl)2))))
                 (= 1 (g i))))]
      )))

테스트 :

(f 12321) 
(f 123321)  ; only this should be false; 

(f 9)
(f 787)
(f 67876)
(f 4567654)
(f 123454321)
(f 12345654321)
(f 1234567654321)
(f 123456787654321)
(f 12345678987654321)

산출:

#t
#f
#t
#t
#t
#t
#t
#t
#t
#t
#t

자바 8, 162 + 19 바이트

에 대 한 19 import java.util.*;

s->{List f=new ArrayList();for(int i=0;i<9;){String l=String.valueOf(++i);for(int j=i;j>0;){f.add(l);String k=String.valueOf(--j);l=k+l+k;}}return f.contains(s);}

다른 Java 답변에 대한 다른 접근 방식으로 가능한 모든 Timmy 숫자를 만들고 문자열이 포함되어 있는지 확인하는 방법을 사용하고 싶었습니다.

옥타브, 56 바이트

@(n)nnz(n)<2||~(abs(diff(+n))-1)&&diff(+n(1:1+end/2))==1

여기 에서 모든 테스트 사례를 확인 하십시오 .

MATLAB에서는 diff(n)문자열에서 작동 하므로 바이트가 2 바이트 줄어 듭니다 . 옥타브에서는 필요합니다 diff(+n).

설명:

@(n)                  % Anonymous function taking a string `n` as argument
    nnz(n)<2          % True if there is only one element in n
            ||        % Short circuit or operator. Expression will be true if this is true
~(abs(diff(+n))-1)    % Takes the absolute value of the difference between adjacent numbers
                      % which should always be 1. Subtracts 1, to get 0
                      % and negates it to get 1 (true)
diff(+n(1:1+end/2))==1   % Checks if the difference between the first half of the numbers
                         % is 1.
                      % If either the first, or both the second and third argument is true
                      % then the function will return 1, otherwise 0. 

매스 매 티카, 56 바이트

조금 짧습니다.

MatchQ[Differences@IntegerDigits@#,{a:1...,b__}/;b==-a]&

자바 (7), 129 (119) 109 바이트

boolean e(char[]a){int l=a[0]-1,f=0,b=a.length-1;for(;f<b&&a[f]==++l&a[f++]==a[b--];);return f==b&l==a[b]-1;}

오래된 재귀 방법, 119

boolean b(char[]a){int b=a.length;return b>1&&a[0]==a[b-1]&a[0]+1==a[1]?b(java.util.Arrays.copyOfRange(a,1,b-1)):b==1;}

Geobits 덕분에 -10 바이트. 우리 는 묶여있다 ...

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

펄 6 , 43 34 바이트

-9 바이트의 Jo King에게 감사합니다.

{!/0/==set comb $_- S:g/..?/1/²:}

항구 Gabriel Benamy의 Perl 솔루션 .

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

잼, 35 바이트

아마도 매우 차선책 일 것입니다 ... 나는 연습이 약간 부족합니다!

q__W%=\_,_2%@@2/)<2ew{:-}%e`,1=]:e&

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

파이썬 2, 50 82 81 80 바이트

def f(a):b=len(a)/2+1;print(1,0)[a[:b-1]!=a[b:][::-1]or a[:b]not in'123456789']

간단한 접근. 문자열을 반으로 나눕니다 (중간 문자 또는 길이가 짝수 인 경우 중간 문자 다음에 누락). 두 번째 절반을 뒤집은 다음 두 번째를 비교하고 첫 번째 절반을 1에서 9의 문자열과 비교하십시오.

편집하다

동료 골퍼의 건설적인 피드백과 실수를 인식하고 수정 한 후에 다시 게시되었습니다.

(폐기물) 공간을 잃어버린 경우 -1

질문을 다시 읽고 0을 고려할 필요가 없다는 것을 깨닫기 위해 -1. 직장에서 긴 하루를 보낸 후에는 반드시 골프를 멈춰야합니다.