[Question]
  [
**This question already has answers here**:
 
 
[Output the Hebrew alphabet](/questions/96950/output-the-hebrew-alphabet)
 (27 answers)
 
[Print the Greek alphabet!](/questions/97049/print-the-greek-alphabet)
 (48 answers)
 
Closed 6 years ago.
[Apparently](https://codegolf.stackexchange.com/questions/96950/output-the-hebrew-alphabet), we [really like](https://codegolf.stackexchange.com/questions/97049/print-the-greek-alphabet) printing [the alphabet](https://codegolf.stackexchange.com/questions/67357/output-the-alphabet-the-alphabet-or-just-a-character) in different languages.
How about the Russian Cyrillic alphabet?
Print/output/return this exact text (trailing whitespace is permitted)
```
АаБбВвГгДдЕеЁёЖжЗзИиЙйКкЛлМмНнОоПпРрСсТтУуФфХхЦцЧчШшЩщЪъЫыЬьЭэЮюЯя
```
This is the Russian Cyrillic alphabet with upper and lower case interleaved (eg `AaBbCc...`)
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so crunch those bytes folks!
  
[Answer]
# [Рапира](https://en.wikipedia.org/wiki/Rapira) (Rapira), ~~172~~ 142 bytes
```
ВЫВОД: "АаБбВвГгДдЕеЁёЖжЗзИиЙйКкЛлМмНнОоПпСсТтУуФфХхЦцЧчШшЩщЪъЫыЬьЭэЮюЯя"
```
[Try it online!](https://tio.run/##DczFEcIAAAXRVpiUQTc5cmPoILhDILgNLsHdaWF/RSGHvbzDRsxwKGJ6HhVcvz5OMGBQZo/NwYcjVU44nKlxwZJNnSsNbjS50@JBmycdXnR50@PjL74M@DGUxUhRxooxUZypEsyUZK4UC6VZKsNKWVzlWCvPRgW2KrJTyfC8Pw "Rapira – Try It Online")
Just for fun, given the challenge. It may not be golfed; I'm not really familiar with the language.
[Answer]
# Mathematica, ~~43~~ 42 bytes
`Alphabet` is a built-in function.
-1 byte from Martin.
```
ToUpperCase@#<>#&/@Alphabet@"Russian"<>""&
```
This may not work on some older versions of Mathematica, but it does work on [Wolfram sandbox](https://sandbox.open.wolframcloud.com "Wolfram sandbox") and [Try it online!](https://tio.run/##RY7BasMwEETv@opFgdAG4/5AGlxKDz30kjYnY8hGXtUCeyWkdeN8vWs50F7nDW9mQOloQHEGZ/s8f/lTCBRfMVG12R8226fqpQ8dXkgqfRxTcsh6f9B6Oz/s1LuFK0HrIhnpbxCiY0mwCMF4FmIBb8HWDWAChCQL/y7g438Srq7vFSWDgcAJiIcTO@PbbGiphE@fFzr8ocxoCj7KOnCX5RDBup4Khdxmwvcba0loErjcII7MuX02KOdS7R6VeltVtRYaQimT6CIfbdRx5FovNfgDzfwL "Wolfram Language (Mathematica) – Try It Online").
---
Another version without builtin `Alphabet` or `ToUpperCase`:
# Mathematica, ~~82~~ 66 bytes (64 chars)
```
Insert[FromCharacterCode@{#,#+32}&/@(1039+Range@32),"Ёё",6]<>""&
```
or
```
Insert[FromCharacterCode@{#,#+32}&/@1040~Range~1071,"Ёё",6]<>""&
```
Unfortunately Martin's trick (use `a<>b` instead of `{a,b}`) doesn't work here.
[Try it online!](https://tio.run/##jc3NasJAFIbh/VzF4QjiT7CJKRXFSIpYcFfcpllM05NJwMzI5PhTpIKX4J3pFaXBumhddfvB872F5IwKyXkiqzSo5roky9GLNcU0k1YmTHZqPijcN5xG1@9/NR/Cluf6w@5CakWh3287eD5eTug8xeMJYrNqdeB5WTNdn24INmTL3GjY5pxBKQuC90@mxKw1j6DTFkIF4j9Vz310D9fowXMH3l1ViFebaw7xTadRDAGgmO1Wpj7FtMc7RgfqPRaLtY4wkQw/a/zLqTunbk79cermqm8 "Wolfram Language (Mathematica) – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 18 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
40r71s6j25Q+ȷỌżŒl$
```
A full program. Pretty similar in nature to an [existing answer by Erik the Outgolfer](https://codegolf.stackexchange.com/a/127683/53748), but I *think* it's different enough.
**[Try it online!](https://tio.run/##y0rNyan8/9/EoMjcsNgsy8g0UPvE9oe7e47uOTopR@X/fwA "Jelly – Try It Online")**
### How?
```
40r71s6j25Q+ȷỌżŒl$  Main link: no arguments
40r71               inclusive range from 40 to 71: [40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71]
     s6             split into sixes: [[40,41,42,43,44,45],[46,47,48,49,50,51],[52,53,54,55,56,57],[58,59,60,61,62,63],[64,65,66,67,68,69],[70,71]]
       j25          join with 25s: [40,41,42,43,44,45,25,46,47,48,49,50,51,25,52,53,54,55,56,57,25,58,59,60,61,62,63,25,64,65,66,67,68,69,25,70,71]
          Q         de-duplicate: [40,41,42,43,44,45,25,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71]
            ȷ       literal 1000
           +        addition: [1040,1041,1042,1043,1044,1045,1025,1046,1047,1048,1049,1050,1051,1052,1053,1054,1055,1056,1057,1058,1059,1060,1061,1062,1063,1064,1065,1066,1067,1068,1069,1070,1071]
             Ọ      cast to characters: "АБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ"
                 $  last two links as a monad:
               Œl     lowercase: "абвгдеёжзийклмнопрстуфхцчшщъыьэюя"
              ż       zip: ["Аа","Бб","Вв","Гг","Дд","Ее","Ёё","Жж","Зз","Ии","Йй","Кк","Лл","Мм","Нн","Оо","Пп","Рр","Сс","Тт","Уу","Фф","Хх","Цц","Чч","Шш","Щщ","Ъъ","Ыы","Ьь","Ээ","Юю","Яя"]
                    implicit print: АаБбВвГгДдЕеЁёЖжЗзИиЙйКкЛлМмНнОоПпРрСсТтУуФфХхЦцЧчШшЩщЪъЫыЬьЭэЮюЯя
```
[Answer]
# C#, Java, Javascript 137 bytes
Note: Java is only valid if you replace `=>` with `->`
```
s=>"АаБбВвГгДдЕеЁёЖжЗзИиЙйКкЛлМмНнОоПпРрСсТтУуФфХхЦцЧчШшЩщЪъЫыЬьЭэЮюЯя"
```
Ahhhh!!! Found a shorter way for
# C#, 102 99 bytes
```
a=>string.Concat(new string[32].Select((x,i)=>(x=(char)(i+1040)+"")+x.ToLower())).Insert(12,"Ёё")
```
Shortened it by using a different approach 
[Try it Online!](https://tio.run/##Sy7WTS7O/K@g4Faal2xTXFKUmZeuowCh7RTSgIIKtgr/E23tIEJ6zvl5yYklGnmp5VBF0cZGsXrBqTmpySUaGhU6mZq2dhoVthrJGYlFmhqZ2oYGJgaa2kpKmtoVeiH5PvnlqUUampqaep55xalFJRqGRjpKFxovTlTS/G/NFV6UWZKqAbJTA6hB0/o/AA)
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~75~~ ~~38~~ ~~32~~ ~~24~~ ~~23~~ 22 bytes
```
;Bi";<=>?@," c+981 ®+v
```
[Test it](https://ethproductions.github.io/japt/?v=1.4.5&code=O0JpIjs8PT4/QCwiIGMrOTgxIK4rdg==&input=)
* 1 byte saved thanks to ETHproductions.
---
## Explanation
```
;B        :The uppercase alphabet
i         :Prepend ...
";<=>?@," :  this string
c         :Map over the charcodes of each character in the string...
+981      :  and increment them by 981
®         :Map over each character in the string, replacing them with themselves...
+Zv       :   and their lowercase selfs
          :Implicit output of resulting string
```
---
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~20~~ 19 bytes
```
71r40s26j25+ȷṚỌżŒl$
```
[Try it online!](https://tio.run/##ASMA3P9qZWxsef//NzFyNDBzMjZqMjUryLfhuZrhu4zFvMWSbCT//w "Jelly – Try It Online")
Thanks to [Jonathan Allan](https://codegolf.stackexchange.com/users/53748/jonathan-allan) for posting his [answer](https://codegolf.stackexchange.com/a/127694/41024) (even though he outgolfs me) for -1 :)
[Answer]
## PHP, ~~68~~ 66
```
for(;$i++<33;)echo$c=ڀ^"
".chr($i-7?16+$j++:1),mb_strtolower($c);
```
slight improvement over the previous attempt by xoring instead of appending.
`ڀ^"\n"` constructs the necessary `"\0xd0\128"` and xors in the lower 7 bit.
[Answer]
## JavaScript (ES6), 106 bytes
```
f=
_=>"АБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ".replace(/./g,c=>c+c.toLowerCase())
console.log(f())
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 22 [bytes](https://github.com/Adriandmen/05AB1E/blob/master/docs/code-page.md)
```
žv47ŸžB+çJ6т‚£'ЁýDløJ
```
[Try it online!](https://tio.run/##ASoA1f8wNWFiMWX//8W@djQ3xbjFvkIrw6dKNtGC4oCawqMn0IHDvURsw7hK//8 "05AB1E – Try It Online")
**Explanation**
```
žv47Ÿ                    # push range [16 ... 47]
     žB+                 # add 1024 to each
        çJ               # convert to a string of characters with those code points
          6т‚£           # split into 2 pieces, the first being 6 chars long
              'Ёý        # merge the 2 strings on "Ё"
                 Dlø     # zip with a lower case copy
                    J    # join to a string
```
[Answer]
# Pyth, 26 bytes
```
X12ssmCM+B+1040d32U32"Ёё
```
```
                  U32     generate the range [0, 1, 2, ..., 30, 31]
     m         d          for each element in the range,
          +1040           add 1040, giving the uppercase cyrillic letter
        +B      32        bifurcate over adding 32, giving [upper, lower]
      CM                  convert each into a character
   ss                     join into a single string
X12                  "Ёё  insert this string at index 12
```
[Try it here](http://pyth.herokuapp.com/?code=X12ssmCM%2BB%2B1040d32U32%22%D0%81%D1%91&debug=0).
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 20 bytes = 18 bytes + 2 UTF-8 bytes
```
T„(GÇ«ŸçJ„ЁЖ6ǝDløJ
```
[Try it online!](https://tio.run/##MzBNTDJM/f8/5FHDPA33w@2HVh/dcXi5F5B3ofHCNLPjc11yDu/w@v8fAA "05AB1E – Try It Online")
---
Credit to Emigna for the `lowercase` trick and for `3°` isntead of `3Tm`.
---
# How?
```
T                  # Push 10.               | [10]
 „(G               # Push "(G"              | [10, "(G"]
    Ç              # Convert to ASCII.      | [10, [40, 71]]
     «             # Concatenate.           | [[1040, 1071]]
      Ÿ            # Range.                 | [[1040, ..., 1071]
       çJ          # Convert to char, join. | ["А..Я"]
         „ЁЖ       # Push "ЁЖ"              | ["А..Я", "ЁЖ"]
            6ǝ     # Replace "Ж" w/ "ЁЖ"    | ["А.Ё.Я"]
              Dl   # Duplicate, lowercase.  | ["А..Ё..Я", "а..ё..я"]
                øJ # Zip together and join. | ["АаБбВвГгДдЕеЁёЖжЗзИиЙйКкЛлМмНнОоПпРрСсТтУуФфХхЦцЧчШшЩщЪъЫыЬьЭэЮюЯя"]
```
---
Alternate 20 byte version (no UTF-8): `T„(GÇŸ„.Ç6ǝ˜«çJDløJ`
Even more random 20 byte nonsense: `T„(GÇŸ„.Ç6ǝ˜«vyçDlJ`
(The key takeaway is that I don't think I'm getting below 20 here).
[Answer]
# [Braingolf](https://github.com/gunnerwolf/braingolf), 58 bytes
```
"ABCDEF2GHIJKLMNOPQRSTUVWXYZ[\\]^_`"{#Ϗ+..#Ёe#P:# |+}>&@
```
[Try it online!](https://tio.run/##SypKzMxLz89J@/9fydHJ2cXVzcjdw9PL28fXzz8gMCg4JDQsPCIyKjomJjYuPkGpWvl8v7aenvKFxlTlACtlhRrtWjs1h///AQ "Braingolf – Try It Online")
Woo!
## Explanation
Adds `Ϗ` (975) to each character in ABCDEF2GHIJKLMNOPQRSTUVWXYZ[\]^\_`
Then duplicates and adds space (32), unless the character is `Ё`, in which case it adds P (80)
[Answer]
# Java, 93 bytes
```
s->"АаБбВвГгДдЕеЁёЖжЗзИиЙйКкЛлМмНнОоПпРрСсТтУуФфХхЦцЧчШшЩщЪъЫыЬьЭэЮюЯя"
```
Source file should be saved in `Windows-1251` encoding so the source makes for 71 bytes, plus flag to compiler `-encoding WINDOWS-1251` for 22 bytes more.
[Answer]
# [Python 3](https://docs.python.org/3/), ~~69~~ 66 bytes
-3 bytes using the form (using `'%c'` to directly apply `chr()`) from [totallyhuman's answer](https://codegolf.stackexchange.com/a/127719/53748), do go give some credit!
```
v=32
while v:print('Ёё'*(v==26),end='%c%c'%(1072-v,1104-v));v-=1
```
A full program (two double-byte characters used, `Ё` and `ё`).
**[Try it online!](https://tio.run/##K6gsycjPM/7/v8zW2IirPCMzJ1WhzKqgKDOvREP9QuPFiepaGmW2tkZmmjqpeSm26qrJqsnqqhqGBuZGumU6hoYGJrplmprWZbq2hv//AwA "Python 3 – Try It Online")**
[Answer]
# Dyalog APL, ~~55~~ 47 bytes
*8 bytes saved thanks to @Zacharý*
```
⎕UCS 66⍴⍉2 33⍴1025+(14+⍳6),0,(20+⍳32),80,52+⍳26
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT////1Hf1EdtE4BkqHOwgpnZo94tj3o7jRSMjYEsQwMjU20NQxPtR72bzTR1DHQ0jAxAbGMjTR0LAx1TIxDHyOz/fwA)
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 71 bytes
```
."Ёё    kdâ¿Ããä©ÃòçÅD´fjÃØÜr
ÔE®8CðÒº[£÷6ÓþC0"
```
[Try it online!](http://pyth.herokuapp.com/?code=.%22%D0%81%D1%91%01%09kd%C2%92%C3%A2%C2%BF%C3%83%C3%A3%C3%A4%C2%A9%C3%83%C3%B2%C3%A7%C2%93%C3%85D%01%C2%B4f%C2%8Fj%C3%83%C3%98%C3%9Cr%C2%96%0A%03%C3%94E%C2%AE%C2%888C%C3%B0%C3%92%C2%BA%5B%C2%A3%06%03%07%14%C3%B7%C2%9D%C2%8E6%C3%93%C3%BEC%C2%840%22&debug=0)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~64~~ ~~47~~ 46 bytes
```
5ÝD1040+s1072+‚øžB>D80+‚«25ÝD1046+s1078+‚ø)˜çJ
```
[Try it online!](https://tio.run/##MzBNTDJM/f/f9PBcF0MDEwPtYkMDcyPtRw2zDu84us/JzsXCAMQ5tNoIqsIMrMICokLz9JzDy73@/wcA "05AB1E – Try It Online")
[Answer]
# [C# (.NET Core)](https://www.microsoft.com/net/core/platform), 94 93 90 bytes
```
_=>{var r="";for(var i='А';i<='Я';)r+=""+i+(char)(i+32)+(i++=='Е'?"Ёё":"");return r;}
```
[Try it online!](https://tio.run/##bY6xasMwEIZ3P8WhxRJKMqRbFDlDoFMLhQ4dg1Dl5MCR4KQEivHQN0iHPEdexXkiR04hXfoP993d/x@cjVMbyA2QZRsTI7xR2JLZF@OmvddRMZmEFo4BP@HVoOfiYf2FRr1/xeT2s@eDt8uYCP12Ar@soAZdDBtdtUdDQJoxVQfi44C67E@lwmXmpVSCZHYlSm53hgRH@TQXMkPqHDiXK9Z/X3/YgjGhyKUDeSDVDar475V18DE0bvZBmNwLesdrng@FeoS7e9cNNw "C# (.NET Core) – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), ~~96~~ 92 bytes
* *@Mayube suggested this to save 2 bytes, and succeeded to golf it down by 1 byte by declaring `chr(i)`.*
* *@Rod golfed 4 bytes by removing `chr(i)`.*
```
for i in[chr(ord(i)+975)for i in"ABCDEF2GHIJKLMNOPQRSTUVWXYZ[\\]^_`"]:print(end=i+i.lower())
```
[Try it online!](https://tio.run/##K6gsycjPM/7/Py2/SCFTITMvOjmjSCO/KEUjU1Pb0txUEyau5Ojk7OLqZuTu4enl7ePr5x8QGBQcEhoWHhEZFR0TExsXn6AUa1VQlJlXopGal2KbqZ2pl5Nfnlqkoan5/z8A)
---
# [Python 3](https://docs.python.org/3/), ~~104~~ 99 bytes
Any suggestions are welcome.
```
for i in"АБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ":print(end=i+i.lower())
```
[Try it online!](https://tio.run/##BcFLCoJQGIDRrYgjJXDSLGg3Gf4Q98pFiIbtINPKSns/NEu38u3odk68SCKthtZOtXHEEeWyImVNRs6GJVt2FOw5cKSk4sSZC1du3Hnw5MWbmoYPLV9@dPTuKDaiEi9Uk7EMJJjpeWg837f2Dw)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 29 bytes
```
1040ÐU5+ŸžB>X6+D25+Ÿ)˜çDl)ø˜J
```
[Try it online!](https://tio.run/##MzBNTDJM/f/f0MDE4PCEUFPtozuO7nOyizDTdjECcTRPzzm83CVH8/CO03O8/v8HAA "05AB1E – Try It Online")
Uses the lowercase / uppercase trick from the python answer
### Explanation
```
1040ÐU5+ŸžB>X6+D25+Ÿ)˜çDl)ø˜J
1040                          # Push 1040
    Ð                         # Triplicate top of stack
     U                        # Saves top of stack in X
      5+Ÿ                     # Push range [1040, ..., 1045]
         žB>                  # Push 1025
            X                 # Push X (1040)
             6+D25+Ÿ          # Push range [1046, ..., 1071]
                    )         # Wrap stack to array
                     ˜        # Flatten array
                      ç       # Convert to character
                       Dl     # Create a lowercase copy
                         )ø   # Zip both together
                           ˜J # Flatten and join
                              # Implicit output
```
[Answer]
# [Python 3](https://docs.python.org/3/), 66 bytes
```
for i in range(32):print(end='%c%c'%(i+1040,i+1072)+'Ёё'*(i==5))
```
[Try it online!](https://tio.run/##K6gsycjPM/7/Py2/SCFTITNPoSgxLz1Vw9hI06qgKDOvRCM1L8VWXTVZNVldVSNT29DAxEAHRJkbaWqrX2i8OFFdSyPT1tZUU/P/fwA "Python 3 – Try It Online")
[Answer]
# PHP>=7.0, 77 Bytes
```
for($t=IntlChar;$i++<33;)echo$c=$t::chr($i-7?1040+$j++:1025),$t::tolower($c);
```
[IntlChar Class](http://php.net/manual/de/class.intlchar.php)
# PHP, 136 Bytes
```
for(;$i<mb_strlen($r=АБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ);)echo$m=mb_substr($r,$i++,1),mb_strtolower($m);
```
[PHP Sandbox Online](http://sandbox.onlinephpfunctions.com/code/e4111a0343b19b6b93f81ed6eb93ba76a60e5cdd)
# [PHP](https://php.net/), 136 bytes
```
<?=АаБбВвГгДдЕеЁёЖжЗзИиЙйКкЛлМмНнОоПпРрСсТтУуФфХхЦцЧчШшЩщЪъЫыЬьЭэЮюЯя;
```
[Try it online!](https://tio.run/##BcHFDUIBAETBiqgACLUQQsIJKAF3d3d3d2nhbTGcPzNel9cwLDYrOXbk2VPgQJEjJU6UOeNXngoXqlypcaPOnQYPmjxp8aLNmw4funzpyUdffgYKMFSQkUKMFWaiCFNFmSnGXHEWSrBUkpVSrJVmowxbZc2G8XN7TA67w@X8Aw "PHP – Try It Online")
[Answer]
# Bash+coreutils, ~~101~~ ~~100~~ ~~93~~ ~~92~~ 74 bytes
```
printf %b\\n \\u04{51,{3,4}{{0..9},{a..f}}}|sort|sed 's/./\u&&/'|tr -d \\n
```
This requires a UTF-8 locale such as `ru_RU.utf8` (English UTF-8 locales also sort correctly). I've not added any score for this, as per the [consensus on meta](//codegolf.meta.stackexchange.com/q/7881).
[Answer]
# Ruby, 60 bytes
```
u=?Џ
l=?Я
32.times{$><<u.next!+l.next!+(l==?е?"Ёё":"")}
```
(Just a demonstration of [`String#next!`](http://ruby-doc.org/core-2.4.1/String.html#method-i-next-21), the multibyte literals ruin the 55 characters score.)
Sample run:
```
bash-4.4$ ruby -e 'u=?Џ;l=?Я;32.times{$><<u.next!+l.next!+(l==?е?"Ёё":"")}'
АаБбВвГгДдЕеЁёЖжЗзИиЙйКкЛлМмНнОоПпРрСсТтУуФфХхЦцЧчШшЩщЪъЫыЬьЭэЮюЯя
```
[Try it online!](https://tio.run/##KypNqvz/v9TW/kI/Vw6QXM9lbKRXkpmbWlytYmdjU6qXl1pRoqidA6U1cmyBirbaK11ovDhRyUpJSbP2/38A "Ruby – Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~59 56 55 54~~ 51 bytes
```
32.times{|x|$><<((x==6?"Ёё":"")<<x+1040<<x+1072)}
```
Thanks to manatwork for at least 4 bytes.
[Try it online!](https://tio.run/##KypNqvz/39hIryQzN7W4uqaiRsXOxkZDo8LW1sxe6ULjxYlKVkpKmjY2FdqGBiYGENrcSLP2/38A "Ruby – Try It Online")
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~26~~ 24 bytes
22 bytes of code (encoded in UTF-8), +2 for the `-P` flag. 
```
#h0o#k2_dÃi'Ё6
®+Zv
```
Similar to the below method, except instead of pairing two arrays, I join each capital letter with itself, lower-cased. 
[Try it Online!](https://tio.run/##y0osKPn/XznDIF852yg@5XBzpvqFRjOuQ@u0o8r@/9cNAAA)
## 26 byte solution:
I had some help from @Shaggy, who discovered that `Ё` wasn't in the `[1040...1071]` char range.
```
#h0o#k2_dÃi'Ё6
íUmv)c
```
## Explanation:
```
#h0o#k2_dÃi'Ё6
íUmv)c
                   // Implicit U =
   o               //   Range      
#h0                //     [1040...
    #k2            //             1071]
       _           //   Map; At each char,
         d         //     Get the char-code
          Ã        //   End mapping;
           i'Ё6    //   Insert "Ё" into index 6;
í                  // U paired with:
 Um                //   U, where each char:
   v               //   Converted to lowercase
     c             // Flatten
-P                 // Join into a string
```
[Try it online!](https://tio.run/##y0osKPn/XznDIF852yg@5XBzpvqFRjOuw2tDc8s0k///1w0AAA "Japt – Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~45~~ ~~44~~ 26 bytes
```
ＦＥ⮌⪫⪪…⮌…γ⁷²¦³²Ｌαi℅⁺℅ιφ⁺↥ιι
```
[Try it online!](https://tio.run/##RY3BCsIwEER/JfS0gXqpBw8ecxPFovgBS9y2C0sStrHg18cED53DDLx3GL@g@ohSyhTVwA0TPGgjXQkukQM8k3AG9/VCbom73Mncm9NgbW@OQ60rhTkvgA103LVx9QJ9JoVRPivc9c0BBbiqydaYUTnkv3ylROqxHjTN1p5LKYdNfg "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
ＦＥ⮌⪫⪪…⮌…γ⁷²¦³²Ｌαi
```
Take the first 72 printable ASCII characters, reverse them, then take the first 32 of those (this is actually shorter than slicing and reversing, although slicing didn't exist at original time of posting anyway), then insert the `i` after the `N`, then reverse again. The resulting characters happen to have ASCII codes that are exactly 1000 less than the desired Russian lower case letters.
```
  ℅⁺℅ιφ
```
Calculate the Russian lower case letter by adding the predefined variable `φ` (`f`) which has the value 1000.
```
    ⁺↥ιι
```
Print the upper and lower case letters. (`«↥ιι` would probably also work.)
[Answer]
## [Alice](https://github.com/m-ender/alice), 31 bytes
```
gr'v6R,' &w'ѷ~-.O' +'С'ёSOk@
```
[Try it online!](https://tio.run/##S8zJTE79/z@9SL3MLEhHXUGtXP3i9jpdPX91BW31CwvVL04M9s92@P8fAA "Alice – Try It Online")
### Explanation
```
g       Read the first character of the source code. That's g itself, with
        code point 103, so this pushes 103. The exact value is irrelevant
        but we need something greater than 31.
r       Range. Turns 103 into 0, 1, 2, ..., 103.
'v      Push 118.
6R,     Move it down the stack by 6 elements, so the top of the stack is
        ..., 96, 97, 118, 98, 99, 100, 101, 102, 103.
' &w    Push the current IP address to the return address stack 32 times, 
        which will cause the following part to be executed 33 times.
  'ѷ~-    Subtract the value on top of the stack from 1143, which gives the
          33 code points of the upper case letters.
  .O      Print a copy of this value as a character.
  ' +     Add 32. This turns the upper case letters in the main range to their
          lower case counterparts. However, this doesn't work for Ё/ё, where
          we obtain C instead.
  'C'ёS   Replace the divisor 1057 with 1105. The only value among the 33 which
          is divisible by 1057 is 1057 (C) itself, so that it simply gets turned into
          1105 (ё). 
  O       Output the lower case character.
k       Jump back to the w as long as there's a copy on the return address stack.
@       Terminate the program.
```
[Answer]
# [Java (OpenJDK 8)](http://openjdk.java.net/), ~~91~~ 88 bytes
```
()->{String s="";for(char i=0,u=1039,l=1071;i<33;)s=i++==6?s+"Ёё":s+ ++u+ ++l;return s;}
```
[Try it online!](https://tio.run/##bVBbT9RgEH3fXzH2qU2hgWyCwVL8AUZ92EfjQ13a5VtLW/t9H4aQTQBRuSty98ZF8H5Hbir6F878orVlN/GFh5lJzpyZc2bq/rDfmaRBXB@43Uz1rUhUqRr5UtJVX8Q0WiJqo1L5Ki/DiRigobxnVlQm4tqNm@RnNWmdUYnq@T5HKxE5oY6rSiSxU9FpGokg62sN9FNIXtO0OvtHWwBJzzDcMMnM6qCfkfC6OrTX3VXu7YjycrHbFX3lsmtJT9i25/VclraBcV40LkmbbFsXKXKzQOksJuk2moUNt3TmpjIiVTDkJFo5aS6lotiMg7vU0jVDpxYo07KsNluEZF4w8BhfsYhveILvWMI@lvEDKzgoNLGKQ6zhCOs4xgZO8BQ/8Qy/8By/8QKneIk/2MRfbPEYtnkcOzyBV3wPuzyJPb6P1/wAb/gh3vIU3vE03vMMPvAsPvIcPvE8PvMCvvAjwwnuaD@S/y2233vuSca1RNH1K0Z@R8FolIpoNP8B "Java (OpenJDK 8) – Try It Online")
Encoded in Windows-1251. Must use a default Russian Windows installation.
[Answer]
## [Alice](https://github.com/m-ender/alice), 33 bytes
```
/ZАе"е"ёяSr@
\"'Я"rЁа""o/
```
[Try it online!](https://tio.run/##S8zJTE79/18/6sKEC1uVgOjixIv9wUUOXDFK6hfWKxVdaLywQUkpX///fwA "Alice – Try It Online")
My other Alice solution was entirely in Cardinal mode, this one is entirely in Ordinal mode. It's conceptually much simpler, but unfortunately two byte longer.
### Explanation
Ignoring the Ordinal template, the program is entirely linear:
```
"АЯ"r"ая"rZ'е"еЁё"So@
```
Alice does have a built-in to convert between lower and upper case, but unfortunately in the Ruby interpreter it only works on ASCII letters, so we still have to get both ranges separately.
```
"АЯ"r     Push "АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ".
"ая"r     Push "абвгдежзийклмнопрстуфхцчшщъыьэюя".
Z         Zip. Interleave the two strings.
'е"еЁё"S  Replace "е" with "еЁё".
o@        Print the result and terminate the program.
```
]