The Mystery String Printer (Rabusie)

26

Wątek gliniarzy można znaleźć tutaj: The Mystery String Printer (Cops)

Twoje wyzwanie

  • Wybierz zgłoszenie z wątku gliniarzy i wydrukuj ciąg z odpowiedzi w tym wątku.
  • Wybrane przez Ciebie zgłoszenie nie może być bezpieczne (musi być nowsze niż 7 dni).
  • Twój program, funkcja lub skrypt REPL musi przestrzegać tych samych reguł, co wątek gliniarzy. Podsumowując:

    • Twój program musi mieć ≤ 128 znaków (jeśli przesłanie policjanta ma mniejszy zakres długości programu, twój program musi również mieć ten zakres długości. Na przykład, jeśli program policjanta ma ≤32 bajtów, twój program musi mieć ≤32 bajtów ).
    • Program musi generować to samo wyjście przy każdym uruchomieniu.
    • Brak funkcji kryptograficznych.
    • Program nie może pobierać danych wejściowych.
    • Brak standardowych luk.
  • Wszystkie nowe zgłoszenia muszą używać tego samego języka. Zgłoszenia sprzed tej reguły są w porządku, nawet jeśli nie.

Punktacja

Punktacja działa podobnie dla złodziei, ale jest nieco inna:

  • Złamanie dowolnego programu o wielkości ≤ 8 bajtów daje 1 punkt.
  • Złamanie programu o wielkości 16 bajtów daje 2 punkty. ≤32 bajtów daje 4 punkty i tak dalej.
  • Każde dodatkowe zgłoszenie, bez względu na długość, daje +5 punktów
  • Zgłoszenie każdego gliniarza może zostać złamane tylko raz - tylko pierwsza osoba, która złamie każde zgłoszenie, otrzymuje punkty.

Zgłoszenia

Każda odpowiedź musi zawierać

  • Link do zgłoszenia policjanta.
  • Twój program i język programowania.
  • Miej także długość programu policjanta (jako potęgę 2) jako ostatnią liczbę w nagłówku.

Dodatkowo proszę skomentować przesłanie policjanta z linkiem do swojej odpowiedzi.

Oto fragment kodu stosu do generowania tabel wyników. Zostaw komentarz, jeśli występuje problem z fragmentem kodu. Jeśli chcesz zobaczyć wszystkie otwarte zgłoszenia gliniarzy, zobacz fragment w wyzwaniu gliniarzy.

Ten konkurs jest teraz zamknięty.

Zwycięzca ogólny: kennytm

Większość zgłoszeń: Sp3000

(Uwaga: liczba zgłoszeń nie przekłada się dokładnie na punkty, ponieważ długość pękniętego programu jest liczona podczas obliczania wyniku).

Daniel M.
źródło
Uwaga: każde dodatkowe zgłoszenie zarabia 5 punktów
Daniel M.

Odpowiedzi:

29

Pyth, Dennis, ≤ 8

V./Tp*FN

Cholera, było fajnie - najtrudniej było wymyślić, jak to zrobić wystarczająco krótko w Pyth.

Analiza

1234Na podpowiedzi startowych że mamy prawdopodobnie do czynienia z listy numerów, drukowane bez separatora. Spróbujmy podzielić liczby w sposób, który ma sens:

1 2 3 4 4 6 5 8 8 9 6 12 10 12 7 16 16 18 12 15 16 8 24 20 24 14 27 18 20 9 32 32 36 24 30 32 16 36 21 24 25 10

Jest kilka wskazówek, że jesteśmy na dobrej drodze:

  • Wszystkie liczby mają czynniki pierwsze mniejsze niż 10
  • Wiele liczb jest bardzo zbliżonych do swojego indeksu na liście

Istnieje jednak kilka osobliwości. Liczba przy indeksie 23 wynosi 24 i jest to jedyny przypadek, w którym liczba przy indeksie jest większa niż sam indeks. Jednak większą wskazówką jest to, że niektóre liczby są wyraźnie mniejsze niż ich sąsiedzi, szczególnie 7 przy indeksie 15, 8 przy indeksie 22 i 9 przy indeksie 30.

Zauważając, że tworzy to wzór 7-8-9, możemy również zobaczyć, że ostatnia liczba to 10 przy indeksie 42. Biorąc pod uwagę ostatnie pytanie @Dennis dotyczące grup abelowych , szybkie sprawdzenie OEIS ujawnia, że 15, 22, 30, 42jest to podsekwencja podziału numery . Pyth ma wbudowane partycje, które dają nam dwa z ośmiu znaków:./

