Último dígito número grande

12

Para una lista dada de número encuentra el último dígito de x x x x n 3 2 1 Ejemplo:[x1,x2,x3,...,xn]X1X2X3...Xnorte

[3, 4, 2] == 1
[4, 3, 2] == 4
[4, 3, 1] == 4
[5, 3, 2] == 5   

Porque .3(4 42)=3dieciséis=43046721

Porque .4 4(32)=4 49 9=262144

Porque .4 4(31)=4 43=64

Porque .5 5(32)=5 59 9=1953125

Reglas:

Este es el código de golf, por lo que gana la respuesta con la menor cantidad de bytes.

Si su idioma tiene límites en el tamaño del entero (ej. ) n será lo suficientemente pequeño como para que la suma encaje en el entero.232-1

La entrada puede tener cualquier forma razonable (stdin, archivo, parámetro de línea de comando, entero, cadena, etc.).

La salida puede tener cualquier forma razonable (stdout, archivo, elemento gráfico de usuario que muestre el número, etc.).

Vi en la guerra de códigos.

Scath
fuente
2
Una pregunta que tengo: en tu publicación solo hablas del numbers. ¿Te refieres a enteros positivos exclusivamente? Es decir, siento cómo se interpretó.
Jonathan Frech
1
¿Es razonable tomar la entrada en reversa? ¿La entrada puede ser cero?
NieDzejkob
1
Yo creo que la intención para el límite para estar en suma de términos, y por lo tanto las rutinas que calculan la suma real a continuación, mod debería fallar. Por ejemplo, la entrada [999999,213412499,34532599,4125159,53539,54256439,353259,4314319,5325329,1242149,142219,1243219,14149,1242149,124419,999999999]es válida y el resultado debería ser. 1Si es así, esto debe aclararse en la pregunta, ya que ha votado respuestas que no resuelven esto (pista: mueva el modinterior del bucle). Quizás agregue algunos ejemplos que aclaren esto.
Neil Slater
1
En realidad, el resultado de mi ejemplo es 9. El esquema de reducción de dígitos necesario para implementar esto es mucho más interesante que las respuestas reales que este problema ha generado.
Neil Slater
2
Estimado OP, necesitamos más casos de prueba.
NieDzejkob

Respuestas:

15

JavaScript (ES7), 22 bytes

Limitado a .253-1

a=>eval(a.join`**`)%10

Pruébalo en línea!

Arnauld
fuente
2
¿Qué demonios, por qué funciona esto?
Caleb Jay
@ komali_2: **es el operador de exponenciación de JavaScript. El resto es bastante sencillo.
Shaggy
2
@ komali_2 a.join`**` es equivalente a.join(['**'])y ['**']es forzado '**'por el joinmétodo.
Arnauld
1
Creo que OP pretende que el límite esté en la suma de valores, en cuyo caso esto no resuelve los problemas planteados.
Neil Slater
1
@AJFaraday el% 10 al final. Al dividir cualquier número entre 10, el resto (el módulo) siempre será el último dígito, por n % 10lo que devolverá el último dígito den
Skidsdev
13

R , 25 bytes

Reduce(`^`,scan(),,T)%%10

Pruébalo en línea!

ngm
fuente
No estoy seguro de lo que a la gente le gustó tanto de esta respuesta.
ngm
1
Personalmente me gusta ver que Reducese use.
JayCe
9

HP 49G RPL, 36.5 bytes

Ejecútelo en modo APROXIMADO (pero ingrese el programa en modo EXACTO). Toma información en la pila con el primer elemento más profundo en la pila, como enteros o reales.

WHILE DEPTH 1 - REPEAT ^ END 10 MOD

Expone directamente en la pila como en la solución de Sophia hasta que queda un valor, luego toma el mod 10 para obtener el último dígito.

La razón por la que uso APPROX para el cálculo es porque 0.0 ^ 0.0 = 1 (cuando ambos son reales), pero 0 ^ 0 =? (cuando ambos son enteros). APPROX obliga a todos los enteros a reales, por lo que la entrada está bien con cualquiera de los dos. Sin embargo, uso EXACT para ingresar al programa porque 10 (entero) se almacena dígito por dígito y tiene 6.5 bytes, pero 10.0 (real) se almacena como un número real completo y tiene 10.5 bytes. También evito usar la reducción de RPL (llamada STREAM) porque introduce un objeto de programa adicional, que es 10 bytes de sobrecarga. Ya tengo uno y no quiero otro.

Limitado a la precisión de un HP 49G real (12 dígitos decimales)

-10 bytes después de la lista vacía -> 1 requisito eliminado.

