Tableaux ASCII de base

36

Titre alternatif: Comptez votre peine de prison sur le mur

Étant donné un nombre n, les résultats de sortie sont regroupés dans les groupes traditionnels de 5 par groupe et de 50 par ligne.


Exemples

1

|
|
|
|

4

||||
||||
||||
||||

5

|||/
||/|
|/||
/|||

6

|||/ |
||/| |
|/|| |
/||| |

50

|||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/
||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/|
|/|| |/|| |/|| |/|| |/|| |/|| |/|| |/|| |/|| |/||
/||| /||| /||| /||| /||| /||| /||| /||| /||| /||| 

51

|||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/
||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/|
|/|| |/|| |/|| |/|| |/|| |/|| |/|| |/|| |/|| |/||
/||| /||| /||| /||| /||| /||| /||| /||| /||| /||| 

|
|
|
|

256

|||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/
||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/|
|/|| |/|| |/|| |/|| |/|| |/|| |/|| |/|| |/|| |/||
/||| /||| /||| /||| /||| /||| /||| /||| /||| /||| 

|||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/
||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/|
|/|| |/|| |/|| |/|| |/|| |/|| |/|| |/|| |/|| |/||
/||| /||| /||| /||| /||| /||| /||| /||| /||| /||| 

|||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/
||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/|
|/|| |/|| |/|| |/|| |/|| |/|| |/|| |/|| |/|| |/||
/||| /||| /||| /||| /||| /||| /||| /||| /||| /||| 

|||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/
||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/|
|/|| |/|| |/|| |/|| |/|| |/|| |/|| |/|| |/|| |/||
/||| /||| /||| /||| /||| /||| /||| /||| /||| /||| 

|||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/ |||/
||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/| ||/|
|/|| |/|| |/|| |/|| |/|| |/|| |/|| |/|| |/|| |/||
/||| /||| /||| /||| /||| /||| /||| /||| /||| /||| 

|||/ |
||/| |
|/|| |
/||| |

Règles

  • 5 points par groupe, 50 points au total.
  • Les 4 premiers points sont verticaux, le 5e passe tous les autres points.
    • Chacun des quatre premiers est composé de 4 |caractères verticaux .
    • Le 5ème décompte final s'étend sur les 4 du premier, avec un /personnage en diagonale.
  • Chaque groupe doit être séparé par un espace, chaque ligne par une nouvelle ligne vierge.
  • Les contraintes sur nsont: 0 <= n <= 1000(pour la simplicité).
  • Les espaces de fin et les nouvelles lignes sont corrects, les précédents ne le sont pas.
  • C'est le , le plus petit nombre d'octets gagnés.

Examiné par ~ 4 personnes dans le bac à sable .


Le PS est amusant, le nombre moyen de notes par ligne en prison était de 50, d’où le niveau alternatif. Titre.

