Sfida:

Input: un numero intero positivo $n$

Produzione:

Crea un elenco nell'intervallo e uniscilo a una stringa (ovvero sarebbe la stringa ). $[1,n]$ $n=13$ 12345678910111213

Ora produciamo un triangolo usando i prefissi o i suffissi di questa stringa, in uno dei seguenti quattro orientamenti basati sull'intero di input:

Se , emettilo a forma di triangolo ◣ $n\equiv 0\pmod 4$
Se , emettilo a forma di triangolo ◤ $n\equiv 1\pmod 4$
Se , emettilo a forma di triangolo ◥ $n\equiv 2\pmod 4$
Se , emettilo a forma di triangolo ◢ $n\equiv 3\pmod 4$

Esempio:

Ingresso: $n=13$

Poiché , la forma sarà ◤. Ecco tre possibili uscite valide: $13\equiv 1\pmod 4$

12345678910111213    11111111111111111    12345678910111213
1234567891011121     2222222222222222     2345678910111213
123456789101112      333333333333333      345678910111213
12345678910111       44444444444444       45678910111213
1234567891011        5555555555555        5678910111213
123456789101         666666666666         678910111213
12345678910          77777777777          78910111213
1234567891           8888888888           8910111213
123456789            999999999            910111213
12345678             11111111             10111213
1234567              0000000              0111213
123456               111111               111213
12345                11111                11213
1234                 1111                 1213
123                  222                  213
12                   11                   13
1                    3                    3

Regole della sfida:

Come puoi vedere dalle tre uscite valide sopra, è importante solo la forma corretta e l'utilizzo di tutte le cifre nell'ordine corretto . A parte questo, sei libero di usare prefissi o suffissi; rovesci / riflette; stampa diagonale; ecc. ecc. È consentita una qualsiasi delle sei uscite possibili per ciascuna forma (vedere il caso di prova di seguito per vedere tutte le uscite valide in base alla forma). Ciò consente alle lingue con builtin di rotazione di usarlo, ma anche quelli che non lo sono possono usare un approccio alternativo per usare i prefissi nella dimensione corretta dall'alto verso il basso o usare i prefissi per due delle forme ma i suffissi per le altre due forme . La scelta delle opzioni di output più appropriate per la tua lingua fa parte del processo di golf. :)
L'input è garantito per essere un numero intero positivo. Per abbiamo semplicemente emesso . $n=1$ 1
È consentita qualsiasi quantità di nuove linee / spazi iniziali / finali, purché stampi il triangolo corretto (senza delimitatori verticali o orizzontali!) Da qualche parte sullo schermo.

Regole generali:

Questo è code-golf , quindi vince la risposta più breve in byte.
Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
Per la tua risposta valgono regole standard con regole I / O predefinite , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti e tipo di ritorno, programmi completi. La tua chiamata.
Sono vietate le scappatoie predefinite .
Se possibile, aggiungi un link con un test per il tuo codice (ad es. TIO ).
Inoltre, si consiglia vivamente di aggiungere una spiegazione per la risposta.

Casi test:

Ingresso: Tutte le possibili uscite valide: $n=5$

12345    54321    12345    54321    11111    55555
1234     5432     2345     4321     2222     4444
123      543      345      321      333      333
12       54       45       21       44       22
1        5        5        1        5        1

Ingresso: Tutte le uscite possibili: $n=6$

123456    654321    123456    654321    111111    666666
 12345     65432     23456     54321     22222     55555
  1234      6543      3456      4321      3333      4444
   123       654       456       321       444       333
    12        65        56        21        55        22
     1         6         6         1         6         1

Ingresso: Tutte le uscite possibili: $n=7$

      1          1          7          7          7          1
     12         21         67         76         66         22
    123        321        567        765        555        333
   1234       4321       4567       7654       4444       4444
  12345      54321      34567      76543      33333      55555
 123456     654321     234567     765432     222222     666666
1234567    7654321    1234567    7654321    1111111    7777777

Ingresso: Tutte le uscite possibili: $n=8$

