Figure et sol

32

figure et fond
Source: Wikipedia

Pour ce défi, vous devez écrire deux programmes qui ressemblent à la figure et au fond de l'image ci-dessus, de telle sorte que l'un d'eux imprime figureet l'autre imprime ground. Plus précisément:

  1. Écrivez un programme qui ne prend aucune entrée et imprime la chaîne figure. Les seuls caractères d' espacement autorisés dans votre programme sont les espaces (point de code 0x20) et les retours à la ligne (retours chariot, 0x0D, sauts de ligne, 0x0A ou une combinaison des deux).
  2. En ignorant les sauts de ligne, le nombre de caractères d'espace (point de code 0x20) et de caractères non-espace doit être le même. Par exemple, ce serait un programme valide (dans une langue hypothétique):

    ab c 
       d
    e f
    

    Notez qu'il y a un espace de fin sur la première ligne.

  3. Si vous changez le n ième caractère d'espace avec le n ième caractère non-blanc, le programme devrait imprimer à la groundplace. Pour l'exemple ci-dessus, le programme ressemblerait à ceci:

      a b
    cde 
     f 
    

    Notez qu'il y a des espaces de fin sur les deuxième et troisième lignes.

La figure et les solutions au sol doivent être des programmes complets dans la même langue qui s'impriment sur STDOUT. Vous pouvez imprimer une seule nouvelle ligne de fin facultative dans les deux cas. Vous pouvez sortir tout ce que vous voulez sur STDERR, tant que STDOUT est correct.

Vous pouvez utiliser n'importe quel langage de programmation , mais notez que ces failles sont interdites par défaut.

Il s'agit de , donc la réponse valide la plus courte - mesurée en octets - l'emporte.

Script d'aide

Vous pouvez utiliser ce script CJam pour convertir entre une figure et un programme au sol . Collez simplement l'un des deux dans le champ de saisie et exécutez le programme. Il vous indiquera également si le nombre d'espaces et de non-espaces ne correspond pas.

Classement

Martin Ender
la source

Réponses:

20

Gelée , 20 octets

Figure

“¦ĠȮ“©ụd» Ṃ         

Neuf espaces de fuite. Essayez-le en ligne!

Sol

         “ ¦ĠȮ“©ụd»Ṃ

Aucun espace de fuite. Essayez-le en ligne!

Comment ça marche

Tout d'abord, notez que les espaces ne sont pas des atomes, donc les caractères d'espace en dehors des littéraux de chaîne n'affectent en aucune façon le programme.

Les littéraux de chaîne utilisent la compression de chaîne par dictionnaire intégrée de Jelly pour produire les mots souhaités. Un littéral de chaîne compressé commence par , se termine par »et utilise en interne pour créer un tableau de chaînes.

Dans le programme de figure , “¦ĠȮ“©ụd»donne la paire de cordes («figure», «sol») , et l'atome sélectionne le minimum lexicographique, c'est-à-dire «figure» .

Dans le programme “ ¦ĠȮ“©ụd»Ground , donne la paire de cordes ("logicallyAbacs", "Ground") à la place. Le minimum lexicographique est désormais «sol» , qui est soigneusement choisi.

Dans les deux cas, l'interpréteur imprime automatiquement la dernière valeur de retour - c'est-à-dire le minimum sélectionné - dans STDOUT.

Dennis
la source
14

Python 2, 53 octets

Remplacez ·par un espace dans les deux réponses:

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

Impressions figure.

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

Impressions ground.

Lynn
la source
14

05AB1E , 15 14 octets

Figure

 'ŠÂ,'í¶      

Essayez-le en ligne!

Sol

'       ŠÂ,'í¶

Essayez-le en ligne!

Utilise le codage CP-1252 . Notez les espaces de fin. Dans le programme Figure , c'est un programme normal sans erreur. Il décompresse les mots suivants:

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

La virgule imprime des pops et imprime le figuremot avec une nouvelle ligne. Étant donné que quelque chose a été imprimé, le haut de la pile n'est plus imprimé.

Dans le programme Ground , il y a quelques erreurs qui sont pratiques dans ce cas. La partie suivante:

'<space>

pousse un caractère espace au-dessus de la pile. Le Šfait pivoter la pile, qui a une arité 3 . Il n'y a qu'un seul élément sur la pile et aucune entrée, donc cela donne une exception, effacer la pile. Le Âbifurque le haut de la pile, mais cela a la même histoire que l'opérateur de rotation. Donc, fondamentalement, la ,commande n'imprime rien.

Cela signifie que le programme affichera toujours le haut de la pile qui est 'í¶. Résultant en ground.

Adnan
la source
9

Rétine , 31 octets

Figure:

|       
figure
 | sol
      

Sol:

 | figure

|       
sol

