¡No debe confundirse con Find the factorial!

Introducción

El factorial de un entero nse puede calcular por

Esto es relativamente fácil y nada nuevo. Sin embargo, los factoriales se pueden extender a factores dobles , de modo que para números pares, y para números impares. Pero no estamos limitados a factoriales dobles. Por ejemplo o or dependiendo de valor inicial

En resumen: donde O, en inglés simple: reste el conteo factorial del número base repetidamente y multiplique todos los enteros positivos resultantes.

El reto

Escriba una función que calcule cualquier tipo de factorial repetido para cualquier número entero no negativo.

Entrada

Ya sea

• Una cadena que contiene un entero de base diez no negativo, seguido de 1 o más signos de exclamación. Por ejemplo, "6!"or "9!!"o "40!!!!!!!!!!!!!!!!!!!!".

o

• Los mismos valores representados por dos enteros: un valor base no negativo y un valor positivo que representa el recuento factorial. Esto se puede hacer de acuerdo con cualquier formato de las reglas de E / S predeterminadas.

Salida

El resultado de dicho cálculo.

Observaciones de desafío

• 0!igual 1por definición. Su código debe dar cuenta de esto.
• El conteo factorial está limitado por fuera de este rango, usted es libre de generar lo que sea. Aparte de , que es la única excepción a esta regla. $$0 < factorial~count \leq base~value$$ 0!

Ejemplos

Input                              Output

3!!!                               3
0!                                 1
6!                                 720
9!!                                945
10!!!!!!!!                         20
40!!!!!!!!!!!!!!!!!!!!             800
420!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!  41697106428257280000000000000000

Pruébelo con una implementación de Python sin golf: ¡ Pruébelo en línea!

Observaciones generales

• Este es el código de golf , por lo que gana la respuesta con la menor cantidad de bytes en cada idioma.
• Se aplican reglas estándar , reglas de E / S y reglas de escapatoria .
• Incluya un enlace Probar en línea para demostrar que su código funciona.
• Motive su respuesta con una explicación de su código.

R , 33 bytes

function(n,k)prod(seq(n+!n,1,-k))

Pruébalo en línea!

Maneja agregando la negación lógica de .$n=0$$n$

ArnoldC , 702 698 634 bytes

LISTEN TO ME VERY CAREFULLY f
I NEED YOUR CLOTHES YOUR BOOTS AND YOUR MOTORCYCLE n
I NEED YOUR CLOTHES YOUR BOOTS AND YOUR MOTORCYCLE p
GIVE THESE PEOPLE AIR
HEY CHRISTMAS TREE r
YOU SET US UP 1
HEY CHRISTMAS TREE c
YOU SET US UP 0
STICK AROUND n
GET TO THE CHOPPER r
HERE IS MY INVITATION r
YOU'RE FIRED n
ENOUGH TALK
GET TO THE CHOPPER n
HERE IS MY INVITATION n
GET DOWN p
ENOUGH TALK
GET TO THE CHOPPER c
HERE IS MY INVITATION 0
LET OFF SOME STEAM BENNET n
ENOUGH TALK
BECAUSE I'M GOING TO SAY PLEASE c
GET TO THE CHOPPER n
HERE IS MY INVITATION 0
ENOUGH TALK
YOU HAVE NO RESPECT FOR LOGIC
CHILL
I'LL BE BACK r
HASTA LA VISTA, BABY

Pruébalo en línea!

Traducido al pseudocódigo:

f(n,p) {
  r=1;
  c=0;
  while (n) {
    r=r*n;
    n=n-p;
    c=n<0;
    if (c) n=0;
  }
  return r;
}

Nota: ArnoldC tiene solo un tipo de datos: entero con signo de 16 bits. Por lo tanto, no puedo probar el 420!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!caso.

Jalea , 4 bytes

RṚmP

Pruébalo en línea!

¿Cómo? Dado y , primero genera el rango (con ), luego con él mantiene todos los elementos de este rango (entonces ), y finalmente los multiplica usando .$n$$k$$n,\cdots, 1$k th n , n - k , n - 2 k , ⋯ , n - ⌊ n / k ⌋ kRṚm$k^{\text{th}}$$n, n-k, n-2k,\cdots,n-\lfloor n/k\rfloor k$P