Ale zauważ, że ostatnia liczba to 10, co jest podejrzane, ponieważ 10 jest zmienną wstępnie zainicjalizowaną w Pyth, as T. ./Tdaje pełną listę 42 partycji liczby 10, co wygląda na to, że może się przydać.

Teraz drukowanie odbywa się bez separatora, więc to wskazuje na użycie p. Być może przeglądamy każdą partycję, coś z tym robimy, a następnie drukujemy p? To daje nam następujący szablon:

V./Tp??N

gdzie Vjest pętla for, która zapętla się nad iterowalnym, przechowując każdy element w zmiennej N.

Szybkie spojrzenie na drugą ostatnią partycję (5, 5)powinno dać jasno do zrozumienia, że ​​chcemy wziąć produkt. Naiwnym sposobem zmniejszenia listy przez pomnożenie jest

u*GHd1

gdzie djest lista, o której mowa. To jednak zdecydowanie za długo.

Niestety właśnie tutaj musiałem wyciągnąć brutalnego forcera. Przez jakiś czas nie nadążałem za Pyth, więc nie znałem wielu nowszych funkcji. Pozostały tylko dwie postacie, które wyglądały na wykonalne.

Brutalny forcer następnie wrócił:

V./Tp*FN

gdzie *Fjest fold by *(mnożenie). Nic dziwnego, że nie znalazłem go podczas wyszukiwania - szukałem słowa kluczowego „zmniejsz” zamiast „pasuj”!

Sp3000
źródło
3
Możliwe nawet w 7:jk*M./T
Jakube,
@Jakube Oh wow, gdyby zasięg był <= 7, byłbym skazany na zagładę. Minęło trochę czasu, odkąd sprawdziłem język.
Sp3000,
10

Mathematica, alfa, ≤ 32

GroupOrder[MonsterGroupM[]]

Nienawidzę tego mówić, ale właśnie rozpoznałem numer na miejscu.

Sp3000
źródło
3
Jeszcze krótszy:31!10!27079205916672
kennytm
2
Cholera, wiedziałem, że ta liczba wygląda znajomo.
Dennis
9

> <>, VTCAKAVSMoACE, ≤ 64

'9?':?!;1-$:'@'+o'3'*'='%$30.

Jak na ironię, nie tylko jest to znacznie niższy limit zasięgu, ale także jest przenośny i współpracuje z tłumaczem online .

Analiza

Zacznijmy od ciągu docelowego:

yh[cPWNkz^EKLBiQMuSvI`n\Yw|JVXDUbZmfoRC_xrq{TlpHjGt]OadFAsgeyh[

> <> wypycha znaki do stosu za pomocą 'lub "w trybie łańcuchowym, ale przy 63 znakach do wydrukowania i tylko 64 bajtach do pracy, obecność wielkich liter (nieprawidłowe instrukcje w> <>, dla standardowej sztuczki z pętlą) powoduje bezpośrednie drukowanie niemożliwy. Dlatego musimy coś robić z punktami kodowymi.

Konwersja na punkty kodowe daje (używam tutaj Pythona):

>>> L = [ord(c) for c in "yh[cPWNkz^EKLBiQMuSvI`n\Yw|JVXDUbZmfoRC_xrq{TlpHjGt]OadFAsgeyh["]
>>> L
[121, 104, 91, 99, 80, 87, 78, 107, 122, 94, 69, 75, 76, 66, 105, 81, 77, 117, 83, 118, 73, 96, 110, 92, 89, 119, 124, 74, 86, 88, 68, 85, 98, 90, 109, 102, 111, 82, 67, 95, 120, 114, 113, 123, 84, 108, 112, 72, 106, 71, 116, 93, 79, 97, 100, 70, 65, 115, 103, 101, 121, 104, 91]

Zauważ, że ostatnie trzy liczby są takie same jak pierwsze trzy. Wskazuje to na możliwą pętlę modulo.

Zobaczmy, ile mamy różnych elementów:

>>> len(set(L))
60

Mamy 63 elementy L, z których pierwsze trzy pokrywają się z trzema ostatnimi. Oznacza to, że oprócz tego zderzenia wszystkie inne elementy są unikalne. To sugeruje coś w rodzaju przejęcia modulo mocy liczby pierwszej. Rzeczywiście, 60 + 1 = 61jest liczbą pierwszą, co jest dobrym znakiem.

Spróbujmy znaleźć najmniejszy element

>>> min(L)
65

i użyj tego, aby przeskalować wszystkie elementy w dół, tak aby element min wynosił 1:

>>> M = [x-64 for x in L]
>>> M
[57, 40, 27, 35, 16, 23, 14, 43, 58, 30, 5, 11, 12, 2, 41, 17, 13, 53, 19, 54, 9, 32, 46, 28, 25, 55, 60, 10, 22, 24, 4, 21, 34, 26, 45, 38, 47, 18, 3, 31, 56, 50, 49, 59, 20, 44, 48, 8, 42, 7, 52, 29, 15, 33, 36, 6, 1, 51, 39, 37, 57, 40, 27]

Zwróć uwagę, jak element po 1to 51. Jeśli dzieje się coś w rodzaju mocy / mnożenia, jest to dobre przypuszczenie dla naszego mnożnika.

Spróbujmy:

>>> (57*51)%61
40
>>> (40*51)%61
27
>>> all((x*51)%61 == y for x,y in zip(M, M[1:]))
True

Bingo! Możemy teraz cofnąć się, podając następujący kod:

x = 57
for _ in range(63):
    print(chr(x + 64), end="")
    x = (x*51)%61

który został następnie przetłumaczony na> <>

Sp3000
źródło
1
Co ciekawe, jest to różne pod wieloma względami do tego, co zrobiłem - użyłem 37 i 112 (miałem użyć 101, ale popełniłem błąd w kodzie. Epicka porażka) jako ciągłego mnożenia i modulo'd z 63, a następnie dodałem 64 do dostać się do czytelnego zakresu ASCII. +1 Dobra robota.
Addison Crump,
Bardzo miło, chciałbym to zrobić;)
J Atkin
7

Pyth, Maltysen, ≤4

C.ZG

Brutalna siła trwała tak długo, że robiłem to szybciej ręcznie.

Analiza

C(konwersja łańcucha na podstawową liczbę int 256) jest najprostszym sposobem na wygenerowanie dużej liczby w Pyth, więc prawdopodobnie jest to pierwszy znak. Jeśli dokonamy konwersji z bazy 256, otrzymamy:

xÚKLJNIMKÏÈÌÊÎÉÍË/(,*.)-+¯¨¬ 

Hmm ... niezbyt pouczające.

Teraz Gjest ciąg alfabetu "abc...z", który wygląda na to, że może być źródłem długiego ciągu, do którego można się zasilać C. Przeglądając dokumenty, znajduję:

.Z    Compresses or decompresses a string.

Jeśli mamy do czynienia z kompresją, nie byłoby zaskoczeniem, aby uzyskać wszelkiego rodzaju rozszerzone znaki ASCII. Próbując C.ZGnastępnie dał odpowiedź.

Sp3000
źródło
6

Fourier, rozpad beta, ≤ 32

2~x1~y20(xoy~z*x~yz~xq^~q)

Lub alternatywnie w CJam:

X0I{_2$+}*]2\f#

Analiza

Na początku możemy zobaczyć wiele potęg 2:

2
1
2
2
4
8
32
256
8192
2097152
...

Jeśli weźmiemy log 2 jako podstawę tych liczb, otrzymamy:

1 0 1 1 2 3 5 8 13 21 ...

która jest serią Fibonacciego, zaczynając od 1, 0.

Sp3000
źródło
6

Ślimaki, feersum, ≤ 2 bajty

z

To w rzeczywistości 2 bajty; znak, zpo którym następuje nowa linia \n.

Nie mam pojęcia, jak to działa ani co robi, ale po przetestowaniu wszystkich możliwych danych wejściowych oprócz ~+i ~,był to jedyny 2-bajtowy program, który został wygenerowany 8jako dane wyjściowe.

Zdobycie tego wyniku zajęło wieki . Nic dziwnego, że nazywa się to „Ślimaki” :-D


Uwaga do siebie: przy następnym fuzzowaniu nieznanego oprogramowania zrób to w maszynie wirtualnej.

piskliwy kostuch
źródło
5

Rdza, Liam Noronha, ≤ 128 bajtów