Figure et sol . Les deux programmes nécessitent que STDIN soit laissé vide pour être des programmes valides de figure ou au sol.

FryAmTheEggman
la source
9

Pyth, 30 octets

Figure

"figure" "ground              

14 espaces de fuite.

Tester

Sol

Pas d'espaces de fuite

        "       figure""ground

Tester

Comment ça marche

De manière plutôt utile, un espace supprime l'impression en Pyth, tandis que les littéraux de chaîne sans fermeture "sont fermés implicitement.

Le premier programme se compose donc de deux chaînes, "figure"et "ground ". La première chaîne est implicitement imprimée et l'impression de la seconde est supprimée, ce qui signifie qu'elle figureest simplement imprimée.

Le deuxième programme se compose de deux chaînes, " figure"et "ground". L'impression de la première est supprimée et la seconde est implicitement imprimée, ce qui signifie que juste groundest imprimé.

TheBikingViking
la source
6

MATL , 37 octets

Premier programme

'figure'         
%x'ground'         

Chaque ligne a 9 espaces de fin.

Essayez-le en ligne!

Deuxième programme

    'figure'%
      x'ground'

Il n'y a pas d'espaces de test ici.

Essayez-le en ligne!

Explication

Rien d'extraordinaire ...

  • Les espaces et les retours à la ligne entre les instructions sont ignorés par MATL.
  • % est le symbole de commentaire, qui ignore le reste de la ligne.
  • x supprime le haut de la pile.
  • La pile est implicitement imprimée à la fin du programme.
Luis Mendo
la source
6

Java, 180 octets

Remplacez .par de l'espace.

Imprime "figure":

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

Imprime "au sol":

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

Befunge, 54 octets

Figure ( Essayez-le en ligne! )

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

Dix espaces de fin sur la deuxième ligne.

Ground ( Essayez-le en ligne! )

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

Un espace de fin sur la première ligne et huit espaces sur la troisième ligne.

James Holderness
la source
4

Mathematica, 50 34 octets

Utilise un environnement REPL. (L'ajout d'un Print[]wrapper avec un nombre égal d'espaces augmenterait le nombre d'octets de 14.) Les deux programmes sont

01figure+0 1ground                

(avec 16 espaces de fin) et

          0       1figure+01ground

La clé ici est que Mathematica traite la concatentation de chiffres sans espaces comme un nombre unique, mais les espaces intermédiaires sont interprétés comme une multiplication voisine, tout comme la concaténation de nombres et de noms de variables arbitraires. Ainsi, la première expression est évaluée 1*figure+0*1*ground, qui est figure; la deuxième expression est évaluée 0*1*figure+1*ground, ce qui est ground.

Greg Martin
la source
4

PHP, 44 42 octets

figure: (16 espaces de fin, 5 espaces entre la figure &;)

echo''?ground:figure     ;                 

au sol: (20 espaces de tête)

                     echo' '?ground:figure;

Assez simple vraiment, ''ça marche parce que c'est falsey et ' 'c'est vrai. Utilisez comme:

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

edit: 2 octets rétrospectivement évidents sauvés grâce à Martin Ender

utilisateur59178
la source
3

Haskell, 96 94 88 82 77 octets

Premier programme, imprime "figure":

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

Deuxième programme, imprime "ground":

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

Appelle l'une des deux fonctions constantes nommées différemment

Angs
la source
3

Haskell, 88 65 octets

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

et

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

.indique un espace. Juste un commentaire de ligne (-> --) jonglant.

nimi
la source
3

Python 2, 52 octets

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

.s indiquent des espaces. Les trois dernières lignes sont divisées en erreur sans en avoir une SyntaxErrorqui empêcherait le code de s'exécuter en premier lieu.

La version sol utilise juste andpour faire imprimer la deuxième chaîne.


Tentatives alternatives (plus longues):

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


print"figure"""and"ground"
.............
.............
Sp3000
la source
3

JavaScript (ES6), 56 octets

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

La figure n'a pas d'espaces de fin.

Neil
la source
Je compte 56 octets pour chaque programme, sauf si les sauts de ligne ne comptent pas. Je doute que cela raccourcisse.
ETHproductions
@ETHproductions Ugh, c'est ce qui se passe lorsque vous comptez les octets manuellement :-(
Neil
2

Rail , 56 octets

Figure

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

Il y a 16 espaces de fin sur la deuxième ligne. Le programme se termine avec une erreur.

Essayez-le en ligne!

Sol

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

Il y a 7 espaces sur la première ligne et 9 espaces de fin sur la dernière ligne. Ce programme se termine également avec une erreur.

Essayez-le en ligne!

Explication

