Zadanie
To proste wyzwanie. Dane wejściowe to pojedynczy niepusty ciąg zawierający tylko cyfry 0123456789
i skróty #
. Będzie zawierał dokładnie jeden ciąg cyfr, który koduje nieujemną liczbę całkowitą i może owijać się na końcu łańcucha, i co najmniej jeden #
. Liczba całkowita może mieć zera na początku. Na przykład ##44##
, 013####
i 23###1
są ważne wejścia, natomiast ###
, 0099
a #4#4
nie są.
Twoim zadaniem jest wyodrębnienie liczby całkowitej n
z łańcucha i wyprowadzenie łańcucha obróconego o n
krok w prawo.
Przykłady
- Dane wejściowe
#1##
należy obrócić o 1 krok w prawo, aby uzyskać prawidłowe wyjście##1#
. - Wejście
#026###
należy obrócić o 26 kroków w prawo, ponieważ wiodące 0 jest ignorowane. Prawidłowe wyjście to26####0
. - Dane wejściowe
1####2
zawierają liczbę całkowitą 21 owiniętą na końcu, dlatego należy ją obrócić o 21 kroków w prawo. Prawidłowe wyjście to##21##
.
Zasady i punktacja
Możesz napisać pełny program lub funkcję. Wygrywa najniższa liczba bajtów, a standardowe luki są niedozwolone.
Możesz założyć, że liczba n
pasuje do standardowego int
typu Twojego języka. I odwrotnie, jeśli ten int
typ standardowy implementuje liczby całkowite o dowolnej dokładności, musisz (teoretycznie) obsługiwać dowolną dużą liczbę n
.
Przypadki testowe
#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
pasuje do rodzimegoint
typu języka (co może być dowolną precyzją). Zaktualizuję tekst wyzwania później.1234
?Odpowiedzi:
CJam, 11 bajtów
Wypróbuj online! lub zweryfikuj wszystkie przypadki testowe .
Zauważ, że to nie zadziała dla dwóch ostatnich przypadków testowych, ponieważ zaangażowane liczby nie pasują do 64 bitów.
Jak to działa
źródło
Julia,
7165 bajtówJest to anonimowa funkcja, która przyjmuje ciąg i zwraca ciąg. Aby go wywołać, przypisz go do zmiennej.
Dołączamy dane wejściowe do siebie, dzielimy je na tablicę
#
jako separator, analizujemy każdą liczbę całkowitą i przyjmujemy maksimum. Określa liczbę przesunięć łańcucha w prawo. Splatamy sznurek wChar
tablicę, przesuwamy i zjoin
powrotem razem.źródło
Python, 66 bajtów
źródło
Siatkówka oka,
655749Zaoszczędź 8 bajtów dzięki Martinowi!
Wypróbuj online!
Zauważ, że skończy się to czas / zabraknie pamięci dla bardzo dużych przypadków testowych online i na większości rozsądnych maszyn, dla niektórych większych.
Pobiera ostatnią liczbę w ciągu i pierwszą lub brak liczby w ciągu i umieszcza je przed ciągiem. Następnie konwertuje tę połączoną liczbę na jednoargumentową i wielokrotnie obraca się, jednocześnie upuszczając jednoargumentową cyfrę.
źródło
Galaretka,
1210 bajtówWypróbuj online! lub zweryfikuj wszystkie przypadki testowe .
tło
Powiedz, że dane wejściowe to
51379#97
.Powtarzając ciąg dwukrotnie (
51379#9751379#97
), możemy upewnić się, że będzie on zawierał ciągłą reprezentację liczby.Następnie stosujemy bitowe NIE do wszystkich znaków. Próbuje rzutować na int, więc „1” jest przetwarzane na 1 , a następnie mapowane na ~ 1 = -2 . W przypadku niepowodzenia (
#
) zwraca 0 .W naszym przykładzie to daje
Następnie dzielimy na zera, aby oddzielić część, która koduje liczbę od reszty.
Bitowe NIE odwzorowuje n na -n - 1 , więc zwiększamy każde, aby uzyskać -n .
Następnie konwertujemy każdą listę z podstawy 10 na liczbę całkowitą.
Najniższa liczba to minus tej, której szukamy. Ponieważ atom rotacji listy żelków
ṙ
obraca się w lewo , pozwala to uniknąć pomnożenia przez -1, aby obrócić w prawo.Jak to działa
źródło
MATL ,
28251716 bajtów8 bajtów mniej pożyczenia pomysł Dennisa na podzielenie tablicy i odwrócenie kolejności elementów
Dwa ostatnie przypadki testowe nie działają, ponieważ liczba jest zbyt duża.
EDYCJA (20 maja 2016 r.) Kod w linku używa
Xz
zamiast zXv
powodu ostatnich zmian w języku.Wypróbuj online!
źródło
PowerShell, 153 bajty
(Ale zobacz sekcję Dodatkowy kredyt poniżej)
PowerShell nie ma pojęcia „przesunięcia” tablicy, więc musiałem stworzyć własne rozwiązanie. Większa liczba zajmie dużo czasu, ale w końcu powinna ukończyć wszystko, co mieści się w 32-bitowej int.
Pobiera dane wejściowe
$a
i ustawia nową zmienną$d
jako obiekt [System.Collections.ArrayList] . Odbywa się to, ponieważ technicznie tablice w PowerShell są niezmienne (wyjaśnione poniżej w Dodatkowym kredycie) , a zatem nie obsługują arbitralnych wstawiania lub usuwania, które są potrzebne do zmiany. Następnie wchodzimy wfor
pętlę.Pierwszy warunek to sztuczka, którą znalazłem - jeśli połączymy dane wejściowe razem, podzielimy
#
i zignorujemy opróżnienia, drugi element wynikowej tablicy będzie równy naszej liczbie, niezależnie od zawijania. Ustawiamy to na$b
i zmniejszamy za$b
każdym razem, aż wyniesie zero.W każdej iteracji ustawiamy pomocnika
$r
jako ostatni element na liście arraylist, usuwamy ten ostatni element, a następnie wstawiamy element z przodu ... skutecznie „przesuwając” tablicę w prawo o jeden element.Wreszcie, po prostu generujemy dane wyjściowe,
-join$d
dzięki czemu jest ono połączone w jeden ciąg.Dodatkowy kredyt
Jeśli problemem było przesunięcie tablicy w lewo zamiast w prawo , możemy to zrobić znacznie krócej przy użyciu wielokrotnego przypisania . Zasadniczo „Jeśli wartość przypisania zawiera więcej elementów niż zmiennych, wszystkie pozostałe wartości zostaną przypisane do ostatniej zmiennej”.
Zasadniczo oznacza to coś podobnego
$c=@(1,2,3)
i$a,$b=$c
będzie zawierało
$a=1
int i$b=@(2,3)
tablicę.PowerShell, 90 bajtów, wykonuje przesunięcie w lewo zamiast w prawo
Tutaj ponownie przyjmujemy dane wejściowe i ustawiamy
$b
jak wyżej. Przerzucamy ponownie$a
jako tablicę znaków, a następnie wchodzimy w tę samąfor
pętlę, co powyżej. Tym razem jednak nie musieliśmy wspierać arbitralnego usuwania / wstawiania, więc nie musimy używać kosztownego[System.Collections.ArrayList]
obiektu ani kosztownych wywołań metod. Zamiast tego po prostu ustawiamy$r
się na pierwszy element$a
, a pozostałe elementy są ponownie zapisywane w$a
. Następnie musimy+=
przywrócić go do końca.(Jak powiedziałem, tablice PowerShell są technicznie niezmienne, ale
+=
operator tutaj jest przeciążony - bierze tablicę i inny obiekt, łączy je razem (termin techniczny) w nową tablicę, zwraca ją i zapisuje jako nazwę zmiennej, i niszczy oryginalna tablica. Funkcjonalnie właśnie dodaliśmy element na końcu tablicy, ale technicznie (i z perspektywy czyszczenia pamięci / usuwania śmieci itp.) jest to zupełnie nowa tablica. To oczywiście może stać się kosztowną operacją jeśli tablica jest duża lub złożona. Z drugiej strony, ponieważ tablice są niezmienne, indeksowanie do nich lub iterowanie nad nimi jest bardzo tanie).Dane wyjściowe pozostają takie same, z
-join
instrukcją, aby przekształcić je w pojedynczy ciąg.źródło
Poważnie, 21 bajtów
Wypróbuj online!
Ostrzeżenie: to rozwiązanie jest bardzo nieefektywne, więc większe przypadki testowe przekroczą limit czasu dla TIO. Skorzystaj z lokalnego tłumacza.
Wyjaśnienie:
źródło
Mathematica, 69 bajtów
Znajdź sekwencje liczb w, jeśli są 2, ich kolejność musi zostać odwrócona. Połącz ciągi znaków (jeśli jest to tylko jeden, po prostu zwraca ciąg liczbowy). Przekształć ciąg na numeryczny i obróć go tyle razy.
źródło
FromDigits
działa zamiastToExpression
.Pyth,
2214 bajtówWypróbuj tutaj!
Wyjaśnienie
Działa to dla wszystkich przypadków testowych, a także prawie natychmiast kończy się dla bardzo dużych liczb.
źródło
-...\#
zamiasth:..."\d+"1
. Ponadto, nie trzeba konwertowaćz
na listę znaków,.>
działa również na ciąg znaków.JavaScript (ES6) 66
Po raz
%
użyteczny jest głupi minus javascript dla liczb ujemnychźródło
b+a
jest łączeniem łańcuchowym.a='32',b='1', (b?b+a:a)=='132', (b|0+a)==33
Pyth, 10 bajtów
Wypróbuj online. Zestaw testowy.
To jest tłumaczenie odpowiedzi Dennisa na CJam . Robię z niej wiki społeczności, ponieważ nie wymyśliłem tego.
Wyjaśnienie
źródło
JavaScript (ES6),
6764 bajtówKolejny port odpowiedzi Dennisa na CJam.
Edycja: Zapisano 3 bajty, przywłaszczając sobie część odpowiedzi edc65, na którą nie zwracał uwagi.
źródło
s+s
Zamiast tego skopiowałem lewę. (Właściwie to myślałem o ostatniej nocy, ale byłem zbyt zmęczony, żeby to wypróbować w tym czasie.)Perl 5, 41 bajtów
39 bajtów plus dwa dla
-lF
flag (-M5.01
jest bezpłatny):perl -lF -M5.01 script.pl
Wyjaśnienie:
-lF
odczytuje dane wejściowe, usuwa końcowy$_
znak nowej linii, umieszcza resztę w ciągu , dzieli ją na znaki i umieszcza ją w tablicy@F
./#+/
znajduje pierwszy ciąg#
s$_
i ustawia wartość$`
równą rzeczy przed nim i$'
równą rzeczy po niej. Jeśli$`
jest pusty,$'
może zawierać więcej#
s. Jednak$'.$`
to ciąg, którego początkowe podciąg jest kilka razy obrócić tablicę.1..$'.$`
, która traktuje$'.$`
jako liczbę całkowitą, a tym samym ją numeruje, co usuwa wszystkie końcowe#
s, więc lista jest od1
liczby razy, aby obrócić tablicę.pop
ostatni element iunshift
na początek).say
wszystkie elementy obróconego układu.źródło
Rubinowy -
687270 bajtówsplit
konwertuje ciąg znaków na tablicę(s+s).scan(/\d+/)
konkatenuj ciąg do siebie i uzyskaj tablicę liczb (jako ciągi)map(&:to_i)
konwertuje ciągi znaków na intsmax
wybierz największą introtate
max
czasy*""
przekonwertować tablicę z powrotem na ciąg (skrót odjoin
)Stosowanie :
ruby scriptname.rb "[string]"
źródło
05AB1E ,
1413 bajtówCóż, bardzo mało prawdopodobne jest, aby kod zakończył się dla liczb większych niż 100000, ale jeśli będziesz wystarczająco cierpliwy, pojawi się wyjście :). Kod:
Wyjaśnienie:
Wypróbuj online!
Wykorzystuje kodowanie CP-1252
źródło
VBSCRIPT,
8299 BYTESpoprzedni kod nie obsługiwał spraw z liczbą zawiniętą na końcu
UNGOLFED
to trochę do bani ... prawdopodobnie jest to lepszy sposób, nawet w VBscript
źródło
a
jest funkcja wejściowa i zwraca wynik? W ten sposób nie będziesz potrzebować połączeńinputbox
imsgbox
.b
?Mathematica,
7358 bajtówDużo bajtów. 15 bajtów zapisywane dzięki do IPoiler
źródło
StringRotateRight
zapisuje tutaj kilka bajtów.Matlab (73)
źródło
matlab
(86)72Funkcja sumuje ciąg dwa razy, raz dla wyodrębnienia liczb całkowitych, drugi dla żądanego zadania, nie zajmuje to zbyt wiele czasu, ponieważ Matlab obraca się dalej,
(Dim)modulus(Length)
z tą różnicą, że ulega awarii segmentacji dla większych zakresów.Będzie walczyć, jak grać w golfa bardziej ....
(86)
źródło