fn main(){print!("AACAAEGAAACIIMOAAACAAEGQQQSYYDFAAACAAEGAAACIIMOHHHJHHLNXXXAGGKMAAACAAEGAAACIIMOAAACAAEGQQQSYYDFOOO");}

Zwykłe wydrukowanie napisu ciągłego to 120 bajtów ...

Klamka
źródło
1
wow, było już późno, kiedy to zrobiłem. Tak głupie przepraszam. Mógłbym znacznie wydłużyć tekst bez wysiłku. Zamieszczę aktualne źródło.
Liam,
5

CoffeeScript, użytkownik2428118, ≤64

alert 0+(btoa k.substr -2 for k of document.body.style).join ''

(działa tylko w Chrome 46.0.2490.71 zgodnie z opisem Cop.)


Wynik jest oczywiście połączeniem krótkich łańcuchów kodowanych base64 ze względu na wszystkie „=”. Po ich zdekodowaniu znajdujemy listę 2-znakowych ciągów takich jak

['nt', 'ms', 'lf', 'ne', 'll', 'on', 'ay', 'on', …

co nie wydaje się mieć sensu. Ale znajduję w nim dziwne przedmioty, takie jak nXi tY. Po ich odfiltrowaniu otrzymujemy

>>> # Python
>>>
>>> [i for i in tt if not re.match('[a-z]{2}$', i)]
['nX', 'nY', 'tX', 'tY', 'wX', 'wY', 'r', 'nX', 'nY', 'tX', 'tY', 'nX', 'nY', 'nX', 'nY', 'nZ', 'x', 'y']

Te X i Y wydają się wskazywać na pierwotny kod pozycji wykorzystujący właściwości pozycji, takie jak offsetX/Y. Szczególnie interesujący jest nZprzedmiot. Aby sprawdzić moje założenie, szukałem wszystkich właściwości, które kończą się na „Z”:

// CoffeeScript
checked = []
f = (o) ->
    if !(o in checked) 
        for k of o
            if /Z$/.test(k)
                console.log(o, k)
            if o[k] instanceof Object
                f o[k]
f window

który pokazuje mnóstwo CSSStyleDeclaration, "webkitTransformOriginZ". Z tego mamy wyraźne wskazanie, że lista składa się z 2 ostatnich znaków wszystkich kluczy styleobiektu, co pokazuje powyższy test.

kennytm
źródło
Znalazłeś to, gratulacje! Oryginalny kod źródłowy
użytkownik2428118
5

Lua <= 4, Egor Skriptunoff

Wielu użytkowników denerwowało się tą odpowiedzią na czacie, więc muszę uwolnić ich od nędzy. Nie znam Lui i nie mogłem tego przetestować, ale byłbym bardzo zaskoczony, gdyby to nie zadziałało.

4^~9

Byłoby to dość oczywiste, ale prawdopodobnie nikt tego nie zrozumiał, ponieważ operatory bitowe zostały dodane tylko w wersji 5.3; ideone.com ma tylko wersję 5.2.

feersum
źródło
facepalm Przeoczyłem operatory bitowe, ponieważ używają tylko liczb całkowitych.
LegionMammal978
5

Python 2, histocrat, ≤16

[[[51002**3/6]]] 

Największą wskazówką jest obietnica, że ​​nie będzie działać w Pythonie 3. Co zmieniło się w Pythonie 3 ? Największym podejrzanym jest to, że operator podziału zwraca a floatw Pythonie 3.

Zakładam więc, że rozwiązanie ma postać ⌊α β / n⌋ = c = 22111101102001, ponieważ potęgowanie jest jedyną krótką drogą do tworzenia wielkich liczb.

Jeśli {α, β, n} rzeczywiście tworzy rozwiązanie, to (cn) 1 / β ≈ α powinno być bardzo zbliżone do liczby całkowitej. Dlatego używam następującego, aby spróbować użyć siły {α, β} dla każdego n:

(* Mathematica *)
n=2; Sort[Table[{N[Abs[k - Round@k] /. k -> (22111101102001*n)^(1/b), 12], b}, {b, 2, 50}]]

(* Output: {{0.00262542213622, 7}, ...}

   The first number is the "quality" of the solution, lower is better.
   the second number is β.
   Thus α ≈ (nc)^(1/β) = 89
   But (89^7)/2 = 22115667447764, which is still far away from the answer.

*)

Rzeczywisty wynik szybko wychodzi, gdy n = 6.

kennytm
źródło
Dobra robota! Takie jest zamierzone rozwiązanie i to, jak spodziewałem się, że ktoś to rozwiąże (chociaż z góry nie zdawałem sobie sprawy, jak bardzo zależało to od platformy).
histocrat
4

MATLAB, StewieGriffin, ≤ 16

[36;87]*' |'*5

Wydruki:

ans =
        5760       22320
       13920       53940
Tom Carpenter
źródło
Miły! Cieszę się, że się podobało :-) drogę Zrobiłam to: 5*'$W'.'*' |'.
Stewie Griffin,
Zastanawiałem się nad tym, aby uczynić to znacznie trudniejszym przez pomnożenie przez np. .73Zamiast 5, zrób +5lub uczyń z 3x3matrycy, ale pomyślałem, że to było fajniejsze. Mógłby wiele zrobić z trzema pozostałymi bajtami.
Stewie Griffin,
@StewieGriffin Nigdy wcześniej się nie spotkałem .', ale ma pełny sens - zastanawiałem się, jak transponować ciąg znaków bez uciekania się do nawiasów.
Tom Carpenter,
4

