La tâche

Ceci est un défi simple. Votre entrée est une seule chaîne non vide, contenant uniquement des chiffres 0123456789et des hachages #. Il contiendra exactement une série de chiffres, qui code un entier non négatif et peut entourer la fin de la chaîne, et au moins un #. L'entier peut avoir des zéros non significatifs. Par exemple, ##44##, 013####et 23###1sont entrées valides, alors que ###, 0099et #4#4ne sont pas.

Votre tâche consiste à extraire l'entier nde la chaîne et à afficher la chaîne en rotation nvers la droite.

Exemples

• L'entrée #1##doit être tournée d'un pas vers la droite, de sorte que la sortie correcte soit ##1#.
• L'entrée #026###doit être tournée de 26 pas vers la droite, car le 0 de tête est ignoré. La sortie correcte est 26####0.
• L'entrée 1####2contient l'entier 21 enroulé sur l'extrémité, il doit donc être tourné de 21 pas vers la droite. La sortie correcte est ##21##.

Règles et notation

Vous pouvez écrire un programme complet ou une fonction. Le nombre d'octets le plus bas l'emporte et les failles standard sont interdites.

Vous pouvez supposer que le numéro ncorrespond au inttype standard de votre langue. Inversement, si ce inttype standard implémente des entiers de précision arbitraire, vous devez prendre en charge (en théorie) un nombre arbitrairement grand n.

Cas de test

#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

CJam, 11 octets

q_'#%W%sim>

Essayez-le en ligne! ou vérifiez tous les cas de test .

Notez que cela ne fonctionnera pas pour les deux derniers cas de test, car les nombres impliqués ne tiennent pas sur 64 bits.

Comment ça marche

q_          e# Read all input and push it twice.
  '#%       e# Split at runs of '#'.
     W%     e# Reverse the resulting array.
       si   e# Cast to string, then to int.
         m> e# Rotate the original input that many places to the right.

Julia, 71 65 octets

s->join(circshift([s...],maximum(parse,split(s*s,"#",keep=1<0))))

Il s'agit d'une fonction anonyme qui accepte une chaîne et renvoie une chaîne. Pour l'appeler, affectez-le à une variable.

Nous ajoutons l'entrée à elle-même, la divisons en un tableau avec #comme séparateur, analysons chaque entier et prenons le maximum. Cela définit le nombre de fois que nous déplaçons la chaîne vers la droite. Nous répartissons la chaîne dans un Chartableau, la décalons et la joinremettons ensemble.

Python, 66 octets

lambda l:(2*l)[-int(''.join(l.split('#')[::-1]))%len(l):][:len(l)]

Rétine, 65 57 49

