Sua tarefa é imprimir este texto exato:

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

(Você tem permissão para imprimir uma nova linha à direita)

Hash SHA256 da codificação UTF-8 do texto:

0ab6f1e0bf216a0db52a4a5a247f95cba6f51496de7a24dfd01f3985dfcf6085

Codificação Base64:

15DXkdeS15PXlNeV15bXl9eY15nXm9ea15zXnted16DXn9eh16LXpNej16bXpden16jXqdeq

Regras

• Você não pode usar um built-in que produza este texto.
• As brechas padrão não são permitidas.
• Isso é código-golfe , então a resposta mais curta vence.

Boa sorte!

MATLAB, 52 51 bytes

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

Exemplo de uso:

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

Explicação

'CCCCCCCCCDADDAEADCDAEADCCC'-66produz a matriz [1 1 ... -1 2 1 1 1], que contém as diferenças consecutivas entre os pontos de código dos caracteres desejados.

[1488 ...]precede 1488, então a matriz é agora [1488 1 1 ... -1 2 1 1 1].

cumsum(...)computa a soma cumulativa: [1488 1489 ... 1514].

[... '']concatena com a cadeia vazia. Isso tem o efeito de converter para char (e é um byte menor que char(...))

Geléia , 22 21 20 bytes

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

Experimente online!

Idéia

Se subtrairmos 1487 de cada ponto de código, obteremos a matriz R a seguir.

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

Isso é apenas o intervalo de 1 a 27 , mas não em ordem crescente; os pares (11, 12) , (14, 15) , (16, 17) , (20, 21) e (22, 23) foram trocados.

Se pegarmos o intervalo ascendente e adicionarmos 2 a 11 , 14 , 16 , 20 e 22 , obteremos o array A a seguir.

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

Isso não é mais uma permutação do intervalo, mas se classificarmos o intervalo de forma estável pelos valores nessa matriz, poderemos reconstruir a 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)

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

O PowerShell Unicode é UTF-16, a menos que seja especificado explicitamente de outra forma, e, de qualquer maneira, é um crapshoot, pois é todo o UTF-16 em segundo plano.

Isso apenas coloca a string literal no pipeline e o padrão Write-Outputno final da execução do programa a imprime na tela.

O mais curto que consegui obter a versão ASCII é 63

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

Que pega o valor ASCII da string ABC...e adiciona 1423a cada um charpara obter a string apropriada.

05AB1E , 36 29 26 25 23 bytes

Economizou 2 bytes graças a Adnan

Usa a codificação CP-1252 .

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

Experimente online!

Explicação

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

Flak cerebral , 172 bytes

Esta resposta é baseada principalmente em uma solução do DJMcMayhem aqui, então eu recomendo que você verifique.

Como a solução do DJMcMayhem, isso usa o -rAsinalizador para reverter a saída e imprimir em unicode.

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

Experimente online!

Explicação

Fiz essa resposta executando várias micro otimizações sobre a solução original fornecida pelo DJMcMayhem. Essas otimizações ao salvar bytes tornam o código ilegível e o algoritmo obtuso. Para ser sincero, eu realmente não entendo como ou o que meu código faz.

Talvez um dia eu entenda como isso funciona ...

Python 3, 50 bytes

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

O arquivo deve ser criado usando a codificação CP862 ou revertendo o seguinte 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                                            ')

Provavelmente, isso pode ser portado para o Python 2 (economizando assim dois bytes), mas me falta o local apropriado para testá-lo. O Python 3 imprime obedientemente uma versão codificada em UTF-8 (ou o que for apropriado para a localidade atual) do alfabeto.

Verificação

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

Experimente online!

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

Flacidez Cerebral , 186 bytes

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

Esse código tem 182 bytes e eu adicionei 4 bytes para dois sinalizadores de linha de comando: -re-u

Experimente online!

Muito obrigado a @Neil por este incrível metagolfer inteiro que criou essa maneira doce de pressionar 1488 (o ponto de código do primeiro caractere)

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

Explicação:

Empurrar um grande número de ataques cerebrais é relativamente difícil. No entanto, como o ato de enviar um número também é avaliado para esse número, podemos enviar vários números ao mesmo tempo para obter grandes economias de bytes. Aqui está um exemplo mais concreto. A parte mais interna (que eu escrevi acima) no código psuedo é

push(1488)

Essa expressão é avaliada em 1488, portanto, envolvemos a coisa inteira em outra instrução push:

push(push(1488) + 1)

Isso empurra 1488 e 1489, além de avaliar para 1489. Então, envolvemos isso:

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

que envia 1488, 1489 e 1490, além de avaliar para 1490. Repita esta etapa para cada número que precisarmos enviar.

No entanto, como os incrementos nem sempre são 1, é um pouco mais complicado que isso. Aqui está uma versão mais legível:

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

/// , 27 bytes

ABCDEFGHIQSRTVUXWYbdcfeghiq

Experimente online!

A saída é codificada no CP424 .

Para verificar você mesmo:

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

JavaScript (ES6), 59 bytes

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

O melhor que pude fazer em ASCII foi 80 79 78 bytes:

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

Se uma matriz de caracteres for aceitável, 75 bytes:

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

Editar: salvou alguns bytes graças a @IsmaelMiguel. Salvou outro byte graças a @ETHproductions. Se você usa o Firefox 30-57, pode salvar outros 2 bytes graças ao @ETHproductions usando compreensão de gerador ou 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

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

Experimente online!

-1 byte graças a Emigna + 28 bytes graças a DJMCMayhem;).

/// , 54 bytes

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

Experimente online!

Não pode haver nenhuma versão mais eficiente do que esta :(

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

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

assumindo UTF-8

Scala, 59 bytes

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

x+1423 é o mesmo que x-'A'+1488

APL (Dyalog) , 35 bytes

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

Experimente online!

C # 6 +, 76 86 82 bytes

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

Primeira tentativa de golfe. Estou fazendo isso certo?

EDIT : +6 bytes para esquecer de incluir em uma função. Obrigado @Kevin

Versão C # 5 e inferior, 86 82 bytes

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

Fourier, 53 bytes

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

Usa funções novamente.

Experimente FourIDE!

ArnoldC, 112 bytes

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

Barril , 34 bytes

Inspirado por uma solução Powershell.

ZYXVWTUSRPQNOMKLJIHGFEDCBA(֏+")(,

TIO

BaCon , 57 bytes

• Na maioria dos BASICs, o ponto de interrogação representa simplesmente PRINT.

• À primeira vista, a solução abaixo se parece com 30 bytes, mas os caracteres hebraicos precisam de 2 bytes de armazenamento por causa do UTF-8. Portanto, existem 27 caracteres x 2 bytes + 1 byte para o '?' e 2 bytes para aspas duplas = 57 bytes.

Solução:

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

s-lang , 59 bytes

Resposta realmente simples ...

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

• t - substituir função (substitui "nada" na entrada pelo alfabeto ...)

Experimente aqui

zsh, 25 21 bytes

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

Meu navegador está estragando tudo: o ת deve ser a primeira letra, depois o א. Se você colar em outro lugar, no entanto, deve funcionar. A versão antiga:

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

Java 7, 85 bytes

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

Eu nem vou me incomodar em postar código de teste ou um 'Experimente aqui', como eu costumo fazer.

Perl 6 (74)

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

Ruby , 49 bytes

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

Experimente online!

Haskell , 23 bytes

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

Experimente online!

Isso funciona na versão do Hasio da TIO

C, 49 bytes

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

Alguns usuários podem precisar ligar setlocaleantes de usar isso, mas funcionou bem para mim.

Limpo , 62 bytes

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

Experimente online!