-2 bytes tomando entrada en la pila.

Jason
fuente
1
Oye, ¿podrías explicar cómo se calcula el bytecount? Es curioso cómo ese lenguaje usa mordiscos .
JungHwan Min
1
@JungHwanMin La HP 49G utiliza un procesador de 4 bits y aritmética BCD, ya que es una calculadora. Internamente, la mayoría de los comandos se transforman en punteros de 2.5 bytes a las rutinas que representan, para ahorrar espacio. Los números pequeños (0-9) también se transforman de esta manera.
Jason
1
El procesador Saturn es bastante divertido de trabajar. Hace mucho tiempo, escribí este puerto de BurgerTime (en ensamblaje) para el HP 48G (X). Más tarde fue portado al 49G . ¡Buenos recuerdos!
Arnauld
7

dc , 17 15 bytes

1[^z1<M]dsMxzA%

Pruébalo en línea!

Toma entrada de la pila, salidas a la pila. Implementación muy sencilla: expone hasta que solo quede un valor en la pila y mod para el último dígito.

¡Gracias a brhfl por guardar dos bytes!

Sophia Lechner
fuente
2
Puede jugar al golf un byte cambiando 10%a A%, y un byte más al no verificar la profundidad de la pila dos veces, simplemente coloque un 1tope de la pila antes de ejecutar desde n ^ 1 == n:1[^z1<M]dsMxA%
brhfl
¡Buenas ideas! No tenía idea de que dc me dejaría usar Acomo literal mientras estaba configurado como entrada decimal. Gracias @brhfl!
Sophia Lechner
1
@SophiaLechner Este truco funciona para todas las bases de entrada: codegolf.stackexchange.com/a/77728/11259
Digital Trauma
6

J , 5 bytes

-3 bytes gracias a cole!

10|^/

Pruébalo en línea!

Galen Ivanov
fuente
No 10|^/funciona
cole
@cole Por supuesto que funciona, ¡gracias!
Galen Ivanov
1
¡Finalmente, un desafío donde J vence a Jelly!
Jonás
6

05AB1E , 4 bytes

.«mθ

Pruébalo en línea!

Explicación

.«     # fold
  m    # power
   θ   # take the last digit
Emigna
fuente
1
Hasta donde sé, los lenguajes basados ​​en la pila pueden suponer que la entrada está presente en la pila en lugar de STDIN o alternativas, por lo que algo como esto debería funcionar para 4 bytes (alternativamente, solo colóquelo Een el encabezado).
Sr. Xcoder
Meta relevante .
Sr. Xcoder
1
He solucionado este problema en la última confirmación para uso futuro.
Adnan
@ Mr.Xcoder: ¡Correcto! Deberia haber recordado eso. Por lo tanto, rara vez es necesario hacerlo con entrada implícita. Gracias :)
Emigna
@ Mr.Xcoder Uh, no estoy seguro de si eso es lo que realmente significa el meta. ¿Qué es una "función" en 05AB1E? Creo que debería ser simplemente una cadena, ya que puede asignarla a una variable y puede evaluarse con ella .V. .«mθse parece más a un fragmento, ya que, por sí solo, no puede asignarlo a una variable para su posterior reutilización. Bueno, Adnan ahora solucionó el problema, pero eh.
Erik the Outgolfer
5

Pure Bash (solo incorporado, sin utilidades externas), 21

