Seu chefe acabou de lhe enviar uma lista de 12 tarefas de programação que ele precisa executar o mais rápido possível. As tarefas são bastante simples, mas seu chefe, sendo um jovem magnata do software amamentado pelas redes sociais, insiste em que suas soluções possam caber em um único tweet no Twitter .

Isso significa que você tem apenas 140 bytes de código para resolver todas as tarefas, uma média de 11,67 bytes por tarefa. (Sim, o Twitter conta caracteres, mas seu chefe disse especificamente bytes.)

Você percebe que não há como resolver todas as 12 tarefas em 140 bytes, mas suspeita que seu chefe não irá testar todas as suas soluções. Assim, você resolve todas as tarefas possíveis, ignorando completamente algumas delas. Sua mentalidade é que não importa qual subconjunto das tarefas que você concluir, importa apenas que o subconjunto seja o maior possível .

Quantas tarefas você pode concluir?

Desafio

Escreva até 12 programas diferentes, cada um dos quais resolve com precisão uma das 12 tarefas listadas abaixo. A soma acumulada dos comprimentos desses programas não pode exceder 140 bytes

Como alternativa, você pode escrever um único programa de no máximo 140 bytes que leve um número inteiro de 1 a 12 e (idealmente) prossiga para resolver a tarefa correspondente, obtendo mais entradas conforme necessário. Nem todas as tarefas precisam funcionar, mas apenas as que contam para a sua pontuação. Tarefas que não funcionam podem errar ou fazer qualquer outra coisa.

Nos dois casos, um "programa" pode de fato ser uma função que recebe a entrada como argumentos ou solicita-a e imprime ou retorna a saída. Portanto, por exemplo, você pode escrever uma função de 140 bytes que seja semelhante f(taskNumber, taskInput)ou escrever trechos de código separados para cada tarefa, alguns como funções e outros como programas de pleno direito.

Outros detalhes:

• Todo o código deve ser escrito no mesmo idioma.

• Como de costume, a entrada deve vir do stdin, da linha de comando, de um argumento de função ou do que for usual para o seu idioma. A saída é impressa no stdout ou na alternativa mais próxima do seu idioma ou retornada em um tipo apropriado.

• Uma quantidade razoável de formatação de entrada é boa; por exemplo, aspas em torno de strings ou em \nvez de novas linhas reais.

• A saída deve ser exatamente o que é solicitado, sem formatação ou espaço em branco estranhos. A exceção é uma nova linha opcional à direita.

• O código que é executado apenas em um ambiente REPL não constitui um programa ou função.

• Você não pode escrever vários programas que resolvem várias tarefas. Ou é um programa que (idealmente) resolve todas as tarefas ou (idealmente) 12 programas que resolvem uma única tarefa.

• Não é permitida a publicação de uma solução de tarefas que você não escreveu ou apenas modificou ligeiramente, sem atribuir o autor original e, idealmente, obtendo permissão também. Se sua resposta compõe principalmente as soluções mais curtas de todas as outras respostas, deve ser um wiki da comunidade.

Pontuação

O envio que concluir a maioria das tarefas é o vencedor. Se houver dois envios, o que tiver menos bytes vence. Se a contagem de bytes estiver empatada, o envio anterior vence. As respostas do wiki da comunidade não têm permissão para vencer.

Não deixe de nos dizer quais tarefas você resolveu, e não quantas!

Handicap para não-golfistas:

É provável que esse desafio seja dominado por idiomas de golfe . Muitos idiomas podem ter problemas para resolver até uma ou duas tarefas em 140 bytes. Portanto, você pode enviar uma resposta não competitiva em que o limite é de 3 tweets, ou seja, 420 bytes. Todas as outras regras permanecem as mesmas.

Tarefas

Tarefa 1 - Três números podem formar um triângulo?

Pegue três números inteiros positivos e produza um valor de verdade / falsidade indicando se três linhas com esses comprimentos podem formar um triângulo . Você não pode presumir que os números vêm em qualquer ordem específica.

