Sacar el alfabeto hebreo

24

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 , por lo que gana la respuesta más corta.

¡Buena suerte!

TuxCrafting
fuente
55
Noté que los puntos de código no están directamente en orden. Usted tiene 1488, 1489, 1490, 1491, 1492, 1493, 1494, 1495, 1496, 1497, 1499, 1498, 1500, 1502, 1501, 1504, 1503, 1505, 1506, 1508, 1507, 1510, 1509, 1511, 1512, 1513, 1514. No sé mucho sobre el hebreo, ¿podría confirmar que esto es intencional?
DJMcMayhem
11
@DJMcMayhem Unicode enumera las letras finales antes de las letras normales, pero en el texto de la pregunta, las letras normales se enumeran antes. No fue realmente intencional, pero al menos alienta respuestas que no son tan aburridas comoprint(map(chr, range(x, y)))
TuxCrafting
66
אני מדבר עברית!
OldBunny2800
66
Aleph null, aleph one, aleph 2, ...
Kritixi Lithos
2
@Angs Eso es porque realmente no coincide. echo 15DXkdeS15PXlNeV15bXl9eY15nXm9ea15zXnted16DXn9eh16LXpNej16bXpden16jXqdeq | base64 -d | sha256sumproduce f1d4b9c12a197912a4bdb80fb3e4d3fad5a0d9b7edd243fae7b2ab3450618036.
hvd

Respuestas:

25

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(...))

Luis Mendo
fuente
19

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.
Dennis
fuente
15

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.

AdmBorkBork
fuente
66
Votó solo porque su versión ASCII es inteligente. Debe ... apoyar ... inteligente ... jugar al golf!
wizzwizz4
1
Me llevó al menos 5 minutos darme cuenta de que no era el alfabeto real en la versión ASCII.
caird coinheringaahing
11

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
Emigna
fuente
Interpretar el número grande como un número de base 5 ahorra dos bytes: 1488•’ÉÇW–moû•5Bvy<+Dç?.
Adnan
@Adnan: Ah, por supuesto. Gran pensamiento!
Emigna
9

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

Asistente de trigo
fuente
6

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
אבגדהוזחטיכךלמםנןסעפףצץקרשת
Dennis
fuente
5

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.
Dennis
fuente
4

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
())
())
DJMcMayhem
fuente
Pensé que era +1 -rporque -no cuenta
NoOneIsHere
66
@NoOneIsHere -no cuenta si ya está presente desde una opción diferente (por ejemplo, en perl -e). Brain-Flak no tiene una opción como esa, por lo tanto -, la opción y el espacio después de todo cuentan para el total.
Riley
Solo una pequeña mejora hice brain-flak.tryitonline.net/…
Wheat Wizard
@WheatWizard Si tuviera que tomar eso, entonces no podría escribir una explicación. Simplemente me parece un revoltijo desordenado de corchetes. : P
DJMcMayhem
Es un cambio muy pequeño. Simplemente moví las dos instancias ()()()al principio y las puse hacia abajo y hacia arriba.
Wheat Wizard
4

/// , 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==
Mego
fuente
¿Qué tipo de código es este? Creo que de todos modos debe convertirse a UTF-8 para verlos. No es que sea necesariamente inválido: P tiene un +1
Erik the Outgolfer
@EriktheGolfer No hay necesidad de convertirlo a UTF-8. Ese no es un requisito en ninguna parte del desafío.
Mego
Creo que entonces podrías atraer votos negativos. Tenga en cuenta que, en su lugar, habría incluido la versión UTF-8 y un hexdump del original ...
Erik the Outgolfer
4

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)]
Neil
fuente
Puede guardar un byte en su alternativa ASCII utilizando 0x377BABBCF7F.toString(3). Combinando esto con .map(), puedes hacerlo _=>0x377BABBCF7F.toString(3,n=1488).split``.map(_=>String.fromCharCode(++n-_))por 78 bytes. Devuelve una serie de caracteres.
Ismael Miguel
@IsmaelMiguel Buena captura en el ..pero no usamos splitpor aquí.
Neil
Agradable. Puede modificar ligeramente la versión de la matriz de caracteres para obtener _=>String.fromCharCode(...[...0x377babbcf7f.toString(3)].map(c=>++n-c,n=1488))1 byte más corto que los 79 bytes actuales.
ETHproductions
@ETHproductions Bah, había jugado String.fromCharCode(...)y había logrado convencerme de que siempre sería más largo. De hecho, ahorra 4 bytes en mi solución base 2 (que sigue siendo 84 bytes porque toma más bytes para decodificar).
Neil
Si está dispuesto a usar comprensiones de matriz, puede obtener 2 bytes de cada una; string:, _=>String.fromCharCode(...[for(c of 0x377babbcf7f.toString(3,n=1488))++n-c])char-array:_=>[for(c of 0x377babbcf7f.toString(3,n=1488))String.fromCharCode(++n-c))
ETHproductions
3

