Die Aufgabe

Dies ist eine einfache Herausforderung. Ihre Eingabe ist eine einzelne nicht leere Zeichenfolge, die nur Ziffern 0123456789und Hashes enthält #. Es enthält genau eine Ziffernfolge, die eine nichtnegative Ganzzahl codiert und möglicherweise das Ende der Zeichenfolge umschließt, und mindestens eine #. Die Ganzzahl kann führende Nullen haben. Zum Beispiel ##44##, 013####und 23###1gelten Eingänge, während ###, 0099und #4#4ist es nicht.

Ihre Aufgabe ist es, die Ganzzahl naus der Zeichenfolge zu extrahieren und die Zeichenfolge schrittweise nnach rechts gedreht auszugeben .

Beispiele

• Die Eingabe #1##sollte 1 Schritt nach rechts gedreht werden, damit die Ausgabe korrekt ist ##1#.
• Die Eingabe #026###sollte 26 Schritte nach rechts gedreht werden, da die führende 0 ignoriert wird. Die korrekte Ausgabe ist 26####0.
• Die Eingabe 1####2enthält die Ganzzahl 21, die über das Ende gewickelt ist, und sollte daher um 21 Schritte nach rechts gedreht werden. Die korrekte Ausgabe ist ##21##.

Regeln und Wertung

Sie können ein vollständiges Programm oder eine Funktion schreiben. Die niedrigste Byteanzahl gewinnt, und Standardlücken sind nicht zulässig.

Sie können davon ausgehen, dass die Nummer nin den Standardtyp intIhrer Sprache passt . Umgekehrt, wenn dieser Standardtyp intGanzzahlen mit willkürlicher Genauigkeit implementiert, müssen Sie (theoretisch) eine willkürlich große Zahl unterstützen n.

Testfälle

#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 Bytes

q_'#%W%sim>

Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Beachten Sie, dass dies in den letzten beiden Testfällen nicht funktioniert, da die beteiligten Zahlen nicht in 64 Bit passen.

Wie es funktioniert

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 Bytes

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

Dies ist eine anonyme Funktion, die eine Zeichenfolge akzeptiert und eine Zeichenfolge zurückgibt. Um es aufzurufen, weisen Sie es einer Variablen zu.

Wir hängen die Eingabe an sich selbst an, teilen sie #als Trennzeichen in ein Array auf , analysieren jede Ganzzahl und nehmen das Maximum. Dies legt fest, wie oft die Zeichenfolge nach rechts verschoben wird. Wir teilen den String in ein CharArray auf, verschieben ihn und setzen joinihn wieder zusammen.

Python, 66 Bytes

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

Retina, 65 57 49

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

8 Bytes gespart dank Martin!

Probieren Sie es online!

Beachten Sie, dass für die sehr großen Online-Testfälle und für einige der größeren auf den meisten vernünftigen Computern das Zeitlimit überschritten wird.

Dies nimmt die letzte Nummer in der Zeichenkette und die erste oder keine Nummer in der Zeichenkette und setzt sie vor die Zeichenkette. Dann konvertiert es diese kombinierte Zahl in eine unäre Zahl und dreht sie wiederholt, während es eine unäre Ziffer fallen lässt.

Gelee, 12 10 Bytes

ẋ2~ṣ0‘ḌṂṙ@

Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Hintergrund

Angenommen, die Eingabe ist 51379#97.

