스스로 먹을 수있는 숫자


30

양의 정수가 주어지면 숫자가 스스로 먹을 수 있는지에 대한 진실 / 거짓 값을 출력하십시오.

규칙

가장 왼쪽은 머리, 가장 오른쪽은 꼬리

머리가 꼬리보다 크거나 같으면 머리가 꼬리를 먹고 새 머리가 ​​합이됩니다.

경우 에스10 다음 헤드로 대체 .에스모드10

에스=0 은 무시할 수 없지만 입력 번호에는 선행 0이 없습니다.

예:

number=2632
head-2, tail-2

2632 -> 463
head-4, tail-3

463 -> 76
head-7, tail-6

76 -> 3
If only one digit remains in the end, the number can eat itself.

어떤 시점에서 머리가 꼬리를 먹을 수 없다면, 그 대답은 거짓입니다.

number=6724
072
False (0<2)

테스트 사례 :

True:
[2632, 92258, 60282, 38410,3210, 2302, 2742, 8628, 6793, 1, 2, 10, 100, 55, 121]

False:
[6724, 47, 472, 60247, 33265, 79350, 83147, 93101, 57088, 69513, 62738, 54754, 23931, 7164, 5289, 3435, 3949, 8630, 5018, 6715, 340, 2194]

이것은 코드 골프 이므로 가장 짧은 코드가 승리합니다.


입력을 문자열로 할 수 있습니까?
lirtosiast

@lirtosiast, 그렇습니다. 자릿수 목록은 아닙니다.
Vedant Kandoi

14
그것들은 자동 식인 숫자 라고 할 수 있습니다 .
Arnauld

6
숫자 목록으로 사용할 수없는 이유는 무엇입니까? 이 문제는 이미 숫자 목록처럼 취급합니다. 그것들을 숫자로 만든다는 것은 당신이 그것들을 목록으로 변환하기 위해 여분의 코드를 고정해야한다는 것을 의미합니다.
밀 마법사

1
진실 / 거짓 대신 두 가지 일관된 고유 값을 반환 할 수 있습니까?
Olivier Grégoire

답변:


7

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

@tsh 덕분에 1 바이트 절약

입력을 문자열로받습니다. 부울 값을 반환합니다.

f=n=>n>[n%10]?f(-(-n[0]-n)%10+n.slice(1,-1)):!n[1]

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

댓글

f = n =>                 // f = recursive function taking n (a string)
  n > [n % 10]           // The last digit is isolated with n % 10 and turned into a
                         // singleton array, which is eventually coerced to a string
                         // when the comparison occurs.
                         // So we do a lexicographical comparison between n and its
                         // last digit (e.g. '231'>'1' and '202'>'2', but '213'<'3').
  ?                      // If the above result is true:
    f(                   //   do a recursive call:
      -(-n[0] - n) % 10  //     We compute (int(first_digit) + int(n)) mod 10. There's no
                         //     need to isolate the last digit since we do a mod 10 anyway.
      + n.slice(1, -1)   //     We add the middle part, as a string. It may be empty.
    )                    //   end of recursive call
  :                      // else:
    !n[1]                //   return true if n has only 1 digit, or false otherwise


6

젤리 , 11 바이트

Ṛṙ-µṖÄ%⁵:ḊẠ

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

작동 원리

Ṛṙ-µṖÄ%⁵:ḊẠ  Main link. Argument: n

Ṛ            Reverse n, after casting it to a digit list.
 ṙ-          Rotate the result -1 units to the left, i.e., 1 unit to the right.
             Let's call the resulting digit list D.
   µ         Begin a new chain with argument D.
    Ṗ        Pop; remove the last digit.
     Ä       Accumulate; take the cumulative sum of the remaining digits.
      %⁵     Take the sums modulo 10.
         Ḋ   Dequeue; yield D without its first digit.
        :    Perform integer division between the results to both sides.
             Integer division is truthy iff greater-or-equal is truthy.
          Ạ  All; return 1 if all quotients are truthy, 0 if not.

