Figura e chão


32

figura e chão
Fonte: Wikipedia

Para esse desafio, você deve escrever dois programas que se assemelham à figura e ao fundo da imagem acima, de modo que um deles imprima figuree o outro imprima ground. Especificamente:

  1. Escreva um programa que não aceite entrada e imprima a string figure. Os únicos caracteres de espaço em branco permitidos no seu programa são espaços (ponto de código 0x20) e novas linhas (retornos de carro, 0x0D, feeds de linha, 0x0A ou uma combinação de ambos).
  2. Ignorando as novas linhas, o número de caracteres de espaço (ponto de código 0x20) e caracteres não espaciais deve ser o mesmo. Por exemplo, este seria um programa válido (em um idioma hipotético):

    ab c 
       d
    e f
    

    Observe que há um espaço à direita na primeira linha.

  3. Se você trocar o n º caractere de espaço com o n º de caracteres não-espaço em branco, o programa deve imprimir groundem seu lugar. Para o exemplo acima, o programa ficaria assim:

      a b
    cde 
     f 
    

    Observe que há espaços à direita na segunda e terceira linhas.

As soluções de figura e solo devem ser programas completos no mesmo idioma que imprimem no STDOUT. Você pode imprimir uma única linha nova à direita opcional em ambos os casos. Você pode enviar o que quiser para STDERR, desde que STDOUT esteja correto.

Você pode usar qualquer linguagem de programação , mas observe que essas brechas são proibidas por padrão.

Isso é , então a resposta mais curta e válida - medida em bytes - vence.

Script auxiliar

Você pode usar esse script CJam para converter entre uma figura e um programa de base . Basta colar um dos dois no campo Entrada e executar o programa. Também informará se o número de espaços e não espaços não corresponde.

Entre os melhores

Respostas:


20

Gelatina , 20 bytes

Figura

“¦ĠȮ“©ụd» Ṃ         

Nove espaços à direita. Experimente online!

Terreno

         “ ¦ĠȮ“©ụd»Ṃ

Sem espaços à direita. Experimente online!

Como funciona

Primeiro, observe que os espaços não são átomos; portanto, os caracteres de espaço fora dos literais da string não afetam o programa de forma alguma.

Os literais de strings usam a compactação de strings baseada em dicionário do Jelly para produzir as palavras desejadas. Um literal de string compactado começa com “, termina com »e usa “internamente para criar uma matriz de strings.

No programa de figuras , “¦ĠȮ“©ụd»produz o par de cordas (“figura”, “solo”) e o átomo Ṃseleciona o mínimo lexicográfico, ou seja, “figura” .

No programa ground, “ ¦ĠȮ“©ụd»gera o par de strings ("logicallyAbacs", "ground") . O mínimo lexicográfico agora é "terreno" , que Ṃseleciona obedientemente.

Nos dois casos, o intérprete imprime automaticamente o último valor de retorno - ou seja, o mínimo selecionado - para STDOUT.


14

Python 2, 53 bytes

Substitua ·por espaço nas duas respostas:

····················
print'······figureground'[6:12]#

Imprime figure.

print'figureground'[
······6:12]#····················

Imprime ground.


14

05AB1E , 15 14 bytes

Figura

 'ŠÂ,'í¶      

Experimente online!

Terreno

'       ŠÂ,'í¶

Experimente online!

Usa a codificação CP-1252 . Observe os espaços à direita. No programa Figura , é um programa normal sem erros. Descompacta as seguintes palavras:

'ŠÂ  ->  figure
'í¶  ->  ground

A vírgula imprime aparece e imprime a figurepalavra com uma nova linha. Como algo foi impresso, a parte superior da pilha não é mais impressa.

No programa Ground , existem alguns erros que são convenientes nesse caso. A seguinte parte:

'<space>

coloca um caractere de espaço no topo da pilha. O Šgira a pilha, que tem uma aridade 3 . Há apenas um elemento na pilha e nenhuma entrada, portanto, isso oferece uma exceção, limpando a pilha. O Âbifurca o topo da pilha, mas isso tem a mesma história que o operador de rotação. Então, basicamente, o ,comando não imprime nada.

Isso significa que o programa ainda exibirá a parte superior da pilha que é 'í¶. Resultando em ground.


9

Retina , 31 bytes

Figura:

|       
figura
 terreno
      

Terra:

 figura

|       
chão

Figura e chão . Ambos os programas exigem que o STDIN seja deixado vazio para ser um programa válido de figuras ou solo.


9

Pitão, 30 bytes

Figura

"figure" "ground              

14 espaços à direita.

Teste

Terreno

Sem espaços à direita

        "       figure""ground

Teste

Como funciona

De maneira bastante útil, um espaço suprime a impressão em Pyth, enquanto literais de seqüência de caracteres sem fechamento "são implicitamente fechados.

O primeiro programa, portanto, consiste em duas seqüências de caracteres, "figure"e "ground ". A primeira sequência é impressa implicitamente e a impressão da segunda é suprimida, significando que apenas figureé impressa.