1           1           8           8           8           1
12          21          78          87          77          22
123         321         678         876         666         333
1234        4321        5678        8765        5555        4444
12345       54321       45678       87654       44444       55555
123456      654321      345678      876543      333333      666666
1234567     7654321     2345678     8765432     2222222     7777777
12345678    87654321    12345678    87654321    11111111    88888888

Input: Solo output possibile: $n=1$

Ingresso: Tutte le uscite possibili: $n=2$

12    21    12    21    11    22
 1     2     2     1     2     1

— Kevin Cruijssen
fonte

Possiamo usare altri valori per triangoli diversi, come 1 per ◤, ecc.?

— Incarnazione dell'ignoranza il

@EmbodimentofIgnorance Un esempio sfortunato, poiché è quello che dice la specifica. Penso che tu volessi chiedere se possiamo cambiare l'ordine dei quattro accordi purché lo manteniamo coerente (penso che sarebbe un no).

— Erik the Outgolfer,

1

Se n==13la riga più in alto può essere '33333333333333333'(o, equivalentemente, '31211101987654321')?

— Chas Brown,

@EmbodimentofIgnorance Siamo spiacenti, ma direi di no in questo caso. Le forme e la loro corrispondente mod 4sono coppie rigorose per questa sfida. Quindi non puoi cambiare le quattro forme per i quattro mod 4casi. Ma bella domanda comunque.

— Kevin Cruijssen,

@ChasBrown Sì, entrambi vanno bene. Ho dato solo tre possibili esempi per

, ma tutte e sei le opzioni (come il caso di test

) sono output validi.

n = 13

$n=13$

n = 5

$n=5$

— Kevin Cruijssen,

9

JavaScript (ES6), 93 89 byte

Restituisce una matrice di caratteri.

n=>[...(g=n=>n?g(n-1)+n:'')(n)].map((d,y,a)=>a.map(_=>y-(n&2)*y--<0?' ':d)).sort(_=>-n%2)

Provalo online!

Motivo alternativo (stessa dimensione):

n=>[...(g=n=>n?g(n-1)+n:'')(n)].map((_,y,a)=>a.map(d=>y-(n&2)*y--<0?' ':d)).sort(_=>-n%2)

Provalo online!

Commentate

n =>                 // n = input
  [...               // split the result of ...
    ( g = n =>       //   ... a call to the recursive function g, taking n
      n ?            //     if n is not equal to 0:
        g(n - 1)     //       append the result of a recursive call with n - 1
        + n          //       append n
      :              //     else:
        ''           //       stop recursion and return an empty string
    )(n)             //   initial call to g
  ].map((d, y, a) => // for each digit d at position y in this array a[]:
    a.map(_ =>       //   for each character in a[]:
      y -            //     we test either y < 0 if (n AND 2) is not set
      (n & 2)        //     or -y < 0 (i.e. y > 0) if (n AND 2) is set
      * y-- < 0      //     and we decrement y afterwards
      ?              //     if the above condition is met:
        ' '          //       append a space
      :              //     else:
        d            //       append d
    )                //   end of inner map()
  )                  // end of outer map()
  .sort(_ => -n % 2) // reverse the rows if n is odd

Riepilogo delle forme

mapsort $n\bmod 4$

 n mod 4  | 0     | 1     | 2     | 3
----------+-------+-------+-------+-------
 n & 2    | 0     | 0     | 2     | 2
----------+-------+-------+-------+-------
 test     | y < 0 | y < 0 | y > 0 | y > 0
----------+-------+-------+-------+-------
 base     | #.... | #.... | ##### | #####
 shape    | ##... | ##... | .#### | .####
          | ###.. | ###.. | ..### | ..###
          | ####. | ####. | ...## | ...##
          | ##### | ##### | ....# | ....#
----------+-------+-------+-------+-------
 n % 2    | 0     | 1     | 0     | 1
----------+-------+-------+-------+-------
 reverse? | no    | yes   | no    | yes
----------+-------+-------+-------+-------
 final    | #.... | ##### | ##### | ....#
 shape    | ##... | ####. | .#### | ...##
          | ###.. | ###.. | ..### | ..###
          | ####. | ##... | ...## | .####
          | ##### | #.... | ....# | #####

— Arnauld
fonte

1

grazie per la spiegazione dei dettagli.

— Chau Giang,

