Você deve concluir quatro tarefas em um idioma que:

• não deve retornar resultados * quando pesquisado neste site (codegolf.se), por exemplo, ToffeeScript ;
• deve ter uma página listada em Esolang , Rosetta Code ou Wikipedia ;
• ser uma linguagem distinta, e não uma versão distinta (por exemplo, o python 2.1 seria válido se o python satisfizesse os dois primeiros critérios).

* A exceção é esse acerto para o ToffeeScript.

As quatro tarefas que você deve concluir são:

1) Escreva uma descrição / promoção tweetable (<140 caracteres) do idioma escolhido.

2) Imprimir "Olá, mundo! Está escrito em <programming language name>."

3) Imprima todos os números ímpares em um intervalo especificado pelo usuário. (por exemplo, um stdin de 20 25deve retornar 21 23 25).

4) Escreva um programa que você sinta melhor, demonstrando uma característica interessante do idioma escolhido.

Pontuação:

• Este é um concurso de popularidade
• Bônus de 10 pontos se listado em dois dos diretórios acima, 25 se nos três.
• Pontuação é a soma dos votos recebidos à meia-noite UTC de 1º de julho de 2015, mais os bônus.

Esclarecimentos:

• A tarefa 1) pode ser um programa tweetável, mas o texto simples também é aceitável.
• Muitos idiomas não têm um intérprete existente; soluções para essas questões são boas, mas serão tomadas de boa fé.
• O segundo critério para a escolha do idioma proíbe as páginas cuja criação data após esta postagem. Se, para um determinado idioma, X, existe uma solução para um problema no Código Rosetta, mas ele não possui uma página própria em algum lugar, ainda é aceitável.

BlooP

Bônus: 10

Existem páginas para BlooP em Esolangs e Wikipedia . Uma pesquisa PPCG para BlooP não retorna resultados. Se você estiver sentindo particularmente maluco, você pode experimentá-lo em repl.it .

Tarefa 1: O Tweet

BlooP: Nada além de loops limitados. ;) #programming #goodtimes

Ele usa o estilo padrão do Twitter, incluindo hashtags e emoticons. Isso agradaria qualquer usuário do Twitter. *

Tarefa 2: O Olá Mundo

DEFINE PROCEDURE ''GREETING'' [N]:
BLOCK 0: BEGIN
  PRINT['Hello World! This is written in BlooP.']
BLOCK 0: END.

GREETING[0];

Como você pode ver, essa é uma linguagem excelente para o golfe. *

Tarefa 3: Os números ímpares

DEFINE PROCEDURE ''IS-ODD'' [N]:
BLOCK 0: BEGIN
  OUTPUT <= 0;
  CELL(0) <= 2;
  LOOP AT MOST N+1 TIMES:
  BLOCK 1: BEGIN
    IF N+1 = CELL(0), THEN:
    BLOCK 2: BEGIN
      OUTPUT <= 1;
      ABORT LOOP 1;
    BLOCK 2: END;
    CELL(0) <= CELL(0) + 2
  BLOCK 1: END;
BLOCK 0: END.

DEFINE PROCEDURE ''ODDS-IN-RANGE'' [A,B]:
BLOCK 0: BEGIN
  CELL(0) = A;
  LOOP AT MOST B TIMES:
  BLOCK 1: BEGIN
    IF CELL(0) > B, THEN:
    ABORT LOOP 1;
    IF IS-ODD[CELL(0)] = 1, THEN:
    PRINT[CELL(0)];
    CELL(0) <= CELL(0) + 1;
  BLOCK 1: END;
BLOCK 0: END.

ODDS-IN-RANGE[20,25];

Os únicos operadores disponíveis no BlooP são atribuição ( <=), adição, multiplicação, maior que, menor que e igual. Por causa de sua sintaxe dolorosamente detalhada, é realmente fácil dizer o que está acontecendo, mesmo sem uma compreensão profunda do idioma.

Tarefa 4: O Interessante

Nota: Meu snippet para esta tarefa está sujeito a alterações, se surgir algo mais interessante.