Exemplos de verdade (um por linha):

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

Exemplos de falsidade:

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

---

Tarefa 2 - mais próxima de um milhão

Dada uma sequência de exatamente 7 dígitos decimais (0-9), reorganize-os para obter um número o mais próximo possível de um milhão. Ou seja, abs(1000000 - rearrangedNumber)deve ser minimizado.

Imprima ou retorne o número resultante como um número inteiro, não como uma string (portanto, não deve haver zeros à esquerda, a menos que seja a norma para o seu idioma).

por exemplo, uma entrada de 9034318deve resultar em 984331(e não 1033489).

2893984deve se tornar 2348899.

0001000deve se tornar 1000000.

0000020deve se tornar 200000.

---

Tarefa 3 - Simulador de teclado simples

Pegue uma sequência de letras minúsculas (az), espaços e colchetes angulares <>. Leia da esquerda para a direita, essa sequência representa as teclas que foram pressionadas em um teclado padrão enquanto um editor de texto inicialmente vazio estava aberto. As letras e o espaço correspondem às teclas normais, mas <correspondem às setas esquerda e >direita, ambas movendo o cursor quando pressionadas.

<move o cursor um caractere para a esquerda ou não faz nada se o cursor estiver no início da string.
>move o cursor um caractere para a direita ou não faz nada se o cursor estiver no final da string.

Saída a string que estaria no editor de texto depois que todas as teclas da string de entrada forem pressionadas. Não é permitido emitir códigos de escape para mover o cursor.

Sempre haverá pelo menos um caractere que não seja da seta na entrada.

por exemplo, a entrada ui<<q>>ck <<<<<<the<<<<>>> >>>>>>>>brown x<o<fdeve render the quick brown fox.

op<<l>>t<<<lam>>>>>>imi<<<><>>>zer<<<<<<<<<<<<<<<<<<>>><>mdeve dar llammoptimizer.

e< <c<b<adeve dar abc e.

<<<>><><<><toast>><<>><><<>><deve dar toast.

---

Tarefa 4 - Cartas da FILTHE

Em muitas fontes, 6 das maiúsculas letras Inglês alfabeto consiste inteiramente de linhas horizontais e verticais: E, F, H, I, L, e T. Nós chamaremos essas letras de FILTHE.

Pegue uma sequência de letras maiúsculas (AZ) e conte o número de linhas nas letras FILTHE, produzindo o número inteiro resultante.

E, F, H, I, L, E Ttem 4, 3, 3, 3, 2, 2 e linhas, respectivamente.

por exemplo, GEOBITStem 4 + 3 + 2 = 9 linhas como parte das letras FILTHE (para .E..IT.), portanto a saída deve ser 9.

ABCDEFGHIJKLMNOPQRSTUVWXYZdeve produzir 17.

ABCDGJKMNOPQRSUVWXYZdeve produzir 0.

FILTHYLINESINLETTERSdeve produzir 39.

---

Tarefa 5 - Alex Recursivo A.

Nosso moderador Alex A. tem uma inicial bastante misteriosa, "A".

Agora não tenho certeza, mas acho que isso A.significa .A xelA. E também tenho certeza de que o que .Aexiste sorrateiramente significa Alex A..

Assim, para obter o nome completo de Alex, precisamos expandir os A.'s e .A' s:

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

Faça com que seu programa obtenha um número inteiro não negativo e expanda Alex A.isso muitas vezes, produzindo a sequência resultante.

Assim,
0torna-se Alex A.,
1torna-se Alex .A xelA,
2torna-se Alex Alex A. xelA,
3torna-se Alex Alex .A xelA xelA,
4torna-se Alex Alex Alex A. xelA xelA,
5torna-se Alex Alex Alex .A xelA xelA xelA,
e assim por diante.

^{(Fiz isso porque me senti mal por deixar inadvertidamente Alex fora do meu desafio de tributo a mod .: P)}

---

Tarefa 6 - Rotação de Numpad