9

Python 2 , 94 byte

n=0;s=''
exec"n+=1;s+=`n`;"*input()
K=k=len(s)
while k:k-=1;print s[k^n/-2%-2:].rjust(n%4/2*K)

Provalo online!

— XNOR
fonte

7

Japt , 8 byte

Restituisce una matrice di linee.

õ ¬å+ zU

Provalo

Salvato 2 byte grazie a Kevin .

õ ¬å+ zU     :Implicit input of integer U
õ            :Range [1,U]
  ¬          :Join to a string
   å+        :Cumulatively reduce by concatenation
      zU     :Rotate clockwise by 90 degrees U times

— ispido
fonte

1

È únecessario? Sembra che la rotazione lo faccia implicitamente?

— Kevin Cruijssen,

@KevinCruijssen, hmm ... così fa. Lo dimentico sempre; raramente si usa z.

— Shaggy,

1

Beh, non conosco affatto Japt. Ero solo curioso di

— sapere

4

Tela , 8 byte

ŗ］∑［］⁸［↷

Provalo qui!

— dzaima
fonte

4

Perl 6 , 94 byte

{[o](|(&reverse xx$_/2+.5),|(*>>.flip xx$_/2+1))([\~](my@a=[~](1..$_).comb)>>.fmt("%{+@a}s"))}

Provalo online!

Blocco di codice anonimo che accetta un numero e restituisce un elenco di righe.

— Jo King
fonte

3

Carbone , 17 byte

Ｎθ≔⭆θ⊕ιηＧLＬηη⟲⊗θ‖

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

Ｎθ

Input n.

≔⭆θ⊕ιη

Crea una stringa concatenando i numeri 1a n.

ＧLＬηη

Riempi un triangolo di quella lunghezza con la stringa.

⟲⊗θ

Ruota il triangolo in senso antiorario di n*90gradi.

‖

Rifletti tutto, finendo così con un triangolo che viene ruotato in senso orario di n*90gradi.

— Neil
fonte

3

C # (compilatore interattivo Visual C #) , 128 byte

n=>{var s="";int i=0,j,p;for(;i<n;s+=++i);for(p=j=s.Length;;)Write("{0,"+(n%4>1?p:0)+"}\n",new string(s[--j],-~n%4>1?j+1:p-j));}

Provalo online!

— Incarnazione dell'ignoranza
fonte

3

Rubino , 95 82 79 byte

->n{r=(0...z=/$/=~s=[*1..n]*'').map{|i|" "*n[1]*i+s[0,z-i]};-n&2>0?r:r.reverse}

Provalo online!

3 byte salvati da G B.

— Kirill L.
fonte

3

R , 152 139 137 134 byte

