상호 모방


17

An 10 진수 으로 구성된 양의 정수라고 합시다 . 를 다른 양의 정수로 하자 .d1,d2,...,dnB

이 과제의 목적을 위해 다음과 같이 양의 정수 하나 이상 있으면 를 의 모방 이라고합니다.ABp1,p2,...,pn

나는=1나는나는=

및 호출되는 상호 모방이 경우 의 모방이고 와 의 모방이다 .

526 과 은 다음 과 같은 이유로 상호 카피 캣입니다.853

5+29+6=853

과:

83+51+32=526

도전

두 개의 양의 정수 와 주어지면 와 가 상호 카피 캣이면 거짓 값을 인쇄하거나 그렇지 않으면 거짓 값을 반환해야합니다.ABAB

설명 및 규칙

  • 합리적이고 모호하지 않은 형식 (예 : 정수, 문자열, 숫자 목록 등)으로 와 를 사용할 수 있습니다AB
  • A 와 는 동일 할 수 있습니다. 숫자가 그 자체의 역사 본이라면 , A007532에 속합니다 .B
  • 진실 / 거짓 값 대신 두 개의 일관된 값을 반환 할 수 있습니다 .
  • 를 들어 과 , 당신의 코드에 완료해야 1 분 미만 . 더 높은 가치를 얻기 위해 너무 많은 시간이 걸리면 이론적으로 해결할 수 있어야합니다.1A<10001B<1000
  • 이것은 입니다.

테스트 사례

Truthy:
1 1
12 33
22 64
8 512
23 737
89 89
222 592
526 853
946 961
7 2401
24 4224
3263 9734
86 79424
68995 59227
32028 695345

Falsy:
1 2
3 27
9 24
24 42
33 715
33 732
222 542
935 994
17 2401
8245 4153

권장 사례 : 17 2401 -> false. 나는 이것에 거의 걸려 넘어졌다.
Shieru Asakoto

답변:


8

Brachylog , 19 바이트

ẹ{∧ℕ₁;?↔^}ᵐ².+ᵐ↔?∧≜

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

출력 true.또는false.

설명

ẹ                     Split the numbers into lists of digits
 {       }ᵐ²          For each digit
  ∧ℕ₁                 Let I be a strictly positive integer
     ;?↔^                Compute the digit to the power I (which is unknown currently)
            .         Call . the list of those new numbers
            .+ᵐ       Their mapped sum results…
               ↔?     …in the reverse of the input
                 ∧≜   Find if there effectively are values for the numbers in . to satisfy
                        these relationships

2
@Arnauld 1 바이트의 비용으로 고정되었습니다. 그것은 내가 긍정적으로 확인한 방식으로 작동하지 않는 2401포함되어 있기 때문에 실패했습니다 ( 바이트를 절약하기 위해 숫자와 숫자 에 모두 매핑했기 때문에 )0II
Fatalize

6

껍질 , 17 바이트

Λλ€⁰mΣΠTṪ^ḣ√⁰d)De

온라인으로 사용해보십시오! 약 11 초 동안 1000 미만의 모든 테스트 사례를 완료합니다.

설명

Λλ€⁰mΣΠTṪ^ḣ√⁰d)De  Implicit inputs, say 12 and 33.
                e  Put into a list: [12,33]
               D   Duplicate: [12,33,12,33]
Λ                  Does this hold for all adjacent pairs:
                    (12,33 is checked twice but it doesn't matter)
                    For example, arguments are 33 and 12.
 λ            )     Anonymous function with arguments 33 (explicit) and 12 (implicit).
             d      Base-10 digits of implicit argument: [1,2]
          ḣ√⁰       Range to square root of explicit argument: [1,2,3,4]
        Ṫ^          Outer product with power: [[1,2],[1,4],[1,8],[1,16],[1,32]]
       T            Transpose: [[1,1,1,1,1],[2,4,8,16,32]]
      Π             Cartesian product: [[1,2],[1,4],...,[1,32]]
    mΣ              Map sum: [3,5,...,33]
  €⁰                Is the explicit argument in this list? Yes.

작동하는 이유

