Su jefe acaba de enviarle por correo electrónico una lista de 12 tareas de programación que necesita realizar lo antes posible. Las tareas son bastante simples, pero su jefe, siendo un joven magnate del software atrapado por las redes sociales, insiste en que sus soluciones puedan encajar en un solo tweet de Twitter .

Esto significa que solo tiene 140 bytes de código para resolver todas las tareas, un promedio de 11.67 bytes por tarea. (Sí, Twitter cuenta caracteres, pero su jefe dijo específicamente bytes).

Te das cuenta de que no hay forma de resolver las 12 tareas en 140 bytes, pero sospechas que tu jefe no probará todas tus soluciones. Entonces procedes a resolver tantas tareas como puedas, omitiendo por completo algunas de ellas. Su mentalidad es que no importa qué subconjunto de tareas complete, solo importa que el subconjunto sea lo más grande posible .

¿Cuántas tareas puedes completar?

Reto

Escriba hasta 12 programas diferentes, cada uno de los cuales resuelve con precisión una de las 12 tareas enumeradas a continuación. La suma acumulativa de las longitudes de estos programas no puede exceder los 140 bytes.

Alternativamente, puede escribir un solo programa de no más de 140 bytes de longitud que tome un número entero de 1 a 12 y (idealmente) proceda a resolver la tarea correspondiente, tomando más información según sea necesario. No todas las tareas deben funcionar, pero solo las que sí cuentan para su puntaje. Las tareas que no funcionan pueden realizar errores o hacer cualquier otra cosa.

En cualquier caso, un "programa" puede ser una función que toma la entrada como argumentos o solicita e imprime o devuelve la salida. Entonces, por ejemplo, puede escribir una función de 140 bytes que se parezca f(taskNumber, taskInput), o puede escribir fragmentos de código separados para cada tarea, algunos como funciones y otros como programas completos.

Otros detalles:

• Todo el código debe estar escrito en el mismo idioma.

• Como de costumbre, la entrada debe provenir de stdin, la línea de comando, un argumento de función o lo que sea habitual para su idioma. La salida se imprime en stdout o la alternativa más cercana a su idioma, o se devuelve en un tipo apropiado.

• Una cantidad razonable de formato de entrada está bien; por ejemplo, comillas alrededor de cadenas o en \nlugar de nuevas líneas reales.

• La salida debe ser exactamente lo que se requiere sin formato extraño ni espacios en blanco. La excepción es una nueva línea final opcional.

• El código que solo se ejecuta en un entorno REPL no constituye un programa o función.

• No puede escribir múltiples programas que resuelvan múltiples tareas. Es un programa que (idealmente) resuelve todas las tareas o (idealmente) 12 programas que resuelven una sola tarea.

• Publicar una solución de tarea que no escribió o que solo modificó ligeramente no está permitido sin atribuir al autor original, e idealmente obtener permiso también. Si su respuesta compone principalmente las soluciones más cortas de todas las otras respuestas, entonces debería ser una wiki comunitaria.

Tanteo

El envío que completa la mayoría de las tareas es el ganador. Si se empatan dos envíos, gana el que tenga menos bytes. Si los recuentos de bytes están vinculados, la presentación anterior gana. Las respuestas wiki de la comunidad no pueden ganar.

¡Asegúrese de decirnos qué tareas resolvió, no solo cuántas!

Handicap para no golfistas:

Es probable que este desafío esté dominado por los idiomas de golf . Muchos idiomas pueden tener problemas para resolver incluso una o dos tareas dentro de 140 bytes. Por lo tanto, puede enviar una respuesta no competitiva donde el límite es de 3 tweets, es decir, 420 bytes. Todas las demás reglas siguen siendo las mismas.

Tareas

Tarea 1: ¿pueden tres números formar un triángulo?

Tome tres enteros positivos y genere un valor verdadero / falso que indique si tres líneas con esas longitudes podrían o no formar un triángulo . No puede asumir que los números vienen en un orden particular.

Ejemplos verdaderos (uno por línea):

20 82 63
1 1 1
2 3 4
1 2 2

Falsy ejemplos:

6 4 10
171 5 4
1 1 2
1 2 3

Tarea 2: más cerca de un millón

Dada una cadena de exactamente 7 dígitos decimales (0-9), reorganícelos para obtener un número lo más cercano posible a un millón. Es decir, abs(1000000 - rearrangedNumber)debe minimizarse.

Imprima o devuelva el número resultante como un entero, no una cadena (por lo que no debería haber ceros a la izquierda a menos que esa sea la norma para su idioma).

por ejemplo, una entrada de 9034318debería resultar en 984331(y no 1033489).

2893984debería convertirse 2348899.

0001000debería convertirse 1000000.

0000020debería convertirse 200000.

Tarea 3: Simulador de teclado simple

Tome una cadena de letras minúsculas (az), espacios y corchetes angulares <>. Leída de izquierda a derecha, esta cadena representa las teclas que se presionaron en un teclado estándar mientras estaba abierto un editor de texto inicialmente vacío. Las letras y el espacio corresponden a sus teclas normales pero <corresponden a la tecla de flecha izquierda y >a la tecla de flecha derecha, las cuales mueven el cursor cuando se presionan.