APL (Dyalog Extended) , ^{SBCS de} 7 bytes

Función de prefijo tácito anónimo. Toma [n,b]como argumento.

×/-\…1¨

Pruébalo en línea!

1¨ uno para cada elemento del argumento; [1,1]

-\ diferencia acumulativa; [n,n-b]

… rango usando el segundo elemento del argumento izquierdo como indicador del paso, por ejemplo, [9,7]continúa con5

×/ producto

Haskell , 21 bytes

n%a=product[n,n-a..1]

Pruébalo en línea!

La combinación de la función de producto incorporada con la enumeración de rango escalonada supera lo que podría codificar de forma recursiva (incluso con un error al guardar un byte).

22 bytes

n%a|n<1=1|m<-n-a=n*m%a

Pruébalo en línea!

Aquí hay una solución que toma la entrada en formato de cadena como 9!!, que creo que es más interesante.

42 bytes

(\[(n,a)]->product[n,n-length a..1]).reads

Pruébalo en línea!

Pyth , 6 bytes

Todos estos son equivalentes de 6 bytes:

*F:Q1E
*F:E1Q
*F%E_S

Pruébalo en línea! ( *F:Q1E)

O, 11 bytes , tomando la entrada como una cadena:

*F:.vQ1/Q\!

Banco de pruebas.

JavaScript (ES6), 21 bytes

Toma entrada como (k)(n).

k=>g=n=>n<1||n*g(n-k)

Pruébalo en línea!

O 24 bytes para admitir BigInts.

JavaScript (ES6), 55 bytes

Toma la entrada como una cadena, utilizando el formato descrito en el desafío.

s=>(a=s.split`!`,k=a.length-1,g=n=>n<1||n*g(n-k))(a[0])

Pruébalo en línea!

Espacio en blanco , 91 bytes

[S S S T    N
Push_1][S N
S _Duplicate_1][S N
S _Duplicate_1][T   N
T   T   _Read_STDIN_as_integer_(base)][T    T   T   _Retrieve_base][S S S N
_Push_0][T  N
T   T   _Read_STDIN_as_integer_(factorial)][N
S S N
_Create_Label_LOOP][S N
S _Duplicate_base][S S S T  N
_Push_1][T  S S T   _Subtract][N
T   T   S N
_If_negative_jump_to_Label_PRINT_RESULT][S N
S _Duplicate_base][S T  S S T   S N
_Copy_0-based_2nd_(result)][T   S S N
_Multiply][S N
T   _Swap_top_two][S S S N
_Push_0][T  T   T   _Retrieve_factorial][T  S S T   _Subtract][N
S N
N
_Jump_to_Label_LOOP][N
S S S N
_Create_Label_PRINT_RESULT][S N
N
_Discard_top][T N
S T _Print_result_as_integer]

Se agregaron letras S(espacio), T(tabulación) y N(nueva línea) solo como resaltado.
[..._some_action]agregado solo como explicación.

Pruébelo en línea (solo con espacios en bruto, pestañas y nuevas líneas).

Explicación en pseudocódigo:

Integer result = 1
Integer base = STDIN as integer
Integer factorial = STDIN as integer
Start LOOP:
  If(base <= 0):
    Call function PRINT_RESULT
  result = result * base
  base = base - factorial
  Go to next iteration of LOOP

function PRINT_RESULT:
  Print result as integer to STDOUT

Python 2 , 29 bytes

f=lambda n,b:n<1or n*f(n-b,b)

Pruébalo en línea!

Perl 6 , 22 bytes

{[*] $^a,*-$^b...^1>*}

Pruébalo en línea!

Codeblock anónimo que devuelve el producto del rango a partir de la primera entrada, disminuyendo en el segundo hasta que esté por debajo 1, excluyendo el último número. Esto funciona para 0, ya que el caso base de una reducción por producto es 1, por lo que la salida es 1.

05AB1E , 10 8 7 bytes

ݦRIιнP

