Wprowadzenie

Dawno temu, kiedy kodowałem gry karciane zwykłymi kartami do gry, podawałem liczbę dla każdej karty i wywoływałem funkcję z pewnym numerem, aby uzyskać kartę. To nieco zainspirowało mnie do podjęcia tego wyzwania.

Tak więc dla osób nieświadomych kart do gry, talia kart składa się z 52 kart (13 w każdym z czterech kolorów, tj. Kier, Diamentów, Pik, Maczug). W każdym kolorze jest 13 kart - najpierw karty ponumerowane od 2 do 10, następnie walet (J), królowa (Q), król (K) i as (A). To jest zamówienie

Wyzwanie

Wyzwanie polega na przyjęciu liczby całkowitej od 1 do 52 jako wartości wejściowej i wyświetleniu karty w tej pozycji. Ale twój wynik musi być w słowach. Ponadto należy zachować porządek, tzn. Pierwsze 13 kart będzie kier, następnie karo, następnie pik i wreszcie trefl.

Na przykład, jeśli ktoś wybierze numer 30. Karta należałaby wówczas do trzeciego koloru, tj. Pik. Byłaby to także czwarta karta w kolorze, co oznacza liczbę 5. Stąd wynik musi być następujący: five of spadesi zawsze powinien być zgodny z tym formatem , tj. Najpierw karta, po której następuje ofi nazwa koloru w koniec z wymaganymi odstępami pomiędzy.

Wejście i wyjście

Dane wejściowe będą liczbami całkowitymi od 1 do 52 (oba włącznie). Pamiętaj, że tutaj liczenie zaczyna się od 1. Możesz zacząć od 0 . Należy jednak zachować kolejność kart wymienionych powyżej. Twój wynik powinien być kartą w tej pozycji zapisaną słowami. Nie musisz obsługiwać nieprawidłowych danych wejściowych. Ponadto dane wyjściowe mogą być pisane małymi lub dużymi literami.

Poniżej znajduje się lista wszystkich możliwych danych wejściowych i ich wyników:

1 -> two of hearts
2 -> three of hearts
3 -> four of hearts
4 -> five of hearts
5 -> six of hearts
6 -> seven of hearts
7 -> eight of hearts
8 -> nine of hearts
9 -> ten of hearts
10 -> jack of hearts
11 -> queen of hearts
12 -> king of hearts
13 -> ace of hearts
14 -> two of diamonds
15 -> three of diamonds
16 -> four of diamonds
17 -> five of diamonds
18 -> six of diamonds
19 -> seven of diamonds
20 -> eight of diamonds
21 -> nine of diamonds
22 -> ten of diamonds
23 -> jack of diamonds
24 -> queen of diamonds
25 -> king of diamonds
26 -> ace of diamonds
27 -> two of spades
28 -> three of spades
29 -> four of spades
30 -> five of spades
31 -> six of spades
32 -> seven of spades
33 -> eight of spades
34 -> nine of spades
35 -> ten of spades
36 -> jack of spades
37 -> queen of spades
38 -> king of spades
39 -> ace of spades
40 -> two of clubs
41 -> three of clubs
42 -> four of clubs
43 -> five of clubs
44 -> six of clubs
45 -> seven of clubs
46 -> eight of clubs
47 -> nine of clubs
48 -> ten of clubs
49 -> jack of clubs
50 -> queen of clubs
51 -> king of clubs
52 -> ace of clubs

Punktacja

To jest golf golfowy , więc wygrywa najkrótszy kod.

Python 3 ,  115  90 bajtów

