La tarea
Este es un desafío simple. Su entrada es una sola cadena no vacía, que contiene solo dígitos 0123456789
y hashes #
. Contendrá exactamente una serie de dígitos, que codifica un entero no negativo y puede ajustarse alrededor del final de la cadena, y al menos uno #
. El entero puede tener ceros a la izquierda. Por ejemplo, ##44##
, 013####
y 23###1
son entradas válidas, mientras que ###
, 0099
y #4#4
no lo son.
Su tarea es extraer el número entero n
de la cadena y generar los n
pasos rotados de la cadena a la derecha.
Ejemplos
- La entrada
#1##
debe girarse 1 paso hacia la derecha, por lo que la salida correcta es##1#
. - La entrada
#026###
debe girarse 26 pasos hacia la derecha, ya que se ignora el 0 inicial. La salida correcta es26####0
. - La entrada
1####2
contiene el número entero 21 envuelto sobre el extremo, por lo que debe rotarse 21 pasos hacia la derecha. La salida correcta es##21##
.
Reglas y puntaje
Puede escribir un programa completo o una función. El conteo de bytes más bajo gana, y las lagunas estándar no se permiten.
Puede suponer que el número se n
ajusta al int
tipo estándar de su idioma. Por el contrario, si ese int
tipo estándar implementa enteros de precisión arbitraria, debe admitir (en teoría) un arbitrariamente grande n
.
Casos de prueba
#1## -> ##1#
##4## -> #4###
1####1 -> ####11
1####2 -> ##21##
#026### -> 26####0
#000### -> #000###
###82399 -> ##82399#
51379#97 -> #9751379
#98##### -> ###98###
#######4## -> #4########
60752#1183 -> 8360752#11
####99366800## -> 366800######99
########9##### -> ###9##########
91#####515694837 -> 1#####5156948379
###6114558###### -> #6114558########
######219088736090042#### -> 9088736090042##########21
#46055080150577874656291186550000138168########### -> 0138168############4605508015057787465629118655000
568375993099127531613012513406622393034741346840434468680494753262730615610086255892915828812820699971764142551702608639695081452206500085233149468399533981039485419872101852######################3680 -> 99533981039485419872101852######################36805683759930991275316130125134066223930347413468404344686804947532627306156100862558929158288128206999717641425517026086396950814522065000852331494683
n
ajusta alint
tipo nativo de su idioma (que puede ser de precisión arbitraria). Actualizaré el texto del desafío más tarde.1234
?Respuestas:
CJam, 11 bytes
Pruébalo en línea! o verificar todos los casos de prueba .
Tenga en cuenta que esto no funcionará en los últimos dos casos de prueba, ya que los números involucrados no caben en 64 bits.
Cómo funciona
fuente
Julia,
7165 bytesEsta es una función anónima que acepta una cadena y devuelve una cadena. Para llamarlo, asígnelo a una variable.
Agregamos la entrada a sí mismo, la dividimos en una matriz con
#
el separador, analizamos cada número entero y tomamos el máximo. Esto define el número de veces que desplazamos la cadena a la derecha. Dividimos la cadena en unaChar
matriz, la desplazamos yjoin
la juntamos nuevamente.fuente
Python, 66 bytes
fuente
Retina,
sesenta y cinco5749¡Guardado 8 bytes gracias a Martin!
Pruébalo en línea!
Tenga en cuenta que esto agota el tiempo / se agota la memoria para los casos de prueba muy grandes en línea, y en la mayoría de las máquinas sanas, para algunos de los más grandes.
Esto toma el último número en la cadena y el primer o ningún número en la cadena y los coloca delante de la cadena. Luego convierte ese número combinado en unario y gira repetidamente mientras suelta un dígito unario.
fuente
Jalea,
1210 bytesPruébalo en línea! o verificar todos los casos de prueba .
Fondo
Digamos que la entrada es
51379#97
.Al repetir la cadena dos veces (
51379#9751379#97
), podemos asegurarnos de que contendrá una representación contigua del número.A continuación, aplicamos NO a nivel de bits a todos los caracteres. Esto intenta convertir a int, por lo que '1' se evalúa a 1 , luego se asigna a ~ 1 = -2 . En caso de fallo (
#
), devuelve 0 .Para nuestro ejemplo, esto da
Luego, nos dividimos en ceros para separar la parte que codifica el número del resto.
Bitwise NO asigna n a -n - 1 , por lo que incrementamos cada uno para obtener -n .
A continuación, convertimos cada lista de base 10 a entero.
El número más bajo es el negativo del que estamos buscando. Dado que el átomo de rotación de la lista Jelly
ṙ
gira hacia la izquierda , esto evita multiplicarse por -1 para girar hacia la derecha.Cómo funciona
fuente
MATL ,
28251716 bytes8 bytes menos tomando prestada la idea de Dennis de dividir la matriz e invertir el orden de las piezas
Los dos últimos casos de prueba no funcionan porque el número es demasiado grande.
EDITAR (20 de mayo de 2016) El código en el enlace se usa en
Xz
lugar deXv
, debido a cambios recientes en el idioma.Pruébalo en línea!
fuente
PowerShell, 153 bytes
(Pero consulte la sección Crédito adicional, a continuación)
PowerShell no tiene el concepto de "cambiar" una matriz, por lo que tuve que lanzar mi propia solución. Tomará mucho tiempo para números más grandes, pero eventualmente debería completar todo lo que cabe en un int de 32 bits.
Toma entrada
$a
y establece una nueva variable$d
como un objeto [System.Collections.ArrayList] . Esto se hace porque, técnicamente, las matrices en PowerShell son inmutables (se explica más adelante en Crédito adicional) y, por lo tanto, no admiten inserciones o eliminaciones arbitrarias, lo cual es necesario para el cambio. Luego, entramos en unfor
bucle.La condición inicial es un truco que encontré: si concatenamos la entrada, la dividimos
#
e ignoramos los vacíos, el segundo elemento de la matriz resultante será igual a nuestro número, independientemente de la envoltura. Lo configuramos$b
y disminuimos$b
cada vez hasta que sea cero.En cada iteración, establecemos helper
$r
como el último elemento en la lista de matrices, eliminamos ese último elemento y luego insertamos el elemento en el frente ... efectivamente "desplazando" la matriz a la derecha por un elemento.Finalmente, simplemente imprimimos con
-join$d
para que se concatene en una cadena.Crédito adicional
Si el problema era desplazar la matriz hacia la izquierda en lugar de hacia la derecha , podemos hacerlo significativamente más corto usando la asignación múltiple . Básicamente, "Si el valor de asignación contiene más elementos que variables, todos los valores restantes se asignan a la última variable".
En esencia, esto significa algo así
$c=@(1,2,3)
y$a,$b=$c
tendrá
$a=1
un int y$b=@(2,3)
una matriz.PowerShell, 90 bytes, realiza un desplazamiento a la izquierda en lugar de un desplazamiento a la derecha
Aquí tomamos una vez más la entrada y la configuramos
$b
como se indica arriba. Relanzamos$a
como un conjunto de caracteres y luego ingresamos al mismofor
bucle que el anterior. Esta vez, sin embargo, no hemos necesitado admitir la eliminación / inserción arbitraria, por lo que no necesitamos usar el[System.Collections.ArrayList]
objeto costoso ni las llamadas a métodos costosos. En cambio, simplemente establecemos$r
ser el primer elemento de$a
, y los elementos restantes se vuelven a guardar$a
. Luego debemos+=
volver a clavarlo hasta el final.(Como dije, las matrices de PowerShell son técnicamente inmutables, pero el
+=
operador aquí está sobrecargado: toma una matriz y otro objeto, los agrupa (término técnico) en una nueva matriz, lo devuelve y lo guarda como el nombre de la variable, y destruye la matriz original. Funcionalmente, acabamos de agregar un elemento al final de la matriz, pero técnicamente (y desde una perspectiva de memoria / limpieza de basura, etc.) es una matriz nueva. Esto obviamente puede convertirse en una operación costosa si la matriz es grande o compleja. La otra cara es que, dado que las matrices son inmutables, indexarlas o iterar sobre ellas es muy barato).La salida sigue siendo la misma acción, con una
-join
declaración para convertirla en una sola cadena.fuente
En serio, 21 bytes
Pruébalo en línea!
Advertencia: esta solución es muy ineficiente, por lo que los casos de prueba más grandes se agotarán en TIO. Utiliza el intérprete local.
Explicación:
fuente
Mathematica, 69 Bytes
Encuentre secuencias de números en el, si hay 2, entonces su orden debe invertirse. Concatene las cadenas (si es solo una, solo devuelve la cadena del número). Convierta la cadena en numérica y gire la cadena esa cantidad de veces.
fuente
FromDigits
funciona en lugar deToExpression
.Pyth,
2214 bytesPruébalo aquí!
Explicación
Esto funciona para todos los casos de prueba y también casi termina instantáneamente para los números muy grandes.
fuente
-...\#
lugar deh:..."\d+"1
. Además, no es necesario convertirloz
en una lista de caracteres,.>
también funciona en una cadena.JavaScript (ES6) 66
Por una vez, el estúpido negativo
%
de javascript para números negativos es útilfuente
b+a
es una concatenación de cadenas.a='32',b='1', (b?b+a:a)=='132', (b|0+a)==33
Pyth, 10 bytes
Pruébalo en línea. Banco de pruebas.
Esta es una traducción de la respuesta de Dennis 'CJam . Lo estoy convirtiendo en una wiki comunitaria, ya que no se me ocurrió.
Explicación
fuente
JavaScript (ES6),
6764 bytesOtro puerto de la respuesta CJam de Dennis.
Editar: ahorró 3 bytes al apropiarse de la parte de la respuesta de edc65 a la que no llamó la atención.
fuente
s+s
truco en su lugar. (De hecho, pensé en eso anoche, pero estaba demasiado cansado para probarlo en ese momento.)Perl 5, 41 bytes
39 bytes más dos para las
-lF
banderas (-M5.01
es gratis):perl -lF -M5.01 script.pl
Explicación:
-lF
lee la entrada, elimina la nueva línea final, coloca el resto en la cadena$_
, lo divide en caracteres y lo divide en la matriz@F
./#+/
encuentra la primera cadena de#
s en$_
y establece$`
igual a las cosas antes e$'
igual a las cosas después de ella. Si$`
está vacío,$'
puede contener más#
s. Sin embargo,$'.$`
es una cadena cuya subcadena inicial es la cantidad de veces que gira la matriz.1..$'.$`
, que trata$'.$`
como un número entero y, por lo tanto, la numera, lo que elimina cualquier#
s final , por lo que la lista es desde1
el número de veces que gira la matriz.pop
el último elemento yunshift
el principio).say
todos los elementos de la matriz girada.fuente
Ruby -
687270 bytessplit
convierte la cadena en una matriz(s+s).scan(/\d+/)
concatenar cadena a sí mismo y obtener una matriz de números (como cadenas)map(&:to_i)
convertir cadenas a intsmax
elige el int más granderotate
max
veces*""
convertir la matriz de nuevo en una cadena (abreviatura dejoin
)Uso:
ruby scriptname.rb "[string]"
fuente
05AB1E ,
1413 bytesBueno, es muy poco probable que el código termine para los números mayores de 100000, pero si eres lo suficientemente paciente, habrá una salida :). Código:
Explicación:
Pruébalo en línea!
Utiliza codificación CP-1252
fuente
VBSCRIPT,
8299 BYTESel código anterior no manejaba casos con número envuelto al final
SIN GOLF
esto apesta ... probablemente hay una mejor manera de hacerlo, incluso en VBscript
fuente
a
está la entrada de la función y devuelve la salida? De esa manera, no necesitarías las llamadasinputbox
ymsgbox
.b
?Mathematica,
7358 bytesMucho byte. 15 bytes guardados gracias a IPoiler
fuente
StringRotateRight
guarda algunos bytes aquí.Matlab (73)
fuente
matlab
(86)72La función gira la cadena dos veces, una vez para la extracción de enteros, la segunda para la tarea deseada, no toma demasiado tiempo porque Matlab continúa girando
(Dim)modulus(Length)
a excepción de que cae en la falla de segmentación para rangos más grandes.Te costará cómo jugar más al golf ...
(86)
fuente