DEFINE PROCEDURE ''MINUS'' [M,N]:
BLOCK 0: BEGIN
  IF M < N, THEN:
  QUIT BLOCK 0;
  LOOP AT MOST M + 1 TIMES:
  BLOCK 1: BEGIN
    IF OUTPUT + N = M, THEN:
    ABORT LOOP 1;
    OUTPUT <= OUTPUT + 1;
  BLOCK 1: END;
BLOCK 0: END.

DEFINE PROCEDURE ''FIB''[N]:
BLOCK 0: BEGIN
  IF N < 1, THEN:
  QUIT BLOCK 0;
  OUTPUT <= 1;
  IF N < 3, THEN:
  QUIT BLOCK 0;
  OUTPUT <= FIB[MINUS[N,1]] + FIB[MINUS[N,2]];
BLOCK 0: END.

FIB[10];

Eis os números de Fibonacci.

* Pode não ser verdade

Mond *

• * A busca por 'Mond' fornece um resultado (não obstante, esta resposta), mas é um falso positivo e não menciona o idioma.
• Página de código Rosetta . Na verdade, ele foi criado após o lançamento do desafio, no entanto, uma solução para a tarefa QuickSort existe desde setembro de 2014.
• Embora o mond pareça muito semelhante ao JavaScript (na verdade, é bastante fácil escrever poliglotas Mond / JS), não é um subconjunto, superconjunto ou reimplementação. É sua própria linguagem distinta.

Experimente no seu navegador

Divulgação completa : Estou envolvido com o processo de desenvolvimento e design da Mond até certo ponto e implementei pessoalmente vários recursos de linguagem importantes, incluindo operadores definidos pelo usuário, demonstrados nas tarefas 3 e 4.

Tarefa nº 1

O operador de pipeline ( |>) é um açúcar de sintaxe que transforma a chamada de função no lado direito em uma chamada de função com o valor no lado esquerdo inserido como o primeiro argumento. foo |> bar()é o mesmo que bar( foo ).

"Simple, elegant scripting language implemented in C# for .NET/Mono" |> printLn();

Tarefa 2

"Hello World! This is written in Mond." |> printLn();

Tarefa nº 3

O código para esta tarefa assume várias coisas:

1. O intervalo de números será inserido em uma única linha
2. Os limites superior e inferior serão separados por um único espaço
3. Os números fornecidos são números inteiros na base 10 e contêm apenas os caracteres 0-9

Experimente aqui

// parse a string to a number
fun toNumber( str ) {
    var n = 0, pow = str.length();

    for( var i = 0; i < str.length(); ++i )
        n += ( str.charCodeAt( i ) - 48 ) * ( 10 ** --pow );

    return n;
}

fun map( arr, fn ) {
    var ret = [ ];

    foreach( var item in arr )
        fn( item ) |> ret.add();

    return ret;
}

// user-defined operator to create an upper-bound inclusive range a-la Ruby
// (i.e. 1 .. 5 produces [ 1, 2, 3, 4, 5 ])
seq( .. )( start, end ) {
    for( var i = start; i <= end; ++i )
        yield i;
}

// read a line from STDIN, trim leading and trailing whitespace,
// split the string to an array, map the array to parse all strings to numbers.
var nums = readLn().trim().split( " " ) |> map( toNumber );

// nums[0] .. nums[1] makes use of the user-defined operator declared on line 22.
// nums[0] is the lower bound, nums[0] is the upper bound.
foreach( var n in nums[0] .. nums[1] ) {
    if( n % 2 != 0 ) printLn( n );
}

Tarefa # 4

Esta tarefa demonstra operadores definidos pelo usuário , que permitem ao programador definir qualquer operador arbitrário (desde que ele ainda não exista) apenas como uma função e usá-lo como faria com qualquer outro operador. Eles vêm em sabores unários e binários.

Experimente aqui .

// forward function compositing user-defined operator.
// the function on the right-hand side is called with
// the result of the function on the left-hand side.
fun( >>> )( fn1, fn2 ) {
    return fun( ...args ) {
        return fn1( ...args ) |> fn2();
    };
}

