Это кодовая версия аналогичного вопроса, который я задал в стеке ранее, но подумал, что это будет интересная головоломка.

Получив строку длиной 10, которая представляет собой базовое число 36, увеличьте его на единицу и верните полученную строку.

Это означает, что строки будут содержать только цифры от 0до 9и буквы от aдо z.

База 36 работает следующим образом:

Правая цифра увеличивается, первый с помощью 0к9

0000000000> 9 итераций> 0000000009

и после этого aTo zиспользуется:

000000000a> 25 итераций> 000000000z

Если zнеобходимо увеличить, он возвращается к нулю, а цифра слева увеличивается:

000000010

Дальнейшие правила:

• Вы можете использовать заглавные или строчные буквы.
• Вы не можете опускать ведущие нули. И вход, и выход являются строками длиной 10.
• Вам не нужно обрабатывать в zzzzzzzzzzкачестве ввода.

Тестовые случаи:

"0000000000" -> "0000000001"
"0000000009" -> "000000000a"
"000000000z" -> "0000000010"
"123456zzzz" -> "1234570000"
"00codegolf" -> "00codegolg"

05AB1E , 10 байтов

Ввод в верхнем регистре .

Код

1ì36ö>36B¦

объяснение

1ì           # Prepend a 1 to the number
  36ö        # Convert from base 36 to decimal
     >       # Increment by 1
      36B    # Convert from decimal to base 36
         ¦   # Remove the first character

Использует кодировку 05AB1E . Попробуйте онлайн! или Проверьте все контрольные примеры .

Japt , 13 байт

n36 Ä s36 ù0A

Попробуйте онлайн! и проверить контрольные примеры

Принимает ввод в виде строки

объяснение

n36            converts input to base 36
    Ä           +1
      s36       to base 36 string
          ù0A   left-pad with 0 to length 10

JavaScript (ES6), 45 байт

Сохранено 4 байта благодаря @OOBalance

s=>(parseInt(1+s,36)+1).toString(36).slice(1)

Попробуйте онлайн!

Haskell , 58 байт

d=['0'..'9']
f s=snd(span(<s)$mapM(\_->d++['a'..'z'])d)!!1

Попробуйте онлайн!

Очень грубая стратегия: сгенерируйте все строки base-36 длины-10 по порядку и найдите ту, которая идет после ввода в списке. Потратьте огромное количество времени на строки далеко от начала списка.

Haskell , 60 байт

q '9'='a'
q c=succ c
f(h:t)|any(<'z')t=h:f t|r<-'0'<$t=q h:r

Попробуйте онлайн!

Читает строку слева направо, пока не достигнет символа, за которым следует суффикс всех z, который может быть пустым. Увеличивает этот символ и заменяет z на 0.

Stax , 7 байт

ûæ≥╡►N▀

Запустите и отладьте его

Объяснение:

|3^|3A|z Full program, implicit input
|3       Convert from base 36
  ^      Increment
   |3    Convert to base 36
     A|z Fill with "0" to length 10
         Implicit output

C (gcc) , 50 48 байтов

Явный флаг переноса не был необходим после реструктуризации цикла до конца, как только перенос не произошел. Настройка 9-> A выполняется во время проверки петли.

Благодарю потолочный кот за предложение.

f(char*s){for(s+=9;(*s+=*s-57?1:8)>90;*s--=48);}

Попробуйте онлайн!

Оригинальная версия: 71 57 байт

Эта версия использует флаг переноса для распространения обновлений: я установил для него значение truey, чтобы начать приращение. Строка изменяется на месте и принимает только 0-9, AZ. Сложной задачей было убедиться, что 9-> A правильно обрабатывается на переносах.

Изменить: я изменил указатель ввода в качестве флага переноса.

f(s){for(char*t=s+9;s;)*t--+=(s=++*t>90)?-43:7*!(*t-58);}

Попробуйте онлайн!

C 82 81 53 50 байтов

f(char*s){for(s+=10;*--s>89;)*s=48;*s+=*s-57?1:8;}

Непосредственно изменяет входную строку; ввод и вывод в верхнем регистре. Попробуйте это онлайн здесь . Спасибо Арно за игру в гольф 24 байта, а допуск к игре в гольф - еще 3 байта.

Ungolfed:

