Il tuo compito è stampare questo testo esatto:

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

(È consentito stampare una nuova riga finale)

Hash SHA256 della codifica UTF-8 del testo:

0ab6f1e0bf216a0db52a4a5a247f95cba6f51496de7a24dfd01f3985dfcf6085

Codifica Base64:

15DXkdeS15PXlNeV15bXl9eY15nXm9ea15zXnted16DXn9eh16LXpNej16bXpden16jXqdeq

Regole

• Non puoi usare un built-in che emette questo testo.
• Le scappatoie standard non sono ammesse.
• Questo è code-golf , quindi vince la risposta più breve.

In bocca al lupo!

MATLAB, 52 51 byte

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

Esempio di utilizzo:

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

Spiegazione

'CCCCCCCCCDADDAEADCDAEADCCC'-66produce l'array [1 1 ... -1 2 1 1 1], che contiene le differenze consecutive tra i punti di codice dei caratteri desiderati.

[1488 ...]antepone 1488, quindi l'array lo è ora [1488 1 1 ... -1 2 1 1 1].

cumsum(...)calcola la somma cumulativa: [1488 1489 ... 1514].

[... '']si concatena con la stringa vuota. Ciò ha l'effetto di convertire in char (ed è un byte più corto di char(...))

Gelatina , 22 21 20 byte

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

Provalo online!

Idea

Se sottraggiamo 1487 da ogni punto di codice, otteniamo l'array R che segue.

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

Questo è solo l'intervallo da 1 a 27 , ma non in ordine crescente; le coppie (11, 12) , (14, 15) , (16, 17) , (20, 21) e (22, 23) sono state scambiate.

Se prendiamo l'intervallo crescente e aggiungiamo da 2 a 11 , 14 , 16 , 20 e 22 , otteniamo l'array A che segue.

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

Questa non è più una permutazione dell'intervallo, ma se ordiniamo stabilmente l'intervallo in base ai valori in quell'array, possiamo ricostruire l'array originale.

Codice

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 è UTF-16 se non diversamente specificato esplicitamente, quindi è comunque un crapshoot dal momento che è tutto UTF-16 in background.

Questo mette semplicemente la stringa letterale sulla pipeline e l'impostazione predefinita Write-Outputalla fine dell'esecuzione del programma la stampa sullo schermo.

Il più breve che ho potuto ottenere la versione ASCII è 63

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

Che prende il valore ASCII della stringa ABC...e si aggiunge 1423a ciascuno charper ottenere la stringa appropriata.

05AB1E , 36 29 26 25 23 byte

Salvato 2 byte grazie ad Adnan

Utilizza la codifica CP-1252 .

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

Provalo online!

Spiegazione

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 byte

Questa risposta si basa principalmente su una soluzione di DJMcMayhem qui, quindi ti consiglio di dare un'occhiata.

Come la soluzione di DJMcMayhem, questa utilizza il -rAflag per invertire l'output e stampare in Unicode.

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

Provalo online!

Spiegazione

Ho fatto questa risposta eseguendo un sacco di micro-ottimizzazioni sulla soluzione originale fornita da DJMcMayhem. Queste ottimizzazioni durante il salvataggio dei byte, rendono il codice illeggibile e l'algoritmo ottuso. Ad essere sincero, non capisco davvero come o cosa faccia il mio codice.

Forse un giorno capirò come funziona ...

Python 3, 50 byte

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

Il file deve essere creato utilizzando la codifica CP862 o invertendo il seguente 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                                            ')

Probabilmente questo potrebbe essere portato su Python 2 (salvando così due byte), ma mi manca la localizzazione corretta per testarlo. Python 3 stampa diligentemente una versione codificata UTF-8 (o qualunque cosa sia appropriata per la locale corrente) dell'alfabeto.

Verifica

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

CJam , 23 byte

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

Provalo online!

Come funziona

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 byte

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

Questo codice è lungo 182 byte e ho aggiunto 4 byte per due flag della riga di comando: -re-u

Provalo online!