6

펄 6 , 63 62 바이트

{!grep {.[*-1]>.[0]},(.comb,{.[0,*-1].sum%10,|.[1..*-2]}...1)}

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

설명:

{                                                            } # Anonymous code block
                     (                                  ... )       # Create a sequence
                      .comb,  # Starting with the input converted to a list of digits
                            {                          }   # With each element being
                             .[0,*-1]   # The first and last element of the previous list
                                     .sum%10  # Summed and modulo 10
                                            ,|.[1..*-2]   # Followed by the intermediate elements
                                                        ...1 # Until the list is length 1
 !grep   # Do none of the elements of the sequence
       {.[*-1]>.[0]},   # Have the last element larger than the first?

5

자바 (JDK) , 83 바이트

n->{int r=0,h=n;while(h>9)h/=10;for(;n>9;h=(h+n)%10,n/=10)r=h<n%10?1:r;return r<1;}

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

크레딧


파이썬 답변의 길이가 주어지면 테스트 케이스가 정상이지만 뭔가를 놓친 것처럼 느껴집니다.
Olivier Grégoire

나는 당신이 아무것도 놓쳤다 고 생각하지 않습니다. 파이썬은 입력을 문자열로 사용하고 인덱싱을 사용하며 입력을 정수로 사용 /10하고 %10루프에서 사용 합니다. 파이썬 답변을 두들겨서 잘했습니다. 나에게서 +1 :)
Kevin Cruijssen

1
당신은 골프 변경 바이트 수 r+=r=?1:0로를 ?1:r.
Kevin Cruijssen

@KevinCruijssen Indeed ... 파이썬 답변은 차선책입니다 : 댓글의 골프는이 답변보다 짧습니다. 또한 저장된 바이트에 감사드립니다! ;-)
Olivier Grégoire

시작 하고 (1 바이트 저장) 수행 하여 또는 1 을 반환 할 수 있습니다. 01r=1r&=h<n%10?0:r;return r;
Arnauld

4

수학, 62 바이트