우리가 =11++ 경우, 여기서 나는 는 숫자이고 나는 는 양의 정수이면, 모든 i에 대해 나는나는 또는 동등하게 p ilog d i B 입니다. 지수 0 또는 1 이 변경되지 않으므로 d i1을 무시할 수 있습니다 . 내 프로그램에서 검색 공간은나는pilogdiBdi1011나는 (시간 제한을 준수하기 위해, I 사용할 것이다1나는달리) 우리가 그렇다면로그나는이면 모든 것이 괜찮습니다. 경우나는이 모든 자연수를 위해 보유유일한 위험 케이스되도록나는=2. 우리는로그2>대해서만=8. 이 경우2=8이지만 검색은 지수12만 고려합니다. 다른 숫자 number에 숫자2가 포함 된 경우0이 아닌 다른 숫자도 포함되므로 (2의 지수는 합계에서이될 수 없음)일부k의 경우=210케이입니다. 후자의 경우A8의 거듭 제곱이 아니므로B의 모방자가 될 수 없습니다케이8 어쨌든 프로그램은 다른 계산에 관계없이 잘못된 값을 올바르게 반환합니다.


허 스크를 배우고 싶은 훌륭한 답변. 두 가지 질문 : 1. 암시적인 주장은 당신이 그것을 소개 한 후에 다시 언급됩니다. 언제 사용됩니까? 2. 왜이 알고리즘이 OP에 제시된 알고리즘과 동등한 지 자세히 설명해 주시겠습니까?
요나

1
@Jonah 1. 숫자 함수 d는 암시 적 인수를 취합니다. 나는 설명에서 이것을 명확히했다. 2. 나는 프로그램의 정확성에 대한 논쟁을 추가했다.
Zgarb

고맙습니다 ... btw, 나를 혼란스럽게 한 부분은 "모든 사람의 목록은 어디에서 왔습니까?"였습니다 .. ... 다시 읽는 것은 1의 모든 힘이 단지 하나이기 때문에 이것을 깨닫는다는 것입니다 ....
요나


4

05AB1E , 26 22 바이트

εVтLIàgãεYSym}OIyKå}˜P

입력을 목록으로 가져옵니다 (예 :) [526,853].

온라인으로 시도 하거나 범위 내에서 대부분의 테스트 사례를 확인 [1,999]하십시오 .

[1,n]목록에 하드 코딩 된 것을 제외하고 아래의 이전 답변과 비슷하며 [1,100]각 입력 매핑에 대해 한 번만 카티 전 목록을 두 번 만듭니다. 이는 성능 측면에서 주요 병목 현상입니다.


이전 26 바이트는 성능에 더 적합합니다.

Z©bgL®gãUεVXεYSym}OsN>èå}P

이 버전에서는 성능을 훨씬 향상시키기 위해 약간의 바이트로 교환 [1,1000]하여 쉽게 실행할 수 있습니다 . 범위 내의 숫자를 포함하는 테스트 사례 [1,9999]는 TIO에서 약 1 초 안에 수행됩니다. [10000,99999]TIO에서 약 10-15 초 범위의 테스트 사례 . 그보다 시간이 초과됩니다.

온라인으로 시도 하거나 범위 내의 숫자로 모든 테스트 사례를 확인하십시오[1,9999] .

설명:

Z                 # Push the max of the (implicit) input-list (without popping)
                  #  i.e. [526,853] → 853
 ©                # Store it in the register (without popping)
  b               # Convert to binary
                  #  i.e. 853 → 1101010101
   g              # Take its length
                  #  i.e. 1101010101 → 10
    L             # Pop and push a list [1, n]
                  #  i.e. 10 → [1,2,3,4,5,6,7,8,9,10]
     ®            # Push the max from the register
      g           # Take its length
                  #  i.e. 853 → 3
       ã          # Cartesian product the list that many times
                  #  i.e. [1,2,3,4,5,6,7,8,9,10] and 3
                  #   → [[1,1,1],[1,1,2],[1,1,3],...,[10,10,8],[10,10,9],[10,10,10]]
        U         # Pop and store it in variable `X`