f(char *s) { // function taking a string argument
     for(s += 10; *--s > 89; ) // skip to the least significant digit, and step through the string until you hit something other than a 'Z' (90 is the ASCII code for 'Z') ...
         *s = 48; // ... replacing each digit with a zero (48 is the ASCII code for '0')
         *s += // the next digit has to be incremented:
         *s - 57 // if it's not a '9' (ASCII code 57) ...
         ? 1 // ... that is straightforward ...
         : 8; // ... otherwise it has to be replaced with an 'A' (ASCII code 65 = 57 + 8)
 }

Симулятор машины Тьюринга онлайн , 745 байт

init:0
accept:2
0,0
0,0,>
0,1
0,1,>
0,2
0,2,>
0,3
0,3,>
0,4
0,4,>
0,5
0,5,>
0,6
0,6,>
0,7
0,7,>
0,8
0,8,>
0,9
0,9,>
0,a
0,a,>
0,b
0,b,>
0,c
0,c,>
0,d
0,d,>
0,e
0,e,>
0,f
0,f,>
0,g
0,g,>
0,h
0,h,>
0,i
0,i,>
0,j
0,j,>
0,k
0,k,>
0,l
0,l,>
0,m
0,m,>
0,n
0,n,>
0,o
0,o,>
0,p
0,p,>
0,q
0,q,>
0,r
0,r,>
0,s
0,s,>
0,t
0,t,>
0,u
0,u,>
0,v
0,v,>
0,w
0,w,>
0,x
0,x,>
0,y
0,y,>
0,z
0,z,>
0,_
1,_,<
1,0
2,1,-
1,1
2,2,-
1,2
2,3,-
1,3
2,4,-
1,4
2,5,-
1,5
2,6,-
1,6
2,7,-
1,7
2,8,-
1,8
2,9,-
1,9
2,a,-
1,a
2,b,-
1,b
2,c,-
1,c
2,d,-
1,d
2,e,-
1,e
2,f,-
1,f
2,g,-
1,g
2,h,-
1,h
2,i,-
1,i
2,j,-
1,j
2,k,-
1,k
2,l,-
1,l
2,m,-
1,m
2,n,-
1,n
2,o,-
1,o
2,p,-
1,p
2,q,-
1,q
2,r,-
1,r
2,s,-
1,s
2,t,-
1,t
2,u,-
1,u
2,v,-
1,v
2,w,-
1,w
2,x,-
1,x
2,y,-
1,y
2,z,-
1,z
1,0,<

Онлайн переводчик

Perl 6 , 34 32 30 байт

Благодаря nwellnhof за -2 байта благодаря использованию oоператора для объединения функций

{S/.//}o{base :36(1~$_)+1: 36}

Попробуйте онлайн!

Функция, которая преобразует аргумент в базу 36, добавляет 1, конвертирует обратно и затем форматирует его. Теперь использует ту же тактику, что и ответ Аднана, чтобы сохранить ведущие нули.

MATL , 12 байт

36ZAQ5M10&YA

Попробуйте онлайн!

           % Implicit input
36ZA       % convert from base 36 to decimal
Q          % increment by 1
5M         % bring the 36 back on stack (done this way to avoid needing space separator after this)
10         % = minimum length of output string
&YA        % convert back to base 36 with those arguments
           % Implicit output

Haskell , 63 байта

r.f.r
f('9':r)='a':r
f('z':r)='0':f r
f(c:r)=succ c:r
r=reverse

Попробуйте онлайн! Переворачивает строку и проверяет первый символ:

• А 9заменяется на a.
• A zзаменяется на A 0и рекурсивно проверяется следующий символ.
• Все остальные символы увеличиваются с помощью succфункции-преемника, которая может использоваться в Chars, потому что они являются экземпляром класса Enum .

Наконец, полученная строка снова переворачивается.

6502 (NMOS *) машинный код подпрограмма , 26 байтов

A0 09 F3 FB B1 FB C9 5B 90 07 A9 30 91 FB 88 10 F1 C9 3A D0 04 A9 41 91 FB 60

*) использует «нелегальный» код операции ISB / 0xF3, работает на всех оригинальных чипах NMOS 6502, а не на более поздних вариантах CMOS.

Ожидается указатель на 10-символьную строку в $fb /$fc которая, как ожидается, будет числом base-36. Увеличивает это число на месте.

