[Question]
  [
Your task is to print this exact text:
```
אבגדהוזחטיכךלמםנןסעפףצץקרשת
```
(You are allowed to print a trailing newline)
SHA256 hash of the UTF-8 encoding of the text:
```
0ab6f1e0bf216a0db52a4a5a247f95cba6f51496de7a24dfd01f3985dfcf6085
```
Base64 encoding:
```
15DXkdeS15PXlNeV15bXl9eY15nXm9ea15zXnted16DXn9eh16LXpNej16bXpden16jXqdeq
```
### Rules
* You can't use a builtin outputting this text.
* Standard loopholes are disallowed.
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest answer wins.
Good luck!
  
[Answer]
# MATLAB, ~~52~~ 51 bytes
```
[cumsum([1488 'CCCCCCCCCDADDAEADCDAEADCCC'-66]) '']
```
Example use:
```
>> [cumsum([1488 'CCCCCCCCCDADDAEADCDAEADCCC'-66]) '']
ans =
אבגדהוזחטיכךלמםנןסעפףצץקרשת
```
### Explanation
`'CCCCCCCCCDADDAEADCDAEADCCC'-66` produces the array `[1 1 ... -1 2 1 1 1]`, which contains the consecutive differences between the codepoints of the desired characters.
`[1488 ...]` prepends `1488`, so the array is now `[1488 1 1 ... -1 2 1 1 1]`.
`cumsum(...)` computes the cumulative sum: `[1488 1489 ... 1514]`.
`[... '']` concatenates with the empty string. This has the effect of converting to char (and is one byte shorter than `char(...)`)
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~22~~ ~~21~~ 20 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
27R+“¿ÇÑÞæ‘¦2Ụ+1487Ọ
```
[Try it online!](http://jelly.tryitonline.net/#code=MjdSK-KAnMK_w4fDkcOew6bigJjCpjLhu6QrMTQ4N-G7jA&input=)
### Idea
If we subtract **1487** from each code point, we get the array **R** that follows.
```
1 2 3 4 5 6 7 8 9 10 12 11 13 15 14 17 16 18 19 21 20 23 22 24 25 26 27
```
That's just the range from **1** to **27**, but not in ascending order; the pairs **(11, 12)**, **(14, 15)**, **(16, 17)**, **(20, 21)**, and **(22, 23)** have been swapped.
If we take the ascending range and add **2** to **11**, **14**, **16**, **20**, and **22**, we get the array **A** that follows.
```
1 2 3 4 5 6 7 8 9 10 13 12 13 16 15 18 17 18 19 22 21 24 23 24 25 26 27
```
This is no longer a permutation of the range, but if we stably sort the range by the values in that array, we can reconstruct the original array.
### Code
```
27R+“¿ÇÑÞæ‘¦2Ụ+1487Ọ  Main link. No arguments.
27R                   Yield [1, ..., 27].
           ¦          Conditional application:
    “¿ÇÑÞæ‘             At indices 11, 14, 16, 20, and 22...
   +        2           add 2 to the corresponding value.
                      This yields the array A from the previous section.
             Ụ        Grade up; sort the indices of the result by its corresponding
                      values. This yields the array R from the previous section.
              +1487   Add 1487 to each integer in R.
                   Ọ  Unordinal; convert integers to characters.
```
[Answer]
## PowerShell v2+, [58 bytes](https://ethproductions.github.io/bytes/?e=utf-16&t=%27%u05D0%u05D1%u05D2%u05D3%u05D4%u05D5%u05D6%u05D7%u05D8%u05D9%u05DB%u05DA%u05DC%u05DE%u05DD%u05E0%u05DF%u05E1%u05E2%u05E4%u05E3%u05E6%u05E5%u05E7%u05E8%u05E9%u05EA%27) (UTF-16)
```
'אבגדהוזחטיכךלמםנןסעפףצץקרשת'
```
PowerShell Unicode is UTF-16 unless explicitly specified otherwise, and then it's a crapshoot anyway since it's all UTF-16 in the background.
This just puts the literal string on the pipeline and the default `Write-Output` at the end of program execution prints it to screen.
The shortest I could get the ASCII version is **63**
```
-join([char[]]'ABCDEFGHIJLKMONQPRSUTWVXYZ['|%{[char](1423+$_)})
```
Which takes the ASCII value of the string `ABC...` and adds `1423` to each `char` to get the appropriate string.
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), ~~36~~ ~~29~~ ~~26~~ ~~25~~ 23 bytes
Saved 2 bytes thanks to *Adnan*
Uses [CP-1252](http://www.cp1252.com) encoding.
```
1488•’ÉÇW–moû•5Bvy<+Dç?
```
[Try it online!](http://05ab1e.tryitonline.net/#code=MTQ4OOKAouKAmcOJw4dX4oCTbW_Du-KAojVCdnk8K0TDpz8&input=)
**Explanation**
```
1488            # push 1488 (accumulator)
•’ÉÇW–moû•      # push 2235174277545950437
5B              # convert from base-5 to base-10 (122222222230330403230403222)
  v             # for each digit in above number
   y<           # decrease it by 1
     +          # add to accumulator
      Dç?       # print a copy of accumulator converted from code point
```
[Answer]
# [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), 172 bytes
This answer is based largely one [DJMcMayhem's solution here](https://codegolf.stackexchange.com/questions/96950/output-the-hebrew-alphabet/96958#96958) so I recomend you check it out.
Like DJMcMayhem's solution this uses the `-rA` flag to reverse output and print to unicode.
```
(((((()()()()()){})))<(((({}{}{}()){({}[()])}{})){}{})>){({}[()]<(({})())>)}{}(((((()()())((((((((({}(((({}())[()])()())()())[()]))[()])()())())()())[()]))[()])()())())())())
```
[Try it online!](https://tio.run/##SypKzMzTTctJzP7/XwMMNGFQs7pWU1PTBiRWXQuCICEgM1pDM1azFiQJEtS0gwvagBSCNNqBpJFM09SAAYgw2CiwMRBZTRgXRRCPOAj9//9ft8gRAA "Brain-Flak – Try It Online")
## Explanation
I made this answer by running a bunch of micro-optimizations over the original solution provided by DJMcMayhem. These optimizations while saving bytes, make the code unreadable and the algorithm obtuse. I, to be honest, do not really understand how or what my code does.
Perhaps someday I will understand how this works...
[Answer]
# Python 3, 50 bytes
```
#coding:cp862
print('אבגדהוזחטיכךלמםנןסעפףצץקרשת')
```
The file must be created using the CP862 encoding or by reversing the following hexdump.
```
0000000: 23 63 6f 64 69 6e 67 3a 63 70 38 36 32 0a 70 72  #coding:cp862.pr
0000010: 69 6e 74 28 27 80 81 82 83 84 85 86 87 88 89 8b  int('...........
0000020: 8a 8c 8e 8d 90 8f 91 92 94 93 96 95 97 98 99 9a  ................
0000030: 27 29                                            ')
```
This could probably be ported to Python 2 (thus saving two bytes), but I lack the proper locale to test it. Python 3 dutifully prints an UTF-8 encoded version (or whatever is appropriate for the current locale) of the alphabet.
### Verification
```
$ base64 > hebrew.py -d <<< I2NvZGluZzpjcDg2MgpwcmludCgngIGCg4SFhoeIiYuKjI6NkI+RkpSTlpWXmJmaJyk=
$ wc -c hebrew.py
50 hebrew.py
$ echo $LANG
en_US.UTF-8
$ python3 hebrew.py
אבגדהוזחטיכךלמםנןסעפףצץקרשת
```
[Answer]
# [CJam](http://sourceforge.net/projects/cjam/), 23 bytes
```
27,"%(*.0"{i_)e\}/'אf+
```
[Try it online!](http://cjam.tryitonline.net/#code=MjcsIiUoKi4wIntpXyllXH0vJ9eQZis&input=)
### How it works
```
27,                     Push [0 ... 26].
   "%(*.0"              Push that string. Its code points are [37 40 42 46 48],
                        which are [10 13 15 19 21] modulo the length of the string.
          {     }/      For each character:
           i              Compute its code point.
            _)            Push an incremented copy.
              e\          Swap the integers of [0 ... 26] at those indices.
                  'אf+  Add all resulting integers to the first character of the
                        Hebrew alphabet.