Matlab, Luis Mendo, ≤16

Znalazłem to, tak!

fix(peaks(9).^2)

Nie wiedziałem, że Octave też może to zrobić.

Wauzl
źródło
W jaki sposób? Czy słyszałeś o peaks()?
lirtosiast
Tak, mam. Przez przypadek bawiłem się peaks.
Wauzl,
4

Python, spacemanjosh, ≤ 64

n=0;d=1;L=[]
exec("L+=[10/(100-n)**.5];n+=d;d+=2;"*10)
print(L)

Chwalebny odwrotny symboliczny kalkulator. Nie za dobrze gra w golfa, ale hej, pasuje.

Edycja: Grałem w golfa.

print([10/(100-n*n)**.5for n in range(10)])
Sp3000
źródło
4

JavaScript ES6, Cᴏɴᴏʀ O'Bʀɪᴇɴ, ≤128 bajtów

var x=122,s='0037122342526683102122';for(var i=23;i<=505;i+=2)s+=(x+=i);s;

Wątpię, żeby było dokładnie tak, ponieważ nie potrzebowałem prawie 128 bajtów, ale znalezienie powtarzającej się sekwencji było fajnym wyzwaniem.

SLuck49
źródło
Łał. Użyłem zupełnie innej metody. Czy to wciąż się liczy? : 3
Conor O'Brien
@ CᴏɴᴏʀO'Bʀɪᴇɴ Zazwyczaj tak. Jestem naprawdę ciekawy oryginału i tego, co produkuje te pierwsze 22 bajty, zgaduję, że coś funky w pętli init
SLuck49
Wyślę to, kiedy będę miał czas. Myślę, że to podłoga funkcji s * s - s / (5-s)
Conor O'Brien
4

Wt, ppperry, <= 64

0::=11
1::=22
2::=33
3::=44
4::=55
a::=bbb
b::=000
::=
aaaaaaa

Zasadniczo rozkłada 2016 na czynniki pierwsze. 62 znaków, więc przypuszczam, że jest to podobne do tego, co chciałeś.

histocrat
źródło
Możesz zrobić 0 :: = 2222, aby zapisać niektóre bajty.
lirtosiast
Racja, wydaje się jednak nieco mniej elegancka.
histocrat
4

> <>, Sp3000, <= 8

'l(?; o>