Pegue um número inteiro de 1 a 9 inclusive (você pode considerá-lo como uma string). Emita o quadrado de 3 × 3 dígitos

789
456
123

girado em incrementos de 90 °, de modo que o dígito de entrada apareça em qualquer lugar na linha superior. Quando 5é inserida, qualquer rotação é uma saída válida, pois 5não pode ser girada para o topo.

por exemplo, quando 3é introduzido, ambos

963
852
741

e

321
654
987

são saídas válidas.

Para entrada 4, apenas

147
258
369

é uma saída válida.

---

Tarefa 7 - Divisão de dígitos em dezenas

Pegue uma sequência não vazia de dígitos decimais (0-9) e forneça um valor verdadeiro, se puder ser dividido em seções contíguas, onde todos os dígitos em cada seção somam exatamente 10. Se isso não for possível, insira um valor falso.

por exemplo, 19306128pode ser dividido como 19|3061|28, todas as seções somando 10 (1 + 9, 3 + 0 + 6 + 1, 2 + 8), portanto, um valor verdadeiro deve ser gerado.

Exemplos de verdade (um por linha):

19306128
073
730
0028115111043021333109010
2222255

Exemplos de falsidade:

6810410
9218
12341
5222225
000

---

Tarefa 8 - Relógio quadrado

Pegue uma cadeia de várias linhas de tamanho consistente.

Saída 12se a entrada for

 _ _
| | |
|_ _|

Saída 3se a entrada for

 _ _
| |_|
|_ _|

Saída 6se a entrada for

 _ _
| | |
|_|_|

Saída 9se a entrada for

 _ _
|_| |
|_ _|

Não há outros casos de entrada.

---

Tarefa 9 - Bracket Art