echo $[${1//,/**}%10]

La entrada se da en la línea de comando como una lista separada por comas.

Los enteros Bash están sujetos a límites enteros con signo normal para las versiones de 64 y 32 bits.

Pruébalo en línea!

Trauma digital
fuente
2
^es XOR bit a bit, por lo que estás 5saliendo del caso de prueba en lugar del correcto 1. Tendrá que agregar un byte para cambiar a**
Sophia Lechner
@SophiaLechner Sí, por supuesto, ¡buena captura! No estoy seguro de cómo se ^introdujo eso : tuve **en iteraciones anteriores de mi ciclo de desarrollo.
Trauma digital
4

Python 2 y Python 3 , 30 bytes

lambda N:eval('**'.join(N))%10

Pruébalo en línea!

Se Nespera que la entrada sea ​​un objeto iterable sobre representaciones de cadenas de literales numéricos .

David Foerster
fuente
4

Ruby, 41 47 bytes

Aumento de tamaño debido al manejo de cualquier 0 en la matriz de entrada, que necesita consideración adicional. Gracias arewritten

->a{a.reverse.inject{|t,n|n<2?n:n**(t%4+4)}%10}

Esto se resuelve porque creo que la fuente original pretendía, es decir, para exponenciaciones muy grandes que no encajan en los enteros nativos del lenguaje; la restricción es que la matriz sumará 2**32-1, no que los cálculos provisionales también estén garantizados. De hecho, ese parece ser el objetivo del desafío en Code Wars. Aunque los enteros nativos de Ruby pueden crecer bastante, no pueden hacer frente al siguiente ejemplo procesado ingenuamente con un% 10 al final

P.ej

Entrada: [999999,213412499,34532597,4125159,53539,54256439,353259,4314319,5325329,1242149,142219,1243219,14149,1242149,124419,999999999]

Salida: 9

Neil Slater
fuente
Impresionante. Por pasar más de 4 bytes, también se puede hacer frente a las torres mucho más altas: sustituir n**(t%4+4)con n**((t-1)%4+1)lo que se obtiene n**1en lugar de n**5etc. felicitaciones por la observación de que en cualquier etapa 4 sería un buen ciclo.
reescrito el
1
Hay un problema si la secuencia tiene 0s
reescrito el
@rewritten: ¡Buen lugar! Tendré que pensar en eso. En teoría, la secuencia debería ser forzada a terminar 2 pasos antes del primer cero.
Neil Slater
De hecho, pero eso requerirá mucho más código, exactamente 6 bytes más: n<2?n:antes n**.
reescrito el
3

C # (.NET Core) , 84 bytes

a=>{int i=a.Length-1,j=a[i];for(;i-->0;)j=(int)System.Math.Pow(a[i],j);return j%10;}

Pruébalo en línea!

  • -7 bytes gracias a @raznagul
digEmAll
fuente
Puede guardar algunos bytes eliminando los brackers ay combinando la condición del bucle con la disminución ( for(var i=a.Lengt-1;i-->0;)). Pero la usingdeclaración debe incluirse en el recuento de bytes.
raznagul
@raznagul: lo siento, soy bastante nuevo en code-golf en C #, ¿está bien ahora?
digEmAll
No hay problema. Sí, esto está bien ahora.
raznagul
1
Puede guardar 3 bytes más utilizando una nueva variable para mantener el resultado y eliminar la mayor parte del acceso al índice de la matriz: ¡ Pruébelo en línea!
raznagul
@raznagul: ¡genial!
digEmAll
3

C (gcc) , 56

  • Guardado 4 bytes gracias a @JonathanFrech

Función recursiva r()llamada desde macro f: se aplican límites de pila normales.

R;r(int*n){R=pow(*n,n[1]?r(n+1):1);}
#define f(n)r(n)%10

Entrada dada como una matriz int terminada en cero. Esto se da por supuesto que ninguna de las x n es cero.

Pruébalo en línea!

Trauma digital
fuente
2
) r(-> )r(.
Jonathan Frech
1
Además, si desea utilizar UB, puede jugar r(int*n){return powal golf R;r(int*n){R=pow.
Jonathan Frech
3

Julia 0.6 , 30 bytes

firstdigitsx->foldl(^,x)

Pruébalo en línea!

Esta es una función anon
∘ es el operador de composición.
Son múltiples bytes

Lyndon White
fuente
3

Japt -h , 7 bytes

OvUqp)ì

Pruébalo en línea!

Explicación:

OvUqp)ì
Ov   )    // Japt eval:
   q      //   Join
  U       //   Input with
    p     //   Power method
      ì   // Split into an array of numbers
-h        // Return the last number
Oliver
fuente
Extraño, eso no funcionaría para mí.
Shaggy
6 bytes
Shaggy
@Shaggy : P
Oliver
¡Ah, por el amor de Jaysis! : \ ¡Eso sucede cada vez más a menudo!
Shaggy
3

Japt -h , 7 6 bytes

Si la entrada se puede tomar en orden inverso, se puede eliminar el primer carácter.

Limitado a 2**53-1.

Ôr!p ì

Intentalo


Explicación

Ô          :Reverse the array
 r         :Reduce by
  !p       :  Raising the current element to the power of the current total, initially the first element
     ì     :Split to an array of digits
           :Implicitly output the last element
Lanudo
fuente
Obtuve exactamente la misma respuesta sin la bandera, por lo que esta parece la forma óptima por ahora.
Nit
@Nit: hasta que se confirme podemos tomar la entrada en reversa :)
Shaggy
@ Oliver Sí, pero todavía estás usando una bandera. Personalmente, creo que el recuento de bytes sin banderas es el resultado de puntuación más preciso.
Nit
@Nit ¿No debería una bandera agregar 3 bytes por meta consenso?
LegionMammal978
@ LegionMammal978, ya no .
Shaggy
2