ε              }  # Map both values of the input list:
 V                # Store the current value in variable `Y`
  Xε    }         # Map `y` over the numbers of variable `X`
    Y             # Push variable `Y`
     S            # Convert it to a list of digits
                  #  i.e. 526 → [5,2,6]
      ym          # Take each digit to the power of the current cartesian product sublist
                  #  i.e. [5,2,6] and [3,9,3] → [125,512,216]
         O        # Take the sum of each inner list
                  #  i.e. [[5,2,6],[5,2,36],[5,2,216],...,[125,512,216],...]
                  #   → [13,43,223,...,853,...]
          s       # Swap to push the (implicit) input
           N>     # Push the index + 1
                  #  i.e. 0 → 1
             è    # Index into the input-list (with automatic wraparound)
                  #  i.e. [526,853] and 1 → 853
              å   # Check if it's in the list of sums
                  #  i.e. [13,43,223,...,853,...] and 853 → 1
                P # Check if it's truthy for both both (and output implicitly)
                  #  i.e. [1,1] → 1


4

펄 6 , 87 84 69 바이트

nwellnhof 덕분에 -15 바이트!

{!grep {!grep $^b,[X+] 0,|map (*X**1..$b.msb+1),$^a.comb},.[0,1,1,0]}

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

True 또는 False를 반환하는 익명 코드 블록

설명:

{!grep {!grep $^b,[X+] 0,|map (*X**1..$b.msb+1),$^a.comb},.[0,1,1,0]}

{                                                                   }  # Anonymous code block
 !grep    # None of:
                                                          .[0,1,1,0]   # The input and the input reverse
       {!grep       # None of
                  [X+]       # All possible sums of
                       0,|   # 0 (this is to prevent single digit numbers being crossed with themself)
                          map                  ,$^a.comb   # Each digit mapped to
                              (*X**           )  # The power of
                                   1..$b.msb+1   # All of 1 to the most significant bit of b plus 1
                                                 # This could just be b+1, but time constraints...
              $^b,  # Is equal to b

@Arnauld, A Junction은 출력하기 전에 boolify 연산자를 사용하여 보여준 것처럼 Truthy / Falsey입니다. 어쨌든 다른 것으로 골프를 쳤지 만 거짓과 그 반대로 진실한 값을 출력 할 수 있다면 바이트를 절약 할 수 있지만 ...?
조 왕

설명해 주셔서 감사합니다. 진실 / 거짓 반전에 대해 : 나는 오히려 거절하고 싶습니다.
Arnauld


2

J , 56 바이트

h~*h=.4 :'x e.+/|:>,{x 4 :''<y&*^:(x&>)^:a:y''"+"."+":y'

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

예, 중첩 된 명시 적 정의!

작동 원리

powers =. 4 :'<y&*^:(x&>)^:a:y'  Explicit aux verb. x = target, y = digit
                             y   Starting from y,
               y&*^:     ^:a:    collect all results of multiplying y
                    (x&>)        until the result is at least x
              <                  Box it.

h=.4 :'x e.+/|:>,{x powers"+"."+":y'  Explicit aux verb. x, y = two input numbers
                            "."+":y   Digits of y
                  x powers"+          Collect powers of digits of y under x
                 {            Cartesian product of each item
           +/|:>,             Format correctly and compute the sums
       x e.                   Does x appear in the list of sums?

h~*h  Tacit main verb. x, y = two input numbers
      Since h tests the condition in only one direction,
      test again the other way around (~) and take the AND.


1

J, 68 바이트

나는 J가 여기에서 잘 수행 할 것이라고 생각했지만, 예상보다 강해졌으며 추가 골프를위한 제안을 좋아할 것입니다 ...

g=.#@#:@[
1 1-:[:(([:+./[=1#.]^"#.1+g#.inv[:i.g^#@])"."0@":)/"1],:|.

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

참고 : 우리 f=.는 주요 기능이 계산되지 않기 때문에 TIO 카운트에서 3 문자를 뺍니다.

언 골프

1 1 -: [: (([: +./ [ = 1 #. ] ^"#. 1 + g #.inv [: i. g ^ #@]) "."0@":)/"1 ] ,: |.
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.