Не делает ничего толкового при неправильном вводе (например, более короткая строка) - обрабатывает ZZZZZZZZZZ "правильно" случайно;)

Прокомментировал разборку

; function to increment base 36 number as 10 character string
;
; input:
;   $fb/$fc: address of string to increment
; clobbers:
;   A, Y
 .inc36:
A0 09       LDY #$09            ; start at last character
 .loop:
F3 FB       ISB ($FB),Y         ; increment character ("illegal" opcode)
B1 FB       LDA ($FB),Y         ; load incremented character
C9 5B       CMP #$5B            ; > 'z' ?
90 07       BCC .checkgap       ; no, check for gap between numbers and letters
A9 30       LDA #$30            ; load '0'
91 FB       STA ($FB),Y         ; and store in string
88          DEY                 ; previous position
10 F1       BPL .loop           ; and loop
 .checkgap:
C9 3A       CMP #$3A            ; == '9' + 1 ?
D0 04       BNE .done           ; done if not
A9 41       LDA #$41            ; load 'a'
91 FB       STA ($FB),Y         ; and store in string
 .done:
60          RTS

Пример ассемблерной программы C64 с использованием подпрограммы:

Онлайн демо

Код в синтаксисе ca65 :

.import inc36   ; link with routine above

.segment "BHDR" ; BASIC header
                .word   $0801           ; load address
                .word   $080b           ; pointer next BASIC line
                .word   2018            ; line number
                .byte   $9e             ; BASIC token "SYS"
                .byte   "2061",$0,$0,$0 ; 2061 ($080d) and terminating 0 bytes

.bss
b36str:         .res    11

.data
prompt:         .byte   "> ", $0

.code
                lda     #<prompt        ; display prompt
                ldy     #>prompt
                jsr     $ab1e

                lda     #<b36str        ; read string into buffer
                ldy     #>b36str
                ldx     #$b
                jsr     readline

                lda     #<b36str        ; address of array to $fb/fc
                sta     $fb
                lda     #>b36str
                sta     $fc
                jsr     inc36           ; call incrementing function

                lda     #<b36str        ; output result
                ldy     #>b36str
                jmp     $ab1e

; read a line of input from keyboard, terminate it with 0
; expects pointer to input buffer in A/Y, buffer length in X
.proc readline
                dex
                stx     $fb
                sta     $fc
                sty     $fd
                ldy     #$0
                sty     $cc             ; enable cursor blinking
                sty     $fe             ; temporary for loop variable
getkey:         jsr     $f142           ; get character from keyboard
                beq     getkey
                sta     $2              ; save to temporary
                and     #$7f
                cmp     #$20            ; check for control character
                bcs     checkout        ; no -> check buffer size
                cmp     #$d             ; was it enter/return?
                beq     prepout         ; -> normal flow
                cmp     #$14            ; was it backspace/delete?
                bne     getkey          ; if not, get next char
                lda     $fe             ; check current index
                beq     getkey          ; zero -> backspace not possible
                bne     prepout         ; skip checking buffer size for bs
checkout:       lda     $fe             ; buffer index
                cmp     $fb             ; check against buffer size
                beq     getkey          ; if it would overflow, loop again
prepout:        sei                     ; no interrupts
                ldy     $d3             ; get current screen column
                lda     ($d1),y         ; and clear 
                and     #$7f            ;   cursor in
                sta     ($d1),y         ;   current row
output:         lda     $2              ; load character
                jsr     $e716           ;   and output
                ldx     $cf             ; check cursor phase
                beq     store           ; invisible -> to store
                ldy     $d3             ; get current screen column
                lda     ($d1),y         ; and show
                ora     #$80            ;   cursor in
                sta     ($d1),y         ;   current row
                lda     $2              ; load character
store:          cli                     ; enable interrupts
                cmp     #$14            ; was it backspace/delete?
                beq     backspace       ; to backspace handling code
                cmp     #$d             ; was it enter/return?
                beq     done            ; then we're done.
                ldy     $fe             ; load buffer index
                sta     ($fc),y         ; store character in buffer
                iny                     ; advance buffer index
                sty     $fe
                bne     getkey          ; not zero -> ok
