Su tarea es imprimir este texto exacto:

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

(Se le permite imprimir una nueva línea al final)

SHA256 hash de la codificación UTF-8 del texto:

0ab6f1e0bf216a0db52a4a5a247f95cba6f51496de7a24dfd01f3985dfcf6085

Codificación Base64:

15DXkdeS15PXlNeV15bXl9eY15nXm9ea15zXnted16DXn9eh16LXpNej16bXpden16jXqdeq

Reglas

• No puede usar un resultado interno que genere este texto.
• Las lagunas estándar no están permitidas.
• Este es el código de golf , por lo que gana la respuesta más corta.

¡Buena suerte!

MATLAB, 52 51 bytes

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

Ejemplo de uso:

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

Explicación

'CCCCCCCCCDADDAEADCDAEADCCC'-66 produce la matriz [1 1 ... -1 2 1 1 1] , que contiene las diferencias consecutivas entre los puntos de código de los caracteres deseados.

[1488 ...]antecede 1488, por lo que la matriz es ahora[1488 1 1 ... -1 2 1 1 1] .

cumsum(...) calcula la suma acumulativa: [1488 1489 ... 1514] .

[... '']concatena con la cadena vacía. Esto tiene el efecto de convertir a char (y es un byte más corto que char(...))

Jalea , 22 21 20 bytes

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

Pruébalo en línea!

Idea

Si restamos 1487 de cada punto de código, obtenemos la matriz R que sigue.

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

Eso es solo el rango de 1 a 27 , pero no en orden ascendente; los pares (11, 12) , (14, 15) , (16, 17) , (20, 21) y (22, 23) han sido intercambiados.

Si tomamos el rango ascendente y sumamos 2 a 11 , 14 , 16 , 20 y 22 , obtenemos la matriz A que sigue.

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

Esto ya no es una permutación del rango, pero si clasificamos el rango de manera estable por los valores de esa matriz, podemos reconstruir la matriz original.

Código

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

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

PowerShell Unicode es UTF-16 a menos que se especifique explícitamente lo contrario, y de todos modos es una trampa ya que todo es UTF-16 en segundo plano.

Esto simplemente coloca la cadena literal en la tubería y el valor predeterminado Write-Outputal final de la ejecución del programa lo imprime en la pantalla.

Lo más corto que pude obtener la versión ASCII es 63

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

Que toma el valor ASCII de la cadena ABC...y agrega 1423a cada uno charpara obtener la cadena adecuada.

05AB1E , 36 29 26 25 23 bytes

Guardado 2 bytes gracias a Adnan

Utiliza la codificación CP-1252 .

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

Pruébalo en línea!

Explicación

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

Esta respuesta se basa principalmente en una solución de DJMcMayhem aquí, por lo que le recomiendo que la revise.

Al igual que la solución de DJMcMayhem, esta utiliza la -rAbandera para invertir la salida e imprimir en unicode.

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

Pruébalo en línea!

Explicación

Di esta respuesta ejecutando un montón de micro optimizaciones sobre la solución original proporcionada por DJMcMayhem. Estas optimizaciones al guardar bytes hacen que el código sea ilegible y el algoritmo sea obtuso. Yo, para ser honesto, realmente no entiendo cómo o qué hace mi código.

Quizás algún día entienda cómo funciona esto ...

Python 3, 50 bytes

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

El archivo debe crearse utilizando la codificación CP862 o invirtiendo el siguiente 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                                            ')

Esto probablemente podría ser portado a Python 2 (ahorrando así dos bytes), pero me falta la configuración regional adecuada para probarlo. Python 3 imprime obedientemente una versión codificada UTF-8 (o lo que sea apropiado para la ubicación actual) del alfabeto.

Verificación

$ 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+

Pruébalo en línea!

Cómo funciona

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

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

Este código tiene una longitud de 182 bytes, y agregué 4 bytes para dos banderas de línea de comando: -ry-u

Pruébalo en línea!

Muchas gracias a @Neil por este increíble metagolfer entero que creó esta dulce forma de impulsar 1488 (el punto de código del primer personaje)

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