(\ d *) # * (\ d +)
2 $ 1 $ 0 $
^ \ d +
$ *
+ `1 (. *) (.)
 2 $ 1 $
<espace>

8 octets enregistrés grâce à Martin!

Essayez-le en ligne!

Notez que cela va expirer / manquer de mémoire pour les très grands cas de test en ligne, et sur la plupart des machines saines, pour certains des plus grands.

Cela prend le dernier numéro de la chaîne et le premier ou aucun numéro de la chaîne et les place devant la chaîne. Il convertit ensuite ce nombre combiné en unaire et pivote à plusieurs reprises tout en supprimant un chiffre unaire.

Gelée, 12 10 octets

ẋ2~ṣ0‘ḌṂṙ@

Essayez-le en ligne! ou vérifiez tous les cas de test .

Contexte

Disons que l'entrée est 51379#97.

En répétant la chaîne deux fois ( 51379#9751379#97), nous pouvons nous assurer qu'elle contiendra une représentation contiguë du nombre.

Ensuite, nous appliquons PAS au niveau du bit à tous les caractères. Cela tente de convertir en int, de sorte que «1» est évalué à 1 , puis mappé à ~ 1 = -2 . En cas d'échec ( #), il renvoie 0 .

Pour notre exemple, cela donne

[-6, -2, -4, -8, -10, 0, -10, -8, -6, -2, -4, -8, -10, 0, -10, -8]

Ensuite, nous nous séparons à zéro pour séparer la partie qui code le nombre du reste.

[[-6, -2, -4, -8, -10], [-10, -8, -6, -2, -4, -8, -10], [-10, -8]]

PAS au niveau du bit mappe n à -n - 1 , nous incrémentons donc chacun pour obtenir -n .

[[-5, -1, -3, -7, -9], [-9, -7, -5, -1, -3, -7, -9], [-9, -7]]

Ensuite, nous convertissons chaque liste de la base 10 en entier.

[-51379, -9751379, -97]

Le nombre le plus bas est le négatif de celui que nous recherchons. Étant donné que l'atome de ṙrotation de la liste Jelly tourne vers la gauche , cela évite de multiplier par -1 pour tourner vers la droite.

Comment ça marche

ẋ2~ṣ0‘ḌṂṙ@  Main link. Input: S (string)

ẋ2          Repeat the string twice.
  ~         Apply bitwise NOT to all characters.
            This maps 'n' to ~n = -(n+1) and '# to 0.
   ṣ0       Split at occurrences of zeroes.
     ‘      Increment all single-digit numbers.
      Ḍ     Convert each list from base 10 to integer.
       Ṃ    Take the minimum.
        ṙ@  Rotate S that many places to the left.

MATL , 28 25 17 16 octets

!G1Y4XXPZcXvUYS!

8 octets de moins en empruntant l'idée de Dennis de diviser le tableau et inverser l'ordre des pièces

Les deux derniers cas de test ne fonctionnent pas car le nombre est trop grand.

EDIT (20 mai 2016) Le code dans le lien utilise à la Xzplace de Xv, en raison de récents changements dans la langue.

Essayez-le en ligne!

!         % take implicit input: string. Transpose into column char array
G         % push input string again
1Y4       % predefined literal '\d' (for regexp)
XX        % match regexp. Gives cell array with 1 or 2 strings
P         % flip that array
ZcXv      % join the strings in that array, without spaces
U         % convert to number
YS        % rotate the transposed input that many times
!         % put back into row form (string). Implicitly display

PowerShell, 153 octets

_{(Mais voir la section Extra Credit, ci-dessous)}

param($a)$d=[System.collections.arraylist][char[]]$a;for($b=+("$a$a"-split"#"-ne'')[1];$b;$b--){$r=$d[-1];$d.removeAt($d.Count-1);$d.insert(0,$r)}-join$d

PowerShell n'a pas le concept de «décalage» d'un tableau, j'ai donc dû rouler ma propre solution. Cela prendra beaucoup de temps pour des nombres plus importants, mais cela devrait finir par compléter tout ce qui tient dans un int 32 bits.

Prend l'entrée $aet définit une nouvelle variable en $dtant qu'objet [System.Collections.ArrayList] . Cela est dû au fait que, techniquement, les tableaux dans PowerShell sont immuables _{(expliqués plus loin dans Extra Credit)} , et ne prennent donc pas en charge les insertions ou les suppressions arbitraires, qui sont nécessaires pour le décalage. Ensuite, nous entrons dans une forboucle.

La condition initiale est une astuce que j'ai trouvée - si nous concaténons l'entrée ensemble, la divisons #et ignorons les vides, le deuxième élément du tableau résultant sera égal à notre nombre, indépendamment de l'habillage. Nous définissons cela sur $bet décrémentons $bchaque fois jusqu'à ce qu'il soit nul.

À chaque itération, nous définissons helper $rcomme le dernier élément de la liste, supprimons ce dernier élément, puis insérons l'élément sur le front ... "décalant" effectivement le tableau vers la droite d'un élément.

Enfin, nous sortons simplement avec -join$dpour qu'il soit concaténé en une seule chaîne.

Crédit supplémentaire

Si le problème était de déplacer le tableau vers la gauche plutôt que vers la droite , nous pouvons le faire beaucoup plus rapidement en utilisant plusieurs affectations . Fondamentalement, "Si la valeur d'affectation contient plus d'éléments que de variables, toutes les valeurs restantes sont affectées à la dernière variable."

En substance, cela signifie quelque chose comme $c=@(1,2,3)et $a,$b=$c
aura $a=1un int et $b=@(2,3)un tableau.

PowerShell, 90 octets, effectue un décalage gauche au lieu d'un décalage droit

param($a)$b=+("$a$a"-split"#"-ne'')[1];$a=[char[]]$a;for(;$b;$b--){$r,$a=$a;$a+=$r}-join$a

Ici, nous prenons à nouveau une entrée et définissons $bcomme ci-dessus. Nous remanions en $atant que tableau de caractères, puis entrons dans la même forboucle que ci-dessus. Cette fois, cependant, nous n'avons pas eu besoin de prendre en charge la suppression / insertion arbitraire, nous n'avons donc pas besoin d'utiliser l' [System.Collections.ArrayList]objet coûteux , ni les appels de méthode coûteux. Au lieu de cela, nous définissons simplement $rle premier élément de $a, et les éléments restants sont réenregistrés dans $a. Ensuite, nous +=pour revenir au bout.

(Comme je l'ai dit, les tableaux PowerShell sont techniquement immuables, mais l' +=opérateur ici est surchargé - il prend un tableau et un autre objet, les rassemble (terme technique) dans un nouveau tableau, le renvoie et l'enregistre sous le nom de variable, et détruit le tableau d'origine. Fonctionnellement, nous venons d'ajouter un élément à la fin du tableau, mais techniquement (et du point de vue de la mémoire / nettoyage des ordures, etc.) c'est un tout nouveau tableau. Cela peut évidemment devenir une opération coûteuse si le tableau est grand ou complexe. Le revers de la médaille est que, comme les tableaux sont immuables, les indexer ou les parcourir est très bon marché.)

La sortie reste la même action, avec une -joininstruction pour la transformer en une seule chaîne.

Sérieusement, 21 octets

,;;+'#@s`≈`MM@#@`/`nΣ

Essayez-le en ligne!

Attention: cette solution est très inefficace, donc les cas de test plus grands expireront sur TIO. Utilisez l'interprète local.

Explication:

,;;+'#@s`≈`MM@#@`/`nΣ
,;;+                   make 3 copies of input, and concatenate two of them
    '#@s               split on #s
        `≈`MM          convert strings to ints, take maximum
             @#@       explode final copy of input
                `/`n   rotate to the right n times
                    Σ  join

Mathematica, 69 octets

#~StringRotateRight~ToExpression[""<>Reverse@TextCases[#,"Number"]]&

Trouvez des séquences de nombres dans le, s'il y en a 2, alors leur ordre doit être inversé. Concatène les chaînes (si ce n'est qu'une seule, elle renvoie simplement la chaîne numérique). Convertissez la chaîne en numérique et faites pivoter la chaîne ce nombre de fois.

Pyth, 22 14 octets

.>zs-.<zxz\#\#

Essayez-le ici!

Explication

.> zs -. <zxz \ # \ # # z = entrée

     . <z # faire pivoter z vers la gauche de
        xz \ # # index de la première occurrence d'un hachage
                  # cela garantit que l'entier n'est pas enroulé autour de la fin
    - \ # # filtre tous les hachages
   s # transtypé en un entier, supprime également les zéros non significatifs
.> z # fait le tour final de la chaîne d'entrée et l'imprime

Cela fonctionne pour tous les testcases et se termine presque instantanément pour les très grands nombres.

JavaScript (ES6) 66

Pour une fois, le stupide négatif %de javascript pour les nombres négatifs est utile

z=>(z+z).substr(-(l=z.length,[a,b]=z.match(/\d+/g),b?b+a:a)%l-l,l)

Pyth, 10 octets

.>zss_cz\#

Essayez-le en ligne. Suite de tests.

Ceci est une traduction de la réponse CJam de Dennis . J'en fais un wiki communautaire, car je ne l'ai pas créé.

Explication

      cz\#   split input at #
     _       reverse
    s        join
   s         cast to integer
.>z          rotate input right

JavaScript (ES6), 67 64 octets

s=>(l=s.length,s+s).substr(l-s.split(/#+/).reverse().join``%l,l)

Un autre port de la réponse CJam de Dennis.

Edit: économisé 3 octets en s'appropriant la partie de la réponse d'edc65 sur laquelle il n'a pas attiré l'attention.

Perl 5, 41 octets

39 octets plus deux pour les -lFdrapeaux ( -M5.01est gratuit):perl -lF -M5.01 script.pl

/#+/;map{unshift@F,pop@F}1..$'.$`;say@F