Excel VBA, 60 bytes

Una función de ventana inmediata anónima VBE que toma la entrada del rango [A1:XFD1]

s=1:For i=-[Count(1:1)]To-1:s=Cells(1,-i)^s:Next:?Right(s,1)
Taylor Scott
fuente
2

CJam , 14 bytes

q~_,({~#]}*~A%

Debería funcionar para cualquier entrada, ya que CJam no está limitado a enteros de 64 bits

Pruébalo en línea!

maxb
fuente
2

Python 3 , 55 bytes

p=lambda l,i=-1:not l or f'{l[0]**int(p(l[1:],0))}'[i:] 

versiones anteriores

p=lambda l,i=-1:len(l)and f'{l[0]**int(p(l[1:],0))}'[i:]or 1    (60 bytes)

PieCot
fuente
¿No debería ser eso p=lambda...? Python no puede manejar lambdas anónimas recursivas, por lo que si necesita que se nombre su función, debe ser parte de su solución, y la asignación de nombres cuenta para su recuento de bytes para desafíos de código de golf.
mypetlion
2

Brain-Flak , 161 bytes

Incluye +1 para -r

([][()]){({}[()]<({}<(({}))>[()]){({}<(({})<({}<>)({<({}[()])><>({})<>}{}<><{}>)>)>[()])}{}{}>)}{}({}((()()()()()){})(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{})

Pruébalo en línea!

El ejemplo [3, 4, 2]lleva más de 60 segundos, por lo que utiliza el enlace TIO [4, 3, 2].

Se -rpuede eliminar si la entrada se puede tomar en orden inverso para un recuento de bytes de 160.

# Push stack size -1
([][()])

# While there are 2 numbers on the stack
{({}[()]<

    # Duplicate the second number on the stack (we're multiplying this number by itself)
    ({}<(({}))>[()])

    # For 0 .. TOS
    {({}<

        # Copy TOS
        (({})<

        # Multiple Top 2 numbers
        ({}<>)({<({}[()])><>({})<>}{}<><{}>)

        # Paste the old TOS
        >)

    # End for (and clean up a little)
    >[()])}{}{}

# End While (and clean up)
>)}{}

# Mod 10
({}((()()()()()){})(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{})
Riley
fuente
2

Z80Golf , 36 bytes

00000000: cd03 80f5 30fa f1f1 57f1 280d 4f41 15af  ....0...W.(.OA..
00000010: 8110 fd47 1520 f818 ef7a d60a 30fc c60a  ...G. ...z..0...
00000020: cd00 8076                                ...v

Pruébalo en línea!

Arnés de prueba de fuerza bruta

Toma la entrada como bytes sin procesar. Limitado a 2 ** 8-1.

Explicación

input:
    call $8003    ;      the input bytes
    push af       ; push                 on the stack
    jr nc, input  ;                                   until EOF
    pop af        ; the last byte is going to be pushed twice
    pop af
outer:
    ld d, a       ; d = exponentiation loop counter, aka the exponent
    pop af        ; pop the new base off the stack
    jr z, output  ; The flags are being pushed and popped together with the
                  ; accumulator. Since the Z flag starts as unset and no
                  ; instruction in the input loop modifies it, the Z flag is
                  ; going to be unset as long as there is input, so the jump
                  ; won't be taken. After input is depleted, a controlled stack
                  ; underflow will occur. Since SP starts at 0, the flags
                  ; register will be set to the $cd byte from the very beginning
                  ; of the program. The bit corresponding to the Z flag happens
                  ; to be set in that byte, so the main loop will stop executing
    ld c, a       ; C = current base
    ld b, c       ; B = partial product of the exponentiation loop
    dec d         ; if the exponent is 2, the loop should only execute once, so
                  ; decrement it to adjust that
pow:
    xor a         ; the multiplication loop sets A to B*C and zeroes B in the
mul:              ; process, since it's used as the loop counter
    add c         ; it's definitely not the fastest multiplication algorithm,
    djnz mul      ; but it is the smallest
    ld b, a       ; save the multiplication result as the partial product
    dec d         ; jump back to make the next iteration of either
    jr nz, pow    ; the exponentiation loop or the main loop, adjusting the
    jr outer      ; loop counter in the process
output:           ; after all input is processed, we jump here. We've prepared
    ld a, d       ; to use the result as the next exponent, so copy it back to A
mod:              ; simple modulo algorithm:
    sub 10        ;            subtract ten
    jr nc, mod    ; repeatedly              until you underflow,
    add 10        ; then undo the last subtraction by adding ten
    call $8000    ; output the result
    halt          ; and exit
NieDzejkob
fuente