done:           lda     #$0             ; terminate string in buffer with zero
                ldy     $fe             ; get buffer index
                sta     ($fc),y         ; store terminator in buffer
                sei                     ; no interrupts
                ldy     $d3             ; get current screen column
                lda     ($d1),y         ; and clear 
                and     #$7f            ;   cursor in
                sta     ($d1),y         ;   current row
                inc     $cc             ; disable cursor blinking
                cli                     ; enable interrupts
                rts                     ; return
backspace:      dec     $fe             ; decrement buffer index
                bcs     getkey          ; and get next key
.endproc

Сетчатка 0.8.2 , 12 байт

T`zo`dl`.z*$

Попробуйте онлайн! Объяснение: dlЧасть места назначения замещения расширяется до0-9a-z пока oкопируется в источник, в результате чего z0-9a-z(хотя второе zигнорируется, поскольку оно никогда не может совпадать). Это увеличивает соответствующие цифры. .z*$Часть шаблона совпадает с последним не- zцифры плюс все хвостовое zс, таким образом , обработке переноса от их приращения к 0.

Рубин , 40 байт

->s{(s.to_i(36)+1).to_s(36).rjust 10,?0}

Попробуйте онлайн!

1. Преобразовать строку в целое число, интерпретируя ее как основание 36
2. Добавить 1
3. Конвертировать обратно в базу 36 строк
4. Левая панель с 0с

"zzzzzzzzzz" возвращает строку длиной 11

брейкфук , 109 байт

,[>>,]<+[++++<[<--->>-<-]-[<->>+<---]<[[-]>-------<]+>>[[+<+>]<<+[>+<------]>>]-[<+>-----]<++++<]<[<<]>>[.>>]

Попробуйте онлайн!

Apl (Dyalog Unicode) , 30 28 24 байта

Спасибо ngn за подсказку, чтобы сохранить несколько байтов.

(f⍣¯1)1+f←36⊥1,(⎕D,⎕A)⍳⊢

Попробуйте онлайн!

• Требуется ⎕IO 0

• Использует верхний регистр

PHP, 69 64 байта

хромая версия :

printf("%010s",base_convert(1+base_convert($argn,36,10),10,36));

Беги как труба с -R. Вход нечувствителен к регистру, вывод строчные.

первый подход, 69 байт:

<?=str_pad(base_convert(1+base_convert($argn,36,10),10,36),10,'0',0);

Беги как труба с -F

зацикливающаяся версия, также 69 байтов :

for($n=$argn;~$c=$n[$i-=1];)$f||$f=$n[$i]=$c!=9?$c>Y?0:++$c:A;echo$n;

• Только для PHP 7.1: старый PHP не распознает отрицательные строковые индексы,
  младший PHP выдаст предупреждения для неопределенных констант.
• требует ввода заглавных букв. Замените Yи Aстрочными буквами для ввода строчных букв.

Беги как труба с -nR

... или попробуйте их онлайн .

Python 2 , 88 байт

def f(s):L,R=s[:-1],s[-1:];return s and[[L+chr(ord(R)+1),f(L)+'0'][R>'y'],L+'a'][R=='9']

Попробуйте онлайн!

Увеличивает строку «вручную».

Уголь , 14 байтов

×0⁹←⮌⍘⊕⍘Ｓ³⁶¦³⁶

Попробуйте онлайн!Ссылка на подробную версию кода. Объяснение:

×0⁹

Печать 9 0с. Это служит для дополнения результата.

←⮌⍘⊕⍘Ｓ³⁶¦³⁶

Преобразуйте входные данные из базы 36, увеличьте их, затем преобразуйте обратно в базу 36. Затем измените результат на обратный и напечатайте его влево.

Java 8, 90 76 56 байт

s->Long.toString(Long.valueOf(1+s,36)+1,36).substring(1)

Принимает как прописные, так и строчные буквы для ввода. Выход всегда в нижнем регистре.

Спасибо Okx за игру в гольф 18 байтов.

Попробуйте это онлайн здесь .

Ungolfed:

s -> // lambda taking a String argument and returning a String
    Long.toString(Long.valueOf(1+s,36)+1,36) // prefix input with '1' to ensure leading zeros, convert to Long using base 36, increment, then convert back to String in base 36
    .substring(1) // remove the leading '1'

JavaScript (ES6), 89 байт

Этот не настолько эффективен в байтах, как другая запись JavaScript , но я сделал это, не замечая этого правила:

Дана строка длиной 10

Так что это не серьезная запись - просто для удовольствия! Он работает со строками общей длины, например 0abc, и добавляет, 1когда первая цифра равна z, например zzz-> 1000. Ввод должен быть в нижнем регистре.

s=>(l=s[s.length-1],r=s.slice(0,-1),l=='z'?f(r||'0')+0:r+(parseInt(l,36)+1).toString(36))

объяснение

Выражение (A, B, C)фактически означает «делай A, потом делай B, потом возвращай C», что я использую для объявления некоторых переменных, которые я снова использую в коде. sозначает «строка», lозначает «последний», rозначает «отдых».

/*1*/ s=>(
/*2*/   l=s[s.length-1],
/*3*/   r=s.slice(0,-1),
/*4*/   l=='z'
/*5*/     ? f(r||'0')+0
/*6*/     : r+(parseInt(l,36)+1).toString(36))

Это рекурсивная функция. Для типичной строки, такой как aza, она будет просто увеличивать последний символ (см. Строку 6) - azb. Но для строки, которая заканчивается z, например h0gz, она будет работать сама на всем, вплоть до последнего символа ( z), и заменять ее 0вместо (см. Строку 5) - f(h0gz)= f(h0g) + 0= h0h0.

В ||'0'строке 5 указано, что функция работает при вызове строки длиной 1 (то есть строка 'z'). Без него f('')вызывается (так как 'z'.slice(0, -1)есть ''), который имеет неопределенное поведение (буквально - попробуйте сами), и это бесполезно. Ожидаемый результат f('z')- то '10', что мы получаем f('0') + 0, поэтому мы используем ||'0'. ( ||'0'особенно полезно, потому что это не мешает обычному случаю - rбыть по крайней мере 1-длины (s мешает по крайней мере 2 длины) - потому что строки являются ложными, только когда они имеют длину 0).

Метод увеличения строки такой же, как и в другой записи JS: преобразовать «число» base-36 в фактическое число, добавить 1, а затем преобразовать его обратно в base-36. Нам не нужно беспокоиться о 1приращении 'z' ( 'z'->'10' ), поскольку на самом деле мы никогда не увеличиваем z (см. Строки 4 и 6: последний символ увеличивается только в том случае, если он не равен z).

Кроме того, мы никогда не рискуем отбросить ведущие нули, потому что на самом деле мы никогда не манипулируем более чем одним символом за раз - только последним символом в строке. Остальные символы аккуратно обрезаются, когда вы разрезаете любую строку и добавляете после слова.

Чисто , 89 84 байта

import StdEnv
@['9':t]=['a':t]
@['z':t]=['0': @t]
@[c:t]=[inc c:t]
r=reverse

r o@o r

Попробуйте онлайн!

Более короткое решение благодаря Laikoni .

Чисто , 115 байт

Мне нравится, когда я использую limit(iterate...

import StdEnv
@'9'='a'
@c=inc c
?[h,'{':t]=[@h,'0': ?t]
?[h:t]=[h: ?t]
?e=e
$l=limit(iterate?(init l++[@(last l)]))

Попробуйте онлайн!

Создает ответ без преобразования баз с использованием сопоставления списков.

• ? :: [Char] -> [Char] выполняет перенос вперед.
• @ :: Char -> Charувеличивается на единицу, учитывая разрыв между '9'и 'z'.
• $ :: [Char] -> [Char]увеличивает последний символ и применяется ?до тех пор, пока значение не стабилизируется.

R , 152 123 байт

function(x)f(utf8ToInt(x),10)
f=function(x,n,y=x[n]){x[n]=y+(y==57)*39+(y==122)*(-75)+1
"if"(y==122,f(x,n-1),intToUtf8(x))}

Попробуйте онлайн!

Совершенно другой подход. Получите кодовые точки ASCII и рекурсивно «увеличивайте» крайнюю правую кодовую точку (заставляя 0(57) переходить к a(97) и z(122) возвращаться к 0(48)), пока не закончится zs. Конвертировать обратно в строку.

Старая версия

function(s,w=gsub("(z)(?=\\1*$)","0",s,,T),x=regexpr(".0*$",w)[1],y=substr(w,x,x),z=chartr("0-9a-z","1-9a-z0",y))sub(p(y,"(0*$)"),p(z,"\\1"),w)
p=paste0

Попробуйте онлайн!

Это все текстовые манипуляции, которые не идут рука об руку с игрой в R код.

Заменить все zв конце строки на 0. Найти местоположение последнего элемента перед вновь отчеканенным трейлингом0 s. Найти следующую базовую 36 цифру. Внести изменения. Будьте рады, что едва ли победили онлайн-симулятор машин Тьюринга.

Звездный , 325 байт

     + , , , , , , , , , ,     +      +   +   +`* +          + +* + +**      + * +* * '    +           + +* +* +* +*      +* `     +  + +                + +  *       +* *  '    +      +*           + +* +* +*  `   +   +           + +* +  *  **   +  + +'    +    +   ` +           + +* +  *    * .           + +* +  *   * +   '

