Переможець (досить очевидно) - Денніс ♦, який використав Jelly з 10 байтами!

Ця проблема все ще буде стояти тут, проте результати більше не братимуться.

Силова передача числа - це концепція Джона Конвей (який також відомий тим, що робить «Гра життя» Конвея, але справа не в цьому). Він визначається так:

Для будь-якого числа ... силова передача числа є ... (тобто кожна 2-а цифра, зліва направо, - це сила цифри до цього). Цей процес повторюється, поки в результаті не буде однозначна цифра.

ПРИКЛАДИ:

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. Желе ( Dennis ♦ ): 10
2. Піт ( DenkerAffe ): 16
3. MATL ( Дон Мюслі ): 21
4. Perl ( Тонне Євангеліє ): 42
5. Хаскелл ( Дамієн ): 64
6. Javascript ES6 ( edc65 ): 71
7. Математика ( мурфі ): 74
8. Mathematica ( LegionMammal978 ) та Haskell ( Renzeee ): 77
9. Пітон 2 ( математика ): 111
10. Пітон 3 ( Ерван ): 161
11. Java 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.

Haskell, 67 64 байт

(>> = (==)) >> = до $ p.show не називається функцією, яка приймає ціле число як вхід і повертає свою силову передачу .

Збережено 3 байти завдяки Zgarb

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

Perl, 42 48 байт

Включити +2 для -lp(ви можете також скинути, -lале мені подобаються нові рядки)

Виконати з введенням на STDIN, наприклад

perl -lp powertrain.pl <<< 1234

powertrain.pl:

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

(для старих перлов можна також скинути пробіл між регулярними виразами і до)

Це не зможе впоратися з фіксованою точкою, 24547284284866560000000000але велике значення все одно не буде працювати, оскільки до цього часу perl перейшов до експоненціальної позначення.

Наведена вище версія насправді буде працювати швидко (у більшості 2592циклів) для всіх чисел, які perl може представляти, не використовуючи експоненціальні позначення, оскільки доведено, що між 2592та 24547284284866560000000000( https://oeis.org/A135385 ) немає фіксованих точок.

Однак це передбачає щось ще недоведене. У принципі може бути зменшення, яке займає більше X=10^7кроків (передбачається, що жодна нефіксована точка не робить більше 16 кроків, https://oeis.org/A133503 ), значення якої опускається нижче X(але вище 10^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. Це дійсні вирази perl, за допомогою яких можна оцінити

$_ = eval

( 0**0є 1в перл). Потім просто покладіть петлю навколо цього з лічильником, який змушує його закінчуватися. Оскільки, окрім фіксованих точок, значення надзвичайно швидко знижуються, серія силових агрегатів сходить до того, як лічильник отримає шанс реально дійти

Pyth, 25 18 11 16 байт

?<Q0Qu*F^McjGT2Q

Спробуйте тут!

7 14 байт збережено за допомогою @Jakube

Пояснення

? <Q0Qu * F ^ McjGT2Q # Q = eval (вхід)

? <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цією рядком. (Інші рішення використовують цю ж ідею; див., Наприклад , відповідь Perl Тона Госпеля .)

Отже, операція перемикається вперед і назад між тим '**'[0:], що є **, і '**'[-1:]що є справедливим *.

Однак до кінця for-loop рядок закінчується операцією (однією чи іншою), тому нам або потрібно відкинути останню операцію, або додати ще одну цифру, щоб рядок мав сенс.

На щастя, додавання в 1кінці спрацює незалежно від того, яка операція остання. (Якщо вам подобається, 1це однобічна ідентичність праворуч як для множення, так і для експоненції. Інший спосіб сказати це - це те, що powertrain(n) == powertrain(10*n + 1)для всіх n>0.)

Нарешті, якщо результат, що evalвідбувається, такий же, як і вхідний (як у 1циклі тривалості ), функція припиняється. В іншому випадку функція викликає себе за результатом. (Він буде вічно зависати на будь-якому циклі довжини > 1, але згідно з коментарями ОП, я можу припустити, що таких циклів немає.)

(Примітка: вищевикладене пояснення працює для одноцифрових додатних цілих чисел, оскільки однозначне введення nбуде завершено, в n**1результаті чого буде 1виведено цілий цикл. Однак нам також потрібно прийняти непозитивне введення, тому умова на починаючи з цього короткого замикання, якщо вхід менший 1. Ми могли би усунути цей рядок і зберегти 17 байт, якби вхід гарантовано був негативним.)

Java 8, 265 244 229 байт

Це моя перша відповідь, але я деякий час читав цей сайт і думаю, що знаю, що роблю. Принаймні це б'є befunge і SQL ...

На жаль, як і інші відповіді, ця не працює для 24547284284866560000000000 через java'a, вбудовану в обмеження щодо можливого отримання великих цілих чисел.

Збережено 36 байт завдяки @JackAmmo

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

JavaScript (ES6) 71

Рекурсивна функція, зупинка при виявленні повторення. Це не могло працювати довше циклів (повторення 2 і більше значень), але, здається, цього не могло статися, принаймні в обмеженому діапазоні точності чисельності javascript (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~#&

Анонімна функція. Не надто складна.

Befunge 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 помилка була виправлена, і розмір значно зменшився.

Haskell, 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.

EDIT: Спасибі nimi за кілька порад.

Математика, 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замінює все негативне функцією, fзастосованою до його десяткових цифр.

MATL , 21 байт

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

Для отримання результату може знадобитися кілька секунд.

EDIT (30 липня 2016 р.): Пов'язаний код замінюється 9Lна, 1Lщоб адаптуватись до останніх змін у мові.

Спробуйте в Інтернеті!

Для зменшення кількості байтів за рахунок ефективності коду використовуються наступні два прийоми:

• Ітераційні nрази замість того, щоб чекати, поки цикл не знайдеться. Це прийнятно відповідно до коментарів ОП.
• Для непарної кількості цифр потрібно 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

Пітон 3, 169 161 байт

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: кількість двоцифрових частин

i: поточна двоцифрова частина для обчислення

f: рядок, що об'єднує повноваження з * як роздільник

t: оцінка f

DECODE переключаються на наступне число, щоб розділити та обчислити, коли всі частини поточного числа виконані.

XMLTABLE (f) приймає вираз і оцінює його, вводячи результат у псевдо колонку "column_value". Це версія для гольфу http://tkyte.blogspot.fr/2010/04/evaluating-expression-like-calculator.html

CYCLE - це встановлення циклу оракула в циклі виявлення і використовується як умова виходу.

Оскільки результат для: 1 <10 дорівнює: 1 і v не повертає жодного рядка для цих випадків, SUM примушує рядок з NULL як значення. NVL повертає: 1 як результат, якщо рядок є нульовим.