function(n,N=nchar(s<-Reduce(paste0,1:n,'')),A=!n%%4%%3)for(i in 1:N)cat(rep('',(M=c(N-i+1,i))[1+!A]*(n%%4>1)),substr(s,1,M[1+A]),'
')

Codice srotolato:

function(n){
  s = Reduce(paste0,1:n,'')      # concat the digits from 1 to n into a string s

  N = nchar(s)                   # store the length of s

  A = !n%%4%%3                   # A = TRUE if n MOD 4 == 1 or 2 

  for(i in 1:N){                 # for 1 to N (length of s)

    M = c(N-i+1,i)               # store N-i+1 and i into a vector

    nSpaces = M[1+!A]*(n%%4>1)   # if n MOD 4 == 1 or 2 then nSpaces = i else nSpaces = N-i+1, 
                                 # but if n MOD 4 == 0 or 1, then force nSpaces = 0

    nDigits = M[1+A]             # if n MOD 4 == 1 or 2 then nDigits = N-i+1 else nDigits = i

    prfx = rep('',)              # create a character vector repeating '' nSpaces times

    sufx = substr(s,1,M[1+A])    # substring s by taking the first nDigits characters

    cat(pr,su,'\n')              # print prfx and sufx using space as separator for the values 
                                 # contatenation (cat function default) and append a newline
  }

Provalo online!

— digEmAll
fonte

... non è stata la mia giornata per giocare a golf, chiaramente.

— Giuseppe,

@Giuseppe: ahah ci sono stato ... e poi di solito mi hai superato: P

— digEmAll

2

APL + WIN, 45 byte

Richiede un numero intero

m←⊃(⍳⍴s)↑¨⊂s←(⍕⍳n←⎕)~' '⋄⍎(' ⊖⍉⌽'[1+4|n]),'m'

Provalo online! Per gentile concessione di Dyalog Classic

— Graham
fonte

2

PowerShell , 108 byte

param($n)0..($y=($x=-join(1..$n)).length-1)|%{' '*(0,0,$_,($z=$y-$_))[$n%4]+-join$x[0..($_,$z,$z,$_)[$n%4]]}

Provalo online!

Un po 'ruvido attorno ai bordi ma funziona. Unisce le cifre da 1 a nuna stringa quindi scorre da 0 alla lunghezza di quella stringa-1. Ogni volta, utilizza l'indicizzazione dell'elenco per passare al metodo di spaziatura e all'intervallo di numeri corretti utilizzati per tagliare la nostra nuova stringa.

— Veskah
fonte

2

Gelatina , 12 byte

D€Ẏ;\z⁶U$⁸¡Y

Provalo online!

— Erik the Outgolfer
fonte

2

05AB1E (legacy) , 14 12 10 byte

L'uso della versione legion come riscrittura è estremamente lento su questo per qualche motivo.

Salvato 2 byte grazie a Kevin Cruijssen

LSηsFRζ}J»

Provalo online!

Spiegazione

L           # push range [1 ... input]
 S          # split to list of individual digits
  η         # calculate prefixes
   sF  }    # input times do:
     R      # reverse list
      ζ     # and transpose it
        J   # join to list of strings
         »  # and join on newlines

— Emigna
fonte

È possibile salvare 2 byte cambiando LJη€Sin LSη, poiché Ssi appiattisce implicitamente.

— Kevin Cruijssen,

@KevinCruijssen: Oh sì, grazie! Me ne ero dimenticato. Ho provato €Sche non ha funzionato molto bene;)

— Emigna il

2

Stax , 10 byte

Ç√çZ╟84Γó║

Esegui ed esegui il debug

— ricorsivo
fonte

2

PowerShell , 105 101 95 byte

-4 byte grazie Arnauld per il trucco con Sort .

param($n)($x=1..$n-join'')|% t*y|%{($s+="$_")}|sort -d:($n%4-in1,2)|% *ft($x.Length*($n%4-ge2))

Provalo online!

Meno golf:

param($n)
$x=1..$n-join''
$x|% toCharArray |% {
    ($s+="$_")
} | sort -Descending:($n%4-in1,2) |% PadLeft ($x.Length*($n%4-ge2))

— Mazzy
fonte

2

R , 175 172 154 byte

function(n)write(c(" ",0:9)[1+(x=utf8ToInt(Reduce(paste0,1:n,""))-47)*!upper.tri(diag(y<-sum(x|1)))["if"(n%%4>1,1:y,y:1),"if"(!n%%4%%3,y:1,1:y)]],1,y,,"")

Provalo online!

Un brutto pasticcio in linea!

-3 byte modificando la condizione di rotazione

-17 byte grazie al suggerimento di digEmAll e un altro byte dopo aver giocato a golf ulteriormente

— Giuseppe
fonte

Mi piace questo approccio upper.triangle e può essere ridotto a 155 byte ... forse anche di più, sono sicuro che mi manca qualcosa di ovvio ...

— digEmAll

