Победителем (довольно очевидно) является Деннис ♦, который использовал желе с 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. Желе ( Денис ♦ ): 10
2. Pyth ( DenkerAffe ): 16
3. МАТЛ ( Дон Мюсли ): 21
4. Perl ( Тон Хоспел ): 42
5. Хаскель ( Дэмиен ): 64
6. Javascript ES6 ( edc65 ): 71
7. Mathematica ( Murphy ): 74
8. Mathematica ( LegionMammal978 ) и Haskell ( Renzeee ): 77
9. Python 2 ( математика ): 111
10. Питон 3 ( Эрван ): 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.

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)

(на старых версиях perl вы можете оставить пробел между регулярным выражением и до)

Это не сможет обработать фиксированную точку, 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в Perl). Тогда просто поместите цикл вокруг этого со счетчиком, который заставляет его истечь. Поскольку, за исключением фиксированных точек, значения очень быстро снижаются, ряд силовых агрегатов сходится до того, как счетчик получит шанс по-настоящему заработать.

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 # вычислить произведение всех сил

Python 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 от Ton Hospel .)

Таким образом, операция переключается между '**'[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);}

Ungolfed Объяснение

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>

Mathematica, 77 байт

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

Анонимная функция. Не слишком сложно.

Befunge 720 490 байт

Не могу удержаться, чтобы сделать еще один после Никогда не говори мне, что шансы . Итак, я оптимизировал «ASCII-уровень» предыдущего. В этом случае я не видел необходимости, чтобы указатель инструкций проходил над цифрами, чтобы прочитать их, поэтому я не предпринял усилий, чтобы сделать их читаемыми человеком. Так что теперь это скорее дигитайзер.

Опять же, если вы, ребята, хотите объяснения, дайте мне знать в комментариях, я постараюсь создать несколько полезных описаний. Вы можете скопировать вставить код в интерпретатор . Я обнаружил, что в примере 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.

РЕДАКТИРОВАТЬ: Спасибо Ними за некоторые советы.

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заменяет все неотрицательные на функцию, fприменяемую к десятичным цифрам.

MATL , 21 байт

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

Может потребоваться несколько секунд, чтобы произвести вывод.

РЕДАКТИРОВАТЬ (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

Python 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]

Ungoldfed

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;

Un-golfed

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: число, которое нужно разделить на две части

c: количество двухзначных частей

i: текущая 2-х значная часть для вычисления

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 как результат, если строка пуста.