05AB1E , 28 * 2-1 = 55 bytes

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

Pruébalo en línea!

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

Urna de pulpo mágico
fuente
44
No sé qué codificación utiliza 05AB1E, pero dudo mucho que sean caracteres de un byte en lo que sea.
DJMcMayhem
@DJMcMayhem Creo que TIO tiene un error, esos caracteres no existen en CP-1252.
Erik the Outgolfer
@EriktheGolfer Lo más probable es que use UTF-8 por conveniencia y luego el intérprete 05AB1E realiza la conversión interna necesaria. Eso es lo que hago para V (que usa latin1).
DJMcMayhem
@DJMcMayhem Aquí creo que se muestra como UTF-8, pero también es compatible con CP-1252, que puede usar para reducir el número de bytes. Sin embargo, esto no es puro CP-1252, por lo que debe ejecutarse con cadenas UTF-8.
Erik the Outgolfer
3

/// , 54 bytes

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

Pruébalo en línea!

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

Erik el Outgolfer
fuente
2

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

corvus_192
fuente
Polygot, también funciona en Groovy; También, vea mi respuesta, bytecount está desactivado.
Urna mágica del pulpo
1
también en python 3 (también python 2 pero luego los paréntesis no son necesarios)
user49822
1
@caruscomputing Sería cauteloso al editar el recuento de bytes de otro usuario porque supones una cierta codificación. ¿Estás seguro de que Scala puede o solo puede manejar UTF-8? Además, el alfabeto hebreo tiene 27 letras, por lo que 61 está mal de una forma u otra.
Dennis
La primera opción también funciona en PHP.
Ismael Miguel
1

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("אבגדהוזחטיכךלמםנןסעפףצץקרשת");}
codificador terrible
fuente
En realidad, debe imprimir una función o un programa completo. Por void F(){Console.WriteLine("אבגדהוזחטיכךלמםנןסעפףצץקרשת");}lo tanto , sería válido, o ()=>{Console.WriteLine("אבגדהוזחטיכךלמםנןסעפףצץקרשת");}también creo (no estoy seguro de esto último). Además, puedes jugar golf usando en .Writelugar de .WriteLine. :) Dicho esto, ¡bienvenido a PPCG! Puede encontrar consejos para jugar golf en C # interesantes para leer. Disfruta tu estancia.
Kevin Cruijssen
Ya sabes, puedes usar <s>your text</s>para tachar texto en lugar de usar caracteres extraños.
Erik the Outgolfer
No estaba al tanto de eso. De todos modos, gracias @EriktheGolfer
terrible-codificador
1

Fourier, 53 bytes

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

Utiliza funciones de nuevo.

Pruébalo FourIDE!

Decaimiento Beta
fuente
1

ArnoldC, 112 bytes

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

Barril , 34 bytes

Inspirado en una solución Powershell.

ZYXVWTUSRPQNOMKLJIHGFEDCBA(֏+")(,

TIO

UNA
fuente
0

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:

?"אבגדהוזחטיכךלמםנןסעפףצץקרשת"
Peter
fuente
Pruebe GW-BASIC con un BIOS CP862 VGA para 30. (Mismo texto)
Joshua
0

argot , 59 bytes

Respuesta realmente simple ...

t[][אבגדהוזחטיכךלמםנןסעפףצץקרשת]
  • t - Reemplazar función (reemplaza "nada" en la entrada con el alfabeto ...)

Pruébalo aquí

MCMastery
fuente
0

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
Elronnd
fuente
No válido, porque las letras finales y las letras normales se invierten en Unicode
TuxCrafting
Además, en realidad son 27 bytes
TuxCrafting
Ah, y el rango debería ser aleph first y tav last. Si la cadena se invierte en la pregunta, es porque el hebreo es un lenguaje RTL
TuxCrafting
@ TùxCräftîñg en mi terminal, se muestra correctamente solo con taf first y aleph last. ¿Qué quiere decir "las letras finales y las letras normales se invierten en Unicode"?
Elronnd
En el texto de la pregunta, כךpor ejemplo, está (kaf normal primero, kaf final segundo), pero en Unicode, las letras finales están antes de las letras normales ( ךכ), por lo que el texto impreso no es válido. Y si se muestra con tav primero, es porque el hebreo es un lenguaje RTL, por lo que el primer carácter se muestra más a la derecha
TuxCrafting
0

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

Kevin Cruijssen
fuente
0

Perl 6 (74)

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

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

Govind Parmar
fuente
Sugerir en for(i=1488;putwchar(i++)<1514;);lugar defor(i=0x5d0;i<=0x5ea;i++)wprintf(L"%lc",i);
ceilingcat