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

Martin Ender
fonte

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.

Dennis
fonte
14

Python 2, 53 bytes

Substitua ·por espaço nas duas respostas:

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

Imprime figure.

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

Imprime ground.

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

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

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

TheBikingViking
fonte
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.
Luis Mendo
fonte
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"
);}}
............
Arnaud
fonte
5

Befunge, 54 bytes

Figura ( Experimente online! )

#v "erugif" v>
      : #, _ @>         
"dnuorg"

Dez espaços à direita na segunda linha.

Ground ( Experimente online! )

  # v "erugif" v 
>: #, _ @> "dnuorg"
        

Um espaço à direita na primeira linha e oito espaços na terceira linha.

James Holderness
fonte
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.

Greg Martin
fonte
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

user59178
fonte
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

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

nimi
fonte
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"
.............
.............
Sp3000
fonte
3

JavaScript (ES6), 56 bytes

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

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

Neil
fonte
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).

Martin Ender
fonte
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.

Martin Ender
fonte
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.

Martin Ender
fonte
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
Conor O'Brien
fonte
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.
Martin Ender
fonte
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"
leite
fonte