Попробуйте онлайн!

Объяснение:

Put-a-zero-at-the-base-of-the-stack
|     +
Read-10-digits
| , , , , , , , , , ,
Initialise-next-stack
|     +
Initialise-carry-bit
|      +
|   +   +
Do
|`
    Top-of-stack:-[output-stack]-[carry-bit]-[next-value]
    Add-Carry-bit-to-digit
    |*

    Compare-with-58-("9"=57)
    | +
    5-double-triple-sub1-double
    |          + +* + +**      + * +*
    Take-difference
    | *
    If-one-above-"9"
    | '
        set-to-"a"=97=6-double-double-double-double-add1
        |    +
        |           + +* +* +* +*      +*
    | `

    Initialise-next-carry-bit
    |     +
    |  +

    Compare-with-123-("z"=122)
    | +
    11-squared-add2
    |                + +  *       +*
    Take-difference
    | *
    If-one-above-"z"
    |  '
        Delete-current-value
        |    +
        set-carry-bit
        |      +*
        Set-to-"0"=48
        |           + +* +* +*
    |  `

    Push-value-to-stack
    |   +   +
    |           + +* +  *
    |  **

    |   +  +
While-next-value-is-not-null
| +'

Pop-carry-bit-and-null-string-terminator
|    +    +
Do
|   `
    Get-top-value
    | +
    |           + +* +  *
    |    *

    Print-it
    | .

    Pop-the-value-off-the-stack
    |           + +* +  *
    |   *