0(IntegerDigits@#//.{a_,r___,b_}/;a>=b:>{Mod[a+b,10],r})=={0}&

먼저 IntegerDigits입력을 호출 하여 숫자 목록을 가져온 후 다음 규칙을 반복해서 적용합니다.

{a_,r___,b_}       (* match the first digit, 0 or more medial digits, and the last digit... *)
/;a>=b             (* under the condition that the number is edible... *)
:>{Mod[a+b,10],r}  (* and replace it with the next iteration *)

패턴이 더 이상 일치하지 않을 때까지 규칙이 적용됩니다.이 경우 한 자리 만 남아 있거나 (머리카락) 머리가 꼬리보다 작습니다 (거짓).

을 호출하는 대신 목록의 모든 요소에 곱한 다음 목록 과 비교 Length[__]==1하여 몇 바이트를 절약 할 수 있습니다 .0(__)=={0}0{0}


1
모르는 경우 TIO에 Mathematica가 있습니다. 온라인으로 사용해보십시오!
Dennis

4

파이썬 3 , 50 바이트

첫 번째 줄은 Black Owl Kai의 답변 에서 도난당했습니다 .

p,*s=map(int,input())
while s:*s,k=s;p%10<k>q;p+=k

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

종료 코드를 통해 출력됩니다. 허위 입력의 경우 실패 (1) 및 정확한 입력의 경우 완료 (0).


p%10<k>qNameError를 발생시키지 않는지 설명 할 수 있습니까 p%10 >= k?
Black Owl Kai

1
@BlackOwlKai 체인 비교는 Python에서 느리게 평가됩니다. 즉, 첫 번째 잘못된 비교가 표시되면 체인이 더 이상 평가되지 않습니다. 이 경우 p%10<k>q와 동일합니다 p%10<k and k>q.
ovs

4

파이썬 2 , 105 82 81 바이트

i,x=map(int,input()),1
for y in i[:0:-1]:
 if i[0]%10<y:x=0
 else:i[0]+=y
print x

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

@ ØrjanJohansen의 엄청난 -23 감사합니다.

또 다른 -1에 대한 @VedantKandoi (및 @ ØrjanJohansen)에게 감사드립니다.


1
for리버스 슬라이스와 함께 사용할 수 있으며 %10테스트 할 때만 수행 할 수 있습니다. 온라인으로 사용해보십시오!
Ørjan Johansen 님이

1
if-else 조건을 교환 if i[0]<i[-1]:x=0한 다음 else:..... @ ØrjanJohansen, 귀하의 답변에도.
Vedant Kandoi

@ ØrjanJohansen-감사합니다. 멋지다.
엘 페드로

안녕하세요 @VedantKandoi. 잘 들리지만 정확히 무슨 뜻인지 확실하지 않습니다. 당신은 저에게 이겼습니다. TIO를 추가 할 수 있습니까? 내가 시도하면 모든 True경우에 작동 하지만 모든 경우에 작동 하지는 않습니다 False.
ElPedro

1
@VedantKandoi가 이것을 의미한다고 생각 합니다 .
Ørjan Johansen

4

Brachylog , 23 바이트

ẹ{bkK&⟨h{≥₁+tg}t⟩,K↰|Ȯ}

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

이것은 Fatalize의 솔루션 보다 1 바이트 절약 입니다. 됩니다. 이것은 반복적 인 대신에 재귀 적 접근법을 사용합니다.

설명

ẹ                          Input into a list of digits
 {                    }    Assert that either
  bk                       | the list has at least 2 elements (see later)
      ⟨h{     }t⟩           | and that [head, tail]
         ≥₁                |  | is increasing (head >= tail)
           +               |  | and their sum
            t              |  | mod 10 (take last digit)
             g             |  | as single element of a list
                ,          | concatenated with
  bkK            K         | the number without head and tail (this constrains the number to have at least 2 digits)
                  ↰        | and that this constraint also works on the newly formed number
                   |Ȯ      | OR is a 1 digit number

3

APL (Dyalog Unicode) , 33 바이트 SBCS

문자열을 인수로 사용하는 익명의 암묵적 접두사 함수.

{⊃⍵<t←⊃⌽⍵:03::1⋄∇10|t+@1⊢¯1↓⍵}⍎¨

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

⍎¨ 각 문자를 평가하십시오 (이것은 우리에게 숫자 목록을 제공합니다)

{} 다음 "dfn"을 적용하십시오. 인수 (숫자 목록)입니다.

  ⌽⍵ 논쟁을 뒤집다

   첫 번째 요소를 선택하십시오 (이것은 꼬리입니다)

  t← 할당 t(대한 t의 괴롭히다)

  ⍵< 각 원래 숫자에 대해 그보다 작은 지 확인하십시오

   첫 번째 참 / 거짓을 고르세요

: 그렇다면:

  0 거짓을 돌려 주다

 그때:

3:: 지금부터는 색인 오류 (범위를 벗어남)가 발생합니다.

  1 참을 돌려 주다

  ¯1↓⍵ 마지막 자리를 버린다

   수율 (분리 1되어 ¯1단일 배열을 형성하지 않음)

  t+@1 첫 번째 숫자 (머리)에 꼬리를 추가

  10| 모드 10

   재귀

한 자릿수에 도달 ¯1↓하면 빈 목록을 만들고 @1첫 번째 숫자가 없으므로 색인 오류가 발생하여 함수가 true를 반환합니다.



3

Brachylog , 24 바이트

ẹ;I⟨⟨h{≥₁+tg}t⟩c{bk}⟩ⁱ⁾Ȯ

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

의 기본 동작을 변경 하여 알 수없는 횟수를 반복해야합니다 (현재는 기본적으로 1 번 반복되어 완전히 쓸모가 없습니다). 그런 다음 […];I[…]⁾3 바이트를 절약 할 필요가 없습니다.

설명

이 프로그램에는 포크 안에 못생긴 포크가 들어 있습니다. 숫자 대신 숫자의 목록에 대한 작업에 필요한 몇 가지 배관도 있습니다 (때문에 우리는 머리와 꼬리 제거하는 경우 76에 남아있는 우리 0에 대한 일 반하지 않는, [7,6]우리가 결국 어디 []).

ẹ                          Input into a list of digits
                       Ȯ   While we don't have a single digit number…
 ;I                  ⁱ⁾    …Iterate I times (I being unknown)…
   ⟨                ⟩      …The following fork:
               c           | Concatenate…
    ⟨         ⟩            | The output of the following fork:
     h       t             | | Take the head H and tail T of the number
      {     }              | | Then apply on [H,T]:
       ≥₁                  | | | H ≥ T
         +                 | | | Sum them
          tg               | | | Take the last digit (i.e. mod 10) and wrap it in a list
                {  }       | With the output of the following predicate:
                 bk        | | Remove the head and the tail of the number

반복 대신 재귀를 사용하고 ,대신 c 포크를 사용하여 1 바이트를 제거 할 수 있습니다. 온라인 사용해보십시오!
Kroppeb

@Kroppeb 정말 멋지다. 내 답변과는 크게 다르기 때문에 자신의 답변을 게시해야한다고 생각합니다!
페이탈 라이즈

3

하스켈, 70 64 60 바이트

f(a:b)=b==""||a>=last b&&f(last(show$read[a]+read b):init b)

입력은 문자열로 간주됩니다.

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

편집 : 별도의 가드 대신 @Laikoni의 트릭 을 사용 하여 -6 바이트 ||. @Laikoni 덕분에 또 다른 -4 바이트.


3
read[l b]read b어쨌든 마지막 숫자 만 보았 기 때문일 수 있습니다 . 인라인으로 4 바이트를 더 절약합니다 last: 온라인으로 사용해보십시오!
Laikoni




2

루비, 139 바이트

->(a){a.length==1?(p true;exit):1;(a[0].to_i>=a[-1].to_i)?(a[0]=(a[-1].to_i+a[0].to_i).divmod(10)[1].to_s;a=a[0..-2];p b[a]):p(false);exit}

온라인으로 사용해보십시오! (함수이기 때문에 입력을 처리하기위한 추가 코드가 있습니다)

Ungolfed 코드 :

->(a) do
    if a.length == 1
        p true
        exit
    if a[0].to_i >= a[-1].to_i
        a[0] = (a[-1].to_i + a[0].to_i).divmod(10)[1].to_s
        a = a[0..-2]
        p b[a]
    else
        p false
        exit
    end
end

1

레티 나 0.8.2 , 42 바이트

\d
$*#;
^((#*).*;)\2;$
$2$1
}`#{10}

^#*;$

온라인으로 사용해보십시오! 테스트 케이스 포함 링크. 설명:

\d
$*#;

숫자를 단항으로 변환하고 구분 기호를 삽입하십시오.

^((#*).*;)\2;$
$2$1

마지막 숫자가 첫 번째 숫자보다 크지 않으면 함께 추가하십시오.

#{10}

적절한 경우 모듈로 10을 줄입니다.

}`

마지막 숫자가 첫 번째 숫자보다 클 때까지 반복하거나 하나의 숫자 만 남습니다.

^#*;$

한 자리 만 남았는지 테스트하십시오.


1

05AB1E , 26 25 24 바이트

[DgD#\ÁD2£D`›i0qëSOθs¦¦«

아마 조금 더 골프를 칠 수 있습니다. 너무 오래 느껴지지만 어쩌면 도전은 미리 생각했던 것보다 코드가 더 복잡 할 수 있습니다.

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

설명:

[                 # Start an infinite loop
 D                #  Duplicate the top of the stack
                  #  (which is the input implicitly in the first iteration)
  gD              #  Take its length and duplicate it
    #             #  If its a single digit:
                  #   Stop the infinite loop
                  #   (and output the duplicated length of 1 (truthy) implicitly)
                  #  Else:
  \               #   Discard the duplicate length
   Á              #   Rotate the digits once towards the left
    D2£           #   Duplicate, and take the first two digits of the rotated number
       D`         #   Duplicate, and push the digits loose to the stack
         i       #   If the first digit is larger than the second digit:
           0      #    Push a 0 (falsey)
            q     #    Stop the program (and output 0 implicitly)
          ë       #   Else (first digit is smaller than or equal to the second digit):
           SO     #    Sum the two digits
             θ    #    Leave only the last digit of that sum
           s      #    Swap to take the rotated number
            ¦¦    #    Remove the first two digits
              «   #    Merge it together with the calculated new digit

1

C ++ (gcc) , 144 바이트

bool f(std::string b){int c=b.length();while(c>1){if(b[0]<b[c-1])return 0;else{b[0]=(b[0]-48+b[c-1]-48)%10+48;b=b.substr(0,c-1);--c;}}return 1;}

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

처음으로 이와 같은 것을 시도하고 있으므로 잘못된 형식을 지정한 경우 알려주십시오. 네임 스페이스를 사용하여 5 바이트 "std ::"를 제거하는 것과 같은 규칙에 대해서는 100 % 확신하지 못하므로 그대로 두었습니다.

언 골프 드 :

bool hunger(std::string input)
{
    int count=input.length();
    while (count>1)
    {
        if (input[0]<input[count-1])                         //if at any point the head cannot eat the tail we can quit the loop
                                                             //comparisons can be done without switching from ascii
        {
            return false;
        }
        else
        {
             input[0]=(input[0]-48+input[count-1]-48)%10+48; //eating operation has to occur on integers so subtract 48 to convert from ASCII to a number
             input=input.substr(0,count-1);                  //get rid of the last number since it was eaten
             --count;
        }

    }
    return true;                                             //if the end of the loop is reached the number has eaten itself
}

1
이론적으로는 또한 #include진술이 필요 합니다. 그러나 나는 C ++ 의 std lib 시설 하위 방언에 #include "std_lib_facilities.h"접두어가있는 프로그래밍을 제안 합니다 using namespace std;. 이 헤더는 C ++을 처음 접하는 학생들을 위해 언어를 되 돌리는 저자 (최신 버전은 2010)입니다.
Yakk

@Yakk 당신을 위해 이것을하는 통역사를 만들고 출판하지 않는 한, std_lib_facilities.h의 포함을 계산해야합니다.
Dennis

@BenH PPCG에 오신 것을 환영합니다! 함수를 컴파일하는 데 필요한 모든 포함 횟수가 필요합니다. 내가 아는 가장 짧은 방법은 #import<string>입니다. 온라인으로 사용해보십시오!
Dennis

@Dennis #!/usr/bin/sh줄 바꿈 gcc -include "std_lib_facilities.h" $@- 내가 그 쉘 스크립트 것이 그 수를 제공하는 C ++ 과정을 찾으면?
Yakk

@Yakk 그 스위치에 대해 몰랐습니다. #include 문과 달리 명령 줄 인수는 기본적으로 새로운 언어이므로 무료 입니다. 에서 C ++ (GCC)-include iostream 이 실제로 144 바이트입니다.
Dennis


1

C (GCC) (string.h)와 , 110 108 바이트

c;f(char*b){c=strlen(b);if(!c)return 1;char*d=b+c-1;if(*b<*d)return 0;*b=(*b+*d-96)%10+48;*d=0;return f(b);}

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

여전히 PPCG에 비교적 새로운 것이기 때문에, 새로운 언어로 라이브러리를 링크하기위한 올바른 구문은 나에게 외국어입니다. 또한 함수는 false / true에 대해 0 또는 1을 리턴하며 stdout에 결과를 인쇄하려면 stdio가 필요합니다. 우리가 농민이고 운동이 출력을 요구한다면, 언어는 stdio도 필요 로합니다.

개념적으로 @BenH의 대답과 비슷하지만 C에서는 재귀를 사용하지만 PPCG에 오신 것을 환영합니다 (btw). 더티 코드는 클린 코드보다 짧기 때문에 배열 포인터 산술도 사용합니다.

이 함수는 꼬리 재귀 적이며 첫 번째 숫자가 마지막을 먹을 수 없거나 길이가 1 인 경우 종료 조건으로 각각 false 또는 true를 반환합니다. 이 값은 문자열의 시작과 끝에서 C-String에 대한 포인터 (문자를 제공함)를 역 참조하고 비교합니다. 문자열의 끝을 찾기 위해 포인터 산술이 수행됩니다. 마지막으로, 마지막 문자는 널 종결 자 (0)로 대체하여 "지워집니다".

모듈러스 산술이 1 또는 2 바이트 단축 될 수 있지만 포인터 조작 후 이미 샤워가 필요합니다.

Ungolfed 버전은 여기

업데이트 : c == 1을! c로 바꾸어 2 바이트를 절약했습니다. 이것은 본질적으로 c == 0입니다. 추가 시간이 걸리며, 삭제하기 전에 두 배가 필요하지만 2 바이트를 절약합니다. 부작용은 길이가 0이거나 길이가 0 인 문자열은 무한 재귀를 유발하지 않습니다 (연습에서는 양의 정수가 표시되므로 null 문자열을 가져 오지 않아야 함).


gcc경고가 발생하더라도 s gcc없이 코드를 행복하게 컴파일 하는 경우에는 라이브러리를 링크 할 필요가 없습니다 #include. 또한를 사용하여 4 바이트를 절약 할 수 -DR=return있습니다. 마지막으로 테스트 코드 \0에서 문자열은 문자 그대로 이미 암시 적으로 포함되어 있기 때문에 불필요합니다.

1
또한, 첫 번째 변수에 할당 함수에서 복귀 할 수 b=case1?res1:case2?res2:res_else;와 동일하다if(case1)return res1;if(case2)return res2;return res_else;

또한 사용하지 않으면 추가 바이트를 흘릴 c수 있습니다. 문자열의 길이가에서 0인지 확인할 수 있습니다 head-tail.


C에서 삼항 (조건부) 연산자를 사용할 수 있다는 것을 몰랐습니다. 항상 그랬습니까? 어쨌든, 알아두면 좋습니다. 앞으로 사용하겠습니다. 건배
앤드류 Baumher

1

파워 쉘, 89 바이트

"$args"-notmatch'(.)(.*)(.)'-or(($m=$Matches).1-ge$m.3-and(.\g(''+(+$m.1+$m.3)%10+$m.2)))

중대한! 스크립트는 재귀 적으로 호출됩니다. 스크립트를g.ps1 현재 디렉토리에 파일 . 또한 스크립트 파일 대신 스크립트 블록 변수를 호출 할 수 있습니다 (아래 테스트 스크립트 참조). 통화 길이는 같습니다.

참고 1 :이 스크립트는 논리 연산자 -or및 의 지연 평가를 사용합니다 -and. 경우 "$args"-notmatch'(.)(.*)(.)'이며 True다음의 오른쪽 표현식 -or평가되지 않습니다. 또한 경우가 ($m=$Matches).1-ge$m.3있다 False다음의 오른쪽 표현식 -and도 평가되지 않습니다. 따라서 무한 재귀를 피합니다.

참고 2 : 정규식 '(.)(.*)(.)'에는 (.*)기본적으로 욕심이 많으 므로 시작 및 끝 앵커가 포함되지 않습니다 .

테스트 스크립트

$g={
"$args"-notmatch'(.)(.*)(.)'-or(($m=$Matches).1-ge$m.3-and(&$g(''+(+$m.1+$m.3)%10+$m.2)))
}

@(
    ,(2632, $true)
    ,(92258, $true)
    ,(60282, $true)
    ,(38410, $true)
    ,(3210, $true)
    ,(2302, $true)
    ,(2742, $true)
    ,(8628, $true)
    ,(6793, $true)
    ,(1, $true)
    ,(2, $true)
    ,(10, $true)
    ,(100, $true)
    ,(55, $true)
    ,(121, $true)
    ,(6724, $false)
    ,(47, $false)
    ,(472, $false)
    ,(60247, $false)
    ,(33265, $false)
    ,(79350, $false)
    ,(83147, $false)
    ,(93101, $false)
    ,(57088, $false)
    ,(69513, $false)
    ,(62738, $false)
    ,(54754, $false)
    ,(23931, $false)
    ,(7164, $false)
    ,(5289, $false)
    ,(3435, $false)
    ,(3949, $false)
    ,(8630, $false)
    ,(5018, $false)
    ,(6715, $false)
    ,(340, $false)
    ,(2194, $false)
) | %{
    $n,$expected = $_
   #$result = .\g $n   # uncomment this line to call a script file g.ps1
    $result = &$g $n   # uncomment this line to call a script block variable $g
                       # the script block call and the script file call has same length
    "$($result-eq-$expected): $result <- $n"
}

산출:

True: True <- 2632
True: True <- 92258
True: True <- 60282
True: True <- 38410
True: True <- 3210
True: True <- 2302
True: True <- 2742
True: True <- 8628
True: True <- 6793
True: True <- 1
True: True <- 2
True: True <- 10
True: True <- 100
True: True <- 55
True: True <- 121
True: False <- 6724
True: False <- 47
True: False <- 472
True: False <- 60247
True: False <- 33265
True: False <- 79350
True: False <- 83147
True: False <- 93101
True: False <- 57088
True: False <- 69513
True: False <- 62738
True: False <- 54754
True: False <- 23931
True: False <- 7164
True: False <- 5289
True: False <- 3435
True: False <- 3949
True: False <- 8630
True: False <- 5018
True: False <- 6715
True: False <- 340
True: False <- 2194

파워 쉘, 90 바이트

재귀가 없습니다. 파일 이름 종속성 및 스크립트 블록 이름 종속성이 없습니다.

for($s="$args";$s[1]-and$s-ge$s%10){$s=''+(2+$s[0]+$s)%10+($s|% S*g 1($s.Length-2))}!$s[1]

Powershell은 오른쪽 피연산자를 왼쪽 피연산자 유형으로 암시 적으로 변환합니다. 따라서 $s-ge$s%10오른쪽 피연산자를 $s%10로 계산 하고 왼쪽 피연산자의 유형이 integerstring인해 비교합니다 string. 그리고 2+$s[0]+$s숯불 변환 $s[0]및 문자열 $sinteger왼쪽 피연산자 때문에를2 정수입니다.

$s|% S*g 1($s.Length-2)A는 바로 가기 로는$s.Substring(1,($s.Length-2))


1

C # (Visual C # 대화식 컴파일러) , 69 바이트

x=>{for(int h=x[0],i=x.Length;i>1;)h=h<x[--i]?h/0:48+(h+x[i]-96)%10;}

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

성공 또는 실패는 다음에 의해 결정됩니다. 예외 유무에 . 입력은 문자열 형태입니다.

덜 골프 ...

// x is the input as a string
x=>{
  // h is the head
  for(int h=x[0],
    // i is an index to the tail
    i=x.Length;
    // continue until the tail is at 0
    i>1;)
      // is head smaller larger than tail?
      h=h<x[--i]
        // throw an exception
        ?h/0
        // calculate the next head
        :48+(h+x[i]-96)%10;
}

문자와 숫자 사이의 변환을 처리하기 위해 추가 바이트가 있지만 전체적으로 크기에 큰 영향을 미치지 않습니다.



1

Brachylog , 18 바이트

ẹ⟨k{z₁{≥₁+t}ᵐ}t⟩ⁱȮ

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

단지 비 결정적 superscriptless 덕분에 Fatalize의 솔루션 오프 3 바이트를 취 이제 기존하지만, 함께 희미 젤리 영감을 일을하여 다른 세 가지를 잃게 z₁사용하지 않도록 c, g또는 심지어 h. 또한 다른 새로운 기능인 ʰ메타 프리디 케이트 를 사용하려는 시도와 실패에서 영감을 얻었습니다 .

                 Ȯ    A list of length 1
                ⁱ     can be obtained from repeatedly applying the following
ẹ                     to the list of the input's digits:
 ⟨k{         }t⟩      take the list without its last element paired with its last element,
    z₁                non-cycling zip that pair (pairing the first element of the list with
                      the last element and the remaining elements with nothing),
      {    }ᵐ         and for each resulting zipped pair or singleton list:
       ≥₁             it is non-increasing (trivially true of a singleton list);
          t           take the last digit of
         +            its sum.

0

PowerShell , 94 91 바이트

for(;$n-and$n[0]-ge$n[-1]){$n=$n-replace"^.",((+$n[0]+$n[-1]-96)%10)-replace".$"}return !$n

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


테스트 스크립트

function f($n){

for(;$n-and$n[0]-ge$n[-1]){$n=$n-replace"^.",((+$n[0]+$n[-1]-96)%10)-replace".$"}return !$n

Remove-Variable n
}
Write-Host True values:
@(2632, 92258, 60282, 38410,3210, 2302, 2742, 8628, 6793, 1, 2, 10, 100, 55, 121) |
    % { Write-Host "  $_ $(' '*(6-$_.ToString().Length)) $(f $_.ToString())" }

Write-Host False values:
@(6724, 47, 472, 60247, 33265, 79350, 83147, 93101, 57088, 69513, 62738, 54754, 23931, 7164, 5289, 3435, 3949, 8630, 5018, 6715, 340, 2194) | 
    % { Write-Host "  $_ $(' '*(6-$_.ToString().Length)) $(f $_.ToString())" }

Ungolfed 코드 :

function f ($inVar){
    # While the Input exists, and the first character is greater than last
    while($inVar -and ($inVar[0] -ge $inVar[-1])){

        # Calculate the first integer -> ((+$n[0]+$n[-1]-96)%10)
        $summationChars = [int]$inVar[0]+ [int]$inVar[-1]
        # $summationChars adds the ascii values, not the integer literals. 
        $summationResult = $summationChars - 48*2
        $summationModulo = $summationResult % 10

        # Replace first character with the modulo
        $inVar = $inVar -replace "^.", $summationModulo

        # Remove last character
        $inVar = $inVar -replace ".$"
    }
    # Either it doesn't exist (Returns $True), or 
    # it exists since $inVar[0] < $inVar[-1] returning $False
    return !$inVar
}

1
당신은 확인할 필요가 없습니다 $n[0]귀하의 for문 - 단지 확인 $n충분합니다.
AdmBorkBork

당신은 사용 위해 할 수있는 -6대신 -96이 캘크 %로 10 정도이기 때문에
mazzy

return 7 바이트를 제거 하고 저장할 수 있습니다
mazzy

바이트 수에 매개 변수 선언을 포함시켜야한다고 생각합니다. 하나 param($n)또는 function f($n).
mazzy

1
@mazzy 포스터는 주석에서 문자열을 사용할 수 있다고 언급했지만 입력 한 숫자 / 문자열 목록으로 입력 할 수 없었습니다. 나는 이것이 ["1","2","3"]유효하지 않은 입력이지만 해석했습니다 "123". @VedantKandoi에 문제가 있으면 분명히 바꿀 수 있습니다!
KGlasier
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.