Ihre Aufgabe ist es, genau diesen Text auszudrucken:

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

(Sie dürfen eine abschließende neue Zeile drucken)

SHA256-Hash der UTF-8-Codierung des Texts:

0ab6f1e0bf216a0db52a4a5a247f95cba6f51496de7a24dfd01f3985dfcf6085

Base64-Codierung:

15DXkdeS15PXlNeV15bXl9eY15nXm9ea15zXnted16DXn9eh16LXpNej16bXpden16jXqdeq

Regeln

• Sie können keine eingebaute Funktion verwenden, um diesen Text auszugeben.
• Standardlücken sind nicht zulässig.
• Das ist Code-Golf , also gewinnt die kürzeste Antwort.

Viel Glück!

MATLAB, 52 51 Bytes

[cumsum([1488 'CCCCCCCCCDADDAEADCDAEADCCC'-66]) '']

Beispiel Verwendung:

>> [cumsum([1488 'CCCCCCCCCDADDAEADCDAEADCCC'-66]) '']
ans =
אבגדהוזחטיכךלמםנןסעפףצץקרשת

Erläuterung

'CCCCCCCCCDADDAEADCDAEADCCC'-66erzeugt das Array [1 1 ... -1 2 1 1 1], das die aufeinander folgenden Unterschiede zwischen den Codepunkten der gewünschten Zeichen enthält.

[1488 ...]voranstellen 1488, so ist das Array jetzt [1488 1 1 ... -1 2 1 1 1].

cumsum(...)berechnet die kumulative Summe: [1488 1489 ... 1514].

[... '']verkettet mit der leeren Zeichenfolge. Dies hat den Effekt der Konvertierung in char (und ist ein Byte kürzer als char(...))

Jelly , 22 21 20 Bytes

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

Probieren Sie es online!

Idee

Wenn wir von jedem Codepunkt 1487 subtrahieren , erhalten wir das Array R , das folgt.

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

Das ist nur der Bereich von 1 bis 27 , aber nicht in aufsteigender Reihenfolge. Die Paare (11, 12) , (14, 15) , (16, 17) , (20, 21) und (22, 23) wurden vertauscht.

Wenn wir den ansteigenden Bereich nehmen und fügen Sie 2 zu 11 , 14 , 16 , 20 und 22 , wir das Array erhalten A , die folgt.

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

Dies ist keine Permutation des Bereichs mehr, aber wenn wir den Bereich stabil nach den Werten in diesem Array sortieren, können wir das ursprüngliche Array rekonstruieren.

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.

PowerShell v2 +, 58 Byte (UTF-16)

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

PowerShell Unicode ist UTF-16, sofern nicht ausdrücklich anders angegeben, und dann ist es sowieso ein Crapshoot, da sich alles in UTF-16 im Hintergrund befindet.

Dadurch wird nur die Literalzeichenfolge in die Pipeline eingefügt, und die Standardzeichenfolge Write-Outputam Ende der Programmausführung wird auf dem Bildschirm ausgegeben.

Die kürzeste mögliche ASCII-Version ist 63

-join([char[]]'ABCDEFGHIJLKMONQPRSUTWVXYZ['|%{[char](1423+$_)})

Wobei der ASCII-Wert der Zeichenfolge verwendet ABC...und 1423zu jeder Zeichenfolge addiert wird char, um die entsprechende Zeichenfolge zu erhalten.

05AB1E , 36 29 26 25 23 Byte

2 Bytes gespart dank Adnan

Verwendet CP-1252- Codierung.

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

Probieren Sie es online!

Erläuterung

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

Brain-Flak , 172 Bytes

Diese Antwort basiert größtenteils auf einer DJMcMayhem-Lösung, daher empfehle ich Ihnen, sie sich anzusehen .

Wie bei der DJMcMayhem-Lösung wird das -rAFlag verwendet, um die Ausgabe umzukehren und in Unicode zu drucken.

(((((()()()()()){})))<(((({}{}{}()){({}[()])}{})){}{})>){({}[()]<(({})())>)}{}(((((()()())((((((((({}(((({}())[()])()())()())[()]))[()])()())())()())[()]))[()])()())())())())

Probieren Sie es online!

Erläuterung