from unicodedata import*
lambda n:name(chr(n%13+n%13//11+[6,0,4,2][-n//13]*8+127137))[13:]

Nienazwana funkcja zwracająca ciąg znaków wielkimi literami.

Wypróbuj online!

W jaki sposób?

Znaki Unicode mają nazwy. Nazwy niektórych z nich przypominają „GRA W KARTĘ DWIE SPADY”, dlatego możemy uzyskać znaki postaci Unicode reprezentujące wymaganą kartę i usunąć 13 pierwszych znaków, aby uzyskać wynik.

Interesujące znaki Unicode znajdują się w bloku, takim jak:

            0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
U+1F0Ax     x   As  2s  3s  4s  5s  6s  7s  8s  9s  Ts  Js  x   Qs  Ks  x
U+1F0Bx     x   Ah  2h  3h  4h  5h  6h  7h  8h  9h  Th  Jh  x   Qh  Kh  x
U+1F0Cx     x   Ad  2d  3d  4d  5d  6d  7d  8d  9d  Td  Jd  x   Qd  Kd  x
U+1F0Dx     x   Ac  2c  3c  4c  5c  6c  7c  8c  9c  Tc  Jc  x   Qc  Kc  x                           

Gdzie xnie jesteśmy znakami, których szukamy (cztery w Ckolumnie to „rycerze”; trzy w Fto „żarty”; jeden w 0jest ogólny, reszta to znaki zastrzeżone).

W związku z tym możemy dodać pewną wartość do 0x1F0A1 = 127137 (As), aby znaleźć kartę, którą chcemy.

Wartość dodaną komplikują tylko trzy rzeczy:

1. Musimy zmienić kolejność kolorów (od s, h, d, c do h, d, s, c)
2. Musimy zmienić kolejność rang od (A, 2, ..., K do 2, ..., K, A)
3. Musimy unikać kolumn bez interesujących kart.

Użycie opcji z jednym indeksowaniem pozwala na zastosowanie ujemnego podziału na liczby całkowite w celu indeksowania do tablicy przesunięć wierszy w celu ponownego uporządkowania koloru za pomocą [6,0,4,2][-n//13]*8+(skutecznie [48,0,32,16][-n//13]), możemy również umieścić asy we właściwych lokalizacjach za pomocą, n%13+a następnie uniknąć rycerze w kolumnie Cz n%13//11+(skutecznie (n%13>10)+).

Perl6 / Rakudo 70 bajtów

Indeks 0

Używanie perl6 -pei bez kompresji słownika:

chr('🂱🃁🂡🃑'.ords[$_/13]+($_+1)%13*1.091).uniname.substr(13)

Po prostu wyszukuje kartę w Unicode (zaczynając od asa), prosi o nazwę i używa jej. Jest to podobna trasa (chociaż wtedy nie znałem!) Do odpowiedzi Pythona Jonathana Aitkena - tylko indeksuję ze wszystkich 4 asów, a nie 4 odsunięcia od asa pik, i mnożę przez 1,091, aby zrobić indeks zaokrąglić od wpisu rycerza w Unicode.

Zobacz wszystkie dane wyjściowe (dla wartości wejściowych od 0 do 51) https://glot.io/snippets/ez5v2gkx83

Edytowane, aby radzić sobie z Rycerzami w talii Unicode, ponieważ Unicode.

Perl6 ♥ Unicode

05AB1E , 54 bajty

0-indeksowane

“»€Å‹¡Šdesž…“#“‚•„í†ìˆÈŒšï¿Ÿ¯¥Š—¿—ÉŸÄ‹ŒÁà“#âí" of "ýsè

Wypróbuj online!

Wyjaśnienie

“»€Å‹¡Šdesž…“#                                          # push list of suits
              “‚•„í†ìˆÈŒšï¿Ÿ¯¥Š—¿—ÉŸÄ‹ŒÁà“#             # push list of ranks
                                           â            # cartesian product
                                            í           # reverse each
                                             " of "ý    # join on " of "
                                                    sè  # index into cardlist with input

Python 2 , 167 148 bajtów

n=input();print 'two three four five six seven eight nine ten jack queen king ace'.split()[n%13]+' of '+['hearts','diamonds','spades','clubs'][n/13]

Zero indeksowane.

Wypróbuj online!

EDYCJA: Bubbler bardzo się przydał, stosując metodę podziału (i udzielając krótszej odpowiedzi). W drugim bloku użycie split () daje taką samą liczbę bajtów.

R , 154 bajtów

paste(el(strsplit("Two,Three,Four,Five,Six,Seven,Eight,Nine,Ten,Jack,Queen,King,Ace",",")),"of",rep(c("Hearts","Diamonds","Spades","Clubs"),e=13))[scan()]

Wypróbuj online!

Pobiera dane wejściowe (1 indeksowane) ze STDIN i za pomocą source(...,echo=T)wypisze wynik na konsolę.

To nie jest ładne, ALE jest o 2 bajty krótsze niż najlepsze rozwiązanie, jakie mogłem zastosować outer(przedstawione poniżej), więc niech to będzie przypomnienie, aby przeanalizować inne podejście!

paste(                          # concatenate together, separating by spaces,
                                # and recycling each arg to match the length of the longest
el(strsplit("Two,...",",")),    # split on commas and take the first element
"of",                           # 
 rep(c("Hearts",...),           # replicate the suits (shorter as a vector than using strsplit
               e=13)            # each 13 times
                    )[scan()]   # and take the input'th index.

R , 156 bajtów

outer(el(strsplit("Two,Three,Four,Five,Six,Seven,Eight,Nine,Ten,Jack,Queen,King,Ace",",")),c("Hearts","Diamonds","Spades","Clubs"),paste,sep=" of ")[scan()]

Wypróbuj online!

Zasadniczo takie same jak powyżej; Jednak outerzrobi recykling właściwie, ale trzeba ustawić sep=" of "na to, pasteże to tylko włosy dłużej.

Emojicode , 202 bajty

🍇i🚂😀🍪🍺🐽🔫🔤two.three.four.five.six.seven.eight.nine.ten.jack.queen.king.ace🔤🔤.🔤🚮i 13🔤 of 🔤🍺🐽🔫🔤hearts.diamonds.spades.clubs🔤🔤.🔤➗i 13🍪🍉

0 zindeksowanych. Wypróbuj online!

Objaśnienie :

🍇		start of the closure block
  i🚂		 closure takes an integer argument i
  😀		 print:
    🍪		  concatenate these strings:
      🍺🐽🔫🔤...🔤🔤.🔤🚮i 13  [a]
      🔤 of 🔤
      🍺🐽🔫🔤...🔤🔤.🔤➗i 13  [b]
    🍪
🍉

[a]:
🍺		tell Emojicode to dereference without checking
🐽		 get the nth element of the following array
  🔫		  create an array using the following string and separator
    🔤...🔤
    🔤.🔤
  🚮 i 13	n, i mod 13

[b]
🍺🐽🔫🔤...🔤🔤.🔤➗i 13
same but with ⌊i÷13⌋

Excel, 156 bajtów

=TRIM(MID("two  threefour five six  seveneightnine ten  jack queenking ace",1+MOD(A1,13)*5,5))&" of "&CHOOSE(1+(A1/13),"hearts","diamonds","spades","clubs")

Karty od 0-51. Niestety, Excel nie ma funkcji do konwersji 1na "one"...

Używanie TRIMi MIDjest krótsze niż używanie CHOOSEdla wartości nominalnych, ale dłuższe niż używanie CHOOSEdla koloru.

Java 8, 141 bajtów

n->"two;three;four;five;six;seven;eight;nine;ten;jack;queen;king;ace".split(";")[n%13]+" of "+"hearts;diamonds;spades;clubs".split(";")[n/13]

Wejście jest indeksowane na 0.

Wyjaśnienie:

Wypróbuj online.

n->         // Method with integer parameter and String return-type
  "two;three;four;five;six;seven;eight;nine;ten;jack;queen;king;ace".split(";")[n%13]
            //  Take `n` modulo-13 as 0-indexed card value
   +" of "  //  append " of "
   +"hearts;diamonds;spades;clubs".split(";")[n/13]
            //  append `n` integer-divided by 13 as 0-indexed suit

Kotlin , 154 152 140 bajtów

i->"two,three,four,five,six,seven,eight,nine,ten,jack,queen,king,ace".split(',')[i%13]+" of ${"heart,diamond,spade,club".split(',')[i/13]}s"

Wypróbuj online!

Zaktualizowano, aby używał tylko wyrażenia lambda.

JavaScript ES6, 124 118 bajtów, 0-indeks

F= x=>(h=btoa`O
?NÞ{ñhº¿Å÷¿J,IëÞñ"6)Þý7§üô.yéÿ*)àüÿÿÿæ«·÷bjj'wû)i׿r[`.split`/`)[x%13]+` of ${h[x/13|16]}s`

console.log (F(51))

Wersja Base64

eD0+KGg9YnRvYWBPCj9OGt578Wi6v8WK979KLH9J696f8SKCG382Kd79N6f8lpyT9C556f8qKeD8Bx7///+F5qu392Jqaid3+ylp179yW5tgLnNwbGl0YC9gKVt4JTEzXStgIG9mICR7aFt4LzEzfDE2XX1zYA==

Stax , 58 57 56 bajtów

î↑à■?R╢8«E▄¡╔ÿ•L╫<<⌠ï∞∟⌡♪Ös1"TàLα╥▀¢¡◄└%≈δñM;;}'░o=⌡»╬í√

Uruchom i debuguj

Oto skomentowana niegolfowana reprezentacja tego samego programu. Używa mocno skompresowanych literałów Stax. Dane wejściowe mają indeks 0. To algorytm 05AB1E Emigny.

`SsUI'S~pTU5T@T^Ez+`j   suits
`fV:l7eTkQtL*L2!CZb6u[&YNO4>cNHn;9(`j   ranks
|*  cross-product
@   index with input
r   reverse pair
`%+(`*  join with " of "

Uruchom ten

Bash, 133 bajty

V=(two three four five six seven eight nine ten jack queen king ace hearts diamonds spades clubs)
echo ${V[$1%13]} of ${V[$1/13+13]}

Wybór użycia 0 w oparciu o podaną opcję, wspieranie 0 (dwóch kier) do 51 (asa trefl)

Łuska , 52 bajty

;↔!Πmw¶¨×‼sÿẋδẎ₆ṡ⁷Ḃ6‰fωθ»&⌈θƒV₆x⁵▼Ëġ`nıEṅ'jĊk⁸"eïkÄc

Wypróbuj online!

Zawsze chętnie pokazuję system kompresji struny Husk: D

Wyjaśnienie

Większość programu (od ¨początku) jest oczywiście skompresowanym łańcuchem. Po rozpakowaniu zmienia się w:

hearts diamonds spades clubs
of
two three four five six seven eight nine ten jack queen king ace

Program to:

;↔!Πmw¶¨…
       ¨…    The previous string
      ¶      Split on lines
    mw       Split each line into words
             - we now have a list of lists of words
   Π         Cartesian product of the three lists
             - with this we obtain all possible combinations of suits and values
               with "of" between the two (e.g. ["spades","of","king"])
  !          Pick the combination at the index corresponding to the input
 ↔           Reverse it, so words are in the correct order
;            Wrap it in a list. Result: [["king","of","spades"]]

Pozostało jeszcze kilka rzeczy do wyjaśnienia:

• Karty budujemy z kolorami przed wartościami ze względu na działanie produktu kartezjańskiego Π: jeśli zrobilibyśmy to na odwrót, lista kart byłaby uporządkowana według wartości (tj. Dwa serca, dwa karo, dwa pik, dwa trefl, trzy serca ...). W konsekwencji musimy odwrócić nasz wynik.

• Wynikiem programu jest dwuwymiarowa macierz ciągów znaków. Jest to automatycznie drukowane przez Husk jako pojedynczy ciąg zbudowany przez połączenie rzędów matrycy ze znakami nowej linii i komórek ze spacjami. Powodem, dla którego budujemy tę matrycę zamiast korzystania z prostszych metod w(łączenie listy słów ze spacjami) jest to, że użycie winferencji typu domyślnie zgaduje inną interpretację programu, co daje inny wynik.

mIRCScript , 157 bajtów

c echo $token(ace two three four five six seven eight nine ten jack queen king,$calc(1+$1% 13),32) of $token(clubs spades diamonds hearts,$calc(-$1// 13),32)

Obciążenie jako alias, a następnie użyć: /c N. mIRC ma indeks 1, więc podział podłogi (//) na ujemną wartość wejściową daje -1 do -4 zgodnie z wymaganiami.

C (gcc) , 148 bajtów

f(n){printf("%.5s of %.7ss","two\0 threefour\0five\0six\0 seveneightnine\0ten\0 jack\0queenking\0ace"+n%13*5,"heart\0 diamondspade\0 club"+n/13*7);}

Wypróbuj online!

W oparciu o 0.

Haskell , 132 bajty

(!!)[v++" of "++s|s<-words"hearts diamonds spades clubs",v<-words"two three four five six seven eight nine ten jack queen king ace"]

Wypróbuj online!

Anonimowa funkcja, wykorzystująca rozumienie listy do zbudowania wszystkich kombinacji koloru i wartości oraz indeksująca do wynikowej listy za pomocą danych wejściowych.

F # 174 168 bajtów

Usunięto dodatkowe białe znaki, jak zauważył Manish Kundu. Dzięki!

let c x=["two";"three";"four";"five";"six";"seven";"eight";"nine";"ten";"jack";"queen";"king";"ace"].[(x-1)%13]+" of "+["hearts";"diamonds";"spades";"clubs"].[(x-1)/13]

Wypróbuj online!

Będę szczery - jestem nowy w golfie kodu, więc nie wiem, czy lepiej jest odpowiedzieć za pomocą czystej funkcji takiej jak ta (z parametrami, ale bez we / wy) lub z działającym blokiem kodu z użytkownikiem I / O.

Oktawa , 155 153 151 150 bajtów

@(x)[strsplit(' of ,s,heart,diamond,spade,club,ace,two,three,four,five,six,seven,eight,nine,ten,jack,queen,king',','){[mod(x,13)+7,1,ceil(2+x/13),2]}]

Wypróbuj online!

To tworzy ciąg rozpoczynający się ' of 'i 's', wtedy wszystkie garnitury przestrzegane przez wszystkich szeregach. Ciąg ten jest dzielony przecinkami na osobne ciągi. Kolorami są przed szeregami, ponieważ to oszczędza bajt podczas tworzenia indeksów. Następnie indeksujemy go za pomocą nawiasów kwadratowych o następujących indeksach:

{[mod(x,13)+7,1,ceil(2+x/13),2]}

czyli ranga, pierwszy element ' of ', następnie kolor, a następnie's' .

Mając 's'jako część garnitury (hearts,diamonds,spades,clubs ) zamiast osobnego łańcucha to dokładnie ta sama długość, ale mniej radości.

Podział na domyślny separator pozwoliłby zaoszczędzić 4 bajty w strsplitwywołaniu -c, ale spacje wokół ' of 'zostałyby usunięte i trzeba by je dodać ręcznie, co kosztuje więcej bajtów.

V , 154 147 144 142 bajtów

-7 bajtów dzięki DJMcMayhem

13i1heart
2diamond
3spade
4club
ÚGxCtwo
three
four
five
six
seven
eight
nine
ten
jack
queen
king
aceH$A of 012j$d4ñ13jPñÍ «/ 
{ÀjYHVGpAs

Wypróbuj online!

Hexdump:

00000000: 3133 6931 6865 6172 740a 3264 6961 6d6f  13i1heart.2diamo
00000010: 6e64 0a33 7370 6164 650a 3463 6c75 620a  nd.3spade.4club.
00000020: 1bda 1647 7843 7477 6f0a 7468 7265 650a  ...GxCtwo.three.
00000030: 666f 7572 0a66 6976 650a 7369 780a 7365  four.five.six.se
00000040: 7665 6e0a 6569 6768 740a 6e69 6e65 0a74  ven.eight.nine.t
00000050: 656e 0a6a 6163 6b0a 7175 6565 6e0a 6b69  en.jack.queen.ki
00000060: 6e67 0a61 6365 1b16 4824 4120 6f66 201b  ng.ace..H$A of .
00000070: 3016 3132 6a24 6434 f131 336a 50f1 cd20  0.12j$d4.13jP.. 
00000080: ab2f 200a 7bc0 6a59 4856 4770 4173       ./ .{.jYHVGpAs

C # , 219 207 202 197 bajtów (0 indeksowanych)

static string O(int i){string[]s={"two","three","four","five","six","seven","eight","nine","ten","jack","queen","king","ace","hearts","diamonds","spades","clubs"};return s[i%13]+" of "+s[i/14+13];}

dzięki wkładowi @Ciaran_McCarthy i @raznagul

Pobiera dane wejściowe z int I, odejmuje 1, aby dopasować 0 indeksowania tablicy ciągów i wypisuje liczbę na podstawie I mod 13 oraz koloru na podstawie i / 14 + 13.

działa całkiem dobrze na moim drugim kodzie golfowym, tylko zastanawiam się, czy mogę go skrócić za pomocą LINQ lub czegoś innego.

PowerShell , 207 192 182 174 165 163 163 157 157 bajtów

Indeksowane 0

$args|%{(-split'two three four five six seven eight nine ten jack queen king ace')[$_%13]+' of '+('hearts','diamonds','spades','clubs')[$_/13-replace'\..*']}

Wypróbuj online!

4 bajty zapisane dzięki AdmBorkBork w komentarzach

CJam , 114 bajtów

riDmd"two three four five six seven eight nine ten jack queen king ace"S/=" of "@"hearts diamonds spades clubs"S/=

Wypróbuj online!

Zero indeksowane. Prawdopodobnie zostaną pokonane przez języki z kompresją słownikową, ale no cóż ...

Galaretka , 61 bajtów

d13Uị"“¢¶/CŻ)Gụ+Ḷ}ċ<ʂḤaỴ£k7Ỵ€^ḥæ]¿9Ụ“¡¢|hḂṗƬßĖ,$ðĿȧ»Ḳ€¤j“ of 

Indeksowanie 0. Wypróbuj online!

Julia 0.6 , 156 bajtów

f(n)=print(split(" of ,hearts,diamonds,spades,clubs,two,three,four,five,six,seven,eight,nine,ten,jack,queen,king,ace",',')[[(n-1)%13+6,1,div(n-1,13)+2]]...)

Wypróbuj online!

-2 bajty dzięki @Stewie Griffin

Haskell , 144 bajty

f n=words"two three four five six seven eight nine ten jack queen king ace"!!(n`mod`13)++" of "++words"hearts diamonds spades clubs"!!(n`div`13)

Wypróbuj online!

Uderza to we wszystkie punkty bólu Haskella.

SOGL V0.12 , 53 bajty

ķζ≡◄Τū┌p9P7šH□≡⅝'╗ΦqΖ▒ƨM.‘θ.wo"C█}y1+►ΚqΚ‘θJ¼ o.'⁰/wp

Wypróbuj tutaj!

Javascript 149 143 140 bajtów

a=_=>"two three four five six seven eight nine ten jack queen king ace".split` `[_%13]+' of '+["hearts","diamonds","spades","clubs"][_/13|0]

-3 bity dzięki @rick hitchcock

a=_=>"two three four five six seven eight nine ten jack queen king ace".split` `[_%13]+' of '+["hearts","diamonds","spades","clubs"][_/13|0]
console.log(a(14))
console.log(a(34))
console.log(a(51))
console.log(a(8))
console.log(a(24))

Perl 5 -p , 119 bajtów

W oparciu o 0

$_=(TWO,THREE,FOUR,FIVE,SIX,SEVEN,EIGHT,NINE,TEN,JACK,QUEEN,KING,ACE)[$_%13].' OF '.(HEART,DIAMOND,SPADE,CLUB)[$_/13].S

Wypróbuj online!

Japt , 91 86 bajtów

0-indeksowane.

Użyłem narzędzia napisanego przez @Shaggy do wygenerowania skompresowanych list.

`{`twodÈ(‚fÆfivÀ£xç P ightdÍÂdȈjackdquÁÈkˆg»­`qd gU}  {`Ê#tsk¹aÚˆäi£kclubs`qk gUzD

Wypróbuj online!

Wyjaśnienie:

Pierwszy skompresowany ciąg zawiera wartości kart ograniczone przez d. Drugi skompresowany ciąg zawiera szeregi kart ograniczone przez k.

Te znaki zostały wybrane przy użyciu narzędzia Shaggy, który generuje ciąg rozdzielany znakiem, który jest optymalnie skompresowany przy użyciu shoco (kompresja, której używa Japt). To pozwala nam stworzyć listę wartości kart i rang.

Używamy wstecznych `znaków do dekompresji tych ciągów, a następnie dzielimy ciąg za pomocą q, a następnie znak char, aby podzielić.

Kiedy mamy listy, mapujemy wartości kart, a następnie otrzymujemy indeks danych wejściowych. Należy zauważyć, że Japt zawija swoje indeksy, więc nie musimy modulo o 13.

Przy każdym elemencie przeglądamy szeregi kart. Otrzymujemy indeks dzieląc dane wejściowe przez 13.

Kiedy już mamy oba przedmioty, łączymy je " of ", co daje końcowy ciąg.

Galaretka , 58 55 bajtów

“ıĿ⁽⁷lg3e/“ẏ“£Ṣ¢÷yḊ⁾⁶ƭ⁼ẎẇḄṡ¿Onṃ⁶ḂḂfṠȮ⁻ẉÑ%»Ḳ€p/⁸ịṚj“ of 

Wypróbuj online!