<mueve el cursor un carácter hacia la izquierda, o no hace nada si el cursor está al comienzo de la cadena.
>mueve el cursor un carácter hacia la derecha o no hace nada si el cursor está al final de la cadena.

Imprima la cadena que estaría en el editor de texto una vez que se hayan presionado todas las teclas de la cadena de entrada. No se permite emitir códigos de escape para mover el cursor.

Siempre habrá al menos un carácter de tecla sin flecha en la entrada.

por ejemplo, la entrada ui<<q>>ck <<<<<<the<<<<>>> >>>>>>>>brown x<o<fdebería rendir the quick brown fox.

op<<l>>t<<<lam>>>>>>imi<<<><>>>zer<<<<<<<<<<<<<<<<<<>>><>mdebería dar llammoptimizer.

e< <c<b<adebería dar abc e.

<<<>><><<><toast>><<>><><<>><debería dar toast.

Tarea 4 - Letras de FILTHE

En muchas fuentes, 6 de las mayúsculas las letras del alfabeto Inglés consisten enteramente de líneas horizontales y verticales: E, F, H, I, L, y T. Llamaremos a estas letras FILTHE.

Tome una cadena de letras mayúsculas (AZ) y cuente el número de líneas en las letras FILTHE, generando el entero resultante.

E, F, H, I, L, Y Ttienen 4, 3, 3, 3, 2, y 2 líneas, respectivamente.

por ejemplo, GEOBITStiene 4 + 3 + 2 = 9 líneas que forman parte de las letras FILTHE (para .E..IT.), por lo que la salida debería ser 9.

ABCDEFGHIJKLMNOPQRSTUVWXYZdebería salir 17.

ABCDGJKMNOPQRSUVWXYZdebería salir 0.

FILTHYLINESINLETTERSdebería salir 39.

Tarea 5: Alex Recursivo A.

Nuestro moderador Alex A. tiene una inicial bastante misteriosa, "A".

Ahora no estoy seguro, pero creo que A.significa .A xelA. Y también estoy bastante seguro de que .Aallí existe sigilosamente Alex A..

Por lo tanto, para obtener el nombre completo de Alex debemos expandir los A.'sy .A' s:

Alex A. -> Alex [A.] -> Alex [.A xelA] -> Alex .A xelA -> Alex [.A] xelA -> Alex [Alex A.] xelA -> Alex Alex A. xelA -> etc.

Haga que su programa tome un número entero no negativo y lo expanda Alex A.muchas veces, generando la cadena resultante.

Así se
0vuelve Alex A., se
1vuelve Alex .A xelA, se
2vuelve Alex Alex A. xelA, se
3vuelve Alex Alex .A xelA xelA, se
4vuelve Alex Alex Alex A. xelA xelA, se
5vuelve Alex Alex Alex .A xelA xelA xelA,
etc.

^{(Hice esto porque me sentí mal por dejar inadvertidamente a Alex fuera de mi desafío tributo mod .: P)}

Tarea 6 - Rotación del teclado numérico

Tome un número entero del 1 al 9 inclusive (puede tomarlo como una cadena). Salida del cuadrado de dígitos 3 × 3

789
456
123

girado en incrementos de 90 ° de modo que el dígito de entrada aparezca en cualquier lugar de la fila superior. Cuando 5se ingresa, cualquier rotación es válida, ya que 5no se puede girar hacia arriba.

por ejemplo, cuando 3se ingresa, ambos

963
852
741

y

321
654
987

Son salidas válidas.

Para entrada 4, solo

147
258
369

Es una salida válida.

Tarea 7: división de dígitos en decenas

Tome una cadena no vacía de dígitos decimales (0-9) y genere un valor verdadero si se puede dividir en secciones contiguas donde todos los dígitos en cada sección sumen exactamente 10. Si esto no es posible, genere un valor falso.

por ejemplo, 19306128se pueden dividir como 19|3061|28, las secciones suman 10 (1 + 9, 3 + 0 + 6 + 1, 2 + 8), por lo que se debe generar un valor verdadero.

Ejemplos verdaderos (uno por línea):

19306128
073
730
0028115111043021333109010
2222255

Falsy ejemplos:

6810410
9218
12341
5222225
000

Tarea 8 - Reloj cuadrado

Tome una cuerda multilínea de tamaño constante.

Salida 12si la entrada es

 _ _
| | |
|_ _|

Salida 3si la entrada es

 _ _
| |_|
|_ _|

Salida 6si la entrada es

 _ _
| | |
|_|_|

Salida 9si la entrada es

 _ _
|_| |
|_ _|

No hay otros casos de entrada.

Tarea 9 - Arte del soporte

