A tarefa
Este é um desafio simples. Sua entrada é uma única string não vazia, contendo apenas dígitos 0123456789
e hashes #
. Ele conterá exatamente uma sequência de dígitos, que codifica um número inteiro não negativo e pode envolver o final da sequência e pelo menos um #
. O número inteiro pode ter zeros à esquerda. Por exemplo, ##44##
, 013####
e 23###1
são entradas válidas, enquanto ###
, 0099
e #4#4
não são.
Sua tarefa é extrair o número inteiro n
da sequência e gerar as n
etapas rotacionadas para a direita.
Exemplos
- A entrada
#1##
deve ser girada 1 passo para a direita, para que a saída correta seja##1#
. - A entrada
#026###
deve ser girada 26 etapas para a direita, pois o 0 inicial é ignorado. A saída correta é26####0
. - A entrada
1####2
contém o número inteiro 21 envolto no final, portanto deve ser girado 21 etapas para a direita. A saída correta é##21##
.
Regras e pontuação
Você pode escrever um programa completo ou uma função. A menor contagem de bytes vence e as brechas padrão não são permitidas.
Você pode assumir que o número n
se encaixa no int
tipo padrão do seu idioma. Por outro lado, se esse int
tipo padrão implementar números inteiros de precisão arbitrária, você deverá suportar (em teoria) um arbitrariamente grande n
.
Casos de teste
#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
se encaixam noint
tipo nativo do seu idioma (que pode ter precisão arbitrária). Atualizarei o texto do desafio mais tarde.1234
?Respostas:
CJam, 11 bytes
Experimente online! ou verifique todos os casos de teste .
Observe que isso não funcionará nos dois últimos casos de teste, pois os números envolvidos não cabem em 64 bits.
Como funciona
fonte
Julia,
7165 bytesEsta é uma função anônima que aceita uma string e retorna uma string. Para chamá-lo, atribua-o a uma variável.
Anexamos a entrada a ela mesma, dividimos em uma matriz com
#
o separador, analisamos cada número inteiro e obtemos o máximo. Isso define o número de vezes que mudamos a string para a direita. Dividimos a corda em umaChar
matriz, trocamos ejoin
a juntamos novamente.fonte
Python, 66 bytes
fonte
Retina,
655749.Economizou 8 bytes graças a Martin!
Experimente Online!
Observe que isso esgotará o tempo limite / memória para os casos de teste muito grandes on-line e, na maioria das máquinas sãs, para alguns dos maiores.
Isso pega o último número da string e o primeiro ou nenhum número da string e os coloca na frente da string. Em seguida, converte esse número combinado em unário e gira repetidamente enquanto solta um dígito unário.
fonte
Gelatina,
1210 bytesExperimente online! ou verifique todos os casos de teste .
fundo
Digamos que a entrada seja
51379#97
.Repetindo a string duas vezes (
51379#9751379#97
), podemos garantir que ela contenha uma representação contígua do número.Em seguida, aplicamos NOT bit a bit a todos os caracteres. Isso tenta converter para int, para que '1' seja avaliado como 1 e , em seguida, mapeado para ~ 1 = -2 . Na falha (
#
), ele retorna 0 .Para o nosso exemplo, isso dá
Em seguida, dividimos em zeros para separar a parte que codifica o número do restante.
Bitwise NOT mapeia n para -n - 1 , então incrementamos cada um para obter -n .
Em seguida, convertemos cada lista da base 10 em número inteiro.
O número mais baixo é o negativo do que estamos procurando. Como o átomo de rotação da lista Jelly
ṙ
gira para a esquerda , evite multiplicar por -1 para girar para a direita.Como funciona
fonte
MATL ,
28251716 bytes8 bytes a menos de empréstimo da idéia de Dennis de dividir a matriz e reverter a ordem das peças
Os dois últimos casos de teste não funcionam porque o número é muito grande.
EDIT (20 de maio de 2016) O código no link usa, em
Xz
vez deXv
, devido a alterações recentes no idioma.Experimente online!
fonte
PowerShell, 153 bytes
(Mas consulte a seção Crédito extra, abaixo)
O PowerShell não tem o conceito de "mudar" uma matriz, então tive que lançar minha própria solução. Levará muito tempo para números maiores, mas acabará por concluir qualquer coisa que se encaixe em um int de 32 bits.
Recebe entrada
$a
e define uma nova variável$d
como um objeto [System.Collections.ArrayList] . Isso é feito porque, tecnicamente, as matrizes no PowerShell são imutáveis (mais explicadas abaixo em Crédito Extra) e, portanto, não suportam inserções ou remoções arbitrárias, necessárias para a troca. Então, entramos em umfor
loop.A condição inicial é um truque que encontrei - se concatenarmos a entrada juntos, dividirmos
#
e ignorarmos os vazios, o segundo elemento da matriz resultante será igual ao nosso número, independentemente do agrupamento. Definimos isso como$b
e diminuímos$b
cada vez até que seja zero.A cada iteração, definimos helper
$r
como o último elemento da lista de matrizes, removemos esse último elemento e inserimos o elemento na frente ... "deslocando" efetivamente a matriz para a direita por um elemento.Finalmente, simplesmente produzimos com
-join$d
para que seja concatenado em uma sequência.Crédito extra
Se o problema foi deslocar a matriz para a esquerda em vez da direita , podemos reduzi-lo significativamente usando várias atribuições . Basicamente, "Se o valor da atribuição contiver mais elementos que variáveis, todos os valores restantes serão atribuídos à última variável."
Em essência, isso significa algo como
$c=@(1,2,3)
e$a,$b=$c
terá
$a=1
um int e$b=@(2,3)
um array.O PowerShell, 90 bytes, faz um desvio à esquerda em vez de um desvio à direita
Aqui, mais uma vez, recebemos informações e definimos
$b
como acima. Relançamos$a
como uma matriz de caracteres e inserimos o mesmofor
loop acima. Desta vez, porém, não precisamos oferecer suporte à remoção / inserção arbitrária, portanto não precisamos usar o[System.Collections.ArrayList]
objeto caro , nem o método caro chama. Em vez disso, simplesmente configuramos$r
para ser o primeiro elemento de$a
, e os elementos restantes são salvos novamente$a
. Em seguida, vamos+=
colocá-lo de volta até o fim.(Como eu disse, as matrizes do PowerShell são tecnicamente imutáveis, mas o
+=
operador aqui está sobrecarregado - ela pega uma matriz e outro objeto, junta-os (termo técnico) em uma nova matriz, retorna isso e o salva como o nome da variável e destrói Funcionalmente, acabamos de adicionar um elemento ao final da matriz, mas tecnicamente (e de uma perspectiva de limpeza de memória / lixo etc.) é uma matriz totalmente nova. Isso obviamente pode se tornar uma operação cara se a matriz for grande ou complexa. O outro lado é que, como as matrizes são imutáveis, a indexação ou a iteração sobre elas é muito barata.)A saída permanece a mesma ação, com uma
-join
instrução para transformá-la em uma única sequência.fonte
Sério, 21 bytes
Experimente online!
Aviso: esta solução é muito ineficiente; portanto, os casos de teste maiores expirarão no TIO. Use o intérprete local.
Explicação:
fonte
Mathematica, 69 bytes
Encontre seqüências de números em, se houver 2, sua ordem precisará ser revertida. Concatene as strings (se for apenas uma, apenas retornará a string numérica). Converta a string em numérico e gire a string esse número de vezes.
fonte
FromDigits
funciona em vez deToExpression
.Pyth,
2214 bytesExperimente aqui!
Explicação
Isso funciona para todos os casos de teste e também quase termina instantaneamente para grandes números.
fonte
-...\#
vez deh:..."\d+"1
. Além disso, não há necessidade de converterz
em uma lista de caracteres,.>
funciona também em uma string.JavaScript (ES6) 66
Pela primeira vez, o estúpido negativo
%
de javascript para números negativos se torna útilfonte
b+a
é uma concatenação de strings.a='32',b='1', (b?b+a:a)=='132', (b|0+a)==33
Pitão, 10 bytes
Experimente online. Suíte de teste.
Esta é uma tradução de resposta Cennis Dennis . Estou transformando-o em um wiki da comunidade, pois não o criei.
Explicação
fonte
JavaScript (ES6),
6764 bytesOutro porto da resposta CJam de Dennis.
Edit: Salva 3 bytes, apropriando-se da parte da resposta do edc65 que ele não chamou a atenção.
fonte
s+s
truque. (Na verdade, eu pensei sobre isso ontem à noite, mas eu estava muito cansado para testá-lo no momento.)Perl 5, 41 bytes
39 bytes mais dois para os
-lF
sinalizadores (-M5.01
é grátis):perl -lF -M5.01 script.pl
Explicação:
-lF
lê a entrada, remove a nova linha à direita, coloca o restante na sequência$_
, divide-a em caracteres e coloca essa divisão na matriz@F
./#+/
encontra a primeira string de#
s in$_
e define$`
igual ao material anterior e$'
igual ao material posterior. Se$`
estiver vazio,$'
pode conter mais#
s. No entanto,$'.$`
é uma string cuja substring inicial é o número de vezes para girar a matriz.1..$'.$`
, que trata$'.$`
como um número inteiro e, assim, a numera, que retira qualquer#
s final ; portanto, a lista é do1
número de vezes que gira o array.pop
o último elemento eunshift
o início).say
todos os elementos da matriz rotacionada.fonte
Rubi -
687270 bytessplit
converte string em uma matriz(s+s).scan(/\d+/)
concatene a string para si mesma e obtenha uma matriz de números (como strings)map(&:to_i)
converter cadeias de caracteres em intsmax
escolha o maior introtate
max
vezes*""
converter a matriz novamente em uma string (abreviação dejoin
)Uso:
ruby scriptname.rb "[string]"
fonte
05AB1E ,
1413 bytesBem, é improvável que o código termine para números maiores que 100000, mas se você for paciente o suficiente, haverá uma saída :). Código:
Explicação:
Experimente online!
Usa a codificação CP-1252
fonte
VBSCRIPT,
8299 BYTESo código anterior não lidava com casos com número agrupado no final
UNGOLFED
isso meio que é péssimo ... provavelmente existe uma maneira melhor de fazê-lo, mesmo em VBscript
fonte
a
está a entrada da função e ela retorna a saída? Dessa forma, você não precisaria das chamadasinputbox
emsgbox
.b
?Mathematica,
7358 bytesMuito byte. 15 bytes economizados graças ao IPoiler
fonte
StringRotateRight
salva alguns bytes aqui.Matlab (73)
fonte
matlab
(86)72A função gira a string duas vezes, uma vez para extração de número inteiro, a segunda para a tarefa desejada, não leva muito tempo porque o matlab passa a girar
(Dim)modulus(Length)
exceto que cai na falha de segmentação para intervalos maiores.Vai lutar como jogar mais ....
(86)
fonte