Mille grazie a @Neil per questo fantastico metagolfer intero che ha creato questo dolce modo di spingere 1488 (il punto di codice del primo carattere)

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

Spiegazione:

Spingere un gran numero di scosse cerebrali è relativamente difficile. Tuttavia, dal momento che l'atto di spingere un numero corrisponde anche a quel numero, possiamo spingere più numeri contemporaneamente per un notevole risparmio di byte. Ecco un esempio più concreto. La parte più interna (che ho scritto sopra) nel codice psuedo è

push(1488)

Questa espressione restituisce 1488, quindi avvolgiamo il tutto in un'altra istruzione push:

push(push(1488) + 1)

Questo spinge il 1488 e il 1489, oltre a valutare il 1489. Quindi concludiamo questo:

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

che spinge 1488, 1489 e 1490, oltre a valutare fino a 1490. Ripetere questo passaggio per ciascun numero che è necessario spingere.

Tuttavia, poiché gli incrementi non sono sempre 1, è un po 'più complicato di così. Ecco una versione più leggibile:

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

/// , 27 byte

ABCDEFGHIQSRTVUXWYbdcfeghiq

Provalo online!

L'output è codificato in CP424 .

Per verificarlo tu stesso:

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

JavaScript (ES6), 59 byte

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

Il meglio che potevo fare in ASCII era 80 79 78 byte:

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

Se una matrice di caratteri è accettabile, 75 byte:

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

Modifica: salvato alcuni byte grazie a @IsmaelMiguel. Salvato un altro byte grazie a @ETHproductions. Se si utilizza Firefox 30-57, è possibile salvare altri 2 byte grazie a @ETHproductions utilizzando la comprensione del generatore o dell'array:

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

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

Provalo online!

-1 byte grazie a Emigna + 28 byte grazie a DJMCMayhem;).

/// , 54 byte

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

Provalo online!

Non ci può essere alcuna versione più giocata a golf di questa :(

Scala / Groovy / Python 3, 9 caratteri ASCII + 27 caratteri a 2 byte = 63 byte

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

assumendo UTF-8

Scala, 59 byte

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

x+1423 equivale a x-'A'+1488

APL (Dyalog) , 35 byte

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

Provalo online!

C # 6 +, 76 86 82 byte

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

Primo tentativo di golf. Lo sto facendo bene?

EDIT : +6 byte per dimenticare di racchiuderlo in una funzione. Grazie @Kevin

C # 5 e versione precedente, 86 82 byte

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

Fourier, 53 byte

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

Usa di nuovo le funzioni.

Provalo FourIDE!

ArnoldC, 112 byte

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

Keg , 34 byte

Ispirato da una soluzione Powershell.

ZYXVWTUSRPQNOMKLJIHGFEDCBA(֏+")(,

TIO

BaCon , 57 byte

• Nella maggior parte dei BASIC, il punto interrogativo rappresenta semplicemente STAMPA.

• A prima vista, la soluzione seguente sembra 30 byte, ma i caratteri ebraici necessitano di 2 byte di memoria a causa di UTF-8. Quindi ci sono 27 caratteri x 2 byte + 1 byte per il '?' e 2 byte per le doppie virgolette = 57 byte.

Soluzione:

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

gergo , 59 byte

Risposta davvero semplice ...

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

• t - funzione di sostituzione (sostituisce "niente" nell'input con l'alfabeto ...)

Provalo qui

zsh, 25 21 byte

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

Il mio browser lo sta incasinando: il ת dovrebbe essere la prima lettera, quindi il א. Se si incolla altrove, tuttavia, dovrebbe funzionare. La vecchia versione:

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

Java 7, 85 byte

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

Non mi preoccuperò nemmeno di pubblicare il codice di prova o un "Provalo qui" come faccio di solito ..

Perl 6 (74)

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

Rubino , 49 byte

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

Provalo online!

Haskell , 23 byte

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

Provalo online!

Funziona con la versione TIO di Haskell

C, 49 byte

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

Alcuni utenti potrebbero dover chiamare setlocaleprima di utilizzare questo, ma ha funzionato bene per me.

Pulito , 62 byte

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

Provalo online!