Simulateur de friteuse

31

Votre tâche consiste à modéliser les effets de la pâte sur les morceaux de nourriture. Veuillez ajouter trois couches de croûte.

[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], // in
 [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
 [0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,0,0,0],
 [0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,1,0,0],
 [0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0],
 [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]
                   |
                   V
[[0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,2,1,2],
 [0,0,2,1,2,2,0,0,0,0,0,0,0,2,2,0,2,0],
 [0,0,2,1,1,1,2,0,0,0,0,0,2,1,1,2,0,0],
 [0,0,0,2,1,2,0,0,0,0,0,2,1,1,2,1,2,0],
 [0,0,0,0,2,0,0,0,0,0,0,0,2,1,1,1,2,0],
 [0,0,0,0,0,0,0,0,0,0,0,0,0,2,2,2,0,0]]
                   |
                   V
[[0,0,3,2,3,3,0,0,0,0,0,0,0,3,3,2,1,2],
 [0,3,2,1,2,2,3,0,0,0,0,0,3,2,2,3,2,3],
 [0,3,2,1,1,1,2,3,0,0,0,3,2,1,1,2,3,0],
 [0,0,3,2,1,2,3,0,0,0,3,2,1,1,2,1,2,3],
 [0,0,0,3,2,3,0,0,0,0,0,3,2,1,1,1,2,3],
 [0,0,0,0,3,0,0,0,0,0,0,0,3,2,2,2,3,0]]
                   |
                   V
[[0,4,3,2,3,3,4,0,0,0,0,0,4,3,3,2,1,2], // out
 [4,3,2,1,2,2,3,4,0,0,0,4,3,2,2,3,2,3],
 [4,3,2,1,1,1,2,3,4,0,4,3,2,1,1,2,3,4],
 [0,4,3,2,1,2,3,4,0,4,3,2,1,1,2,1,2,3],
 [0,0,4,3,2,3,4,0,0,0,4,3,2,1,1,1,2,3],
 [0,0,0,4,3,4,0,0,0,0,0,4,3,2,2,2,3,4]]

Un peu d'aide visuelle:

Afficher l'extrait de code

L'entrée est une matrice booléenne représentant la friteuse: 0 pour l'huile, 1 pour la nourriture. Votre fonction ou programme doit ajouter les trois couches sous forme de 2, 3 et 4 autour des 1, écrasant ainsi certains des 0. La pâte colle horizontalement et verticalement (mais pas en diagonale) aux aliments de toute forme ou taille, y compris les beignets (aliments avec des trous) et s'effrite (aliments isolés "pixels"), et est limité aux limites de la friteuse. Les couches de pâte antérieures se transforment en croûte et ne sont pas affectées par les couches ultérieures.

En d'autres termes, vous devez d'abord remplacer tous les 0 qui se trouvent dans les quartiers de von-Neumann de 1 avec 2, puis remplacer tous les 0 dans les quartiers de von-Neumann de 2 avec 3, et enfin remplacer tous les 0 dans les quartiers de von-Neumann de 3s avec 4s. Ainsi, les nombres 2,3,4 représentent une quantité supérieure à la distance de Manhattan à la cellule 1 la plus proche.

La friteuse sera de taille au moins 3 par 3 et elle contiendra au moins un morceau de nourriture. Les E / S sont flexibles - utilisez un format matriciel adapté à votre langue. Des espaces supplémentaires sont autorisés, un code plus court est souhaitable, les échappatoires sont interdites.

Plus de tests:

 [[0,0,1], // in
  [0,0,0],
  [0,1,0]]

 [[3,2,1], // out
  [3,2,2],
  [2,1,2]]

 -

 [[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], // in
  [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
  [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,0,0,0,0,0,0],
  [1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0],
  [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,1,0,0,1,0,0,0],
  [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,1,0,0,1,0,0,0,0,0,0],
  [0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,0],
  [0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0],
  [0,0,0,1,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1],
  [0,0,1,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0],
  [0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
  [0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,1,1,0,0,0,0,0,0],
  [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
  [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0]]

 [[3,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,3,3,4,3,3,3,4,4,4,3,2,1], // out
  [2,3,4,0,0,0,0,0,0,0,0,0,0,0,0,4,3,2,2,3,2,2,2,3,3,4,4,3,2],
  [1,2,3,4,0,0,0,0,0,0,0,0,0,0,4,3,2,1,1,2,1,1,1,2,2,3,4,4,3],
  [1,1,2,3,4,4,4,4,0,0,0,0,0,4,3,2,1,1,1,1,1,1,1,1,1,2,3,4,4],
  [2,2,3,4,4,3,3,3,4,0,0,0,4,3,2,1,1,2,1,1,1,1,1,2,2,1,2,3,4],
  [3,3,4,4,3,2,2,2,3,4,0,0,4,3,2,1,2,2,1,1,2,2,1,2,3,2,3,4,4],
  [4,4,4,3,2,1,1,1,2,3,4,0,4,3,2,1,1,2,1,2,3,3,2,2,2,3,4,3,3],
  [0,4,3,2,1,1,2,1,2,3,4,0,0,4,3,2,2,2,1,2,3,3,2,1,1,2,3,2,2],
  [4,3,2,1,1,2,2,1,2,3,4,0,0,0,4,3,3,3,2,3,4,4,3,2,2,3,2,1,1],
  [3,2,1,2,1,1,1,1,2,3,4,0,0,0,0,4,4,3,3,3,4,3,3,3,3,3,2,1,2],
  [4,3,2,1,2,2,1,2,3,4,0,0,0,0,0,4,3,2,2,2,3,2,2,3,4,4,3,2,3],
  [0,4,3,2,1,1,2,3,2,3,4,0,0,0,4,3,2,1,1,1,2,1,1,2,3,4,4,3,4],
  [0,0,4,3,2,2,3,2,1,2,3,4,0,0,0,4,3,2,2,2,3,2,2,3,4,4,3,2,3],
  [0,0,0,4,3,3,4,3,2,3,4,0,0,0,0,0,4,3,3,3,4,3,3,4,4,3,2,1,2],

Un peu d'aide visuelle:

Afficher l'extrait de code

Merci @Tschallacka pour les visualisations.

code-golf  matrix 
— ngn
source
4
Pourriez-vous fournir un exemple pas à pas, s'il vous plaît? Ce n'est pas clair pour moi quand ou pourquoi utiliser 2, 3 ou 4. (Je préfère le VTC, mais j'ai un marteau maintenant et il semble que je suis en minorité)
— Shaggy
1
@Shaggy Ma compréhension est que les chiffres identifient la "couche". Un exemple 1D: 000010000→ 000212000→ 003212300→043212340
— georgewatson
4
Merci, @georgewatson; on dirait que tu as raison. Cela ne ressort pas clairement de la spécification, cependant, qui mentionne que la "pâte" ne devrait coller qu'à la nourriture et que les couches de pâte antérieures ne sont pas affectées par les couches ultérieures. La seule façon de le déterminer est de le déchiffrer des cas de test.
— Shaggy
6
Votre prochain défi devrait être un simulateur Friar.
— Magic Octopus Urn
5
@ngn vraiment ? (͡ ° ͜ʖ ͡ °)
— Urne de poulpe magique

Réponses:

10

Pochoir : 1 + 14 = 15 octets

Argument de ligne de commande: 3

Code: s<×⌈/N:1+⌈/N⋄S

Essayez-le en ligne!

3 répétez la transformation suivante trois fois:

 s si l' elfe s n'est pas vide

 < est inférieur à

 × le signe de

 ⌈/N le maximum de von Neuman N quartier

 : alors la nouvelle valeur devient

  1+ un plus

  ⌈/N le maximum de von Neuman N quartier

 ⋄ autre

  S la valeur reste inchangée ( S elfe)

— Adam
source
Cela ne devrait-il pas être de 15 octets (14 + 1 pour l'argument 3)? La première fois que je vois Stencil , mais si je comprends bien, c'est une extension pour Dyalog APL pour bénéficier des matrices? Aussi, petite remarque: le N majuscule au début de Neumanndoit être en gras au lieu du petit à la fin dans votre explication. :)
— Kevin Cruijssen
1
Eh bien, le plus récent consensus semble indiquer que diverses configurations d'une seule langue devraient être comptées comme des langues distinctes, mais je vais l'ajouter
— Adám
1
@KevinCruijssen Stencil peut être utilisé comme un outil Dyalog APL pour les automates cellulaires faciles, mais il se démarque également en tant que langage de golf. En effet, son code peut nécessiter une modification lors du passage de l'utilisation de l'outil au langage de golf.
— Adám
1
@KevinCruijssen Non, le N final gras est intentionnel. Consultez la documentation selon laquelle Stencil utilise les premières et dernières lettres de moore et von neumann comme mnémoniques pour avec et sans soi, et utilise des minuscules et des majuscules comme mnémoniques pour le nombre de non-vides et la liste réelle des éléments.
— Adám
@KevinCruijssen Je dois également mentionner que Stencil n'est qu'une interface avec le module ⌺intégré de Dyalog APL (appelé Stencil ). Voir aussi sa documentation . Un langage de golf complet construit sur un seul build-in! En fait, j'ai créé deux autres langages de golf basés sur des modules intégrés Dyalog APL: QuadR et QuadS .
— Adám
10

Java 8, 271 269 247 210 202 198 193 193 octets

a->{for(int n=0,i,j,t,I,J;++n<4;)for(i=a.length;i-->0;)for(j=a[0].length;j-->0;)for(t=4;a[i][j]==n&t-->0;)try{a[I=t>2?i-1:t>1?i+1:i][J=t<1?j-1:t<2?j+1:j]+=a[I][J]<1?n+1:0;}catch(Exception e){}}

Java et matrices dépendantes de l'index .. Pas une bonne combinaison pour un langage déjà verbeux pour commencer ..

Modifie la matrice d'entrée au lieu d'en renvoyer une nouvelle.

Explication:

Essayez-le en ligne.

a->{                            // Method with integer-matrix parameter and no return-type
  for(int n=0,i,j,t,I,J;++n<4;) //  Loop `n` in range [1, 4)
    for(i=a.length;i-->0;)      //   Inner loop over the rows
      for(j=a[0].length;j-->0;) //    Inner loop over the columns
        for(t=4;a[i][j]==n&     //     If the current cell contains the current `n`:
                t-->0;)         //      Loop `t` downwards in the range (4, 0]
          try{a[                //       Get the cell at a location relative to the current
                I=t>2?          //        If `t` is 3:
                 i-1            //         Take the cell above
                :t>1?           //        Else if `t` is 2:
                 i+1            //         Take the cell below
                :i][J=t<1?      //        Else if `t` is 0:
                 j-1            //         Take the cell left
                :t<2?           //        Else if `t` is 1:
                 j+1:j]         //         Take the cell right
              +=a[I][J]<1?      //       And if this cell contains a 0:
                 n+1:0;         //        Fill it with `n+1`
          }catch(Exception e){} //       catch and ignore ArrayIndexOutOfBoundsExceptions
                                //       (try-catch saves bytes in comparison to if-checks)
— Kevin Cruijssen
source
3

JavaScript (ES6), 107 105 octets

f=(m,k=1)=>k<4?f(m.map((r,y)=>r.map((v,x)=>v|[-1,0,1,2].every(d=>(m[y+d%2]||0)[x+~-d%2]^k)?v:k+1)),k+1):m

Cas de test

Afficher l'extrait de code

Commenté

f = (m, k = 1) =>                  // given the input matrix m[] and starting with k = 1
  k < 4 ?                          // if this is not the 4th iteration:
    f(                             //   do a recursive call:
      m.map((r, y) =>              //     for each row r[] at position y in m[]:
        r.map((v, x) =>            //       for each cell v at position x in r[]:
          v |                      //         if v is non-zero
          [-1, 0, 1, 2].every(d => //         or each neighbor cell at (x+dx, y+dy), with:
            (m[y + d % 2] || 0)    //           dy = d % 2 --> [-1, 0, 1, 0]
            [x + ~-d % 2]          //           dx = (d - 1) % 2 --> [0, -1, 0, 1]
            ^ k                    //           is different from k  
          ) ?                      //         then:
            v                      //           let the cell unchanged
          :                        //         else:
            k + 1                  //           set the cell to k + 1
        )                          //       end of inner map()
      ),                           //     end of outer map()
      k + 1                        //     increment k for the next iteration
    )                              //   end of recursive call
  :                                // else:
    m                              //   stop recursion and return m[]
— Arnauld
source
3

Python 3 , 176 octets

f=lambda a,i=-2,e=enumerate:a*i or f([[E or int((6*max(len(a)>i>-1<j<len(a[i])and a[i][j]for i,j in((r+1,c),(r-1,c),(r,c+1),(r,c-1))))**.5)for c,E in e(R)]for r,R in e(a)],i+1)

Essayez-le en ligne!

-18 octets grâce à Mr. Xcoder
-20 octets grâce à ovs

— HyperNeutrino
source
9
" Quand je me réveillerai demain matin et que je regarderai à nouveau ce code, je vais probablement me sentir très stupide. " ; P
— Kevin Cruijssen
1
@KevinCruijssen ce D: pas acceptable. ne doit pas être battu par Java: P
— HyperNeutrino
1
Battons Java: c - 196 octets .
— M. Xcoder
@ Mr.Xcoder yay merci: c: D
— HyperNeutrino
@ovs oh nice, ty!
— HyperNeutrino
3

Python 2 , 146 143 octets

e=enumerate;l=input()
for y,f in e(l):
 for g,h in e(f):x=1+min(abs(y-a)+abs(g-c)for a,b in e(l)for c,d in e(b)if d==1);l[y][g]=x*(x<5)
print l

Essayez-le en ligne!

— ovs
source
3

Fortran 95, 309 299 294 287 269 ​​octets

subroutine f(a)
integer::a(:,:),s(2)
integer,allocatable::b(:,:)
s=shape(a)
allocate(b(0:s(1)+1,0:s(2)+1))
do1 k=0,3
do1 i=1,s(1)
do1 j=1,s(2)
b(i,j)=a(i,j)
if(any((/b(i+1,j)==k,b(i-1,j)==k,b(i,j+1)==k,b(i,j-1)==k/)).and.b(i,j)<1.and.k>0)b(i,j)=k+1
1 a(i,j)=b(i,j)
end

Fortran n'est pas une langue de golf.

  • Edit: enregistré 10 octets en utilisant d'étranges boucles do à l'ancienne.
  • Edit 2: enregistré 5 octets avecany()
  • Edit 3: enregistré 7 octets en supprimant un inutileif
  • Edit 4: 18 octets enregistrés en réduisant la déclaration des
— georgewatson
source
1

Nettoyer , 157 octets

import StdEnv,StdLib
t=transpose
z=zipWith
?n=n+sign n
f[0,h:l]=[?h:f[h:l]]
f[h,0:l]=[h,?h:f l]
f[h:l]=[h:f l]
f l=l
$l=z(z max)(t(map f(t l)))(map f l)


$o$o$

Essayez-le en ligne!

En tant que fonction littérale.

— Οurous
source
1

Perl, 63 octets

Comprend +3 pour 0ap

perl -0ape 's/0(?=$a|.{@{-}}$a)/$a+1/seg,$_=reverse while($a+=$|-=/
/)<4'

Donnez la matrice d'entrée sous forme de bloc de chiffres sans retour à la ligne final, par exemple

001
000
010

pour l'exemple 3x3. Le format de sortie est le même, un bloc de chiffres sans nouvelle ligne finale.

Vous pouvez utiliser un petit script comme 

perl -i -0pe 's/\n*$//' <file>

pour supprimer facilement les dernières lignes d'un fichier si cela est difficile à faire dans votre éditeur préféré

— Ton Hospel
source
1

Rétine , 93 87 84 octets

1
4
3{m`(?<=^(.)*)0(?=4|.*¶(?>(?<-1>.)*)4|(?<=40|^(?(1)_)(?<-1>.)*4.*¶.*))
5
T`1-5`d

Essayez-le en ligne! Basé sur ma réponse à Kill it With Fire . Edit: sauvé 6 9 octets grâce à @MartinEnder. Explication:

1
4

Transformez tous les 1 en 4.

3{

Répétez le reste du programme (au maximum) 3 fois.

m`(?<=^(.)*)0(?=4|.*¶(?>(?<-1>.)*)4|(?<=40|^(?(1)_)(?<-1>.)*4.*¶.*))
5

Changez tous les 0 adjacents à 4s en 5s.

T`1-5`d

Décrémentez tous les chiffres.

Retina 0.8.2 , 100 94 octets

1
3
{m`(?<=^(.)*)0(?=3|.*¶(?>(?<-1>.)*)3|(?<=30|^(?(1)_)(?<-1>.)*3.*¶.*))
4
T`1-4`d`^[^1]+$

Essayez-le en ligne! Explication:

1
3

Transformez tous les 1 en 3.

{

Répétez jusqu'à ce que la sortie ne change pas.

m`(?<=^(.)*)0(?=3|.*¶(?>(?<-1>.)*)3|(?<=30|^(?(1)_)(?<-1>.)*3.*¶.*))
4

Changez tous les 0 adjacents à 3 en 4.

T`1-4`d`^[^1]+$

S'il n'y a pas de 1, décrémentez tous les chiffres.

— Neil
source
Vous pouvez enregistrer quelques octets en utilisant un caractère comme !(qui ne peut pas apparaître dans l'entrée) au lieu de (?!).
— Martin Ender
@MartinEnder Merci, cela fonctionne aussi pour Kill it With Fire (et j'ai trouvé un golf séparé de 2 octets pendant que j'y étais!)
— Neil
1

Ruby , 183 158 146 octets

->a{3.times{|n|a.size.times{|i|r=a[i];r.size.times{|j|(r[j]<1&&[i>0?a[i-1][j]:0,a[i+1]&.at(j),j>0?r[j-1]:0,r[j+1]].include?(n+1))?r[j]=n+2:0}}};a}

Essayez-le en ligne!

Utilise l'algorithme évident à trois boucles. Le fait que Ruby autorise une indexation négative dans les tableaux signifie qu'il n'y a aucun moyen (que je puisse voir) de faire les vérifications des limites. Atteindre au-delà de la limite d'un tableau revient nil, donc seules les vérifications liées négatives sont nécessaires. La vérification a[i+1][j]doit simplement utiliser l'opérateur d'accès sécurisé.

J'ai également rasé quelques octets en utilisant une variable pour a[0].

-12 octets de plus: utilisez .timesau lieu de (0...x).map(à trois endroits).

->a{
  3.times{|n|                    # For n from 0 to 2
    a.size.times{|i|             # For each row
      r=a[i];
      r.size.times{|j|           # For each column
        (r[j]<1 && [             # If the current cell is 0, and any of
            i>0 ? a[i-1][j] : 0, #     the cell to the north,
            a[i+1]&.at(j),       #     the cell to the south,
            j>0 ? r[j-1] : 0,    #     the cell to the west,
            r[j+1]               #     or the cell to the east
          ].include?(n+1)        #   are set to the previous value,
        ) ? r[j]=n+2 : 0         # Set this cell to the next value (or 0)
      }
    }
  };
  a                              # Return the modified array
}
— benj2240
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.