Entrada como dos entradas separadas: la primera entrada es base; segunda entrada siendo factorial.

Pruébelo en línea o verifique todos los casos de prueba .

-2 bytes gracias a @ Mr.Xcoder .
-1 byte gracias a @JonathanAllan .

Explicación:

Ý        # Create a list in the range [0, (implicit) base-input]
 ¦       # And remove the first item to make it the range [1, base]
         # (NOTE: this is for the edge case 0. For the other test cases simply `L` instead
         #  of `ݦ` is enough.)
  R      # Reverse this list so the range is [base, 1]
   Iι    # Uninterleave with the second input as step-size
         #  i.e. base=3, factorial=7: [[3],[2],[1],[],[],[],[]]
         #  i.e. base=10, factorial=8: [[10,2],[9,1],[8],[7],[6],[5],[4],[3]]
         #  i.e. base=420, factorial=30: [[420,390,360,...,90,60,30],[419,389,359,...],...]
     н   # Only leave the first inner list
      P  # And take the product of its values
         # (which is output implicitly as result)

Respuesta original de 10 bytes :

L0KD¤-IÖÏP

Entrada como dos entradas separadas: la primera entrada es base; segunda entrada siendo factorial.

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

L           # Create a list in the range [1, (implicit) base-input]
 0K         # Remove all 0s (edge case for input 0, which will become the list [1,0])
   D        # Duplicate this list
    ¤       # Get the last value (without popping)
            # (could also be `Z` or `¹` for max_without_popping / first input respectively)
     -      # Subtract it from each item in the list
      IÖ    # Check for each if they're divisible by the second factorial-input
        Ï   # In the list we copied, only leave the values at the truthy indices
         P  # And take the product of those
            # (which is output implicitly as result)

Código de máquina x86-64, 12 bytes

El mismo código de máquina hace lo mismo en modo de 32 bits, y para enteros de 16 bits en modo de 16 bits.

Se trata de una función, se puede llamar con argumentos n=RCX, k=ESI. Valor de retorno de 32 bits en EAX.

Se puede llamar desde C con la convención de llamadas del sistema V x86-64 con argumentos falsos para obtener los argumentos reales en los registros correctos. uint32_t factk(int, uint32_t k, int, uint64_t n); No podría simplemente usar Windows x64 porque los mulclobbers de 1 operando son RDX, y no queremos que los prefijos REX accedan a R8 / R9. nno debe tener basura en los 32 bits altos para que JRCXZ funcione, pero aparte de eso, todo es de 32 bits.