Zu dieser Antwort habe ich eine Reihe von Mikrooptimierungen für die ursprüngliche Lösung von DJMcMayhem durchgeführt. Diese Optimierungen beim Speichern von Bytes machen den Code unlesbar und den Algorithmus stumpf. Um ehrlich zu sein, verstehe ich nicht wirklich, wie oder was mein Code tut.

Vielleicht werde ich eines Tages verstehen, wie das funktioniert ...

Python 3, 50 Bytes

#coding:cp862
print('אבגדהוזחטיכךלמםנןסעפףצץקרשת')

Die Datei muss mit der CP862-Codierung oder durch Umkehren des folgenden Hexdumps erstellt werden.

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                                            ')

Dies könnte wahrscheinlich auf Python 2 portiert werden (wodurch zwei Bytes gespart werden), aber mir fehlt das richtige Gebietsschema, um es zu testen. Python 3 druckt pflichtbewusst eine UTF-8-codierte Version (oder was auch immer für das aktuelle Gebietsschema geeignet ist) des Alphabets.

Nachprüfung

$ base64 > hebrew.py -d <<< I2NvZGluZzpjcDg2MgpwcmludCgngIGCg4SFhoeIiYuKjI6NkI+RkpSTlpWXmJmaJyk=
$ wc -c hebrew.py
50 hebrew.py
$ echo $LANG
en_US.UTF-8
$ python3 hebrew.py
אבגדהוזחטיכךלמםנןסעפףצץקרשת

CJam , 23 Bytes

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

Probieren Sie es online!

Wie es funktioniert

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.

Brain-Flak , 186 Bytes

(((((((((((((((((((((((((((((((((()()()()()){})){}{}()){({}[()])}{})){}{})())())())())())())())())())()())[()])()())()())[()])()()())[()])()())())()())[()])()()())[()])()())())())())

Dieser Code ist 182 Byte lang und ich habe 4 Byte für zwei Befehlszeilenflags hinzugefügt: -rund-u

Probieren Sie es online!

Vielen Dank an @Neil für diesen fantastischen Ganzzahl-Metagolfer , der diese süße Art des Drückens von 1488 (dem Codepunkt des ersten Zeichens) geschaffen hat.

(((((((()()()()()){})){}{}()){({}[()])}{})){}{})

Erläuterung:

Es ist relativ schwierig, eine große Anzahl von Hirnschuppen einzuschieben. Da das Pushen einer Zahl jedoch auch diese Zahl ergibt, können mehrere Zahlen gleichzeitig gepusht werden, um massive Byteeinsparungen zu erzielen. Hier ist ein konkreteres Beispiel. Der innerste Teil (den ich oben geschrieben habe) im Pseudocode ist

push(1488)

Dieser Ausdruck ergibt 1488, daher schließen wir das Ganze in eine weitere Push-Anweisung ein:

push(push(1488) + 1)

Dies schiebt 1488 und 1489 sowie die Auswertung auf 1489. Also wickeln wir dies:

push(push(push(1488) + 1) + 1)

Dies drückt 1488, 1489 und 1490 und bewertet 1490. Wiederholen Sie diesen Schritt für jede Zahl, die wir drücken müssen.

Da die Inkremente jedoch nicht immer 1 sind, ist es etwas komplizierter. Hier ist eine besser lesbare Version:

(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
(
#Push 1488
(((((((()()()()()){})){}{}()){({}[()])}{})){}{})
())     # + 1
())
())
())
())
())
())
())
())
()())   # + 2
[()])   # - 1
()())   # + 2
()())
[()])   # - 1
()()()) # + 3
[()])   # - 1
()())   # + 2
())     # + 1
()())   # + 2
[()])   # - 1
()()()) # + 3
[()])   # - 1
()())   # + 2
())     # + 1
())
())

/// 27 Bytes

ABCDEFGHIQSRTVUXWYbdcfeghiq

Probieren Sie es online!

Der Ausgang ist im CP424 codiert .

So überprüfen Sie es selbst:

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

JavaScript (ES6), 59 Byte

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

Das Beste, was ich in ASCII machen konnte, waren 80 79 78 Bytes:

_=>String.fromCharCode(...[...0x377babbcf7f.toString(3)].map(c=>++n-c,n=1488))

