Votre tâche consiste à imprimer ce texte exact:

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

(Vous êtes autorisé à imprimer une nouvelle ligne de fin)

Hachage SHA256 de l'encodage UTF-8 du texte:

0ab6f1e0bf216a0db52a4a5a247f95cba6f51496de7a24dfd01f3985dfcf6085

Encodage Base64:

15DXkdeS15PXlNeV15bXl9eY15nXm9ea15zXnted16DXn9eh16LXpNej16bXpden16jXqdeq

Règles

• Vous ne pouvez pas utiliser de sortie intégrée pour ce texte.
• Les failles standard ne sont pas autorisées.
• C'est le golf de code , donc la réponse la plus courte l'emporte.

Bonne chance!

MATLAB, 52 51 octets

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

Exemple d'utilisation:

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

Explication

'CCCCCCCCCDADDAEADCDAEADCCC'-66produit le tableau [1 1 ... -1 2 1 1 1], qui contient les différences consécutives entre les points de code des caractères souhaités.

[1488 ...]ajoute 1488, donc le tableau est maintenant [1488 1 1 ... -1 2 1 1 1].

cumsum(...)calcule la somme cumulée: [1488 1489 ... 1514].

[... '']concatène avec la chaîne vide. Cela a pour effet de convertir en char (et est un octet plus court que char(...))

Gelée , 22 21 20 octets

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

Essayez-le en ligne!

Idée

Si nous soustrayons 1487 de chaque point de code, nous obtenons le tableau R qui suit.

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

C'est juste la plage de 1 à 27 , mais pas dans l'ordre croissant; les paires (11, 12) , (14, 15) , (16, 17) , (20, 21) et (22, 23) ont été échangées.

Si nous prenons la plage ascendante et ajoutons 2 à 11 , 14 , 16 , 20 et 22 , nous obtenons le tableau A qui suit.

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

Ce n'est plus une permutation de la plage, mais si nous trions la plage de manière stable en fonction des valeurs de ce tableau, nous pouvons reconstruire le tableau d'origine.

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 octets (UTF-16)

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

PowerShell Unicode est UTF-16 sauf indication contraire explicite, puis c'est un crapshoot de toute façon car tout est UTF-16 en arrière-plan.

Cela place simplement la chaîne littérale sur le pipeline et la valeur par défaut Write-Outputà la fin de l'exécution du programme l'imprime à l'écran.

Le plus court que j'ai pu obtenir la version ASCII est 63

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

Ce qui prend la valeur ASCII de la chaîne ABC...et s'ajoute 1423à chacun charpour obtenir la chaîne appropriée.

05AB1E , 36 29 26 25 23 octets

Enregistré 2 octets grâce à Adnan

Utilise l' encodage CP-1252 .

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

Essayez-le en ligne!

Explication

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 octets

Cette réponse est basée en grande partie sur une solution de DJMcMayhem ici, donc je vous recommande de la vérifier.

Comme la solution de DJMcMayhem, elle utilise le -rAdrapeau pour inverser la sortie et imprimer en unicode.

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

Essayez-le en ligne!

Explication

J'ai fait cette réponse en exécutant un tas de micro-optimisations sur la solution originale fournie par DJMcMayhem. Ces optimisations, tout en économisant des octets, rendent le code illisible et l'algorithme obtus. Pour être honnête, je ne comprends pas vraiment comment ni ce que fait mon code.

Peut-être qu'un jour je comprendrai comment cela fonctionne ...

Python 3, 50 octets

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

Le fichier doit être créé à l'aide de l'encodage CP862 ou en inversant le vidage hexadécimal suivant.

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

Cela pourrait probablement être porté sur Python 2 (économisant ainsi deux octets), mais je n'ai pas les paramètres régionaux appropriés pour le tester. Python 3 imprime consciencieusement une version encodée UTF-8 (ou ce qui est approprié pour les paramètres régionaux actuels) de l'alphabet.

Vérification

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

CJam , 23 octets

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

Essayez-le en ligne!

Comment ça marche

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 octets

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

Ce code fait 182 octets et j'ai ajouté 4 octets pour deux drapeaux de ligne de commande: -ret-u

Essayez-le en ligne!