Wskaźnik instrukcji zawija się i następują następujące kroki:

  • 'l(?; o>'wypycha wartości ASCII l(?; o>na stos
  • l przesuwa rozmiar stosu na stosie
  • (porównaj dwa górne elementy stosu: size of stackiord('>')
  • ?; zatrzymuje program, jeśli rozmiar stosu był większy
  • owypisuje górny element stosu jako znak (będzie to zawsze o)
  • > ustawia kierunek IP, tutaj nie ma opcji
  • wracamy do pierwszego kroku

Dane wyjściowe to oooooooooooo.

Możemy uzyskać wiele różnych wyników, zmieniając [space]na coś, co popycha lub wyskakuje na stosie i używając innego ważnego znaku zamiast >, który może również popychać lub pop.

randomra
źródło
Miły! Dla porównania miałem:'l=?;o*
Sp3000
4

CJam, Reto Koradi, ≤ 4

HJK#

Popycha 17 , a następnie 19 20 = 37589973457545958193355601 .

Wypróbuj online.

Jest tylko tyle rzeczy, które możesz zrobić w czterech bajtach. Tak duża liczba musiała w jakiś sposób obejmować moce lub silnie, a silnia miałaby końcowe zera.

Dennis
źródło
To jest poprawne. Później zajmę się oficjalną aktualizacją postów.
Reto Koradi
4

Pyth <= 4, Dennis

ljyG

To długość łączenia na nowych liniach wszystkich podzbiorów alfabetu.

Testowe uruchomienie:

$ pyth -cd 'ljyG'
==================== 4 chars =====================
ljyG
==================================================
imp_print(Plen(join(subsets(G))))
==================================================
939524095

Doszedłem do wniosku, że liczba 2^27 * 7 - 1jest silną wskazówką, na której się opiera yG, która jest 2^26długa. Wtedy domyśliłem się, że trzeba go przekonwertować na sznurek i wydrukować jego długość. Jednak jedynym sposobem na zrobienie tego, o czym mogłem pomyśleć, był ``, repr. Potem pomyślałem o tym j, co idealnie pasuje.

isaacg
źródło
4

C, tucuxi, ≤64

main(i){for(i=0;i<11000;++i)if(!(i&2*i))printf("1%d",!(i&1));}

Dane wyjściowe to 0 i 1, ale C nie może wydrukować pliku binarnego bezpośrednio, więc jest bardzo prawdopodobne, że są to wyniki logiczne.

Jest więcej niż 1 zera, więc zapisałem pozycje 0s ( 3, 9, 13, 19, …), co okazuje się być OEIS A075318 . Nie jest to jednak przydatne, nie ma prostej formuły określającej, gdzie jest liczba w tej sekwencji.

Ale zauważamy, że wszystkie liczby nieparzyste są, więc być może (x-1)/2 = {1, 4, 6, 9, 12, …}mają bardziej przydatne informacje. A to jest A003622 .

A003622 można zdefiniować jako „pozycje 1 w A003849 ”, i właśnie to musimy tutaj złamać. A A003849 jest zdefiniowany jako „ A003714 mod 2”, gdzie A003714 to po prostu wszystkie liczby całkowite x & (2*x) == 0. Tak więc mamy rozwiązanie.

OEIS rox.

kennytm
źródło
naprawdę imponujące - nigdy nie przestaję być zaskoczony przez użytkowników tej strony
tucuxi
4

Dyalog APL, Dennis, ≤4

*⍨⍟8

Oblicza ln (8) ^ ln (8). Czy StackExchange przestanie konwertować moje odpowiedzi? Napiszę tu kilka rzeczy, żeby nie zamieniły się w komentarz.

Lynn
źródło
Miałem, 8*⍟⍟8ale nie wiedziałem o tym .
Dobra
3

Stuck, @ quartata, ≤8

Następujący program w języku Pyth :

^33 9

produkuje pożądaną moc wyjściową

46411484401953

Metoda pękania: przeszukałem numer Google.

lirtosiast
źródło
3

Pyth, xnor, ≤ 4

C`CG

CG(konwersja ciągu alfabetu "abc...z"z bazy 256) jest typowym sposobem Pyth'a na generowanie naprawdę dużej liczby. Po tym to po prostu skreślić i przekonwertować z bazy ponownie.

Sp3000
źródło
3

Python 3, Mego, ≤128

(Przy użyciu Python 3.5.0, nie testowany na poprzednich wersjach. 105 98 bajtów.)

import sys
a=sys.stdout
sys.stdout=None
from this import*
a.write(s.translate(s.maketrans(d))[4:])
kennytm
źródło
Bardzo dobrze! Zrobiłem to w 94, zobacz kod mojego gliniarza.
Mego,
3

Matlab / Octave, Wauzl, ≤16

"234"'*"567"

Korzystając z tego samego pomysłu, co odpowiedź Toma Carpentera

(Jeśli to nie zadziałało, spróbuj tego :)

[50;51;52]*'567'
kennytm
źródło
@NaN Zobacz aktualizację. Oba mają ≤16 bajtów i działają na ideone.
kennytm
Miły. Miałem (1*'234')'*'567'na myśli, ponieważ twoja pierwsza odpowiedź nie działa w Matlabie.
Wauzl,