```
[Answer]
# [///](http://esolangs.org/wiki////), 27 bytes
```
ABCDEFGHIQSRTVUXWYbdcfeghiq
```
[Try it online!](http://slashes.tryitonline.net/#code=QUJDREVGR0hJUVNSVFZVWFdZYmRjZmVnaGlx&input=)
Output is encoded in [CP424](http://unicode.org/Public/MAPPINGS/VENDORS/MISC/CP424.TXT).
To verify it yourself:
```
$ echo ABCDEFGHIQSRTVUXWYbdcfeghiq | ./slashes.pl | python3 -c 'print(bytes(input(), "utf-8").decode("cp424"))' | base64
15DXkdeS15PXlNeV15bXl9eY15nXm9ea15zXnted16DXn9eh16LXpNej16bXpden16jXqdeqCg==
```
[Answer]
## JavaScript (ES6), 59 bytes
```
_=>"אבגדהוזחטיכךלמםנןסעפףצץקרשת"
```
Best I could do in ASCII was ~~80~~ ~~79~~ 78 bytes:
```
_=>String.fromCharCode(...[...0x377babbcf7f.toString(3)].map(c=>++n-c,n=1488))
```
If a character array is acceptable, 75 bytes:
```
_=>[...0x377babbcf7f.toString(3)].map(c=>String.fromCharCode(++n-c),n=1488)
```
Edit: Saved some bytes thanks to @IsmaelMiguel. Saved another byte thanks to @ETHproductions. If you use Firefox 30-57 then you can save another 2 bytes thanks to @ETHproductions using generator or array comprehensions:
```
_=>String.fromCharCode(...(for(c of 0x377babbcf7f.toString(3,n=1488))++n-c))
_=>[for(c of 0x377babbcf7f.toString(3,n=1488))String.fromCharCode(++n-c)]
```
[Answer]
# [Brain-Flak](http://github.com/DJMcMayhem/Brain-Flak), 186 bytes
```
(((((((((((((((((((((((((((((((((()()()()()){})){}{}()){({}[()])}{})){}{})())())())())())())())())())()())[()])()())()())[()])()()())[()])()())())()())[()])()()())[()])()())())())())
```
This code is 182 bytes long, and I added 4 bytes for two command line flags: `-r` and `-u`
[Try it online!](http://brain-flak.tryitonline.net/#code=KCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCkoKSgpKCkoKSl7fSkpe317fSgpKXsoe31bKCldKX17fSkpe317fSkoKSkoKSkoKSkoKSkoKSkoKSkoKSkoKSkoKSkoKSgpKVsoKV0pKCkoKSkoKSgpKVsoKV0pKCkoKSgpKVsoKV0pKCkoKSkoKSkoKSgpKVsoKV0pKCkoKSgpKVsoKV0pKCkoKSkoKSkoKSkoKSk&input=&args=LXJ1&debug=on)
Many thanks to @Neil for this [awesome integer metagolfer](https://codegolf.stackexchange.com/a/90608/31716) that created this sweet way of pushing 1488 (the code point of the first character)
```
(((((((()()()()()){})){}{}()){({}[()])}{})){}{})
```
Explanation:
Pushing large number in brain-flak is relatively difficult. However, since the act of pushing a number also evaluates to that number, we can push several numbers at the same time for massive byte savings. Here is a more concrete example. The innermost part (that I wrote above) in psuedo code is
```
push(1488)
```
This expression evaluates to 1488, so we wrap the entire thing in another push statement:
```
push(push(1488) + 1)
```
This pushes 1488 *and* 1489, as well as evaluating to 1489. So we wrap this:
```
push(push(push(1488) + 1) + 1)
```
which pushes 1488, 1489, and 1490, as well as evaluating to 1490. Repeat this step for each number we need to push.
However, since the increments aren't always 1, it's a little bit more complicated than that. Here is a more readable version:
```
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
#Push 1488
(((((((()()()()()){})){}{}()){({}[()])}{})){}{})
())     # + 1
())
())
())
())
())
())
())
())
()())   # + 2
[()])   # - 1
()())   # + 2
()())
[()])   # - 1
()()()) # + 3
[()])   # - 1
()())   # + 2
())     # + 1
()())   # + 2
[()])   # - 1
()()()) # + 3
[()])   # - 1
()())   # + 2
())     # + 1
())
())
```
[Answer]
# [///](//esolangs.org/wiki////), 54 bytes
```
אבגדהוזחטיכךלמםנןסעפףצץקרשת
```
[Try it online!](//slashes.tryitonline.net#code=15DXkdeS15PXlNeV15bXl9eY15nXm9ea15zXnted16DXn9eh16LXpNej16bXpden16jXqdeq)
There can't be any version more golfed than this :(
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), 28\*2-1=55 bytes
```
"אבגדהוזחטיכךלמםנןסעפףצץקרשת
```
[Try it online!](http://05ab1e.tryitonline.net/#code=IteQ15HXkteT15TXldeW15fXmNeZ15vXmtec157Xndeg15_Xodei16TXo9em16XXp9eo16nXqiI&input=)
-1 byte thanks to Emigna + 28 bytes thanks to DJMCMayhem ;).
[Answer]
# Scala/Groovy/Python 3, 9 ascii-chars + 27 2-byte chars = 63 bytes
```
print("אבגדהוזחטיכךלמםנןסעפףצץקרשת")
```
assuming UTF-8
# Scala, 59 bytes
```
print("ABCDEFGHIJLKMONQPRSUTWVXYZ["map(x=>(x+1423).toChar))
```
`x+1423` is the same as `x-'A'+1488`
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), 35 bytes
```
d←⍳27
d[⎕A⍳'KNPTV']+←2
⎕UCS 1487+⍋d
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///P@VR24RHvZuNzLlSoh/1TXUEstW9/QJCwtRjtYFSRlxAQZCSvqmhzsEKhiYW5tqPertT/v8HAA "APL (Dyalog Unicode) – Try It Online")
[Answer]
# C#6+, ~~76~~ ~~86~~ 82 bytes
```
void f()=>Console.Write("אבגדהוזחטיכךלמםנןסעפףצץקרשת");
```
First attempt at Golfing. Am I doing this right?
**EDIT**: +6 bytes for forgetting to enclose in a function. Thanks @Kevin
# C#5 and below version, ~~86~~ 82 bytes
```
void f(){Console.Write("אבגדהוזחטיכךלמםנןסעפףצץקרשת");}
```
[Answer]
# Fourier, 53 bytes
```
|+2a|X1488~i+10(ia^~i)^avaXXva+3avaX^aXva+3avaX^a^a^a
```
Uses functions again.
[**Try it FourIDE!**](https://beta-decay.github.io/editor/?code=fCsyYXxYMTQ4OH5pKzEwKGlhXn5pKV5hdmFYWHZhKzNhdmFYXmFYdmErM2F2YVheYV5hXmE)
[Answer]
# ArnoldC, 112 bytes
```
IT'S SHOWTIME
TALK TO THE HAND "אבגדהוזחטיכךלמםנןסעפףצץקרשת"
YOU HAVE BEEN TERMINATED
```
[Answer]
## [Keg](https://github.com/JonoCode9374/Keg), 34 bytes
Inspired by a Powershell solution.
```
ZYXVWTUSRPQNOMKLJIHGFEDCBA(֏+")(,
```
[TIO](https://tio.run/##y05N//8/KjIiLDwkNDgoINDP39fbx8vTw93N1cXZyVHjWr@2kqaGzv//AA)
[Answer]
# **[BaCon](http://www.basic-converter.org), 57 bytes**
* In most BASICs, the question mark simply represents PRINT.
* At first glance, the solution below looks like 30 bytes, but the Hebrew characters need 2 bytes of storage because of UTF-8. So there are 27 characters x 2 bytes + 1 byte for the '?' and 2 bytes for the double quotes = 57 bytes.
Solution:
```
?"אבגדהוזחטיכךלמםנןסעפףצץקרשת"
```
[Answer]
# [s-lang](http://dgrissom.com/s-lang/), 59 bytes
Really simple answer...
```
t[][אבגדהוזחטיכךלמםנןסעפףצץקרשת]
```
* `t` - replace function (replaces "nothing" in the input with the alphabet...)
## [Try it here](http://dgrissom.com/s-lang/?t[][%D7%90%D7%91%D7%92%D7%93%D7%94%D7%95%D7%96%D7%97%D7%98%D7%99%D7%9B%D7%9A%D7%9C%D7%9E%D7%9D%D7%A0%D7%9F%D7%A1%D7%A2%D7%A4%D7%A3%D7%A6%D7%A5%D7%A7%D7%A8%D7%A9%D7%AA])
[Answer]
# zsh, ~~25~~ 21 bytes
```
echo ${(j..):-{ת..א}}
```
My browser is messing it up: the ת should be the first letter, then the א. If you paste somewhere else, though, it should work. The old version:
```
for i in {ת..א};printf $i
```
[Answer]
# Java 7, 85 bytes
```
void c(){System.out.print("אבגדהוזחטיכךלמםנןסעפףצץקרשת");}
```
I'm not even gonna bother posting test code or a 'Try it here' like I usually do..
[Answer]
## Perl 6 (74)
```
(map (*+1488).chr,[\+] '122222222230330403230403222'.comb >>->>1.join.say
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), 49 bytes
```
-11.upto(15){|r|$><<(""<<r+1499-2601[r]+5202[r])}
```
[Try it online!](https://tio.run/##KypNqvz/X9fQUK@0oCRfw9BUs7qmqEbFzsZGQ0nJxqZI29DE0lLXyMzAMLooVtvUyMAISGvW/v8PAA "Ruby – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), 23 bytes
```
main=putStr['א'..'ת']
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/PzcxM8@2oLQkuKQoWv36BHU9PfXrq9Rj//8HAA "Haskell – Try It Online")
This works in TIO's version of Haskell
[Answer]
# C, 49 bytes
```
f(i){for(i=0x5d0;i<=0x5ea;i++)wprintf(L"%lc",i);}
```
Some users may need to call `setlocale` before using this but it worked fine for me.
[Answer]
# [Clean](https://clean.cs.ru.nl), 62 bytes
```
Start="אבגדהוזחטיכךלמםנןסעפףצץקרשת"
```
[Try it online!](https://tio.run/##BcFtEkJQGIDRrTT@W0KrsIJLGDMXM2gfJUL5iIja0LMbb@c42lWRhPHprN1DqIJIrEwl2dHgwpWcGwUldypqGp48aOnpeDEwMjHz5sPCysaXnyGyO55Wfiqm/Qc "Clean – Try It Online")
]