O segundo programa consiste em duas seqüências de caracteres, " figure"e "ground". A impressão do primeiro é suprimida e o segundo é implicitamente impresso, o que significa que apenas groundé impresso.


6

MATL , 37 bytes

Primeiro programa

'figure'         
%x'ground'         

Cada linha possui 9 espaços à direita.

Experimente online!

Segundo programa

    'figure'%
      x'ground'

Não há espaços tentadores aqui.

Experimente online!

Explicação

Nada muito chique ...

  • Espaços e novas linhas entre instruções são ignorados pelo MATL.
  • % é o símbolo de comentário, que ignora o restante da linha.
  • x exclui a parte superior da pilha.
  • A pilha é impressa implicitamente no final do programa.

6

Java, 180 bytes

Substitua .por espaço.

Imprime "figura":

class
A{public
static
void
main(String[]a){System.out.println(
//"ground"
//
.....
........
......
....
...................................
..
........
..........
....
"figure");}}

Imprime "terra":

.....
........
......
....
...................................
..........
..
class
A{public
static
void
main(String[]a){System.out.println(
//
"ground"
//"figure"
);}}
............


4

Mathematica, 50 34 bytes

Usa um ambiente REPL. (Adicionar um Print[]wrapper com um número igual de espaços aumentaria a contagem de bytes em 14.) Os dois programas são

01figure+0 1ground                

(com 16 espaços à direita) e

          0       1figure+01ground

A chave aqui é que o Mathematica trata a concatentação de dígitos sem espaços como um número único, mas os espaços intermediários são interpretados como multiplicação vizinha, assim como a concatenação de números e nomes de variáveis ​​arbitrários. Portanto, a primeira expressão é avaliada como 1*figure+0*1*ground, que é figure; a segunda expressão é avaliada como 0*1*figure+1*ground, que é ground.


4

PHP, 44 42 bytes

figure: (16 espaços à direita, 5 espaços entre a figura &;)

echo''?ground:figure     ;                 

terreno: (20 espaços principais)

                     echo' '?ground:figure;

Muito simples, realmente, funciona porque ''é falsey e ' 'é verdade. Use como:

php -r "echo''?ground:figure     ;                "
php -r "                    echo' '?ground:figure;"

edit: 2 bytes retrospectivamente óbvios salvos graças a Martin Ender


3

Haskell, 96 94 88 82 77 bytes

Primeiro programa, imprime "figure":

main              =          putStr$idid"ground"
idid    _          ="figure"

Segundo programa, imprime "ground":

    main=putStr$id id"ground"                   
    idid _="figure"         

Chama uma de duas funções constantes com nomes diferentes


3

Haskell, 88 65 bytes

main=putStr
...........--
.."figure"..........
--"ground"........

e

...........
main=putStr..
--........"figure"--
.........."ground"

.indica um espaço. Apenas algum comentário de linha (-> --) malabarismo.


3

Python 2, 52 bytes

........................
print"figure"
an
d
"ground"

.s indicam espaços. As últimas três linhas são divididas em erro sem ter uma SyntaxErrorque impediria a execução do código em primeiro lugar.

A versão básica é usada apenas andpara imprimir a segunda sequência.


Tentativas alternativas (mais longas):

.......
print(#"ground")#
"figure")...................


print"figure"""and"ground"
.............
.............

3

JavaScript (ES6), 56 bytes

alert('figure'
                //&&'ground'
           )
              
alert('figure'//            
&&'ground') 

A figura não possui espaços à direita.


Conto 56 bytes para cada programa, a menos que as novas linhas não contem. Duvido que fique mais curto.
— ETHproductions