// the mythical "goes down to" operator of legend.
// a lazy sequence that returns all numbers starting from 'hi'
// down to (and including) 'lo'
seq( --> )( hi, lo ) {
    for( var i = hi; i >= lo; --i )
        yield i;
}

seq map( iterable, callback ) {
    foreach( var item in iterable )
        yield item |> callback();
}

// doubles the value of n
fun double( n ) -> n *  2;

// squares the value of n (** is the power operator, a-la Python or Ruby)
fun square( n ) -> n ** 2;

// gets the sequence for 10 down to 0, passes it into
// map, which maps it through the composited function of
// double and square, which first doubles the given value
// then squares it.
var nums = ( 10 --> 0 ) |> map( double >>> square );

foreach( var n in nums )
    printLn( n );

jq

Nenhum dos 14 resultados no codegolf.se é sobre o idioma. ( jq(e variantes em maiúsculas) parece ser uma declaração frequente em Pyth.)

Existe uma categoria jq no código Rosetta .

Você pode experimentá-lo online, mas alguns dos exemplos abaixo precisam da versão mais recente 1.5.

Tarefa 1: O Tweet

jq é como sed para JSON; você pode usá-lo para processar dados estruturados com a mesma facilidade que sed, awk, grep e amigos permitem que você jogue com texto

(Desavergonhadamente, twittou o primeiro parágrafo de seu site.)

Tarefa 2: O Olá Mundo

bash-4.3$ jq -n -r '"Hello World! This is written in jq."'
Hello World! This is written in jq.

Tarefa 3: Os números ímpares

bash-4.3$ jq -R 'split(" ") | range(.[0] | tonumber; .[1] | tonumber + 1) | select(. % 2 == 1)' <<< '20 25'
21
23
25

Tarefa 4: O Interessante

O arquivo ~ / .mozilla / firefox / *. Default / extensions.json que contém informações sobre as extensões instaladas do Firefox possui 0 novas linhas em 171 Kb nos dados JSON, o que dificulta a leitura.

Bonita imprimir os dados JSON:

bash-4.3$ jq '' ~/.mozilla/firefox/*.default/extensions.json

Doh. As linhas 8000 ++ são muito longas, portanto, passe para o pager, mas mantenha o destaque:

bash-4.3$ jq -C '' ~/.mozilla/firefox/*.default/extensions.json | less -r

Ai. Quantas extensões existem?

bash-4.3$ jq '.addons | length' ~/.mozilla/firefox/*.default/extensions.json
58

Ok, mas alguns deles estão desativados. Quantos exatamente?

bash-4.3$ jq '[.addons[] | select(.active | not)] | length' ~/.mozilla/firefox/*.default/extensions.json
7

Alguns deles são bastante abandonados e não funcionam mais com o Firefox atual:

bash-4.3$ jq -r '.addons[] | [.defaultLocale.name, (.targetApplications[] | select(.id == "{ec8030f7-c20a-464f-9b0e-13a3a9e97384}"))] | select(.[1].maxVersion | gsub("[^\\d.]"; "") | tonumber < 38.0) | .[0]' ~/.mozilla/firefox/*.default/extensions.json
Unity Desktop Integration
Unity Websites integration
Ubuntu Firefox Modifications

(Isso depois não é verdade. Por algum motivo, extensions.json contém outros intervalos de versão que não o install.rdf das extensões. Mas, de qualquer forma, isso não é culpa do jq.)

ooc

Sim, estou com um mês de atraso. E daí???

• A pesquisa de ooc atualmente não dá resultados.
• Link para ooc no Rosetta Code .

Tarefa 1

ooc é uma linguagem de programação que compila até C99 que possui uma sintaxe elegante e suporta desenvolvimento de alto e baixo nível.

135 bytes! Essa foi por pouco!

Além disso, pontos de bônus falsos para o insanamente legal logotipo ASCII-art da ooc :

           +(NNhBBhss+'                  ~+'(sNBND=~.         
           -(=NDhNN+=+=' .   .  .    . .+='+~DNND+=.          
           .+-DBDDh+(D-<'      .....  -<+ (=~DNh+<(           
            '+<NNNB=~=z-(<-<<(+('-'~<<=- .+'sBNh~+            
             (~=NNND+=DB~(-.    . .    ...(=BNB+s--      ALL YOUR 
             .=-=DBDz-'~. .   ..'. .... '  '~s<<szh<.         
               <(~'. .  .  ..sD='-~'-'-DDs.. . .~sD(     CODEBASE  
            . ~+'  '  .-(-..sBNB~(~~+=hNNNz'<<z='-z(               
           . .=. -DDz<~s~  'BNNN=~+<shNNNND(sNNNh~(+    ARE BELONG
            .=<.(NNNNDDs. (hhs+=s=hNDNNBNBBs<BNND<<=.             
            .'-'~sNNs((- .''. ' -~NNDz+((~---~sB<'''.     TO US!
                '=(++(-..  . ...-~+B~'....'.''-+(     .             
                -=z<<'.. .'-...'-~hz~-'.''''-~-<=                     
                 .~+~s~  ~z<~'-'--hN=~((~'---(~~z~                    
                   (+<-.'+=''''~(+=Bz--~(((=+s+~(s                     
  IT'S OVER      . '+-..~<----~-+(sBNh+zBNNBNh+<z'                     
                   .<-'--''(<~=B=hDDD=<<<++=++<=.                   
  9000 BUGS!     .. s~..'h=++ss=D<<~+B(<(+<=Nz=+                     
                    +'.''+NNDN(+z(((sB<((s+hNh<+             
                   .= -~(~(zDNz+z+zhNDz=szhhBz++.       MADNESS?        
                   '+. ss<'~=NBNBBDzBzhshDD=+<<-                   
                   -= . +s~-(+==hhDBNBDDs==hz+<     THIS! IS! LLAMA!
                 '(<-  . '~~(<+<=+<sz=+sshzs(..               
                .+<.    '('-~(((((<++(<<((= .                 
                 .--.. ....'.'.'.'..''..'-..

Tarefa 2

"Hello, world!" println()

Tarefa 3

import text/StringTokenizer
import structs/ArrayList
input := stdin readLine() split(' ', false)
(begin, end) := (input[0] toInt(), input[1] toInt())
for (i in begin..end+1) {
    if (i % 2 != 0) { "%d " printf(i) }
}
println()

Implementação bastante direta. Além disso, isso mostra um aspecto interessante do ooc: chamadas de método usam espaços como delimitadores, não pontos. Por exemplo, observe stdin readLine() split(' ', false)acima. Na maioria dos idiomas, isso seria escrito como stdin.readLine().split(' ', false), mas ooc reserva isso para o encadeamento de chamadas (role para baixo até o exemplo de código).

Tarefa 3

Isso mostra meu recurso ooc favorito: correspondência de tipo. É como a correspondência de padrões. Em um idioma OO. Impressionante.

import structs/ArrayList
import math/Random

Animal: abstract class {
    makeNoise: abstract func
}

Sheep: class extends Animal {
    init: func
    makeNoise: func {
        "Baaaaaaa!" println()
    }
}

Wolf: class extends Animal {
    init: func
    makeNoise: func {
        "Hooooowl!" println()
    }
}

animals := [Sheep new(), Sheep new(), Sheep new()] as ArrayList<Animal>
badNumber := Random randRange(0, 3)
animals[badNumber] = Wolf new()
animal: Animal

"Enter a number between 0 (inclusive) and 3 (exclusive)" println()
inputNumberString := stdin readLine()
for (chr in inputNumberString) {
    if (!(chr.digit?())) {
        "NUMBER, not CHARACTER! Can't you read!?" println()
        exit(1)
    }
}
inputNumber := inputNumberString toInt()
try {
    animal = animals[inputNumber]
} catch (e: OutOfBoundsException) {
    "I said a number between one and three, you idiot!" println()
    exit(1)
}
"Animal noise:" println()
animal makeNoise()
match (animal) {
    case sheep: Sheep => { "It's a stupid, annoying sheep!" println() }
    case wolf: Wolf => { "AHH! A WOLF! You got eaten. :/ R.I.P." println() }
}