Explication:

• -lFlit l'entrée, supprime la nouvelle ligne de fin, place le reste dans la chaîne $_, le divise en caractères et place ce fractionnement dans le tableau @F.
• /#+/trouve la première chaîne de #s dans $_et définit$` égal à la substance avant et $'égale à la substance après. Si $`est vide, alors $'peut contenir plus de #s. Cependant, $'.$`est une chaîne dont la sous-chaîne initiale est le nombre de fois que vous faites pivoter le tableau.
• Maintenant, nous construisons la liste 1..$'.$` , qui la traite $'.$`comme un entier et donc la numère, ce qui supprime tout #s final , de sorte que la liste va du 1au nombre de fois où faire pivoter le tableau.
• Pour chaque élément de cette liste, nous faisons pivoter le tableau ( pople dernier élément et unshiftcelui - ci au début).
• Ensuite, saytous les éléments du tableau pivoté.

Rubis - 68 72 70 octets

s=ARGV[0]
p s.split(//).rotate(-(s+s).scan(/\d+/).map(&:to_i).max)*""

• split convertit la chaîne en un tableau
• (s+s).scan(/\d+/) concaténer la chaîne à elle-même et obtenir un tableau de nombres (sous forme de chaînes)
• map(&:to_i) convertir des chaînes en pouces
• max choisir le plus grand int
• rotate max fois
• *""reconvertir le tableau en chaîne (raccourci pour join)

Utilisation: ruby scriptname.rb "[string]"

05AB1E , 14 13 octets

Eh bien, il est très peu probable que le code se termine pour les nombres supérieurs à 100000, mais si vous êtes assez patient, il y aura une sortie :). Code:

'#¡rJ¹sF¤rS\J

Explication:

'#¡             # Split the input on '#'
   r            # Reverse the stack
    J           # Join the stack
     ¹          # Take the first input
      s         # Swap with the number
       F        # For N in range(0, number), do...
        ¤       #   Obtain the last character
         r      #   Reverse the stack
          S     #   Split everything to individual characters
           \    #   Delete the last character
            J   #   Join the stack

Essayez-le en ligne!

Utilise l' encodage CP-1252

VBSCRIPT, 82 99 BYTES

le code précédent ne gérait pas les cas avec un numéro enveloppé à la fin

b=len(a):f=replace(a,"#","/",1,1):c=replace(split(f&f,"/")(1),"#",d) mod b:d=right(a,c)&left(a,b-c)

NON GOLFE

b=len(a)                                 -a->implicit input, get its length 
f=replace(a,"#","/",1,1)  -replace first instance of # so we can split later
c=replace(split(f&f,"/")(1),"#",d) mod b    -get the number and calc the mod
d=right(a,c)&left(a,b-c)                    -d->implicit output

ça craint un peu ... il y a probablement une meilleure façon de le faire, même dans VBscript

Mathematica, 73 58 octets

#~StringRotateRight~Max[FromDigits/@StringSplit[#<>#,"#"]]&

Beaucoup d'octets. 15 octets économisés grâce à IPoiler

Matlab (73)

  @(a)regexprep(a,'(\d*)#*(\d*)#*','${circshift($0,[0 str2num([$2 $1])])}')

• Ceci utilise une autre approche que je me demande si @luis l'a utilisée, car en se référant à sa description, il y a des points communs alors que (dé)? Heureusement, je ne comprends pas le langage Matl recadré.

matlab (86) 72

 @(n)circshift(n,[0 str2num(circshift(n(n~='#'),[0,-find(n=='#',1)+1]))])

• La fonction totalise la chaîne deux fois, une fois pour l'extraction de nombres entiers, la seconde pour la tâche souhaitée, cela ne prend pas trop de temps car matlab continue de tourner (Dim)modulus(Length)à l'exception qu'il tombe en échec de segmentation pour des plages plus grandes.

• Aura du mal à jouer au golf plus ....

(86)

  @(n)circshift(n,[0 str2num([strtok(n(find(n=='#',1,'last'):end),'#') strtok(n,'#')])])

• La différence entre cette fonction et la précédente, celle-ci concatène deux occurrences éloignées d'entiers en arrière, tandis que la première la fait simplement pivoter.