While-stack-is-not-null
| +   '

Wolfram Language (Mathematica) , 39 байт

IntegerString[#~FromDigits~36+1,36,10]&

Попробуйте онлайн!

Python 3.6+ и gmpy2 , 62 байта

from gmpy2 import*;f=lambda s:f'{digits(mpz(s,36)+1,36):0>10}'

Попробуйте онлайн!

(Обратите внимание, что gmpy2 не является частью стандартной библиотеки Python и требует отдельной установки)

Пайк , 11 байт

? b!!R+bhbt

Попробуй это здесь!

? b         - Change default base of `base` command to 36 
            -  This is kind of clever because it modifies the list of characters 
            -  the command uses to exactly the same as it was originally, whilst
            -  forcing an overwrite from the default settings of 10. 
            -  The default setup works for base 36, you just have to specify it
            -  time when using the command.
            -  Literally `b.contents = modify(b.contents, func=lambda: noop)`
   !!       - The previous command returns `0123456789abcdefghijklmnopqrstuvwxyz`
            -  So we convert it into a 1 with (not not ^) for the following command:
     R+     -     "1"+input
       b    -    base(^, 36)
        h   -   ^ + 1
         b  -  base(^, 36)
          t - ^[1:]

Может быть короче на 2 байта при следующем изменении языка: если используется шестнадцатеричный режим, измените все использования base_36 и base_10 на base_92 (который в любом случае не является базовым 92 в этом контексте)

sed , 94 байта

s/$/#:0123456789abcdefghijklmnopqrstuvwxyz#0/
:l
s/\(.\)#\(.*:.*\1\)\(#*.\)/\3\2\3/
tl
s/:.*//

Попробуйте онлайн!

Сед очень страдает от необходимости менять персонажей при поиске.

Зш , 41 36 байт

echo ${(l:10::0:)$(([##36]36#$1+1))}

Попробуйте онлайн!

Желе , 21 байт

ØBḊiⱮḅ‘bɗ36Ż9¡ṫ-9‘ịØB

Попробуйте онлайн!

Использует прописные буквы. Ссылка TIO позволяет использовать нижний / смешанный регистр.