당첨자는 10 바이트로 Jelly를 사용한 Dennis ♦입니다!

이 도전은 여전히 ​​여기에 있지만 결과는 더 이상 얻지 않을 것입니다.

숫자의 파워 트레인은 John Conway (Conway의 Game of Life 제작에도 주목할 만하지 만 요점이 아닙니다)의 개념입니다. 다음과 같이 정의됩니다.

모든 숫자에 대해 숫자 의 파워 트레인은 ...입니다 (즉, 왼쪽에서 오른쪽으로 두 번째 숫자마다 그 전의 숫자의 거듭 제곱입니다). 결과가 한 자리가 될 때까지이 프로세스가 반복됩니다.

예 :

2592 => (2^5)(9^2) = 2592 <= Cannot be further decomposed 135 => (1^3)5 = 5 1234 => (1^2)(3^4) = 81 => (8^1) = 8 1100 => (1^1)(0^0) = 1 # (0^0) = 1 -42 => -42 # Negative numbers output the input

n입력의 숫자 에 상관없이 출력으로 출력을 반환해야합니다 powertrain(n)(즉 n, 파워 트레인 분해가 완료된 후).

이것은 코드 골프이므로 가장 짧은 바이트 수가 이깁니다.

면책 조항 :

• 입력에 홀수의 자릿수를 가질 수 있으며 마지막 자릿수에는 전력이 없습니다.
• 0 ^ 0은 1이므로 0이면 많은 숫자가 즉시 0 또는 1로 축소됩니다.
• 계산 프로세스의 어느 부분에서든 숫자를 파괴 할 수없는 경우 (예 :로 끝나는 경우 2592) 숫자 만 출력하면됩니다.
• 입력이 < 10(즉, 모든 한 자리 숫자 및 음수)이면 입력을 출력하십시오.

아마 몇 시간 후에 승자를 발표 할 것입니다 .

현재 리더 보드 :

1. 젤리 ( 데니스 ♦ ) : 10
2. 피스 ( DenkerAffe ) : 16
3. MATL ( 돈 뮤 즐리 ) : 21
4. 펄 ( 톤 호스 ) : 42
5. 하스켈 ( 다미 엔 ) : 64
6. 자바 스크립트 ES6 ( edc65 ) : 71
7. 매스 매 티카 ( 머피 ) : 74
8. Mathematica ( LegionMammal978 ) 및 Haskell ( Renzeee ) : 77
9. 파이썬 2 ( mathmandan ) : 111
10. 파이썬 3 ( Erwan ) : 161
11. 자바 8 ( 블루 ) : 229
12. Oracle SQL 11.2 ( Jeto ) : 456
13. Befunge '93 ( Lex ) : 490

젤리, 15 14 12 10 바이트

Ds2*/€Pµ³¡

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

작동 원리

Ds2*/€Pµ³¡  Main link. Argument: n

D           Convert n into the array of its decimal digits.
 s2         Split into pairs of digits.
   */€      Reduce each pair by exponentiation.
      P     Take the product of the resulting powers.
       µ    Push the preceding chain as a link, and start a new one.
        ³¡  Execute the link n times and return the last result.

하스켈, 67 64 바이트

(>> = (==)) >> = until $ p.show 는 정수를 입력으로 받아 파워 트레인을 반환하는 명명되지 않은 함수입니다.

Zgarb 덕분에 3 바이트 절약

p(x:y:r)=p[x]^p[y]*p r;p[]=1;p x=read x
(>>=(==))>>=until$p.show

펄, 42 48 바이트

에 +2 포함 -lp( -l너무 떨어 뜨릴 수 있지만 줄 바꿈이 마음에 듭니다)

STDIN에서 입력으로 실행

perl -lp powertrain.pl <<< 1234

powertrain.pl:

s/\B/1&pos?"**":"*"/eg until++$.>($_=eval)

(오래된 perls에서는 정규 표현식과 사이에 공백을 넣을 수도 있습니다)