Durch zweimaliges Wiederholen der Zeichenfolge ( 51379#9751379#97) können wir sicherstellen, dass sie eine zusammenhängende Darstellung der Zahl enthält.

Als nächstes wenden wir bitweise NICHT auf alle Zeichen an. Dieser versucht, auf int umzuwandeln, sodass '1' zu 1 ausgewertet und dann auf ~ 1 = -2 abgebildet wird . Bei einem Fehler ( #) wird 0 zurückgegeben .

Für unser Beispiel gibt dies

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

Als nächstes teilen wir bei Nullen, um den Teil, der die Zahl codiert, vom Rest zu trennen.

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

Bitweise NICHT abbildet n zu n - 1 , so dass wir jede Erhöhung zu erhalten -n .

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

Als nächstes konvertieren wir jede Liste von der Basis 10 in eine Ganzzahl.

[-51379, -9751379, -97]

Die niedrigste Zahl ist das Negativ der gesuchten. Da sich das Jelly-List-Rotationsatom ṙnach links dreht , vermeiden Sie das Multiplizieren mit -1 , um sich nach rechts zu drehen.

Wie es funktioniert

ẋ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 Bytes

!G1Y4XXPZcXvUYS!

8 Bytes weniger als Dennis 'Idee, das Array aufzuteilen und die Reihenfolge der Teile umzukehren

Die beiden letzten Testfälle funktionieren nicht, weil die Anzahl zu groß ist.

EDIT (20. MAI 2016) Der Code in den Link verwendet Xzstatt Xv, in der Sprache , auf die jüngsten Veränderungen zurückzuführen ist .

Probieren Sie es online!

!         % 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 Byte

_{(Siehe aber den Abschnitt "Extra Credit" weiter unten)}

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 hat nicht das Konzept, ein Array zu "verschieben", daher musste ich meine eigene Lösung entwickeln. Für größere Zahlen wird es lange dauern , aber irgendwann sollte alles fertig sein, was in eine 32-Bit-Ganzzahl passt.

Übernimmt Eingaben $aund legt eine neue Variable $dals Objekt [System.Collections.ArrayList] fest . Dies ist darauf zurückzuführen, dass Arrays in PowerShell technisch gesehen unveränderlich sind _{(weiter unten unter "Zusätzliche Gutschrift" erläutert)} und daher keine willkürlichen Einfügungen oder Entfernungen unterstützen, die zum Verschieben erforderlich sind. Dann betreten wir eine forSchleife.

Die Ausgangsbedingung ist ein Trick, den ich gefunden habe: Wenn wir die Eingabe zusammenfügen, aufteilen #und Leergut ignorieren, entspricht das zweite Element des resultierenden Arrays unserer Zahl, unabhängig vom Zeilenumbruch. Wir setzen das auf $bund dekrementieren $bjedes Mal, bis es Null ist.

Bei jeder Iteration setzen wir den Helfer $rals letztes Element in der Array-Liste, entfernen das letzte Element und fügen dann das Element auf der Vorderseite ein. Dadurch wird das Array effektiv um ein Element nach rechts verschoben.

Schließlich geben wir einfach mit aus, -join$ddamit es zu einer Zeichenfolge verkettet wird.

Extra Gutschrift

Wenn das Problem darin bestand, das Array nach links statt nach rechts zu verschieben , können wir es durch Mehrfachzuweisung erheblich verkürzen . Grundsätzlich gilt: "Wenn der Zuweisungswert mehr Elemente als Variablen enthält, werden alle verbleibenden Werte der letzten Variablen zugewiesen."

Im Wesentlichen bedeutet dies so etwas wie $c=@(1,2,3)und $a,$b=$c
wird $a=1ein Int und $b=@(2,3)ein Array haben.

PowerShell, 90 Byte, führt eine Linksverschiebung anstelle einer Rechtsverschiebung durch

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

Hier nehmen wir noch einmal die Eingabe und setzen $bwie oben. Wir werden $aals Char-Array neu umgewandelt und geben dann dieselbe forSchleife wie oben ein. Dieses Mal mussten wir jedoch kein willkürliches Entfernen / Einfügen unterstützen, sodass wir weder das kostspielige [System.Collections.ArrayList]Objekt noch die teuren Methodenaufrufe verwenden müssen. Stattdessen stellen wir einfach $rdas erste Element von ein $aund die restlichen Elemente werden in gespeichert $a. Dann machen wir +=es wieder bis zum Ende.

(Wie ich bereits sagte, sind PowerShell-Arrays technisch unveränderlich, aber der +=Operator hier ist überladen. Er nimmt ein Array und ein anderes Objekt auf, fasst sie zu einem neuen Array zusammen (Fachbegriff), gibt das zurück und speichert es als Variablennamen und zerstört es Funktionell haben wir gerade ein Element am Ende des Arrays hinzugefügt, aber technisch (und aus Sicht der Speicher- / Speicherbereinigung usw.) handelt es sich um ein brandneues Array. Dies kann offensichtlich zu einer kostspieligen Operation werden Wenn das Array groß oder komplex ist, ist die Kehrseite: Da Arrays unveränderlich sind, ist es sehr billig, sie zu indizieren oder darüber zu iterieren.)

Die Ausgabe bleibt dieselbe Aktion, mit der -joinAnweisung, sie in eine einzelne Zeichenfolge umzuwandeln.

Im Ernst, 21 Bytes

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

Probieren Sie es online!

Warnung: Diese Lösung ist sehr ineffizient, sodass bei größeren Testfällen eine Zeitüberschreitung bei TIO auftritt. Verwenden Sie den lokalen Dolmetscher.

Erläuterung:

,;;+'#@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 Bytes

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

Suchen Sie Zahlenfolgen in, wenn es 2 gibt, muss deren Reihenfolge umgekehrt werden. Verketten Sie die Zeichenfolgen (wenn es nur eine ist, wird nur die Zahlenzeichenfolge zurückgegeben). Konvertieren Sie die Zeichenfolge in eine numerische Zeichenfolge und drehen Sie sie so oft.

Pyth, 22 14 Bytes

.>zs-.<zxz\#\#

Probieren Sie es hier aus!

Erläuterung

.> zs -. <zxz \ # \ # # z = Eingabe

     <z # drehen z links von
        xz \ # # Index des ersten Auftretens eines Hashs
                  # dies stellt sicher, dass die Ganzzahl nicht um das Ende gewickelt wird
    - \ # # Alle Hashes herausfiltern
   s # in eine Ganzzahl umgewandelt, entfernt auch führende Nullen
.> z # mache das letzte Roating der Eingabezeichenfolge und drucke es aus

Dies funktioniert für alle Testfälle und endet auch bei sehr großen Zahlen sofort.

JavaScript (ES6) 66

Ausnahmsweise ist das blöde Negativ %von Javascript für negative Zahlen nützlich

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

Pyth, 10 Bytes

.>zss_cz\#

Probieren Sie es online aus. Testsuite.

Dies ist eine Übersetzung von Dennis 'CJam-Antwort . Ich mache es zu einem Community-Wiki, da ich es mir nicht ausgedacht habe.

Erläuterung

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

JavaScript (ES6), 67 64 Bytes

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

Ein weiterer Port von Dennis 'CJam-Antwort.

Bearbeiten: 3 Bytes gespart, indem der Teil der Antwort von edc65 übernommen wurde, auf den er nicht aufmerksam gemacht hat.

Perl 5, 41 Bytes

39 Bytes plus zwei für die -lFFlags ( -M5.01ist frei):perl -lF -M5.01 script.pl

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

Erläuterung:

• -lFLiest die Eingabe, entfernt den abschließenden Zeilenumbruch, fügt den Rest in den String ein $_, teilt ihn in Zeichen auf und fügt diesen in das Array ein @F.
• /#+/Findet die erste Zeichenkette von #s in $_und setzt sie $`gleich dem Zeug davor und $'gleich dem Zeug danach. Wenn $`leer ist, $'können weitere #s enthalten sein . Es handelt sich jedoch $'.$`um eine Zeichenfolge, deren anfänglicher Teilstring angibt, wie oft das Array gedreht werden soll.
• Jetzt erstellen wir die Liste 1..$'.$`, die $'.$`als Ganzzahl behandelt und damit nummeriert wird, wodurch alle abschließenden #s entfernt werden. Die Liste gibt also an 1, wie oft das Array gedreht werden soll.
• Für jedes Element in dieser Liste drehen wir das Array ( popdas letzte Element und unshiftes an den Anfang).
• Dann sayalle Elemente des gedrehten Arrays.

Ruby - 68 72 70 Bytes

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

• split wandelt einen String in ein Array um
• (s+s).scan(/\d+/) Verketten Sie den String mit sich selbst und erhalten Sie ein Array von Zahlen (als Strings)
• map(&:to_i) Zeichenketten in Ints konvertieren
• max wähle den größten int
• rotate max mal
• *""konvertiere das Array zurück in einen String (Abkürzung für join)

Verwendung : ruby scriptname.rb "[string]"

05AB1E , 14 13 Bytes

Nun, es ist sehr unwahrscheinlich, dass der Code für Zahlen größer als 100000 endet, aber wenn Sie geduldig genug sind, wird es eine Ausgabe geben :). Code:

'#¡rJ¹sF¤rS\J

Erläuterung:

'#¡             # 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

Probieren Sie es online!

Verwendet die CP-1252- Codierung

VBSCRIPT, 82 99 BYTES

Der vorherige Code behandelte keine Fälle, bei denen die Nummer über dem Ende steht

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)

UNGOLFED

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

das nervt irgendwie ... es gibt wahrscheinlich eine bessere Möglichkeit, dies zu tun, sogar in VBscript

Mathematica, 73 58 Bytes

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

Viel Byte. 15 Bytes gespeichert Dank an IPoiler

Matlab (73)

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

• Dies ist ein anderer Ansatz, den ich frage mich, ob @luis ihn verwendet hat, da es in Bezug auf seine Beschreibung einige Gemeinsamkeiten gibt, während (un) - zum Glück verstehe ich die beschnittene Matl-Sprache nicht.

matlab (86) 72

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

• Die Funktion summiert die Zeichenfolge zweimal, einmal für die Ganzzahlextraktion, zweitens für die gewünschte Aufgabe, und es dauert nicht allzu lange, da Matlab (Dim)modulus(Length)mit der Ausnahme, dass es bei größeren Bereichen zu Segmentierungsfehlern kommt , weiter rotiert .

• Wird kämpfen, wie man es mehr Golf spielt ....

(86)

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

• Der Unterschied zwischen dieser und der vorherigen Funktion besteht darin, dass zwei entfernte Vorkommen von ganzen Zahlen rückwärts verkettet werden, während die erste Funktion sie nur dreht.