Listado NASM (dirección relativa, código de máquina, fuente)

 1                         factk:
 2 00000000 6A01             push 1
 3 00000002 58               pop rax             ; retval = 1
 4 00000003 E306             jrcxz  .n_zero      ; if (n==0) return
 5                         .loop:                ; do {
 6 00000005 F7E1              mul   ecx            ; retval *= n  (clobbering RDX)
 7 00000007 29F1              sub   ecx, esi       ; n -= k
 8 00000009 77FA              ja   .loop         ; }while(sub didn't wrap or give zero)
 9                         .n_zero:
10 0000000B C3               ret

0xc = 12 bytes

O 10 bytes si no necesitábamos manejar el n=0caso especial, dejando de lado el jrcxz.

Para el factorial estándar, usaría en looplugar de sub / ja para guardar 2 bytes, pero por lo demás exactamente el mismo código.

Llamada de prueba que pasa argccomo k, con ncodificación fija.

align 16
global _start
_start:
  mov  esi, [rsp]
;main:
  mov  ecx, 9
  call factk

  mov  esi, eax
  mov  edx, eax
  lea  rdi, [rel print_format]
  xor  eax, eax
extern printf
  call printf
extern exit
  call exit

section .rodata
print_format: db `%#x\t%u\n`

```

APL (Dyalog Unicode) , ^{SBCS de} 11 bytes

Función de infijo tácito anónimo. Toma ncomo argumento correcto y bcomo argumento izquierdo.

×/1⌈⊢,⊢-×∘⍳

Pruébalo en línea!

×∘⍳ se multiplican bpor los Ɩ ntegers 1 a travésn

⊢- restar eso de n

⊢, anteponer n

1⌈ máximo de uno y cada uno de esos

×/ producto

Rubí , 25 bytes

f=->s,r{s<1?1:s*f[s-r,r]}

Pruébalo en línea!

Wolfram Language (Mathematica) , 22 21 bytes

1##&@@Range[#,1,-#2]&

Pruébalo en línea!

-1 gracias a attinat: Times --> 1##&

Explicación: se usa Rangepara hacer una lista de los valores {n, n-k, n-2k, n-3k, ...}, deteniéndose antes de ir por debajo de 1 (es decir, deteniéndose justo). Luego, multiplique todos los números en esta lista con Times(o 1##&).

Java 10, 44 bytes

f->b->{int r=1;for(;b>0;b-=f)r*=b;return r;}

Toma el factorial como primera entrada, la base como segunda.

Pruébalo en línea.

Esto anterior no funciona para el caso de prueba más grande debido al rango entero limitado (32 bits). Para solucionar esto podemos usar BigIntegers, que casualmente es exactamente el doble del tamaño - 88 79 bytes :

f->b->{var r=f.ONE;for(;b.signum()>0;b=b.subtract(f))r=r.multiply(b);return r;}

-9 bytes gracias a @ OlivierGrégoire .

Pruébalo en línea.

Explicación:

f->b->{       // Method with two integer parameters and integer return-type
  int r=1;    //  Result-integer, starting at 1
  for(;b>0;   //  Loop as long as the base is still larger than 0
      b-=f)   //    After every iteration: decrease the base by the factorial
    r*=b;     //   Multiply the result by the base
  return r;}  //  Return the result

Japt , 8 bytes

TõUV f ×

Intentalo

-1 gracias a EoI que señala cuán tonto y descafeinado puede ser Shaggy.

C (gcc) , 41 bytes

r;f(n,k){for(r=1;n>0;n-=k)r*=n;return r;}

Pruébalo en línea!

MathGolf , 7 6 bytes

╙╒x%ε*

Pruébalo en línea!

¡Encontré una manera inteligente de manejar 0! sin cambiar los otros casos de prueba. Toma la entrada como k n(orden inverso), lo que ayuda con el estallido implícito.

Explicación

╙        maximum of two elements (pops largest of k and n,
         which is n for every valid case except 0!, where 1 is pushed)
 ╒       range(1,n+1)
  x      reverse int/array/string
   %     slice every k:th element
    ε*   reduce list with multiplication

Agregado , 21 19 bytes

${x<y∨x*$[x-y,y]}

Pruébalo en línea! Implementación recursiva bastante directa. (Nota: truees esencialmente 1, ya que se puede usar en operaciones aritméticas como 1.) Este es uno de los pocos programas que he escrito para este sitio donde usar un operador unicode ahorra bytes (1, para ser precisos).

Alternativas

20 bytes: ${x<y or x*$[x-y,y]}

21 bytes: Prod@${{_%y=x%y}\1:x}

27 bytes: ${x*[`1,$][x>y][x-y,y]∨1}

27 bytes: ${If[x>y,x*$[x-y,y],_or 1]}