이것은 고정 소수점을 처리 할 수 24547284284866560000000000는 없지만 그 시간이 지나면 perl이 지수 표기법으로 전환 되었기 때문에 큰 값은 작동하지 않습니다.

위의 버전은 실제로 2592perl이 지수 표기법을 사용하지 않고 나타낼 수있는 모든 숫자에 대해 (최대 루프에서) 빠르게 작동합니다 ( 2592와 https 사이에 고정 소수점이 없다는 것이 입증되었으므로 24547284284866560000000000( https://oeis.org/A135385 )

그러나 이것은 아직 입증되지 않은 것으로 가정합니다. 원칙적 으로 값이 아래로 떨어지고 (그러나 위 ) 올라가는 X=10^7단계 보다 더 많은 감소가있을 수 있습니다 (고정되지 않은 점은 16 단계를 넘지 않아야합니다 ( https://oeis.org/A133503 )). 다시. 그럴 경우에는 다음으로 넘어 가야합니다.X10^7

s/\B/1&pos?"**":"*"/eg until$s{$_=eval}++||/-/

설명

코드 는 숫자 사이 에 **및 *(대체) 하여 작동합니다.

s/\B/1&pos?"**":"*"/eg

그래서 2592하게 2**5*9**2및 12345된다 1**2*3**4*5. 이것들은 다음과 같이 평가 할 수있는 유효한 펄 표현식입니다

$_ = eval

( 0**0인 1펄). 그런 다음 카운터를 사용하여 루프를 끝내십시오. 고정 점을 제외하고 값이 매우 빠르게 내려 가기 때문에 파워 트레인 시리즈는 카운터가 실제로 이동하기 전에 수렴합니다.

Pyth, 25 18 11 16 바이트

?<Q0Qu*F^McjGT2Q

여기 사용해보십시오!

@Jakube의 도움으로 7 14 바이트 저장

설명

? <Q0Qu * F ^ McjGT2Q # Q = 평가 (입력)

? <Q0Q # 입력이 음수이면 Q
     u Q # 사이클에 도달 할 때까지 다음 기능을 적용합니다               
                   # 시작 값은 Q이고 현재 값은 G입니다
           jGT # 입력을 숫자 목록으로 분할
          c 2 # 2의 쌍으로 분할
        ^ M # 모든 쌍의 검정력을 계산합니다
      * F # 모든 거듭 제곱의 곱을 계산합니다

파이썬 2, 111 바이트

def p(n,b=0,o=''):
 if n<1:return n
 for c in str(n):o+=c+'**'[b:];b=~b
 j=eval(o+'1');return p(j)if j-n else j

아이디어의 숫자가 문자열을 확인하는 것입니다 n사이의 대체 작업으로 분리 *하고 **, 다음 eval문자열이 있습니다. (다른 솔루션도 같은 아이디어를 사용합니다 (예 : Ton Hospel 's Perl answer ) 참조)

따라서, 동작은 다시 전환 전후 사이 '**'[0:]인 **및 '**'[-1:]막 인 *.

그러나 for-loop 의 끝 에서 문자열은 연산 (하나 또는 다른 것)으로 끝나므로 문자열을 이해하기 위해 마지막 연산을 삭제하거나 다른 숫자를 추가해야합니다.

운 좋게 1끝에 끝에 추가하면 어떤 작업이 마지막에 관계없이 작동합니다. (원하는 경우 1곱셈과 지수에 대한 오른쪽의 일방적 인 정체성입니다. 이것을 말하는 또 다른 방법은 powertrain(n) == powertrain(10*n + 1)모두 를 위한 것 n>0입니다.)

마지막으로, 결과가 eval입력과 동일한 경우 (길이 1주기 에서와 같이 ) 기능이 종료됩니다. 그렇지 않으면 함수가 결과를 호출합니다. (길이가 길면 영원히 멈추지 > 1만 OP의 의견에 따르면 그러한주기가 없다고 가정 할 수 있습니다.)

(참고 : 위의 설명은 한 자릿수 입력 n이 완료되어- 사이클 n**1이 발생 하기 때문에 한 자릿수 양의 정수 에 적용됩니다 1. 그러나 우리는 또한 양수가 아닌 입력도 허용해야합니다. 입력이보다 작 으면 단락을 시작합니다 1. 입력이 음이 아닌 것으로 보장되면 해당 라인을 제거하고 17 바이트를 절약 할 수 있습니다.)

자바 (8), 265 (244) 229 바이트

이것이 나의 첫 번째 대답이지만, 나는이 사이트를 잠시 동안 읽었으며 내가하고있는 일을 알고 있다고 생각합니다. 적어도 그것은 befunge와 SQL을 능가합니다 ...

불행히도 다른 답변과 마찬가지로이 정수는 큰 정수를 얻을 수있는 방법에 대한 내장 제한으로 인해 24547284284866560000000000에서 작동하지 않습니다.

@JackAmmo 덕분에 36 바이트 절약

public int p(int n){if(n<10)return n;int i=1,t=1,s=(int)Math.log10(n)+1,r[]=new int[s];for(;i<=s;){int a=(int)Math.pow(10,i);r[s-i++]=n%a/(a/10);}for(i=0;i<s-1;i++)t*=Math.pow(r[i],r[++i]);if(s%2==1)t*=r[s-1];return n==t?n:p(t);}

풀리지 않은 설명

public int powertrain(int input){
    //handles negative and 1-digit cases
    if(input<10)return input;
    //initialize output variable       
    int total=1;
    // get "length" of number. Shorter than getting length of string representation
    int size=(int)Math.log10(input)+1;
    //initialize array to store digits
    int[] array=new int[size];
    //Now, because Java doesn't have support
    // for the "**" operation, and the way of turning
    // an integer into a string takes too many bytes,
    // I decided just to put every digit into an array with
    // math and iterate from there
    for(int i=1;i<=size;){
        int place=(int)Math.pow(10,i);
        //crazy math. Saved 1 byte by incrementing i when accessed
        array[size-i++]=input%place/(place/10);
    }
    for(int i=0;i<size-1;i++)
        //This is where the train happens.
        //Saved 1 byte by incrementing while accessing 
        //again, instead of i+=2 and i+1
        total*=Math.pow(array[i],array[++i]);
    //Make sure last number isn't left out if size is odd
    if(size%2==1)
        total*=array[size-1];
    //if we end up with same number, stop.
    //otherwise, keep recurring
    return input==total?input:powertrain(total);
}

자바 스크립트 (ES6) 71

반복이 발견되면 중지되는 재귀 함수입니다. 이것은 더 긴 루프 (2 개 이상의 값 반복)에는 작동하지 않지만 적어도 자바 스크립트 숫자 정밀도 (17 자리)의 제한된 범위에서는 발생할 수없는 것 같습니다

f=n=>[...n+'1'].map((c,i)=>i&1?r*=Math.pow(d,c):d=c,r=1)&&n-r?f(r):n

테스트

f=n=>[...n+'1'].map((c,i)=>i&1?r*=Math.pow(d,c):d=c,r=1)&&n-r?f(r):n

function go()
{
  v=+I.value
  R.textContent=f(v)
}  

go()

<input id=I value="1234"><button onclick="go()">Go</button>
<span id=R></span>

수학, 77 바이트

Times@@(If[#2<1,1,#^#2]&)@@@Partition[IntegerDigits@#,2,2,1,1]&~FixedPoint~#&

익명의 기능. 너무 복잡하지 않습니다.

비 펀지 (720) 490 바이트

절대 나에게 가능성을 말하지 말고 한 번 더 저항하지 못했습니다 . 그래서 이전의 "ASCII-fier"를 최적화했습니다. 이 경우 명령 포인터가 숫자를 읽도록 지시하지 않아도되므로 사람이 읽을 수 있도록 노력하지 않았습니다. 자 이제 더 많은 디지타이저입니다.

다시 한 번 설명을 원한다면 의견으로 알려주세요. 유용한 설명을 만들어 보겠습니다. 코드를 복사 하여 인터프리터에 붙여 넣을 수 있습니다 . 예제 24547284284866560000000000이 0을 출력한다는 것을 알았지 만 최종 단계에서 올바른 값이 저장되어 있음을 분명히 알 수 있으므로 그리드의 한 지점에서 큰 값을 얻는 데 문제가있는 것 같습니다.

v                                                    //top row is used for "variables"
>&:0`#v_.@                                           //initialize the counter                          
v     <                           g01_v#-p01:  <     //on our way back to the digitifier, check if we're done
>::>210p>55+%:10g0p-55+/:v            >10g.@         //digitifier, creates a series of ASCII characters at the top line, one for each digit in the source
        ^p01+1g01    _v#:<
v1$$                  <                              //forget some remainders of the digitifier, put 1 on the stack as a base of calculation
                      v p0-1g01-1g0-1g01*g0g01<      //taking powers of each pair of digit
>10g2-!#v_10g1-!#v_  1>                10g1-0g|
^                                  p01-2g01  *<
        >10g0g*  >                             ^     //extra multiplication with last digit if the number of digits was odd

이 버전은 음수 입력도 지원합니다. 내가 직접 말하면 이전 버전에서 크게 개선되었습니다. 최소 1 개의 버그가 수정되었으며 크기가 크게 줄었습니다.

하스켈, 100 79 77 바이트

g x|x==h x=x|1<2=g$h x;h=i.map(read.(:[])).show;i[]=1;i[a]=a;i(a:b:c)=a^b*i c

골프하지 않음 :

g x|x==h x=x|1<2=g$h x
h=i.map(read.(:[])).show
i[]=1
i[a]=a
i(a:b:c)=a^b*i c

이 함수는 입력을 숫자로 나누고를 통해 트릭을 수행 i합니다.

편집 : 몇 가지 팁을 주셔서 감사합니다.

Mathematica, 74 바이트

0~f~0=f[]=1
f@n_=n
f[a_,b_,c___]:=f[c]a^b
#//.i_/;i>0:>f@@IntegerDigits@i&

설명

이 솔루션은 f숫자의 숫자를 인수로 사용하고 파워 트레인 작업의 한 번의 반복을 적용 하는 도우미 함수를 사용 합니다. 마지막 줄은 더 이상 변경되지 않을 때까지 표현식 (이 경우 순수한 함수 의 인수) 에 규칙을 적용하는 ReplaceRepeated함수 (또는 //.짧게) 를 활용하도록 만들어진 #순수한 함수입니다. 이 규칙 i_/;i>0:>f@@IntegerDigits@i은 음수가 아닌 것을 f10 진수에 적용된 함수로 대체합니다 .

MATL , 21 바이트

tt0>*:"V!UtQgv9L2#)^p

출력을 생성하는 데 몇 초가 걸릴 수 있습니다.

편집 (2016 년 7 월 30 일) : 연결된 코드는 다음 9L으로 대체 됩니다.1L 언어의 최근 변화에 적응합니다.

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

코드 효율성을 희생하면서 바이트 수를 줄이기 위해 다음 두 가지 트릭을 사용합니다.

• n주기가 발견 될 때까지 기다리지 않고 시간을 반복하십시오 . 이것은 OP의 의견에 따라 허용됩니다.
• 홀수 자릿수의 1경우 최종 전력 작업을 완료하려면 최종 전력을 추가해야합니다. 그 대신에1 된 숫자는 자릿수입니다. 이렇게하면 짝수가 보장되므로 모든 전원 작업을 수행 할 수 있습니다 (마지막 1^1작업 이 불필요한 작업 인 경우에도 ).

암호:

t         % implicitly take input x. Duplicate
t0>*      % duplicate. Is it greater than 0? Multiply. This gives 0 if input is negative,
          % or leaves the input unchanged otherwise
:         % Generate array [1,2,...,x]
"         % for each (repeat x times)
  V       %   convert x to string
  !       %   transpose into column char array
  U       %   convert each char into number
  tQg     %   duplicate. Add 1 so that no entry is zero. Convert to logical: gives ones
  v       %   concatenate vertically
  9L2#)   %   separate odd-indexed and even-indexed entries
  ^       %   element-wise power
  p       %   product of all entries
          % implicitly end for each
          % implicitly display

Python 3, 169161 바이트

def f(s):
 o=[['1',s]['-'in s]]
 while s not in o:
  o+=[s];s+='1'*(len(s)%2==1);r=1;
  for i,j in zip(s[::2],s[1::2]):r*=int(i)**int(j);s=str(r);
 return o[-1]

금잔화

def f(s):
 o=[['1',s]['-'in s]]
 while s not in o:
  o+=[s]
  s+='1'*(len(s)%2==1)
  r=1
  for i,j in zip(s[::2],s[1::2]):
   r*=int(i)**int(j)
  s=str(r)
 return o[-1]

결과

>>> [f(i) for i in ['135', '1234', '642', '2592', '-15']]
['5', '8', '2592', '2592', '-15']

Oracle SQL 11.2, 456 바이트

WITH v(n,c,i,f,t)AS(SELECT:1+0,CEIL(LENGTH(:1)/2),1,'1',0 FROM DUAL UNION ALL SELECT DECODE(SIGN(c-i+1),-1,t,n),DECODE(SIGN(c-i+1),-1,CEIL(LENGTH(t)/2),c),DECODE(SIGN(c-i+1),-1,1,i+1),DECODE(SIGN(c-i+1),-1,'1',RTRIM(f||'*'||NVL(POWER(SUBSTR(n,i*2-1,1),SUBSTR(n,i*2,1)),SUBSTR(n,i*2-1,1)),'*')),DECODE(SIGN(c-i+1),-1,0,TO_NUMBER(column_value))FROM v,XMLTABLE(f)WHERE i<=c+2 AND:1>9)CYCLE n,c,i,f,t SET s TO 1 DEFAULT 0SELECT NVL(SUM(n),:1) FROM v WHERE s=1;

언 골프

WITH v(n,c,i,f,t) AS
(
  SELECT :1+0,CEIL(LENGTH(:1)/2),1,'1',0 FROM DUAL
  UNION ALL
  SELECT DECODE(SIGN(c-i+1),-1,t,n),
         DECODE(SIGN(c-i+1),-1,CEIL(LENGTH(t)/2),c),
         DECODE(SIGN(c-i+1),-1,1,i+1),
         DECODE(SIGN(c-i+1),-1,'1',RTRIM(f||'*'||NVL(POWER(SUBSTR(n,i*2-1,1),SUBSTR(n,i*2,1)),SUBSTR(n,i*2-1,1)),'*')),
         DECODE(SIGN(c-i+1),-1,0,TO_NUMBER(column_value))
  FROM v,XMLTABLE(f) WHERE i<=c+2 AND :1>9 
)  
CYCLE n,c,i,f,t SET s TO 1 DEFAULT 0
SELECT NVL(SUM(n),:1) FROM v WHERE s=1;

v는 재귀 뷰이며 매개 변수는

n : 2 자리 숫자로 나눌 숫자

c : 2 자리수

i : 계산할 현재 2 자리 부분

f : *를 분리 자로 사용하여 전력을 연결하는 문자열

t : f의 평가

DECODE는 다음 숫자로 전환되어 현재 숫자의 모든 부분이 완료되면 분할하고 계산합니다.

XMLTABLE (f)는 표현식을 평가하여 의사 열 "column_value"에 결과를 넣습니다. http://tkyte.blogspot.fr/2010/04/evaluating-expression-like-calculator.html 의 골프 버전입니다.

CYCLE은주기 감지시 Oracle 빌드이며 종료 조건으로 사용됩니다.

: 1 <10의 결과는 : 1이고 v는 이러한 경우 행을 리턴하지 않으므로 SUM은 NULL을 값으로 사용하여 행을 강제 실행합니다. 행이 null 인 경우 NVL은 결과로 : 1을 반환합니다.