Output the Hebrew alphabet

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, so the shortest answer wins.

Good luck!

Answer 1

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 2

Jelly, 22 21 20 bytes

27R+“¿ÇÑÞ摦2Ụ+1487Ọ

Try it online!

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 3

PowerShell v2+, 58 bytes (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 4

05AB1E, 36 29 26 25 23 bytes

Saved 2 bytes thanks to Adnan

Uses CP-1252 encoding.

1488•’ÉÇW–moû•5Bvy<+Dç?

Try it online!

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 5

Brain-Flak, 172 bytes

This answer is based largely one DJMcMayhem's solution here 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!

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 6

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 7

CJam, 23 bytes

27,"%(*.0"{i_)e\}/'אf+

Try it online!

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 8

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!

Many thanks to @Neil for this awesome integer metagolfer 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 9

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 10

///, 27 bytes

ABCDEFGHIQSRTVUXWYbdcfeghiq

Try it online!

Output is encoded in CP424.

To verify it yourself:

$ echo ABCDEFGHIQSRTVUXWYbdcfeghiq | ./slashes.pl | python3 -c 'print(bytes(input(), "utf-8").decode("cp424"))' | base64
15DXkdeS15PXlNeV15bXl9eY15nXm9ea15zXnted16DXn9eh16LXpNej16bXpden16jXqdeqCg==

Answer 11

05AB1E, 28*2-1=55 bytes

"אבגדהוזחטיכךלמםנןסעפףצץקרשת

Try it online!

-1 byte thanks to Emigna + 28 bytes thanks to DJMCMayhem ;).

Answer 12

///, 54 bytes

אבגדהוזחטיכךלמםנןסעפףצץקרשת

Try it online!

There can't be any version more golfed than this :(

Answer 13

APL (Dyalog), 35 bytes

d←⍳27
d[⎕A⍳'KNPTV']+←2
⎕UCS 1487+⍋d

Try it online!

Answer 14

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 15

ArnoldC, 112 bytes

IT'S SHOWTIME
TALK TO THE HAND "אבגדהוזחטיכךלמםנןסעפףצץקרשת"
YOU HAVE BEEN TERMINATED

Answer 16

Fourier, 53 bytes

|+2a|X1488~i+10(ia^~i)^avaXXva+3avaX^aXva+3avaX^a^a^a

Uses functions again.

Try it FourIDE!

Answer 17

Keg, 34 bytes

Inspired by a Powershell solution.

ZYXVWTUSRPQNOMKLJIHGFEDCBA(֏+")(,

TIO

Answer 18

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 19

Perl 6 (74)

(map (*+1488).chr,[\+] '122222222230330403230403222'.comb >>->>1.join.say

Answer 20

Ruby, 49 bytes

-11.upto(15){|r|$><<(""<<r+1499-2601[r]+5202[r])}

Try it online!

Answer 21

Haskell, 23 bytes

main=putStr['א'..'ת']

Try it online!

This works in TIO's version of Haskell

Answer 22

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 23

Clean, 62 bytes

Start="אבגדהוזחטיכךלמםנןסעפףצץקרשת"

Try it online!

Answer 24

BaCon, 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 25

s-lang, 59 bytes

Really simple answer...

t[][אבגדהוזחטיכךלמםנןסעפףצץקרשת]

• t - replace function (replaces "nothing" in the input with the alphabet...)

Try it here

Answer 26

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 27

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..