27 bytes: ${x*[`1,$][x>y][x-y,y]or 1}

29 bytes: ${If[x>y,x*$[x-y,y],_+not _]}

Óxido , 92 73 61 bytes

fn f(n:i128,k:i128)->i128{if n<=0{return 1}return n*f(n-k,k)}

Estoy empezando a aprender el óxido, así que estoy seguro de que esto puede ser más corto. Se actualizará a medida que aprendo. El valor de retorno debe ser i128para calcular la última prueba.

Editar: La recursión es más corta.

Pruébalo en línea!

Puede agregar su propia prueba o editar una de las ya existentes.

q , 59 57 55 53 bytes

{prd 2+(&)1_i=last i:("J"$x(&)not[n])#(!)sum n:"!"=x}

explicación:

q)x:"12!!" / let our input be 12!!, assign to x
q)sum n:"!"=x / count "!"s
2i
q)(!)sum n:"!"=x / (!)m -> [0,m)
0 1
q)("J"$x(&)not[n]) / isolate the number in input
12
q)("J"$x(&)not[n])#(!)sum n:"!"=x / x#y means take x items from list y, if x>y, circle around
0 1 0 1 0 1 0 1 0 1 0 1
q)i:("J"$x(&)not[n])#(!)sum n:"!"=x / assign to i
q)i
0 1 0 1 0 1 0 1 0 1 0 1
q)(last i)=i:("J"$x(&)not[n])#(!)sum n:"!"=x / take last elem of i and see which are equal in i
010101010101b
q)1_(last i)=i:("J"$x(&)not[n])#(!)sum n:"!"=x / drop first elem
10101010101b
q)(&)1_(last i)=i:("J"$x(&)not[n])#(!)sum n:"!"=x / indices of 1b (boolean TRUE)
0 2 4 6 8 10
q)2+(&)1_(last i)=i:("J"$x(&)not[n])#(!)sum n:"!"=x / add 2 across array
2 4 6 8 10 12
q)prd 2+(&)1_(last i)=i:("J"$x(&)not[n])#(!)sum n:"!"=x / product across array
46080

aquí también hay una versión en k (misma lógica), 42 41 bytes

{*/2+&1_i=last i:("J"$x@&~:n)#!+/n:"!"=x}

Physica , 22 bytes

f=>n;k:n<1||n*f[n-k;k]

Pruébalo en línea!

26 bytes

Volver a aprender a usar mi propio "idioma" \ o / ... Si supiera cómo escribir un analizador hace 2 años, esto habría sido de 20 bytes :(

->n;k:GenMul##[n…1]{%%k}

o

->n;k:GenMul##Range[n;1;k]

Pruébalo en línea!

Retina , 66 bytes

^0
1
\d+
*!,
+`(!+)(!+),\1$
$1$2,$2,$1
!+$
1
+`(!+),(\d+)
$.($2*$1

Pruébalo en línea! El enlace incluye casos de prueba más rápidos. Mauls números sin signos de exclamación. Explicación:

^0
1

Arreglar 0!.

\d+
*!,

Convierte na unario y agrega un separador.

+`(!+)(!+),\1$
$1$2,$2,$1

Restar repetidamente kde nwhile n>ky recopilar los resultados.

!+$
1

Reemplazar kcon 1(en decimal).

+`(!+),(\d+)
$.($2*$1

Multiplica por cada valor intermedio a su vez, convirtiendo a decimal.

Japt , 8 bytes

1õUV f ×

Intentalo

JavaScript (Node.js) , 35 bytes

(n,i,f=i)=>i-n<1?f:r(n,i-n,f*(i-n))

Pruébalo en línea!

Adelante (gforth) , 50 bytes

: f 1 1 2over / 1+ 0 do 2over i * - 1 max * loop ;

Pruébalo en línea!

Explicación del código

: f                \ start a new word definition
  1 1              \ add placeholder and accumulator to stack
  2over / 1+       \ get the number of times to run the loop (num/factorial + 1)
  0 do             \ start loop from 0 to num/factorial
    2over          \ copy num and factorial to the top of the stack
    i * -          \ get the current number to multiply by (num - factorial * i)
    1 max          \ make sure it can't be 0 or negative [set to 1 if it is]
    *              \ multiply accumulator by result
  loop             \ end loop
;                  \ end the word definition           

Perl 5 -Mbigint -p , 45 bytes

$b=s/!//g;$\=1*$_||1;$\*=$_ while($_-=$b)>0}{

Pruébalo en línea!

Stax , 6 bytes

å▐█ΩV∟

Ejecutar y depurarlo

Toma entrada en el formulario {count} {base}.

Gaia , 6 bytes

…)¦v%Π

Pruébalo en línea!

Toma la entrada como n, kpor lo que la entrada de 3 4sería 3!!!!.

…	 push [0...n-1], or [] if n == 0
 )¦	 increment each value (does nothing if [])
   v	 reverse list
    %	 take every k'th element
     Π	 product; product([]) = 1.