Rail recherche une ligne commençant par (notation regex) \$.*'main'pour trouver un point d'entrée. Le train (pointeur d'instructions) part alors du $sud-est en mouvement. Les choses qui ne sont pas accessibles par le train peuvent être complètement ignorées pour le programme. Cela inclut tout ce qui se trouve sur la même ligne que le point d'entrée. Étant donné que le -sud-est du $train tourne immédiatement vers l'est, les deux programmes se réduisent simplement à:

 -[figure]o
 -[ground]o

[...]désigne un littéral de chaîne et l' oimprime. Normalement, vous avez besoin d'un #pour terminer le rail, mais si vous l'omettez, le programme s'arrête quand même (mais se plaint sur STDERR que le train s'est écrasé).

Martin Ender
la source
2

> <> , 39 octets

Utiliser ·pour représenter des espaces.

Figure

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

Essayez-le en ligne!

Sol

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

Essayez-le en ligne!

Les deux programmes se terminent avec une erreur.

Explication

En écrivant le code verticalement, j'ai pu réutiliser le get le rentre les deux solutions, ainsi que les guillemets et le >et opour la boucle de sortie.

Dans les deux cas, le seul bit qui est exécuté est la colonne sous la v, qui pousse les lettres du mot requis sur la pile dans l'ordre inverse. >Redirige ensuite le pointeur d'instruction vers la droite, où il parcourt le o, imprimant les caractères jusqu'à ce que la pile soit vide.

Martin Ender
la source
Je viens de commencer à travailler sur ma propre> <> version, puis je suis tombée sur la vôtre. J'aime vraiment l'idée que la vôtre travaille verticalement (la mienne est très «normale»).
Pélican bleu sarcelle
@Tealpelican Je n'ai pas trouvé ça avant d'avoir trouvé la réponse de Fission. Avant cela, ma meilleure solution> <> était de 42 octets: !__|"druong">o<"figure"(où _sont les espaces, et les espaces restants vont simplement à la fin de la ligne).
Martin Ender
Ma version actuelle la plus courte est celle-ci; ## "de nr uu og ri GF"> o! ~ ~! <## Lequel est assez drôle aussi 42 octets! Mes versions précédentes avaient une vérification des erreurs mais ne pouvaient que réduire à 53 octets.
Pélican bleu canard
2

Fission , 37 octets

Utiliser ·pour représenter des espaces.

Figure

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

Essayez-le en ligne!

Sol

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

Essayez-le en ligne!

Explication

Fonctionne essentiellement de la même manière que ma> <> réponse (bien que j'aie trouvé celle-ci en premier). Les seules différences sont que "les caractères sont imprimés immédiatement dans Fission, c'est pourquoi les mots ne sont pas écrits à l'envers et pourquoi nous devons seulement terminer le programme ;à la fin.

Martin Ender
la source
1

réticulaire, 46 octets

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

Essayez-le en ligne! Cela imprime ground.

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

Essayez-le en ligne! Cela imprime figure.

sol

Code pertinent:

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

figure

Code pertinent:

"ground""figure"""?$$o;
................         push these two strings
                ""?$     doesn't activate
                    $    pop ""
                     o;  output and terminate
Conor O'Brien
la source
1

Brian & Chuck , 55 53 octets

Figure

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

Il y a 13 espaces de fin sur chaque ligne.

Essayez-le en ligne!

Sol

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

Essayez-le en ligne!

Explication

Ah, ça fait un moment depuis la dernière fois que j'ai utilisé Brian & Chuck. Pour rappel, Brian et Chuck sont deux instances de type Brainfuck, qui utilisent le code source de l'autre comme bande. Seul Chuck peut utiliser la commande d'impression ., ?commute conditionnellement entre les deux instances, et }est un peu comme [>]dans Brainfuck. Les commandes inconnues sont simplement ignorées.

Étant donné que les espaces au début des programmes sont ignorés, les deux programmes sont presque identiques. La seule différence vient du fait qu'après la commande de commutation ?, le pointeur d'instruction se déplace avant d' exécuter la commande suivante. Par conséquent, la première commande sur la bande de Chuck est toujours ignorée. Donc, la seule vraie différence est que le programme sol exécute le }alors que le programme figure ne le fait pas. Voici donc comment fonctionne le code:

?   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
la source
0

WinDbg, 74 octets

Sol

                      ea2000000"      groundfigure";;;da       2000006  L6

Figure

ea2000000"groundfigure          ";;;da                  2000006       L6  

La figure a 2 espaces de fin. Je pense qu'au moins 2 ou 4 octets devraient être jouables au golf ...

Il fonctionne en écrivant une chaîne dans la mémoire et en affichant 6 caractères. Les caractères de la chaîne sont réorganisés afin que les caractères affichés changent entre les programmes:

* 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

Sortie:

0:000>                       ea2000000"      groundfigure";;;da       2000006  L6
02000006  "ground"
0:000> ea2000000"groundfigure          ";;;da                  2000006       L6  
02000006  "figure"
Lait
la source