Urne Magique De Pieuvre
la source
Connexes
Urne Magic Octopus
Grand défi, complexe mais simple.
ATaco
@ATaco Je veux vraiment trouver la solution qui regroupe les barres obliques dans la "grande image" et tient compte du fait que la structure des barres obliques peut être déduite par rangée (c'est la victoire facile).
Urne Magic Octopus
2
Merci beaucoup de leur faire des barres obliques au lieu de barres obliques.
totalement humain
1
@totallyhuman Oh mon dieu, le gars dans l'image que j'ai posté fait ... C'EST QUOI UNIVERS? Ce sont les ours Bernstein qui recommencent ... La pièce at-elle atterri sur la tête ou la queue pour décider des dernières élections américaines?!
Urne magique Octopus

Réponses:

11

Charbon de bois , 30 à 25 octets

FN«J﹪ι⁵⁰×⁵÷ι⁵⁰¿﹪⊕ι⁵↓⁴«←↙⁴

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Explication:

 N                          Input number
F «                         Loop over implicit range
     ι     ι                Loop index
      ⁵⁰    ⁵⁰              Literal 50
    ﹪                       Modulo
          ÷                 Integer divide
         ⁵                  Literal 5
        ×                   Multiply
   J                        Jump to column, row
                 ι          Loop index
                ⊕           Incremented
                  ⁵         Literal 5
               ﹪            Modulo
              ¿             If
                   ↓⁴       Print 4 `|`s downwards
                     «      Implicit else
                      ←     Move left
                       ↙⁴   Print 4 `/`s down and left
Neil
la source
6

Funky , 156 132 133 octets

n=>{k=n=>((l="|"::rep)(3-i)+"/"+l(i)+" ")::rep(n)p=print L=f=>fori=0i<4i++p(f())forc=0c<n//50c++{L@k(10);p()}L@k((m=n%50)//5)+l(m%5)}

Essayez-le en ligne!

ATaco
la source
1
Funky est un ... et maintenant? Intéressant. Jamais vu cette langue sur aucun de mes défis auparavant.
Urne Magique Octopus
1
@MagicOctopusUrn Probablement parce que je l'ai écrit: P
ATaco
1
Un langage basé sur JavaScript? Dangereux. Mais ce n'est pas grave, j'adore le danger.
Magic Octopus Urn
1
fori=0i<4i++p(f())forc=0c<n//50c++quelle est cette bête impie prenant le nom de syntaxe
totalement humain
6

Haskell , 117 octets

f m|m<1=""|n<-min 50 m=unlines[[last$"| "!!(0^c%5):['/'|r+c%5==4,n-n%5>c]|c<-[1..n]]|r<-[0..3]]++'\n':f(m-50)
(%)=mod

Essayez-le en ligne!

Laikoni
la source
5

Gelée , 37 octets

:5[“|||/”]ẋ;”|ẋ⁸%5¤¤W¤ṙ€4Ḷ¤s⁵Z€G€j⁾¶¶

Essayez-le en ligne!

Explication

:5[“|||/”]ẋ;”|ẋ⁸%5¤¤W¤ṙ€4Ḷ¤s⁵Z€G€j⁾¶¶  Main Link
:5                                     Floordiv by 5
  [“|||/”]ẋ                            Repeat ["|||/"] by this number
           ;                           Append
            ”|ẋ    ¤                   "|" repeated by
               ⁸%5¤                    The argument modulo 5
                    W¤                 Then wrapped to prevent weirdness
                      ṙ€               Rotate each tally segment by
                        4Ḷ¤            (each) [0, 1, 2, 3]
                           s⁵          Slice into pieces of length 10 (to get 50 per row)
                             Z€        Transpose each
                               G€      Convert each into a grid
                                 j⁾¶¶  Join these grids by a double newline

quand c'est trop long

HyperNeutrino
la source
@FrownyFrog corrigé, merci!
HyperNeutrino
4

Coque , 29 octets

J;øṀṪṙŀ4C10§:oR"|||/"÷5oR'|%5

Essayez-le en ligne!

Je pense que le premier 5est redondant, mais le supprimer donne une erreur de type ...

Explication

J;øṀṪṙŀ4C10§:oR"|||/"÷5oR'|%5  Implicit input, an integer n.
                       oR'|    Repeat the character '|'
                           %5  n mod 5 times.
             oR"|||/"          Repeat the string "|||/"
                     ÷5        n/5 times.
           §:                  Tack the '|'-string to the end of that list.
        C10                    Cut the list of strings into pieces of length 10.
   Ṁ                           For each piece,
    Ṫ ŀ4                       for each k in [0,1,2,3],
     ṙ                         rotate each string k steps to the left
                               and collect the results into a list.
                               Now we have a list of lists of lists of strings.
J;ø                            Join them with the list [[]].
                               Implicitly join each list of strings by spaces,
                               then join the resulting list of strings by newlines,
                               and print the result.
Zgarb
la source
4

SOGL V0.12 , 33 octets

ā.{┐4∙F5\?X1w⁄3-14╚╬5@}┼FM»\?O¶oā

Essayez-le ici!

Jouer au téléphone sur un téléphone est difficile.

Explication:

ā                                  push an empty array
 .{                                repeat input times
   ┐4∙                               push a 4 tall line
      F5\?            }              if the counter (1-indexed) divides by 5
          X                            pop that vertical line
           1w⁄                         get the width of the main array
              3-                       subtract 3 from that width - X position
                1                      push 1 - Y position
                 4╚                    push a 4 long diagonal
                   ╬5                  place that in the main array at [width-3; 1]
                     @                 push a space - for the below to add spacing
                       ┼             append horizontally
                        FM»\?        if the counter divides by 50
                             O         output the main array
                              ¶o       output a newline
                                ā      push a new array
                                       (note that the outputting here doesn't disable
                                       implicit outputting)
dzaima
la source
4

JavaScript (ES6), 139 137 octets

n=>eval('s="";for(i=0;i++<=n/50;s+=N)for(j=5;--j;s+=N=`\n`)for(k=0;k<(x=(y=n-i*50)<0?50+y:50);)s+=++k%5?k%5-j|k>5*(x/5|0)?"|":"/":" ";s')

Retourne une chaîne avec une nouvelle ligne de fin lorsque nn'est pas un multiple de 50 et une avec plusieurs nouvelles lignes de fin lorsque n est un multiple de 50.

Ungolfed

n=>{
    s=""
    for(i=0; i++ <= n/50; s+=N)
        for(j=5; --j; s+=N=`\n`)
            for(k=0; k < (x = (y = n-i*50) < 0 ? 50+y : 50);)
                s += ++k%5 ?
                    k%5-j|k>5*(x/5|0) ?
                        "|"
                    : "/"
                : " "
    return s
}

Test Snippet

Non- evalsolution, 150 octets

n=>(A=(v,m)=>j=>[...Array(v).keys()].map(m).join(j))(n/50+1|0,i=>A(4,j=>A(x=(y=n+~i*50)<0?50+y:50,k=>++k%5?k%5-4+j|k>5*(x/5|0)?"|":"/":" ")``)`
`)`

`

Peut-être capable de jouer au golf plus loin, mais la evalméthode a été plus courte jusqu'à présent.

Justin Mariner
la source
Il m'a fallu 10 bonnes minutes pour comprendre et comprendre la version non-golfée. = ^ P Vous avez quelques bons trucs dedans.
DLosc
à peu près sûr que vous pouvez faire pour (i = 0; ++ i <n / 50; s + = N) qui enregistre un caractère
DanielIndie
@DanielIndie Cela échoue car la boucle externe s'exécute une fois de trop: essayez-la en ligne!
Justin Mariner
4

J , 50 48 45 35 33 octets

_50|:\'|/ '{~[{.(|.2,=i.4)$~]-5|]

Essayez-le en ligne!

                (    =i.4)          Identity matrix of size 4.
                (  2,    )          Prepend a row of 2s.
                (|.      )          Upside down.
                          $~        Take __ rows.
                            ]-5|]   Input rounded down to a multiple of 5.
             [{.                    Pad with rows of zeroes to [input] rows.
      '|/ '{~                       Get the characters.
_50|:\                              Transpose and fit to width.
FrownyFrog
la source
J'aime l'idée d'utiliser des infixes pour cette partie4,&' '\7$'|||/'
Jonah
@Jonah il fallait y aller :(
FrownyFrog
3

C (gcc), 170 octets

char*s="|||/ \0||/| \0|/|| \0/||| \0";h;k;g(x){for(h=0;h<5;h++){for(k=x;k>4;k-=5)printf(s+6*h);for(;k&&h-4;k--)printf("|");putchar(10);}}f(x){for(;x>49;x-=50)g(50);g(x);}

Essayez-le en ligne!

fest une fonction prenant un entier non négatif ( x) et imprimant que beaucoup de compteurs, groupés comme spécifié, sur stdout

gest une fonction d’aide qui imprime des xtableaux, groupés par 5, sans séparer les lignes.

fappelle g(50)et décrémente xde 50 jusqu'à ce qu'il soit inférieur à 50, puis appelle g(x)pour imprimer les résultats restants sur une ligne.

sest char*tel que, en tant que chaîne, sest la première ligne d'un paquet, s+6est la deuxième, s+12est la troisième et s+18est la quatrième et s+24est une chaîne vide.

g(x)imprime les paquets et diminue x de 5 jusqu'à ce que x soit inférieur à 5, puis imprime xdes compteurs simples.

pizzapants184
la source
135 octets
ceilingcat
2

Python 2 , 142 octets

n=input()
while n>0:print"\n".join("".join("|/ "[2*(j%5>3)+(n/(5*(j/5+1))and 3-i==j%5)]for j in range(min(50,n)))for i in range(4)),"\n";n-=50

Essayez-le en ligne!

Halvard Hummel
la source
1
142 octets en 18 minutes? Pas mal :).
Magic Octopus Urn
3
Vous devez vous mettre au travail rapidement lorsque vous auriez vraiment dû vous coucher Il y a une heure
Halvard Hummel
Quick ~= Quality;). Bon travail.
Urne magique Octopus
3
Euh ... ça peut être mal interprété. Dire que vous avez fait un travail de qualité rapidement… Pas le contraire.
Magic Octopus Urn
2
138 octets
ovs
2

Haskell , 134 octets

f#n=unlines$(concat.f.(<$[1..n`div`5]))<$>["|||/ ","||/| ","|/|| ","/||| "]
f n|n>50=id#50++'\n':f(n-50)|1>0=(++['|'<$[1..n`mod`5]])#n

Essayez-le en ligne!

asdfghjkl-- Ouais, j'y travaille.

totalement humain
la source
2

PHP, 138 141 + 1 octets

probablement pas la solution la plus courte possible

for(;0<$z=50+min($n=$x=$y=0,$argn-=50);print"
")while($n++<$z||!$x=+(3<$y+=$n=print"
"))echo"/| "[$n%5?($y+$x++)%4<3|$n%5+$y<4|$z-$z%5<$n:2];

Exécuter en pipe -nRou essayer en ligne .

Titus
la source
Soigné! Mais à partir de la deuxième ligne, les points ne sont pas complètement franchis.
SpazzMarticus
Lorsque vous exécutez votre exemple "essayez-le en ligne" à partir de la version 5.5, localement 5.6.31 et 7.1.9.
SpazzMarticus
1
$xest seulement indéfini dans la première boucle, cela gâche la sortie pour un total supérieur à 54. Corrigé, mais pas joué au golf
SpazzMarticus
@SpazzMarticus corrigé
Titus
Cool! C'était la première fois que je déboguais du code golfé, tu m'as donné du fil à retordre! :) Je pense que je suis accro!
SpazzMarticus
2

Python, 129 113 112 octets

f=lambda n:n>50and f(50)+"\n\n"+f(n-50)or"\n".join(("|||/|||"[k:k+4]+" ")*(n//5)+" "+"|"*(n%5)for k in range(4))

Explication

def p(n):
  if n > 50:
    return p(50) + "\n\n" + p(n-50) # Handle 50-groups recursively
  else:
    # For each of the 4 lines:
    rows = []
    for row in range(4):
      #  - Build the "|||/"-blocks by slicing the correct part of "|||/|||".
      #  - Do that n/5 times
      #  - Then add "|" n%5 times
      rows += [("|||/|||"[row:row+4]+" ")*(n//5) + " " + "|"*(n%5)]

    # Join the four rows together
    return "\n".join(rows)

Fonctionne en Python 2 et 3.

Essayez-le en ligne

Lukas Boersma
la source
1

Java (OpenJDK 8) , 188 octets

i->{int j=0,l,k;String r="";for(;j<~-i/50+1;j++,r+="\n")for(l=0;l<4;l++,r+="\n")for(k=0;k<(j*50+50>i?i-j*50:50);k++)r+=k%5>3?" ":k%5==3-l?"/":"|";return r.replaceAll("/(?=(\\|*\n))","|");}

Essayez-le en ligne!

Roberto Graham
la source
179 octets
ceilingcat
1

Ruby , 100 octets

->n{(n/-50*-4).times{|i|j=[n-i/4*50,50].min
$><<("|||/|||"[i%4,4]+" ")*(j/5)+?|*(j%5)+$/*(1+i%4/3)}}

Commenté

->n{(n/-50*-4).times{|i|              #Calculate rows of tallies (Ruby rounds division towards negative infinity. Multiply by 4 lines per tally and iterate through them.)
  j=[n-i/4*50,50].min                 #Number of strokes printed in current row is either the number remaining, or 50, whichever is less
    $><<("|||/|||"[i%4,4]+" ")*(j/5)+ #Send to stdout the correct 4 chars selected from "|||/|||" plus a space, j/5 times (rounded down, which eliminates odd strokes.) 
    ?|*(j%5)+                         #If there are any odd strokes, add them to the output
    $/*(1+i%4/3)                      #followed by a newline (2 for the final line of each row of tallies.)
  }
}

Essayez-le en ligne!

Level River St
la source
1

Pip , 47 46 octets

Wa-:yP('|X4.sRA3-_'/M,4)X(YMN[a50])/5.'|Xy%5.n

Essayez-le en ligne!

Explication

        Implicit: a is 1st cmdline arg, y is "", s is space, n is newline
W       While loop:
 a-:y   Each iteration, subtract y from a and check if a is still nonzero
        (Since "" is 0 in numeric contexts, this does nothing the first time through)
     P  Print the following:

('|X4.sRA3-_'/M,4)X(YMN[a50])/5.'|Xy%5.n
              M                           Map this function to each number in
               ,4                         range(4):
 '|X4                                      String of four pipe characters
     .s                                    Concatenate a space
       RA                                  Replace the character at index
         3-_                                (3 minus function argument)
            '/                              with forward slash

                                          We now have a list of four strings representing
                                           the rows of a group of 5 tally marks; the
                                           following operations apply to the list
                                           element-wise:

                       [a50]              List of a (number of remaining tallies) and 50
                     MN                   Get the min (number of tallies on this row)
                    Y                     Yank it into y
                   (        )/5           Divide by 5 (number of groups on this row)
(                )X                       String-multiply by that amount
                                   y%5    Number of leftover tallies on this row
                                '|X       String-multiply that many pipes
                               .          Concatenate
                                      .n  Concatenate a newline

La liste résultante ressemblera à ceci:

["|||/ ||\n" "||/| ||\n" "|/|| ||\n" "/||| ||\n"]

Par défaut, Pconcatène le contenu de la liste et les affiche avec une nouvelle ligne. Ainsi, nous obtenons

|||/ ||
||/| ||
|/|| ||
/||| ||

avec deux nouvelles lignes de fin (une du contenu de la liste et une ajoutée par P). S'il y a une autre ligne à imprimer, cela donne la ligne vide requise entre les deux.

DLosc
la source
0

Befunge, 125 à 105 octets

$&:!#@_:::"2"v>*\5%4\`+1g1-,1+:14g\`#v_55+,$:#v_55+,
!}0:+*`"2"\-\<^!-g01%5\!`g41+5*5/5:::<0p01:-1<<<4-p4

Essayez-le en ligne!

James Holderness
la source
0

05AB1E , 28 octets

5‰"|||/"¬‚×J4ôTôεε3Ý._}ø»¶«,

Essayez-le en ligne.

Explication:

5              # Divmod the (implicit) input-integer by 5
                #  i.e. 111 → [22,1]
  "|||/"        # Push string "|||/"
        ¬       # Push its first character (without popping the string itself): "|"
               # Pair them together: ["|||/","|"]
          ×     # Repeat it based on the divmod
                #  i.e. [22,1] → ["|||/|||/|||/...|||/|||/|||/","|"]
           J    # Join everything together to a single string
                #  → "|||/|||/|||/...|||/|||/|||/|"
            4ô  # Which is then split into block of size 4
                #  → ["|||/","|||/","|||/",...,"|||/","|||/","|||/","|"]
Tô              # Then split this list into sublists of size 10
                #  → ["|||/","|||/","|||/",...],[...,"|||/"],["|||/","|||/","|"]]
  ε             # For-each over the sublists:
   ε            #  Map over the strings in the sublist:
    3Ý          #   Push list [0,1,2,3]
      ._        #   For each: rotate the string that many times
                #    ("|||/" → ["|||/","||/|","|/||","/|||"])
              #  After the map: zip/transpose; swapping rows/columns
     »          #  Join each inner list by spaces, and then the strings by newlines
      ¶«        #  Append a newline to each string
        ,       #  And print with trailing newline

¶«,Bien sûr, a quelques alternatives possibles d'octets égaux, comme ,¶?ou ,õ,.

Kevin Cruijssen
la source
0

C (gcc) , 107 106 octets

i,j;f(n){for(;n>50;f(50))n-=50;for(i=5;--i;)for(j=0;putchar(++j+~n?j%5?(j-i)%5|n-j<n%5?'|':47:32:10)%5;);}

Essayez-le en ligne!

-1 grâce à ceilingcat

attinat
la source