Ah ah ah, molto migliorato, ma ancora lungo :-(

— Giuseppe

1

Wolfram Language (Mathematica) , 137 byte

(t=Table[Table[" ",If[(m=#~Mod~4)>1,Tr[1^s]-k,0]]<>ToString/@s[[;;k]],{k,Length[s=Join@@IntegerDigits/@Range@#]}];If[0<m<3,Reverse@t,t])&

Provalo online!

— J42161217
fonte

1

Python 2 , 116 byte

n=input()
s=''.join(map(str,range(1,n+1)));L=len(s)
p=-~n/2%2;i=~-L*p+1
exec'print s[:i].rjust(n/2%2*L);i+=1-2*p;'*L

Provalo online!

— Chas Brown
fonte

1

Rosso , 155 byte

func[n][b: copy""repeat i n[append b i]repeat i l:
length? b[t:[l - i + 1]set[k m]pick[i t[l t][l i]]n % 4 + 1
print pad/left copy/part b do do m do do k]]

Provalo online!

— Galen Ivanov
fonte

1

perl 5, 117 byte

$p=$_++&2?'/ ':'$/';$s='(.*\d.\n)';$r=$_--&2?$s.'\K$':"^(?=$s)";$_=(join"",1..$_).$/;1while s,$r,'$1=~s/\d'."$p/r",ee

TIO

— Nahuel Fouilleul
fonte

1

PHP ,116 111 109 byte

for($m=$l=strlen($s=join(range(1,$n=$argn)));$l--;)printf('%'.($n&2?$m:-$l).'.'.($n-1&2?$m-$l:$l+1)."s
",$s);

Provalo online!

Esegui con php -nFinput da STDIN.

$ echo 6|php -nF t.php

— 640KB
fonte

1

Java (JDK) , 247 209 188 186 160 148 byte

i->{String s="";int l=0,w;for(;l<i;s+=++l);for(w=s.length(),l=0;l<w;)System.out.printf("%"+(1>i%4/2?1:w)+"s\n",s.substring(0,1>~-i%4/2?w-l++:++l));}

Provalo online!

-38 bytes grazie a @KevinCruijssen
-21 bytes lasciando printfgestire l'imbottitura.
-2 byteseseguendo la sottostringa prima della sostituzione, consentendoci di incrementare lin una posizione anziché in due.
-26 bytes- printffacendo il padding, la stringa piena di spazi non era più necessaria e le stringhe di cifre potevano essere generate in modo apparentemente più breve.
-12 bytesnon scherzando con le singole cifre invece di stampare sottostringhe della stringa di cifre perfettamente funzionante che già abbiamo.

Ungolfed

input->{
    // Lambda expression with target type of IntConsumer
    String allDigits = "";
    int lineLength, line = 0;

    // Collect a list of all digits in order.
    for (;line < input; allDigits += ++line) {}

    // Save the max length of a line, and create a string of that many spaces.
    for (lineLength=allDigits.length(), line=0; line < lineLength;) {
        System.out.printf(   "%" // construct a format string to handle the padding
                           + (   1 > input%4/2
                               ? 1 // No padding
                               : w // Yes padding
                             )
                           + "s\n"
                         , allDigits.substring( 0
                                              ,   1 > (i-1)%4/2
                                                ? w - l++
                                                : ++l
                                              ) // A string containing only the digit we want.
                         );
    }
}

— Sara J
fonte

1

Bella risposta. Ci sono un sacco di cose da golf in più, però: gli spazi dopo il for(possono essere rimossi. new String(new char[w=s.length()]).replace('\0',' ')può " ".repeat(w=s.length())usare Java 11+. È possibile rimuovere la parentesi attorno ai controlli ternari. 1>(i-1)%4/2può essere 1>~-i%4/2. w-1-l++può essere w+~l++. E non devi contare il punto e virgola finale nel conteggio byte. Che tutto combinato diventa 209 byte .

— Kevin Cruijssen,

I triangoli delle cifre

Sfida:

Regole della sfida:

Regole generali:

Casi test:

JavaScript (ES6), 93 89 byte

Commentate

Riepilogo delle forme

Python 2 , 94 byte

Japt , 8 byte

Tela , 8 byte

Perl 6 , 94 byte

Carbone , 17 byte

C # (compilatore interattivo Visual C #) , 128 byte

Rubino , 95 82 79 byte

R , 152 139 137 134 byte

APL + WIN, 45 byte

PowerShell , 108 byte

Gelatina , 12 byte

05AB1E (legacy) , 14 12 10 byte

Stax , 10 byte

PowerShell , 105 101 95 byte

R , 175 172 154 byte

Wolfram Language (Mathematica) , 137 byte

Python 2 , 116 byte

Rosso , 155 byte

perl 5, 117 byte

PHP ,116 111 109 byte

Java (JDK) , 247 209 188 186 160 148 byte

Ungolfed