Explicación:

Empujar un gran número de ataques cerebrales es relativamente difícil. Sin embargo, dado que el acto de presionar un número también se evalúa a ese número, podemos empujar varios números al mismo tiempo para obtener ahorros masivos en bytes. Aquí hay un ejemplo más concreto. La parte más interna (que escribí anteriormente) en el código psuedo es

push(1488)

Esta expresión se evalúa como 1488, por lo que envolvemos todo en otra declaración push:

push(push(1488) + 1)

Esto empuja a 1488 y 1489, además de evaluar a 1489. Así que concluimos esto:

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

que empuja 1488, 1489 y 1490, además de evaluar hasta 1490. Repita este paso para cada número que necesitemos empujar.

Sin embargo, dado que los incrementos no siempre son 1, es un poco más complicado que eso. Aquí hay una versión más legible:

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

/// , 27 bytes

ABCDEFGHIQSRTVUXWYbdcfeghiq

Pruébalo en línea!

La salida está codificada en CP424 .

Para verificarlo usted mismo:

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

JavaScript (ES6), 59 bytes

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

Lo mejor que pude hacer en ASCII fue 80 79 78 bytes:

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

Si una matriz de caracteres es aceptable, 75 bytes:

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

Editar: guardado algunos bytes gracias a @IsmaelMiguel. Se guardó otro byte gracias a @ETHproductions. Si usa Firefox 30-57, entonces puede guardar otros 2 bytes gracias a @ETHproductions usando el generador o la comprensión de la matriz:

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

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

Pruébalo en línea!

-1 byte gracias a Emigna + 28 bytes gracias a DJMCMayhem;).

/// , 54 bytes

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

Pruébalo en línea!

No puede haber ninguna versión más desarrollada que esta :(

Scala / Groovy / Python 3, 9 caracteres ascii + 27 caracteres de 2 bytes = 63 bytes

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

asumiendo UTF-8

Scala, 59 bytes

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

x+1423 es lo mismo que x-'A'+1488

APL (Dyalog) , 35 bytes

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

Pruébalo en línea!

C # 6 +, 76 86 82 bytes

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

Primer intento de golf. ¿Lo estoy haciendo bien?

EDITAR : +6 bytes para olvidar encerrar en una función. Gracias @Kevin

C # 5 y versiones inferiores, 86 82 bytes

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

Fourier, 53 bytes

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

Utiliza funciones de nuevo.

Pruébalo FourIDE!

ArnoldC, 112 bytes

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

Barril , 34 bytes

Inspirado en una solución Powershell.

ZYXVWTUSRPQNOMKLJIHGFEDCBA(֏+")(,

TIO

BaCon , 57 bytes

• En la mayoría de los BÁSICOS, el signo de interrogación simplemente representa IMPRESIÓN.

• A primera vista, la solución a continuación se ve como 30 bytes, pero los caracteres hebreos necesitan 2 bytes de almacenamiento debido a UTF-8. Entonces hay 27 caracteres x 2 bytes + 1 byte para el '?' y 2 bytes para las comillas dobles = 57 bytes.

Solución:

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

argot , 59 bytes

Respuesta realmente simple ...

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

• t - Reemplazar función (reemplaza "nada" en la entrada con el alfabeto ...)

Pruébalo aquí

zsh, 25 21 bytes

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

Mi navegador lo está estropeando: el ת debería ser la primera letra, luego el א. Sin embargo, si pega en otro lugar, debería funcionar. La versión anterior:

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

Java 7, 85 bytes

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

Ni siquiera me voy a molestar en publicar el código de prueba o un 'Pruébalo aquí' como hago habitualmente ...

Perl 6 (74)

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

Ruby , 49 bytes

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

Pruébalo en línea!

Haskell , 23 bytes

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

Pruébalo en línea!

Esto funciona en la versión de TIO de Haskell

C, 49 bytes

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

Algunos usuarios pueden necesitar llamar setlocaleantes de usar esto, pero funcionó bien para mí.

Limpio , 62 bytes

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

Pruébalo en línea!