Tome en una cadena de 4 bytes que contiene uno de cada una de las ménsulas izquierda (, [, {, y <en cualquier orden.

Agregue los corchetes derechos correspondientes para que la cadena tenga 8 bytes de longitud y tenga una línea de simetría vertical. por ejemplo se [<({convierte [<({})>].

Luego invierta cada paréntesis en esta cadena. por ejemplo se [<({})>]convierte ]>)}{(<[.

Imprima la cadena de soporte de 8 bytes original con la versión invertida arriba y abajo en líneas separadas.

Entonces la salida final para la entrada [<({sería

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

Del mismo modo, la salida para <({[debería ser

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

La entrada (<<[no es válida porque {falta y hay un extra <.

Tarea 10 - Perimiterizar

Tome una cuadrícula de texto rectangular (1 × 1 como mínimo) hecha de .'s que representan espacios vacíos y X' s que representan mosaicos sólidos. Las celdas más allá de los límites de la cuadrícula se consideran vacías. Puede suponer que cada una de las 4 filas y columnas del borde de la cuadrícula contendrá al menos una X.

Por ejemplo, una entrada válida podría ser:

XXX.....X.....
X..X...X.X....
XXX.....X....X

Imprima otra cuadrícula de texto rectangular en la que se convierte cada celda vacía que se encuentra junto a una Xortogonal o diagonal, incluidas las que están fuera de la cuadrícula de entradao . Así que esencialmente ose dibuja un perimitador alrededor de todas las porciones de mosaicos sólidos. La nueva cuadrícula no debe ser más grande de lo que debe ser.

Entonces la salida del ejemplo anterior sería:

ooooo...ooo.....
oXXXoo.ooXoo....
oXooXo.oXoXo.ooo
oXXXoo.ooXoo.oXo
ooooo...ooo..ooo

Del mismo modo, la salida de entrada XXX..X.Xdebe ser

oooooooooo
oXXXooXoXo
oooooooooo

y salida

oooooooooo.
oXXXooXoXo.
oooooooooo.

sería inválido ya que la columna vacía más a la derecha es innecesaria.

Puede utilizar cualquiera de los 3 distintos ASCII imprimibles caracteres en lugar de ., X, y o.

Tarea 11 - Plaza Sator

Salida del cuadrado de Sator :

SATOR
AREPO
TENET
OPERA
ROTAS

Cualquiera de las letras puede ser minúscula o mayúscula, por lo que

SatOR
aRePO
tenet
OPERa
RoTaS

También es una salida válida.

No hay entrada

Tarea 12 - Primer Tweet

No ingrese nada, pero envíe una cadena ASCII imprimible de 140 bytes que contenga al menos uno de cada uno de los 95 caracteres ASCII imprimibles. (Entonces 45 caracteres serán duplicados).

La suma de los códigos de caracteres de los 140 bytes en esta cadena debe ser un primo de Sophie Germain , es decir, un número primo ptal que 2p+1también sea primo. El código de caracteres para el espacio es 32, 33 para !, 34 para ", y así hasta 126 para ~. La suma podría calcularse en Python como sum(map(ord, myString)).

Un ejemplo de salida es:

! "#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~STUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~d

La suma del código de caracteres es el primo 12203 cuyo primo seguro correspondiente es 24407.

Pyth, 9 tareas en 136 bytes

Tarea 1: 7 bytes

<-F_SQ0

Demostración

Ordene en orden descendente ( _SQ), doble la resta sobre ellos ( a-b-c), verifique si el resultado es negativo.

Tarea 2: 14 bytes

sho.a-sN^T6.pz

Demostración

Forme todas las permutaciones de cadena ( .pz), ordénelas ( o) según el valor absoluto de la diferencia ( .a-) entre el número ( sN) y un millón ( ^T6).

Tome la primera cadena de este tipo ( h) y conviértala en un número. ( s)

Tarea 4: 19 bytes

s/L+\EPP*3"EFHILT"z

Demostración

Replica "EFHILT"tres veces ( *3), elimina el final LT( PP) y agrega un E( +\E). Asigne cada letra en la entrada a su recuento de apariencia en esa cadena. ( /L ... z) Suma. ( s)

Tarea 5: 16 bytes

u+"Alex "_GhQ".A

Demostración

Comenzando con "A.", invierta y agregue un "Alex "al inicio, ingrese + 1 veces.

Tarea 7: 13 bytes

}Y-RTsMM./sMz

Convierta la cadena de entrada en una lista de números de 1 dígito ( sMz). Formar todas las particiones ( ./). Suma cada elemento de cada partición ( sMM). Elimine todos los 10 de cada sublista ( -RT). Compruebe si esto vació alguna de las sublistas comprobando si la lista vacía está en la lista general ( }Y).

Tarea 8: 11 bytes

*3h%%CQC\Ç4

Demostración

Módulo de magia. Convierte a number ( CQ), tómalo mod 199 ( C\Ç= 199) y toma ese mod 4. Luego suma 1 y multiplica por 3.

Tarea 9: 21 bytes

J+Xz"<{[()]}>")_zJ_JJ

Demostración

Primero, generamos la primera línea, que consiste en la entrada traducida a los caracteres espejo ( Xz"<{[()]}>")), seguida de la entrada invertida ( + ... _z), y la guardamos en J. Luego imprima esa línea, su reverso y esa línea nuevamente ( J_JJ).

Tarea 11: 22 bytes

+J"SATOR
AREPO
TEN"t_J

Demostración

Simplemente imprima una cadena y su inversión, pero no duplique el centro N.

Tarea 12: 13 bytes

++G*19\3srd\

Demostración

Hay un carácter invisible DEL( 7F) al final del código.

Esto imprime

abcdefghijklmnopqrstuvwxyz3333333333333333333 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

que tiene suma de caracteres 11321. Consiste en Gel alfabeto, 19 3s y todos los caracteres ASCII imprimibles.

CJam, 8 9 tareas en 140 bytes

En primer lugar, aquí hay un script que puede usar para ordenar sus soluciones y decirle cuáles encajarán en el tweet:

{\s\Se[oSo}:F;
qN/ee{W=,}${)_,_T+:T140>X*_{0:X;}*'=@11+*N+*o\~)YF_,ZFTZFoNo}/

Simplemente pegue sus 12 soluciones en la entrada, una en cada línea. Ejecútalo aquí. La primera columna es el número de la tarea, la segunda es su tamaño (en caracteres , tendrá que arreglar esto usted mismo si es diferente del recuento de bytes), la tercera el tamaño acumulado. Los programas que se ajustan al tweet se separan del resto con una línea de ===.

Para mí, la salida se ve así:

 1   7   7 q~$~\->
 8  10  17 qDbJ%5/)3*
12  12  29 ',32>_51>'d
 7  13  42 Aq{~-Ace|}/N&
 2  15  57 qe!{~1e6-z}$0=~
 4  19  76 q"FIHEELT"3*H<fe=:+
 5  20  96 ".A"q~){" xelA"+W%}*
 9  22 118 q_{_')>+)}%W%+_W%N@N3$
11  22 140 "SATOR\AREPO\TEN"_W%1>
====================================
 6  25 165 9,:)s3/zq~))3mdg*{W%z}*N*
 3  43 208 LLq{_'=-z({+}{'=>_)$\[{)@+\}{\(@\+}]=&}?}/\
10  45 253 0XW]_m*qN/{'.f+W%z}4*f{\~@m>fm>N*}(\{8f^.e>}/

Así que aquí están las tareas que actualmente puedo incluir en el tweet.

Tarea 1: ¿pueden tres números formar un triángulo? - 8 7 bytes

Gracias a jimmy23013 por guardar 1 byte.

q~$~\->

Banco de pruebas.

Se espera que la entrada sea una lista de estilo CJam.

Esto es bastante sencillo: verifique si el lado más grande es más corto que la suma de los otros dos. O, de manera equivalente, verifique que el lado más corto sea más largo que la diferencia de los otros dos:

q~  e# Read and eval input.
$~  e# Sort the values and dump them on the stack.
\-  e# Subtract the middle value from largest.
>   e# Check if the smallest value is greater than that.

Tarea 2: más cercano a un millón: 15 bytes

qe!{~1e6-z}$0=~

Banco de pruebas.

Fuerza bruta simple:

q        e# Read input.
e!       e# Get all permutations.
{        e# Sort by...
  ~      e#   Evaluate the permutation to get its numerical value X.
  1e6-z  e#   abs(X - 1,000,000)
}$
0=       e# Pick the first element (which minimises the difference)
~        e# Evaluate it to get rid of the leading zeroes.

Tarea 4 - Cartas FILTHE - 21 19 bytes

Gracias a jimmy23013 por guardar 2 bytes.

q"FIHEELT"3*H<fe=:+

Banco de pruebas.

La idea es crear una cadena que contenga cada una de las letras FILTHE una vez para cada una de sus líneas ortogonales. Esto se hace a través de alguna manipulación de cadena divertida:

q          e# Read the input.
"FIHEELT"  e# Push this string. It first contains the 3-line letters, then the 2-line 
           e# letters, where we include 'E' twice to make it count for 4.
3*         e# Repeat 3 times: "FIHEELTFIHEELTFIHEELT"
H<         e# Truncate to 17 characters: "FIHEELTFIHEELTFIH". This is chosen such that
           e# it discards the third repetition of the 2-line letters.
fe=        e# For each character in the input, count its occurrences in this new string.
:+         e# Sum them all up.

Tarea 5: Alex Recursivo A. - 27 20 bytes

".A"q~){" xelA"+W%}*

Banco de pruebas.

Implementar la sustitución de A.y .Adirectamente es demasiado costoso. En cambio, notamos que solo tenemos que manejar un caso, si invertimos la cadena cada vez. Además, anteponer Alex(y un espacio) cada vez es equivalente a expandir la inicial. Podemos guardar otro byte agregando el reverso antes de revertir la cadena:

".A"        e# Start with ".A" (the -1st iteration if you like).
q~)         e# Read input, eval, increment (so the following block is run at least once.)
{           e# Repeat this block that many times...
  " xelA"+  e#   Append " xelA".
  W%        e#   Reverse the string.
}*

Tarea 7: división de dígitos en decenas: 18 16 13 bytes

Aq{~-Ace|}/N&

Banco de pruebas. (Con corchetes alrededor de cada salida).

No es exactamente fácil de usar: el valor verdadero es una nueva línea, el valor falso es la cadena vacía.

La idea básica es simple: agregar los dígitos a un total acumulado que restablecemos cada vez que llega exactamente a 10. El total debe ser cero al final de la entrada. Para empezar, resulta ser más corto al total en 10 y restar los dígitos, restableciendo el total cada vez que pulsamos 0. Sin embargo, debemos asegurarnos de que no devolvemos algo verdadero cuando la entrada es todos ceros. La forma más corta que encontré para hacer eso fue restablecer el total al carácter con el punto de código 10 (el salto de línea), y luego verificar al final que realmente tenemos ese carácter en la pila, y no el número 10. Esto funciona, porque tanto el entero cero como el carácter cero (el byte nulo) son falsos:

A     e# Push a 10, the initial running total.
q{    e# For each character in the input...
  ~-  e#   Evaluate the character to get the digit and subtract it from the total.
  Ac  e#   Push a linefeed character.
  e|  e#   Logical OR of the running total and the linefeed character (using
      e#   short-circuiting).
}/
N&    e# Take the set intersection with the string containing a linefeed character.
      e# If the total is still a number of any character other than the linefeed,
      e# this will yield an empty string. Otherwise, the string will remain unchanged
      e# and the linefeed will be printed.

Tarea 8 - Reloj cuadrado - 10 bytes

qDbJ%5/)3*

Banco de pruebas.

Esta es solo una magia de módulo bastante aleatoria en los códigos de caracteres que sucede con el hash a los valores correctos. Estoy bastante convencido de que es posible algo más corto, pero es el más corto que encontré (programáticamente) para este tipo de estructura:

q   e# Read the input.
Db  e# Treat the character codes of the string as digits in base 13. This maps the
    e# four inputs to the values: 2023940117708546863
    e#                            2023940113755405840
    e#                            2023940781838850791
    e#                            2023940113755390292
J%  e# Take the result modulo 19. This gives [2, 5, 12, 18], respectively.
5/  e# Divide by 5 (rounding down). [0, 1, 2, 3], respectively.
)   e# Increment. [1, 2, 3, 4], respectively.
3*  e# Multiply by 3. [3, 6, 9, 12], respectively.

Tarea 9 - Diseño del soporte - 23 22 bytes

Gracias a Sp3000 por guardar 1 byte.

q_{_')>+)}%W%+_W%N@N3$

Banco de pruebas.

Bastante sencillo. La asignación entre los corchetes izquierdo y derecho se realiza agregando 2 (o 1 para paréntesis):

q_      e# Read input and duplicate.
{       e# Map this block onto each character...
  _')>  e#   Duplicate and check if it's not a parenthesis.
  +     e#   Add the result, leaving parentheses unchanged and incrementing the
        e#   other bracket types.
  )     e#   Increment again.
}%
W%+     e# Reverse and add to the original, giving the middle line.
_W%     e# Duplicate and reverse, giving the first line.
N@      e# Push a linefeed, pull up the middle line.
N3$     e# Push another linefeed, copy the first line.

Tarea 11 - Sator Square - 22 bytes

"SATOR
AREPO
TEN"_W%1>

Pruébalo aquí.

Probablemente la solución más aburrida de todas. Empuja la primera mitad de la cuerda y luego la invierte:

"SATOR
AREPO
TEN"    e# Push everything up to the centre of the square.
_W%     e# Duplicate and reverse.
1>      e# Discard the "N", because we don't want that twice.

Tarea 12 - Primer Tweet - 13 12 bytes

',32>_51>'d

Pruébalo aquí. (Con salida de diagnóstico para el resultado).

Después 'está el no imprimible <DEL>(0x7F), que SE elimina. Para copiar y pegar, use esta versión en su lugar:

'~),32>_51>'d

La cadena impresa es

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~STUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~d

Es decir, contiene una ejecución de todos los caracteres, seguida de otra ejecución de Sa ~, seguida de una sola d. La suma de los códigos de caracteres es 12203. Encontré esto a través de un poco de prueba y error.

'~),32>  e# Push a string with all printable characters.
_51>     e# Duplicate this and discard the first 51 of them.
'd       e# Push a "d".

Pyth, 9 tareas en 138 bytes

Esto tomó bastante tiempo.

Creo que 9 tareas es el límite para Pyth. La inclusión del siguiente programa más corto (Sator Square) da como resultado 160 bytes. Jugar al golf 20 bytes es bastante improbable. Hay 2 o 3 tareas que son un poco feas y tal vez se pueden acortar, pero en general estoy bastante satisfecho con las soluciones.

Tarea 1: ¿pueden tres números formar un triángulo ?, 8 bytes

>FsMc2SQ

Pruébelo en línea: entrada regular o conjunto de pruebas

Tarea 2: más cercano a un millón, 14 bytes

ho.a-^T6NsM.pz

Pruébelo en línea: entrada regular o conjunto de pruebas

Tarea 4 - Letras de FILTHE, 20 bytes

s*Vtsmmdd5/Lz"TLIHFE

Pruébelo en línea: entrada regular o conjunto de pruebas

Tarea 5: Alex Recursivo A., 16 bytes

u+"Alex "_GhQ".A

Pruébelo en línea: entrada regular o conjunto de pruebas

Tarea 6: rotación del teclado numérico, 20 bytes

jeo}zhN.uC_N3_c3jkS9

Pruébelo en línea: entrada regular o conjunto de pruebas

Tarea 7: división de dígitos en decenas, 15 bytes

qTu+WnGTvHG-zZZ

Pruébelo en línea: entrada regular o conjunto de pruebas

Tarea 8: reloj cuadrado, 12 bytes

*3%%Cz1978 5

Pruébelo en línea: entrada regular o conjunto de pruebas

Tarea 9 - Diseño del soporte, 20 bytes

V3_WtN+z_Xz"[<({})>]

Pruébelo en línea: entrada regular o conjunto de pruebas

Tarea 12: Primer Tweet, 13 bytes

++*d44srd\\&

Pruébelo en línea: entrada regular

TI-BASIC, 11 12 Tareas en 728 830 bytes

Tarea 1 en 7 bytes

:2max(Ans)`<`sum(Ans

La entrada es una lista en Ans.

Tarea 2 en 92 110 bytes

:seq(expr(sub(Ans,I,1)),I,1,7→L₁
:SortA(L₁
:min(7,1+sum(not(L₁
:{L₁(1)+sum(seq(L₁(I))₁₀^(I-8),I,2,7)),L₁(Ans)+sum(seq((I`>`Ans)L₁(I)₁₀^(1-I),I,2,7
:ᴇ6Ans(1+(0`>`min(ΔList(abs(1-Ans

Solicita una lista de dígitos La entrada es una cadena Ans.

Tarea 3 en 119 bytes

:Input Str1
:"  →Str2
:For(I,1,length(Str1
:sub(Str1,I,1→Str3
:inString("`<>`",Ans
:If Ans:Then
:max(0,min(L,C+2Ans-3→C
:Else
:C+1→C
:L+1→L
:sub(Str2,1,C)+Str3+sub(Str2,C+1,L-C+1→Str2
:End
:End
:sub(Str2,2,L

Solicita una cadena. Asume que C y L son indefinidos o 0.

Tarea 4 en 35 bytes

:sum(int(2seq(inString("TLIHFE",sub(Ans,I,1))^.4,I,1,length(Ans

La entrada es una cadena de entrada Ans.

Tarea 5 en 63 bytes

:Ans/2→C
:sub("A.A",1+2fPart(C),2
:For(I,0,C
 :"Alex "+Ans
 :If I≠C
  :Ans+" xelA
:End
:Ans

La entrada es un número en Ans.

Tarea 6 en 66 bytes

: 𝑖 ^ ((Ans <7) (Ans-3 (Ans >3: For (Y, ⁻1,1: Disp sum (seq ((5-real (AnsX + Ans𝑖Y) -3imag (AnsX + Ans𝑖Y)) ₁₀ ^ ( X + 1), X, ⁻1,1: Fin

La entrada es un número en Ans.

Tarea 7 en 36 43 bytes

:Input <strike>L₁</strike>Str1
:.5
:For(I,1,<strike>dim(L₁</strike>length(Str1
 :Ans+<strike>L₁(I</strike>expr(sub(Str1,I,1
 :If 10=int(Ans
  :0
:End
:not(Ans

Solicita una lista de cadenas de dígitos .

Tarea 8 en 29 bytes

:18fPart(sum(seq(I(sub(Ans,I,1)=" ")/6,I,1,15

La entrada es una cadena de entrada Ans.

Tarea 9 en 83 bytes

:For(I,1,16,2
 :If I<8
  :Ans+sub("`)}]>`",inString("`({[<`",sub(Ans,4,1)),1
 :sub(Ans,I,1)+Ans
:End
:For(I,⁻1,1
 :Disp sub(Ans,9-8abs(I),8
:End

La entrada es una cadena de entrada Ans.

Tarea 10 en 159 bytes

:1→X
:Input Str1
:2+length(Str1→L
:"X
:While 2+L`>`length(Ans
 :Ans+Ans→Str2
:End
:Ans→Str3
:While 1
 :"XX
 :Ans+Str1+Ans→Str1
 :For(I,1,L
  :Ans+sub("0X.",2expr(sub(Str2,I+1,1))+not(expr(sub(Ans,I,3)+sub(Str2,I,3)+sub(Str3,I,3))),1
 :End
 :Disp sub(Ans,L+3,L
 :Str2→Str3
 :Str1→Str2
 :Input Str1
:End

Usos en X0.lugar de .Xorespectivamente (lo siento, nada coincide). Solicita la entrada línea por línea. Debe ingresar dos líneas de Xs para ver toda la salida, y luego 2nd + Salir para salir.

Tarea 11 en 39 bytes

:Disp "SATOR
:Disp "AREPO
:Disp "TENET
:Disp "OPERA
:Disp "ROTAS

Tarea 12 en 77 bytes

: Ans + "tvm_I% LinReg (ax + b) DS <(getKeyconj (1-PropZTest (dayOfWk (Manual-Fit C / YANOVA (* row (HorizRegEQUnarchive [J]!) # $ &'', .234567890:; = >? @GBQX \^ _`qw {|} ~

O como hexadecimal:

72702ABB21FFDBADBB25BB3EEF06EF16
6331BB5917746201BB695C092DBBD2BB
D3BBD4AEAE2B3A323334353637383930
3EBBD66A6CAFBBD147425158BBD7F0BB
D9BBD5BBC1BBC708BBD809BBCF

Entrada es una cadena que contiene "en Ans.

Esto es realmente imposible en TI-BASIC. Es posible editar hexadecimalmente un programa básico y usar ciertos tokens de 2 bytes para obtener todos los caracteres ascii imprimibles en el código fuente, pero ese no es el problema. El problema es que no hay forma de almacenar un "carácter en una cadena en puro básico en un cálculo limpio sin entrada de programa (lo mismo se aplica al →carácter, pero eso no es imprimible ascii). Sin embargo, es posible poner "una ecuación fuera de basic, después de lo cual puede usar basic para convertir la ecuación en una cadena y mostrar esa cadena. Además de todo eso, de todos modos solo hay suficiente espacio en pantalla para 128 caracteres a la vez.

Perl, 4 tareas en 117 bytes

Probemos un lenguaje real ;)

Aún no se ha dado por vencido, ¡incluso podría exprimir 5 tareas en 140 bytes, aunque es poco probable!

* Tarea 1: 30 + 1 = 31 bytes

@F=sort@F;say$F[0]+$F[1]>$F[2]

Uso: perl -aM5.010 entry.pl input.txt

* Tarea 4: 32 + 1 = 33 bytes

y/ELTFHI/4223/;s/./+$&/g;$_=eval

Uso: perl -p entry.pl input.txt

Tarea 5: 54 bytes

say"Alex "x($_/2+1).qw(A. .A)[$_%2]." xelA"x(--$_/2+1)

-2b gracias a Dom Hastings

Uso: echo 4 | perl -M5.010 entry.pl

Tarea 7: 37 + 2 = 39 bytes

($i+=$_)>10&&exit,$i%=10for@F;$_=!$i;

Uso: perl -pF entry.pl input.txt

* Tarea 8: 21 + 2 = 23 bytes

$_=y/|_ 
/14/dr/64%14

Esto es un poco complicado. Iniciado a cabo mediante la sustitución de cada uno |con xy cada uno _con yespacios a continuación, reemplazando a producir una cadena única de dos dígitos para cada rejilla ( yyxxyxxyyx, yyxxyxxyyxyyxxxxyxyx, yyxxxxyxyxyyxyxxxyyx, yyxyxxxyyxyyxxxxyyx, yyxxxxyyx). A continuación, escribí un programa para los valores de fuerza bruta para xy y, y las operaciones matemáticas que podrían realizarse en los números producidos después de la sustitución xy ypara dar una salida de 3,6,9,12 para cada número. Al final, x=1, y=4y la operación de la magia era /64%14.

Uso: perl -0p entry.pl input.txt

Tarea 11: 34 bytes

say"SATOR
AREPO
TENET
OPERA
ROTAS"

Uso: perl -M5.010 entry.pl

* Tarea 12: 30 bytes

say d.pack"C*",32..126,83..126

Uso: perl -M5.010 entry.pl

Descargo de responsabilidad: -M5.010 se considera 'gratis'

Ruby, 4 tareas en 280 bytes (no competitivo)

Esto es solo un intento, seguiré haciendo tareas más tarde (y con suerte jugaré las existentes).

Tarea 1

a=gets.split.map &:to_i;p a.all?{|e|e<a.inject(:+)-e}

Tarea 2

p gets.chars.permutation.map{|a|a.join.to_i}.min_by{|x|(x-1e6).abs}

Tarea 4

n,b='EFHILT',0;gets.chars.map{|c|b+=n[c]==p ? 0:[4,3,3,3,2,2][n.index c]};p b

Tarea 5

a='Alex A.';gets.to_i.times{|i|i%2<1 ? a.sub!('A.','.A xelA'):a.sub!('.A',a)};$><<a

TI-BASIC, 12 tareas en 994 bytes

Descargue todo como un archivo de grupo de TI ( .8xg )

(Etiquetas de spoiler agregadas por solicitud).

Tarea 1: ¿pueden tres números formar un triángulo? - 7 bytes

Descargar como un archivo de programa TI-83 + ( .8xp )

:2max(Ans)<sum(Ans

Tarea 2: más cercano a un millón: 114 bytes

Descargar como un archivo de programa TI-83 + ( .8xp )

:int(10fPart(Ans\10^(\-cumSum(binomcdf(6,0→X
:"sum(\L\X\10^(\cumSum(not(binompdf(6,0→\Y1\
:SortD(\L\X
:\Y1\→X
:sum(not(\L\X
:If Ans
:Then
:If max(\L\X=1
:X+\E\6-\10^(\6-Ans→X
:SortA(\L\X
:augment(ΔList(cumSum(\L\X)),{0→X
:End
:{X,\Y1\
:Ans(1+(0>min(ΔList(abs(\E\6-Ans

Tarea 3: Simulador de teclado simple: 131127 bytes

Descargar como un archivo de programa TI-83 + ( .8xp )

:Input Str1
:DelVar X1→Y
:"..→Str2
:For(Z,1,length(Str1
:sub(Str1,Z,1→Str3
:(Ans=">")-(Ans="<
:If Ans
:Then
:max(1,min(Y+Ans,X+1→Y
:Else
:sub(Str2,1,Y)+Str3+sub(Str2,Y+1,X-Y+2→Str2
:X+1→X
:Y+1→Y
:End
:End
:sub(Str2,2,X

Tarea 4 - Cartas FILTHE - 34 bytes

Descargar como un archivo de programa TI-83 + ( .8xp )

:sum(int(\³√(\12seq(inString("TLIHFE",sub(Ans,X,1)),X,1,length(Ans

Tarea 5: Alex Recursivo A. - 107 bytes

Descargar como un archivo de programa TI-83 + ( .8xp )

:Input X
:".A..
:For(X,0,X
:Ans→Str1
:5int(.5X+.5
:sub(Str1,1,Ans+1)+sub(".A xelAlex A.",6gcd(X,2)-5,7)+sub(Str1,Ans+4,5X-Ans+1
:End
:sub(Ans,2,5X+2

Tarea 6 - Rotación del teclado numérico - 86 bytes

Descargar como un archivo de programa TI-83 + ( .8xp )

:.3Ans+2(Ans=6→X
:[[9,6,3][8,5,2][7,4,1
:For(X,0,X
:rowSwap(Ans\^T\),1,3
:End
:Ans
:*row+(10,*row+(10,Ans\^T\,1,2),2,3
:For(X,1,3
:Disp Ans(3,X
:End

Tarea 7: división de dígitos en decenas: 77 bytes

Descargar como un archivo de programa TI-83 + ( .8xp )

:Ans+"0
:seq(expr(sub(Ans,X,1)),X,1,length(Ans
:augment(Ans,{10not(not(max(Ans→X
:1→X
:Repeat Ans≥dim(\L\X
:Ans+1
:If 10=sum(\L\X,X,Ans
:Ans+1→X
:End
:X=Ans

Tarea 8 - Reloj cuadrado - 35 bytes

Descargar como un archivo de programa TI-83 + ( .8xp )

:12-3max(seq(X(sub(Ans,6gcd(X,2)+X,1)≠" "),X,1,3

Tarea 9 - Diseño del soporte - 86 bytes

Descargar como un archivo de programa TI-83 + ( .8xp )

:Input Str1
:For(X,1,4
:For(Y,0,1
:abs(X-9not(Y→Z
:"()[]{}<>
:sub(Ans,inString(Ans,sub(Str1,X,1))+Y,1
:Output(1,Z,Ans
:Output(2,9-Z,Ans
:Output(3,Z,Ans
:End
:End

Tarea 10 - Perimiterizar - 218 bytes

Descargar como un archivo de programa TI-83 + ( .8xp )

:".
:For(A,0,\E\9
:Input Str1
:Ans+Str1→Str2
:If Str1≠".
:End
:length(Ans→X
:round(A\^-1\(Ans-2→B
:seq(expr(sub(Str2,A,1)),A,2,X-1→B
:πAns→C
:"augment(Ans,augment(Ans,\L\B))+augment(Ans,augment(\L\C,Ans))+augment(\L\B,augment(Ans,Ans→X
:seq(0,A,1,B
:\L\X→A
:For(C,0,A+1
:seq(\L\A(A+BC),A,1,B→C
:int(Ans→B
:{0
:1+not(\L\X)+not(fPart(\L\X→B
:".
:For(X,1,B+2
:Ans+sub("120",\L\B(X),1
:End
:Disp sub(Ans,2,B+2
:End

Estas sustituciones se han realizado: 0= ., 1= X, 2=o

Para la entrada (después de que comience el programa), escriba una fila a la vez, presionando enter en cada salto de línea, hasta que se escriba la última fila. Luego presione enter, escriba un punto, luego presione enter nuevamente para enviar la cadena completa.

Tarea 11 - Cuadrado Sator - 38 bytes

Descargar como un archivo de programa TI-83 + ( .8xp )

:Disp "SATOR","AREPO","TENET","OPERA
:"ROTAS

Tarea 12 - Primer Tweet - 151 bytes

Descargar como un archivo de programa TI-83 + ( .8xp )

:Ans+"!#$%&'()*+,-./01234567889:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
:For(X,1,45
:Ans+" 
:End
:Ans

Ansdebe contener una comilla doble, realizada escribiendo una directamente \Y1\desde el editor de ecuaciones y ejecutándose Equ►String(\Y1\,Str1:Str1desde la pantalla de inicio.

La longitud de salida es 140. 8 aparece dos veces, y hay 45 espacios junto con los otros caracteres ASCII, cada uno de los cuales aparece una vez. Esto equivale a (33 + 34 + ... + 126) + 56 + 32 × 45 = 8969, una prima de Sophie Germain.

Python 3, 1 tarea, 268 bytes, no competitivo

Intenté la Tarea # 2 en Python 3.5.2 Soy nuevo en el código de golf y Python

import itertools
def f2(l):
    n=1000000
    l=list(itertools.permutations(l))
    j = len(l)
    m=[None]*j
    while j>0:
        j -= 1
        m[j]= int(''.join(str(i) for i in l[j]))
        l[j]=abs(n-m[j])
    l.sort()
    k=n-l[0]
    return(n+l[0],k)[k in m]