Wenn ein Zeichenarray zulässig ist, 75 Byte:

_=>[...0x377babbcf7f.toString(3)].map(c=>String.fromCharCode(++n-c),n=1488)

Bearbeiten: Einige Bytes dank @IsmaelMiguel gespeichert. Dank @ETHproductions wurde ein weiteres Byte gespeichert. Wenn Sie Firefox 30-57 verwenden, können Sie dank @ETHproductions mit Generator- oder Array-Verständnis weitere 2 Bytes einsparen:

_=>String.fromCharCode(...(for(c of 0x377babbcf7f.toString(3,n=1488))++n-c))
_=>[for(c of 0x377babbcf7f.toString(3,n=1488))String.fromCharCode(++n-c)]

05AB1E , 28 * 2-1 = 55 Bytes

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

Probieren Sie es online!

-1 Byte dank Emigna + 28 Byte dank DJMCMayhem;).

/// 54 Bytes

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

Probieren Sie es online!

Es kann keine Version geben, die mehr Golf spielt als diese :(

Scala / Groovy / Python 3, 9 ASCII-Zeichen + 27 2-Byte-Zeichen = 63 Byte

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

unter der Annahme von UTF-8

Scala, 59 Bytes

print("ABCDEFGHIJLKMONQPRSUTWVXYZ["map(x=>(x+1423).toChar))

x+1423 ist das gleiche wie x-'A'+1488

APL (Dyalog) , 35 Bytes

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

Probieren Sie es online!

C # 6 +, 76 86 82 Bytes

void f()=>Console.Write("אבגדהוזחטיכךלמםנןסעפףצץקרשת");

Erster Golfversuch. Mache ich das richtig?

EDIT : +6 Bytes, um zu vergessen, eine Funktion einzuschließen. Vielen Dank @ Kevin

C # 5 und niedriger Version, 86 82 Bytes

void f(){Console.Write("אבגדהוזחטיכךלמםנןסעפףצץקרשת");}

Fourier, 53 Bytes

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

Verwendet wieder Funktionen.

Probieren Sie es aus FourIDE!

ArnoldC, 112 Bytes

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

Fass , 34 Bytes

Inspiriert von einer Powershell-Lösung.

ZYXVWTUSRPQNOMKLJIHGFEDCBA(֏+")(,

TIO

BaCon , 57 Bytes

• In den meisten BASICs steht das Fragezeichen lediglich für PRINT.

• Auf den ersten Blick sieht die unten stehende Lösung wie 30 Bytes aus, aber die hebräischen Zeichen benötigen wegen UTF-8 2 Bytes Speicherplatz. Es gibt also 27 Zeichen x 2 Bytes + 1 Byte für das '?' und 2 Bytes für die doppelten Anführungszeichen = 57 Bytes.

Lösung:

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

s-lang , 59 Bytes

Wirklich einfache Antwort ...

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

• t - Funktion ersetzen (ersetzt "nichts" in der Eingabe durch das Alphabet ...)

Probieren Sie es hier aus

zsh, 25 21 Bytes

echo ${(j..):-{ת..א}}

Mein Browser bringt es durcheinander: Das ת sollte der erste Buchstabe sein, dann das א. Wenn Sie es jedoch an einer anderen Stelle einfügen, sollte es funktionieren. Die alte Version:

for i in {ת..א};printf $i

Java 7, 85 Bytes

void c(){System.out.print("אבגדהוזחטיכךלמםנןסעפףצץקרשת");}

Ich werde mir nicht einmal die Mühe machen, einen Testcode oder ein 'Try it here' zu posten, wie ich es normalerweise tue.

Perl 6 (74)

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

Ruby , 49 Bytes

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

Probieren Sie es online!

Haskell , 23 Bytes

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

Probieren Sie es online!

Dies funktioniert in der TIO-Version von Haskell

C 49 Bytes

f(i){for(i=0x5d0;i<=0x5ea;i++)wprintf(L"%lc",i);}

Einige Benutzer müssen möglicherweise anrufen, setlocalebevor sie dies verwenden, aber es hat für mich gut funktioniert.

Sauber , 62 Bytes

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

Probieren Sie es online!