@ETHproductions Ugh, isso é o que acontece quando você contagem de bytes manualmente :-(
— Neil

2

Trilho , 56 bytes

Figura

$'main'
 -[figure]o                
-          [ground]o

Existem 16 espaços à direita na segunda linha. O programa termina com um erro.

Experimente online!

Terreno

       
$ 'main' - [figura] o
 - [chão] o         

Existem 7 espaços na primeira linha e 9 espaços à direita na última linha. Este programa também termina com um erro.

Experimente online!

Explicação

O trilho procura uma linha começando com (notação regex) \$.*'main'para encontrar um ponto de entrada. O trem (ponteiro de instruções) começa a partir do $sudeste em movimento. Coisas que não são acessíveis pelo trem podem ser completamente ignoradas no programa. Isso inclui qualquer coisa na mesma linha que o ponto de entrada. Como o -sudeste do $imediatamente vira o trem para o leste, ambos os programas simplesmente se reduzem a:

 -[figure]o
 -[ground]o

[...]denota uma string literal e a oimprime. Normalmente, você precisa #finalizar o trilho, mas se você o omitir, o programa será encerrado de qualquer maneira (mas reclama do STDERR que o trem caiu).


2

> <> , 39 bytes

Usando ·para representar espaços.

Figura

v·
"·dnuo
e·
r·
u·
g··
i··
f···
"·
>·o·

Experimente online!

Terreno

·v
·"····
·d
·n
·u
·oe
·ru
·gif
·"
·>·o

Experimente online!

Ambos os programas terminam com um erro.

Explicação

Ao escrever o código verticalmente, fui capaz de reutilizar as soluções entre ge rentre, bem como as aspas e o >e opara o loop de saída.

Nos dois casos, o único bit executado é a coluna abaixo da v, que coloca as letras da palavra necessária na pilha na ordem inversa. Em seguida, >redireciona o ponteiro de instruções para a direita, onde passa pelo o, imprimindo os caracteres até que a pilha esteja vazia.


Comecei a trabalhar na minha própria versão> <> e me deparei com a sua. Eu realmente gosto da ideia de você trabalhar verticalmente (o meu é muito 'normal').
— Teal pelican

@Tealpelican Eu não inventei isso até descobrir a resposta da Fissão. Antes disso, minha melhor>> solução era de 42 bytes: !__|"druong">o<"figure"(onde _estão os espaços e os espaços restantes simplesmente vão no final da linha).
— Martin Ender #

Minha versão atual mais curta é a seguinte; ## "de nr uu og ri GF"> o! ~ ~! <## Que engraçado o suficiente também tem 42 bytes! Minhas versões anteriores tinham verificação de erro, mas só podiam ser reduzidas para 53 bytes.
— Teal pelican

2

Fissão , 37 bytes

Usando ·para representar espaços.

Figura

D·
"···
f··
i··
g·
u·
r·
e·ound
"·
;·

Experimente online!

Terreno

·D
·"fi
·gu
·re
·o
·u
·n
·d····
·"
·;

Experimente online!

Explicação

Funciona basicamente da mesma forma que a minha>> resposta (embora eu tenha encontrado essa primeira). As únicas diferenças são que "imprime os caracteres imediatamente em Fission, e é por isso que as palavras não são escritas de cabeça para baixo e por que precisamos encerrar o programa ;no final.


1

reticular, 46 bytes

                      "ground""figure"" "?$$o;

Experimente online! Isso imprime ground.

"ground""figure"""?$$o                 ;      

Experimente online! Isso imprime figure.

chão

Código relevante:

"ground""figure"" "?$$o;
................          push these two strings
                " "?$     pop " " off (since " " is truthy, `?` executes `$`)
                     $    pop TOS ("figure")
                      o;  output and terminate

figura

Código relevante:

"ground""figure"""?$$o;
................         push these two strings
                ""?$     doesn't activate
                    $    pop ""
                     o;  output and terminate

1

Brian & Chuck , 55 53 bytes

Figura

erugif?dnuorg             
}<.<.<.<.<.<.             

Existem 13 espaços finais em cada linha.

Experimente online!

Terreno

             erugif?dnuorg
             }<.<.<.<.<.<.

Experimente online!

Explicação

Ah, já faz um tempo desde a última vez que usei Brian & Chuck. Como um breve lembrete, Brian e Chuck são duas instâncias do tipo Brainfuck, que usam o código-fonte um do outro como fita. Somente Chuck pode usar o comando de impressão ., ?alterna entre as duas instâncias condicionalmente e }é mais ou menos como[>] Brainfuck. Comandos desconhecidos são simplesmente ignorados.

Como os espaços no início dos programas são ignorados, os dois programas são quase idênticos. A única diferença vem do fato de que, após o comando de alternância ?, o ponteiro da instrução se move antes de executar o próximo comando. Portanto, o primeiro comando na fita de Chuck é sempre ignorado. Portanto, a única diferença real é que o programa em terra executa o }passo que o programa em figura não. Então, aqui está como o código funciona:

?   Switch control to Chuck.
}   GROUND PROGRAM ONLY: Move the tape head on Brian to the end of the tape.
<.  Move the tape head left and print the character there.
... Do the same another five times to print the remainder of the string.

0

WinDbg, 74 bytes

Terreno

                      ea2000000"      groundfigure";;;da       2000006  L6

Figura

ea2000000"groundfigure          ";;;da                  2000006       L6  

A figura possui 2 espaços à direita. Eu sinto que pelo menos 2 ou 4 bytes deveriam ser jogáveis ​​...

Ele funciona escrevendo uma string na memória e mostrando 6 caracteres. Os caracteres na sequência são reorganizados para que os caracteres mostrados sejam alterados entre os programas:

* Ground:
ea 2000000 "      groundfigure";     * Write string "      groundfigure" starting at 2000000
;                                    * No-op
;                                    * No-op
da 2000006 L6                        * Print 6 ascii chars, from 2000006, ie- ground

* Figure:
ea 2000000 "groundfigure          "; * Write string "groundfigure          " to memory
;                                    * No-op
;                                    * No-op
da 2000006 L6                        * Print 6 ascii chars, ie- figure

Saída:

0:000>                       ea2000000"      groundfigure";;;da       2000006  L6
02000006  "ground"
0:000> ea2000000"groundfigure          ";;;da                  2000006       L6  
02000006  "figure"
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.