Un grand merci à @Neil pour ce génial métagolfer entier qui a créé cette douce façon de pousser 1488 (le point de code du premier caractère)

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

Explication:

Il est relativement difficile de pousser un grand nombre dans le cerveau-flak. Cependant, étant donné que l'acte de pousser un nombre est également évalué à ce nombre, nous pouvons pousser plusieurs nombres en même temps pour des économies massives d'octets. Voici un exemple plus concret. La partie la plus intérieure (que j'ai écrite ci-dessus) dans le code pseudo est

push(1488)

Cette expression est évaluée à 1488, nous enveloppons donc le tout dans une autre instruction push:

push(push(1488) + 1)

Cela pousse 1488 et 1489, ainsi que l'évaluation à 1489. Nous terminons donc ceci:

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

qui pousse 1488, 1489 et 1490, ainsi que l'évaluation à 1490. Répétez cette étape pour chaque nombre que nous devons pousser.

Cependant, comme les incréments ne sont pas toujours à 1, c'est un peu plus compliqué que ça. Voici une version plus lisible:

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

/// , 27 octets

ABCDEFGHIQSRTVUXWYbdcfeghiq

Essayez-le en ligne!

La sortie est codée en CP424 .

Pour le vérifier vous-même:

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

JavaScript (ES6), 59 octets

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

Le mieux que je pouvais faire en ASCII était de 80 79 78 octets:

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

Si un tableau de caractères est acceptable, 75 octets:

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

Edit: sauvé quelques octets grâce à @IsmaelMiguel. Un autre octet enregistré grâce à @ETHproductions. Si vous utilisez Firefox 30-57, vous pouvez économiser encore 2 octets grâce à @ETHproductions à l'aide de générateurs ou de compréhensions de tableaux:

_=>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 octets

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

Essayez-le en ligne!

-1 octet grâce à Emigna + 28 octets grâce à DJMCMayhem;).

/// , 54 octets

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

Essayez-le en ligne!

Il ne peut y avoir de version plus jouée que celle-ci :(

Scala / Groovy / Python 3, 9 caractères ascii + 27 caractères 2 octets = 63 octets

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

en supposant UTF-8

Scala, 59 octets

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

x+1423 est le même que x-'A'+1488

APL (Dyalog) , 35 octets

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

Essayez-le en ligne!

C # 6 +, 76 86 82 octets

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

Première tentative de golf. Suis-je en train de faire ça?

EDIT : +6 octets pour oublier d'inclure dans une fonction. Merci @Kevin

Version C # 5 et inférieure, 86 82 octets

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

Fourier, 53 octets

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

Utilise à nouveau les fonctions.

Essayez-le FourIDE!

ArnoldC, 112 octets

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

Keg , 34 octets

Inspiré d'une solution Powershell.

ZYXVWTUSRPQNOMKLJIHGFEDCBA(֏+")(,

TIO

BaCon , 57 octets

• Dans la plupart des BASIC, le point d'interrogation représente simplement PRINT.

• À première vue, la solution ci-dessous ressemble à 30 octets, mais les caractères hébreux ont besoin de 2 octets de stockage en raison de l'UTF-8. Il y a donc 27 caractères x 2 octets + 1 octet pour le "?" et 2 octets pour les guillemets doubles = 57 octets.

Solution:

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

s-lang , 59 octets

Réponse vraiment simple ...

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

• t - remplacer la fonction (remplace "rien" dans l'entrée par l'alphabet ...)

Essayez-le ici

zsh, 25 21 octets

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

Mon navigateur est en train de tout gâcher: le ת devrait être la première lettre, puis le א. Si vous collez ailleurs, cela devrait fonctionner. L'ancienne version:

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

Java 7, 85 octets

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

Je ne vais même pas prendre la peine de poster du code de test ou un "Essayez-le ici" comme je le fais habituellement ..

Perl 6 (74)

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

Rubis , 49 octets

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

Essayez-le en ligne!

Haskell , 23 octets

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

Essayez-le en ligne!

Cela fonctionne dans la version TIO de Haskell

C, 49 octets

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

Certains utilisateurs peuvent avoir besoin d'appeler setlocaleavant d'utiliser cela, mais cela a bien fonctionné pour moi.

Nettoyer , 62 octets

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

Essayez-le en ligne!