Leve de uma cadeia de 4 byte contendo um de cada um dos suportes esquerdo (, [, {, e <em qualquer ordem.

Adicione os colchetes direitos correspondentes para que a cadeia tenha 8 bytes de comprimento e tenha uma linha vertical de simetria. por exemplo, [<({torna-se [<({})>].

Em seguida, inverta todos os colchetes nessa sequência. por exemplo, [<({})>]torna-se ]>)}{(<[.

Emita a string de suporte de 8 bytes original com a versão invertida acima e abaixo em linhas separadas.

Portanto, a saída final para entrada [<({seria

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

Da mesma forma, a saída para <({[deve ser

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

A entrada (<<[é inválida porque {está faltando e há um extra <.

---

Tarefa 10 - Perimiterar

Pegue uma grade retangular de texto (1 × 1 no menor) feito de .'s que representam espaço vazio e X' s que representam blocos sólidos. As células além dos limites da grade são consideradas vazias. Você pode assumir que cada uma das quatro linhas e colunas da borda da grade conterá pelo menos uma X.

por exemplo, uma entrada válida pode ser:

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

Saída outra grade retangular de texto onde todas as células vazias vizinhas a uma Xortogonal ou diagonal, incluindo aquelas fora da grade de entrada , se tornam o. Então, essencialmente, um perimitro de o's é desenhado em torno de todas as partes dos ladrilhos sólidos. A nova grade não deve ser maior do que deve ser.

Portanto, a saída do exemplo acima seria:

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

Da mesma forma, a saída da entrada XXX..X.Xdeve ser

oooooooooo
oXXXooXoXo
oooooooooo

e saída

oooooooooo.
oXXXooXoXo.
oooooooooo.

seria inválido, pois a coluna mais à direita vazia é desnecessária.

Você pode usar qualquer 3 distintas ASCII imprimíveis caracteres no lugar de ., Xe o.

---

Tarefa 11 - Praça Sator

Saída do Sator Square :

SATOR
AREPO
TENET
OPERA
ROTAS

Qualquer uma das letras pode ser minúscula ou maiúscula, portanto

SatOR
aRePO
tenet
OPERa
RoTaS

também é saída válida.

Não há entrada.

---

Tarefa 12 - Prime Tweet

Não aceite entrada, mas produza uma sequência ASCII imprimível de 140 bytes que contém pelo menos um de cada um dos 95 caracteres ASCII imprimíveis. (Portanto, 45 caracteres serão duplicados.)

A soma dos códigos de caracteres de todos os 140 bytes nessa string deve ser um primo de Sophie Germain , ou seja, um número primo p, que 2p+1também é primo. O código de caractere para o espaço é 32, 33 para !, 34 para "e assim por diante até 126 para ~. A soma pode ser calculada em Python como sum(map(ord, myString)).

Um exemplo de saída é:

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

A soma do código de caractere é o primo 12203, cujo primo seguro correspondente é 24407.

Pitão, 9 tarefas em 136 bytes

Tarefa 1: 7 bytes

<-F_SQ0

Demonstração

Classifique em ordem decrescente ( _SQ), dobre a subtração sobre eles ( a-b-c), verifique se o resultado é negativo.

Tarefa 2: 14 bytes

sho.a-sN^T6.pz

Demonstração

Forme todas as permutações de string ( .pz), classifique-as ( o) com base no valor absoluto da diferença ( .a-) entre o número ( sN) e um milhão ( ^T6).

Pegue a primeira string ( h) e converta-a para um num. ( s)

Tarefa 4: 19 bytes

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

Demonstração

Replicar "EFHILT"três vezes ( *3), remover o final LT( PP) e adicionar um E( +\E). Mapeie cada letra na entrada para sua contagem de aparência nessa sequência. ( /L ... z) Soma. ( s)

Tarefa 5: 16 bytes

u+"Alex "_GhQ".A

Demonstração

Começando com "A.", inverter e adicionar um "Alex "ao início, insira + 1 vezes.

Tarefa 7: 13 bytes

}Y-RTsMM./sMz

Converta a sequência de entrada em uma lista de números de 1 dígito ( sMz). Forme todas as partições ( ./). Soma cada elemento de cada partição ( sMM). Remova todos os 10s de cada sub-lista ( -RT). Verifique se isso esvaziou alguma das sublistas, verificando se a lista vazia está na lista geral ( }Y).

Tarefa 8: 11 bytes

*3h%%CQC\Ç4

Demonstração

Módulo mágico. Converta para o número ( CQ), faça o mod 199 ( C\Ç= 199) e faça o mod 4. Em seguida, adicione 1 e multiplique por 3.

Tarefa 9: 21 bytes

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

Demonstração

Primeiro, geramos a primeira linha, que consiste na entrada convertida nos caracteres do espelho ( Xz"<{[()]}>")), seguida pela entrada reversa ( + ... _z), e a salvamos J. Em seguida, imprima essa linha, seu reverso e essa linha novamente ( J_JJ).

Tarefa 11: 22 bytes

+J"SATOR
AREPO
TEN"t_J

Demonstração

Apenas imprima uma string e sua inversão, mas não duplique o centro N.

Tarefa 12: 13 bytes

++G*19\3srd\

Demonstração

Há um caractere invisible DEL( 7F) no final do código.

Isso imprime

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

que possui soma de caracteres 11321. Ele consiste Gno alfabeto, 19 se 3todos os caracteres ASCII imprimíveis.

CJam, 8 9 tarefas em 140 bytes

Primeiro, aqui está um script que você pode usar para classificar suas soluções e dizer quais se encaixam no tweet:

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

Basta colar suas 12 soluções na entrada, uma em cada linha. Execute-o aqui. A primeira coluna é o número da tarefa, a segunda, seu tamanho (em caracteres - você precisará corrigir isso se for diferente da contagem de bytes) e a terceira o tamanho cumulativo. Os programas que se encaixam no tweet são separados dos demais por uma linha de ===.

Para mim, a saída é assim:

 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>}/

Então, aqui estão as tarefas que atualmente posso incluir no tweet.

Tarefa 1 - Três números podem formar um triângulo? - 8 7 bytes

Obrigado a jimmy23013 por economizar 1 byte.

q~$~\->

Suíte de teste.

A entrada deve ser uma lista no estilo CJam.

Isso é bastante direto: verifique se o lado maior é menor que a soma dos outros dois. Ou, equivalentemente, verifique se o lado mais curto é maior que a diferença dos outros dois:

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.

Tarefa 2 - Próximo a um milhão - 15 bytes

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

Suíte de teste.

Força bruta simples:

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.

Tarefa 4 - FILTHE Cartas - 21 19 bytes

Obrigado a jimmy23013 por salvar 2 bytes.

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

Suíte de teste.

A idéia é criar uma string que contenha cada uma das letras FILTHE uma vez para cada uma de suas linhas ortogonais. Isso é feito através de alguma manipulação engraçada de strings:

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.

Tarefa 5 - Alex Recursivo A. - 27 20 bytes

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

Suíte de teste.

Implantar a subestação A.e .Adiretamente é muito caro. Em vez disso, percebemos que só precisamos lidar com um caso, se revertermos a string a cada vez. Além disso, acrescentar Alex(e um espaço) a cada vez é equivalente a expandir a inicial. Podemos salvar outro byte acrescentando o reverso antes de reverter a string:

".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.
}*

Tarefa 7 - Divisão de dígitos em dezenas - 18 16 13 bytes

Aq{~-Ace|}/N&

Suíte de teste. (Com colchetes ao redor de cada saída.)

Não é exatamente fácil de usar: o valor de verdade é uma única linha nova, o valor de falsy é a sequência vazia.

A idéia básica é simples: adicione os dígitos a um total em execução, que redefinimos sempre que atingir exatamente 10. O total deve ser zero no final da entrada. Para começar, acaba sendo mais curto para o total em 10 e subtrai os dígitos, redefinindo o total sempre que atingimos 0. No entanto, precisamos garantir que não retornemos algo verdadeiro quando a entrada estiver com zero. A maneira mais curta que encontrei foi redefinir o total para o caractere com o ponto de código 10 (o avanço de linha) e depois verificar no final se realmente temos esse caractere na pilha, e não o número 10. Isso funciona, porque o número inteiro zero e o caractere zero (o byte nulo) são 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.

Tarefa 8 - Relógio quadrado - 10 bytes

qDbJ%5/)3*

Suíte de teste.

Isso é apenas uma mágica de módulo bastante aleatória nos códigos de caracteres que acontece com os valores corretos. Estou bastante convencido de que algo mais curto é possível, mas é o mais curto que encontrei (programaticamente) para esse tipo de estrutura:

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.

Tarefa 9 - Bracket Art - 23 22 bytes

Agradecimentos ao Sp3000 por economizar 1 byte.

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

Suíte de teste.

Bastante direto. O mapeamento entre os colchetes esquerdo e direito é feito adicionando 2 (ou 1 entre parênteses):

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.

Tarefa 11 - Quadrado do Sator - 22 bytes

"SATOR
AREPO
TEN"_W%1>

Teste aqui.

Provavelmente a solução mais chata de todas. Empurra a primeira metade da corda e depois a inverte:

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

Tarefa 12 - Prime Tweet - 13 12 bytes

',32>_51>'d

Teste aqui. (Com saída de diagnóstico para o resultado.)

Depois, 'há o imprimível <DEL>(0x7F), que o SE retira. Para copiar e colar, use esta versão:

'~),32>_51>'d

A sequência impressa é

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

Ou seja, ele contém uma execução de todos os caracteres, seguida por outra execução de Spara ~, seguida por uma única d. A soma dos códigos de caracteres é 12203. Encontrei isso através de algumas tentativas e erros.

'~),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".

Pitão, 9 tarefas em 138 bytes

Isso levou um bom tempo.

Eu acho que 9 tarefas é o limite para Pyth. A inclusão do próximo programa mais curto (Sator Square) resulta em 160 bytes. Golfe de 20 bytes é bastante improvável. Existem 2 ou 3 tarefas que são um pouco feias e podem ser reduzidas, mas no geral estou bastante satisfeito com as soluções.

Tarefa 1 - Três números podem formar um triângulo ?, 8 bytes

>FsMc2SQ

Experimente online: Entrada regular ousuíte de testes

Tarefa 2 - Próximo a um milhão, 14 bytes

ho.a-^T6NsM.pz

Experimente online: Entrada regular ou suíte de testes

Tarefa 4 - FILTHE Letras, 20 bytes

s*Vtsmmdd5/Lz"TLIHFE

Experimente online: Entrada regular ou suíte de testes

Tarefa 5 - Alex Recursivo A., 16 bytes

u+"Alex "_GhQ".A

Experimente online: Entrada regular ou suíte de testes

Tarefa 6 - Rotação de Numpad, 20 bytes

jeo}zhN.uC_N3_c3jkS9

Experimente online: Entrada regular ou suíte de testes

Tarefa 7 - Divisão de dígitos em dezenas, 15 bytes

qTu+WnGTvHG-zZZ

Experimente online: Entrada regular ou suíte de testes

Tarefa 8 - Relógio quadrado, 12 bytes

*3%%Cz1978 5

Experimente online: Entrada regular ou suíte de testes

Tarefa 9 - Bracket Art, 20 bytes

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

Experimente online: Entrada regular ou suíte de testes

Tarefa 12 - Prime Tweet, 13 bytes

++*d44srd\\&

Experimente online: Entrada regular

TI-BASIC, 11 12 Tarefas em 728 830 bytes

Tarefa 1 em 7 bytes

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

Entrada é uma lista em Ans.

Tarefa 2 em 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 uma lista de dígitos A entrada é uma string Ans.

Tarefa 3 em 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 uma sequência. Assume que C e L são indefinidos ou 0.

Tarefa 4 em 35 bytes

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

Entrada é uma string Ans.

Tarefa 5 em 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

Entrada é um número em Ans.

Tarefa 6 em 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: Fim

Entrada é um número em Ans.

Tarefa 7 em 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 uma lista de sequência de dígitos .

Tarefa 8 em 29 bytes

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

Entrada é uma string Ans.

Tarefa 9 em 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

Entrada é uma string Ans.

Tarefa 10 em 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

Usa em X0.vez de .Xorespectivamente (desculpe, nada corresponde). Solicita a entrada de linha por linha. Você deve inserir duas linhas deX s para ver toda a saída e, em seguida, 2º + sair para sair.

Tarefa 11 em 39 bytes

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

Tarefa 12 em 77 bytes

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

Ou como hexadecimal:

72702ABB21FFDBADBB25BB3EEF06EF16
6331BB5917746201BB695C092DBBD2BB
D3BBD4AEAE2B3A323334353637383930
3EBBD66A6CAFBBD147425158BBD7F0BB
D9BBD5BBC1BBC708BBD809BBCF

Entrada é uma sequência que contém "in Ans.

Isso é realmente impossível no TI-BASIC. É possível editar em hexadecimal um programa básico e usar determinados tokens de 2 bytes para inserir todos os caracteres ascii imprimíveis no código-fonte, mas esse não é o problema. O problema é que não há como armazenar um "caractere em uma string no básico puro, em um cálculo limpo, sem entrada de programa (o mesmo se aplica ao →caractere, mas isso não é ascii imprimível). É possível, no entanto, "inserir uma equação fora do básico, após o qual você pode usar o básico para converter a equação em uma sequência e exibir essa sequência. Além disso, só há espaço suficiente na tela para 128 caracteres por vez.

Perl, 4 tarefas em 117 bytes

Vamos tentar uma linguagem real ;)

Ainda não desistiu, pode até conseguir espremer 5 tarefas em 140 bytes, embora improvável!

* Tarefa 1: 30 + 1 = 31 bytes

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

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

* Tarefa 4: 32 + 1 = 33 bytes

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

Uso: perl -p entry.pl input.txt

Tarefa 5: 54 bytes

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

-2b graças a Dom Hastings

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

Tarefa 7: 37 + 2 = 39 bytes

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

Uso: perl -pF entry.pl input.txt

* Tarefa 8: 21 + 2 = 23 bytes

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

Este é um pouco complicado. Começou por substituindo cada |com xe cada um _com yespaços, em seguida, substituindo a produzir uma seqüência de dois dígitos exclusivo para cada grade ( yyxxyxxyyx, yyxxyxxyyxyyxxxxyxyx, yyxxxxyxyxyyxyxxxyyx, yyxyxxxyyxyyxxxxyyx, yyxxxxyyx). Em seguida, escrevi um programa para valores de força bruta para xe y, e operações matemáticas que poderiam ser feitas nos números produzidos após a substituição xe ypara fornecer uma saída de 3,6,9,12 para cada número. No final, x=1, y=4ea operação de magia era /64%14.

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

Tarefa 11: 34 bytes

say"SATOR
AREPO
TENET
OPERA
ROTAS"

Uso: perl -M5.010 entry.pl

* Tarefa 12: 30 bytes

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

Uso: perl -M5.010 entry.pl

Isenção de responsabilidade: -M5.010 é considerado "gratuito"

Ruby, 4 tarefas em 280 bytes (não competitivo)

Esta é apenas uma tentativa, continuarei fazendo as tarefas mais tarde (e espero jogar as existentes).

Tarefa 1

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

Tarefa 2

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

Tarefa 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

Tarefa 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 tarefas em 994 bytes

Baixar tudo como um arquivo de grupo de TI ( .8xg )

(Tags de spoiler adicionadas por solicitação.)

Tarefa 1 - Três números podem formar um triângulo? - 7 bytes

Faça o download como um arquivo de programa da TI-83 + ( .8xp )

:2max(Ans)<sum(Ans

Tarefa 2 - Próximo a um milhão - 114 bytes

Faça o download como um arquivo de programa da 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

Tarefa 3 - Simulador de teclado simples - 131 127 bytes

Faça o download como um arquivo de programa da 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

Tarefa 4 - FILTHE Cartas - 34 bytes

Faça o download como um arquivo de programa da TI-83 + ( .8xp )

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

Tarefa 5 - Alex Recursivo A. - 107 bytes

Faça o download como um arquivo de programa da 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

Tarefa 6 - Rotação de Numpad - 86 bytes

Faça o download como um arquivo de programa da 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

Tarefa 7 - Divisão de dígitos em dezenas - 77 bytes

Faça o download como um arquivo de programa da 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

Tarefa 8 - Relógio quadrado - 35 bytes

Faça o download como um arquivo de programa da TI-83 + ( .8xp )

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

Tarefa 9 - Bracket Art - 86 bytes

Faça o download como um arquivo de programa da 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

Tarefa 10 - Perimiterar - 218 bytes

Faça o download como um arquivo de programa da 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 substituições foram feitas: 0= ., 1= X, 2=o

Para entrada (após o início do programa), digite uma linha de cada vez, pressionando enter a cada quebra de linha, até que a última linha seja gravada. Em seguida, pressione enter, digite um ponto e pressione enter novamente para enviar a sequência inteira.

Tarefa 11 - Quadrado do Sator - 38 bytes

Faça o download como um arquivo de programa da TI-83 + ( .8xp )

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

Tarefa 12 - Prime Tweet - 151 bytes

Faça o download como um arquivo de programa da TI-83 + ( .8xp )

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

Ansdeve conter aspas duplas, digitando uma diretamente no \Y1\editor de equações e executandoEqu►String(\Y1\,Str1:Str1 na tela inicial.

O comprimento da saída é 140. 8 aparece duas vezes e há 45 espaços junto com os outros caracteres ASCII, cada um aparecendo uma vez. Isso equivale a (33 + 34 + ... + 126) + 56 + 32 × 45 = 8969, um primo da Sophie Germain.

Python 3, 1 tarefa, 268 bytes, não competitivo

Eu tentei a Tarefa 2 no Python 3.5.2 Eu sou novo no código de golfe e 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]